Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

Expand documentation, testing, and functionality of ValueTrackers; remove ExponentialValueTracker (#1382)

SwiddisZwei855ea2d12856
diff --git a/manim/mobject/value_tracker.py b/manim/mobject/value_tracker.py
index 394be02bf..16998fd3b 100644
--- a/manim/mobject/value_tracker.py
+++ b/manim/mobject/value_tracker.py
@@ -1,8 +1,10 @@
"""Mobjects that dynamically show the change of a variable."""
-__all__ = ["ValueTracker", "ExponentialValueTracker", "ComplexValueTracker"]
+__all__ = ["ValueTracker", "ComplexValueTracker"]
+from typing import Union
+
import numpy as np
from ..mobject.mobject import Mobject
@@ -18,6 +20,8 @@ class ValueTracker(Mobject):
uses for its update function, and by treating it as a mobject it can
still be animated and manipulated just like anything else.
+ This value changes continuously when animated using the :attr:`animate` syntax.
+
Examples
--------
.. manim:: ValueTrackerExample
@@ -28,37 +32,38 @@ class ValueTracker(Mobject):
pointer = Vector(DOWN)
label = MathTex("x").add_updater(lambda m: m.next_to(pointer, UP))
- pointer_tracker = ValueTracker(0)
+ tracker = ValueTracker(0)
pointer.add_updater(
lambda m: m.next_to(
- number_line.n2p(pointer_tracker.get_value()),
+ number_line.n2p(tracker.get_value()),
UP
)
)
self.add(number_line, pointer,label)
- pointer_tracker += 1.5
+ tracker += 1.5
self.wait(1)
- pointer_tracker -= 4
+ tracker -= 4
self.wait(0.5)
- self.play(pointer_tracker.animate.set_value(5)),
+ self.play(tracker.animate.set_value(5)),
self.wait(0.5)
- self.play(pointer_tracker.animate.set_value(3))
- self.play(pointer_tracker.animate.increment_value(-2))
+ self.play(tracker.animate.set_value(3))
+ self.play(tracker.animate.increment_value(-2))
self.wait(0.5)
.. note::
- You can also link ValueTrackers to updaters. In this case, you have to make sure that the ValueTracker is added to the scene by ``add``
+ You can also link ValueTrackers to updaters. In this case, you have to make sure that the
+ ValueTracker is added to the scene by ``add``
.. manim:: ValueTrackerExample
class ValueTrackerExample(Scene):
def construct(self):
- pointer_tracker = ValueTracker(0)
- label = Dot(radius=3).add_updater(lambda x : x.set_x(pointer_tracker.get_value()))
+ tracker = ValueTracker(0)
+ label = Dot(radius=3).add_updater(lambda x : x.set_x(tracker.get_value()))
self.add(label)
- self.add(pointer_tracker)
- pointer_tracker.add_updater(lambda mobject, dt: mobject.increment_value(dt))
+ self.add(tracker)
+ tracker.add_updater(lambda mobject, dt: mobject.increment_value(dt))
self.wait(2)
"""
@@ -69,7 +74,7 @@ class ValueTracker(Mobject):
self.set_value(value)
def get_value(self) -> float:
- """Get the current value of the ValueTracker. This value changes continuously when :attr:`animate` for the ValueTracker is called."""
+ """Get the current value of this ValueTracker."""
return self.points[0, 0]
def set_value(self, value: float):
@@ -80,17 +85,47 @@ class ValueTracker(Mobject):
def increment_value(self, d_value: float):
"""Increments (adds) a scalar value to the ValueTracker"""
self.set_value(self.get_value() + d_value)
+ return self
+
+ def __bool__(self):
+ """Return whether the value of this value tracker evaluates as true."""
+ return bool(self.get_value())
def __iadd__(self, d_value: float):
"""adds ``+=`` syntax to increment the value of the ValueTracker"""
self.increment_value(d_value)
return self
+ def __ifloordiv__(self, d_value: float):
+ """Set the value of this value tracker to the floor division of the current value by ``d_value``."""
+ self.set_value(self.get_value() // d_value)
+ return self
+
+ def __imod__(self, d_value: float):
+ """Set the value of this value tracker to the current value modulo ``d_value``."""
+ self.set_value(self.get_value() % d_value)
+ return self
+
+ def __imul__(self, d_value: float):
+ """Set the value of this value tracker to the product of the current value and ``d_value``."""
+ self.set_value(self.get_value() * d_value)
+ return self
+
+ def __ipow__(self, d_value: float):
+ """Set the value of this value tracker to the current value raised to the power of ``d_value``."""
+ self.set_value(self.get_value() ** d_value)
+ return self
+
def __isub__(self, d_value: float):
"""adds ``-=`` syntax to decrement the value of the ValueTracker"""
self.increment_value(-d_value)
return self
+ def __itruediv__(self, d_value: float):
+ """Sets the value of this value tracker to the current value divided by ``d_value``."""
+ self.set_value(self.get_value() / d_value)
+ return self
+
def interpolate(self, mobject1, mobject2, alpha, path_func=straight_path):
"""
Turns self into an interpolation between mobject1
@@ -100,25 +135,40 @@ class ValueTracker(Mobject):
return self
-class ExponentialValueTracker(ValueTracker):
- """
- Operates just like ValueTracker, except it encodes the value as the
- exponential of a position coordinate, which changes how interpolation
- behaves
- """
+class ComplexValueTracker(ValueTracker):
+ """Tracks a complex-valued parameter.
- def get_value(self):
- return np.exp(ValueTracker.get_value(self))
+ When the value is set through :attr:`animate`, the value will take a straight path from the
+ source point to the destination point.
- def set_value(self, value):
- return ValueTracker.set_value(self, np.log(value))
+ Examples
+ --------
+ .. manim:: ComplexValueTrackerExample
+ class ComplexValueTrackerExample(Scene):
+ def construct(self):
+ tracker = ComplexValueTracker(-2+1j)
+ dot = Dot().add_updater(
+ lambda x: x.move_to(tracker.points)
+ )
+
+ self.add(NumberPlane(), dot)
+
+ self.play(tracker.animate.set_value(3+2j))
+ self.play(tracker.animate.set_value(tracker.get_value() * 1j))
+ self.play(tracker.animate.set_value(tracker.get_value() - 2j))
+ self.play(tracker.animate.set_value(tracker.get_value() / (-2 + 3j)))
+ """
-class ComplexValueTracker(ValueTracker):
def get_value(self):
+ """Get the current value of this value tracker as a complex number.
+
+ The value is internally stored as a points array [a, b, 0]. This can be accessed directly
+ to represent the value geometrically, see the usage example."""
return complex(*self.points[0, :2])
def set_value(self, z):
+ """Sets a new complex value to the ComplexValueTracker"""
z = complex(z)
self.points[0, :2] = (z.real, z.imag)
return self
diff --git a/tests/test_value_tracker.py b/tests/test_value_tracker.py
index 1f6793b76..0c0f5d656 100644
--- a/tests/test_value_tracker.py
+++ b/tests/test_value_tracker.py
@@ -1,4 +1,5 @@
-from manim.mobject.value_tracker import ValueTracker
+from manim.mobject.geometry import Dot
+from manim.mobject.value_tracker import ComplexValueTracker, ValueTracker
def test_value_tracker_set_value():
@@ -14,6 +15,14 @@ def test_value_tracker_get_value():
assert tracker.get_value() == 10.0
+def test_value_tracker_interpolate():
+ """Test ValueTracker.interpolate()"""
+ tracker1 = ValueTracker(1.0)
+ tracker2 = ValueTracker(2.5)
+ tracker3 = ValueTracker().interpolate(tracker1, tracker2, 0.7)
+ assert tracker3.get_value() == 2.05
+
+
def test_value_tracker_increment_value():
"""Test ValueTracker.increment_value()"""
tracker = ValueTracker(0.0)
@@ -21,6 +30,14 @@ def test_value_tracker_increment_value():
assert tracker.get_value() == 10.0
+def test_value_tracker_bool():
+ """Test ValueTracker.__bool__()"""
+ tracker = ValueTracker(0.0)
+ assert not tracker
+ tracker.increment_value(1.0)
+ assert tracker
+
+
def test_value_tracker_iadd():
"""Test ValueTracker.__iadd__()"""
tracker = ValueTracker(0.0)
@@ -28,8 +45,56 @@ def test_value_tracker_iadd():
assert tracker.get_value() == 10.0
+def test_value_tracker_ifloordiv():
+ """Test ValueTracker.__ifloordiv__()"""
+ tracker = ValueTracker(5.0)
+ tracker //= 2.0
+ assert tracker.get_value() == 2.0
+
+
+def test_value_tracker_imod():
+ """Test ValueTracker.__imod__()"""
+ tracker = ValueTracker(20.0)
+ tracker %= 3.0
+ assert tracker.get_value() == 2.0
+
+
+def test_value_tracker_imul():
+ """Test ValueTracker.__imul__()"""
+ tracker = ValueTracker(3.0)
+ tracker *= 4.0
+ assert tracker.get_value() == 12.0
+
+
+def test_value_tracker_ipow():
+ """Test ValueTracker.__ipow__()"""
+ tracker = ValueTracker(3.0)
+ tracker **= 3.0
+ assert tracker.get_value() == 27.0
+
+
def test_value_tracker_isub():
"""Test ValueTracker.__isub__()"""
tracker = ValueTracker(20.0)
tracker -= 10.0
assert tracker.get_value() == 10.0
+
+
+def test_value_tracker_itruediv():
+ """Test ValueTracker.__itruediv__()"""
+ tracker = ValueTracker(5.0)
+ tracker /= 2.0
+ assert tracker.get_value() == 2.5
+
+
+def test_complex_value_tracker_set_value():
+ """Test ComplexValueTracker.set_value()"""
+ tracker = ComplexValueTracker()
+ tracker.set_value(1 + 2j)
+ assert tracker.get_value() == 1 + 2j
+
+
+def test_complex_value_tracker_get_value():
+ """Test ComplexValueTracker.get_value()"""
+ tracker = ComplexValueTracker(2.0 - 3.0j)
+ assert tracker.get_value() == 2.0 - 3.0j