MF-Algebra 0.5.0__tar.gz

mf_algebra-0.5.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.3
+Name: MF-Algebra
+Version: 0.5.0
+Summary: Manim plugin which aims to make it much easier to meaningfully transform algebra expressions.
+License: None
+Author: John Connell
+Author-email: johnconnelltutor@gmail.com
+Requires-Python: >=3.8
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: manimce
+Provides-Extra: manimgl
+Requires-Dist: MF_Tools (>=1.3.3)
+Requires-Dist: manim (>=0.17.0) ; extra == "manimce"
+Requires-Dist: manimgl (>=1.7.0) ; extra == "manimgl"
+Project-URL: Repository, https://github.com/TheMathematicFanatic/MF_Algebra
+Description-Content-Type: text/markdown
+
+## Introduction
+
+This is a ManimGL / ManimCE plugin (**still under construction**) for the automated animation of algebra. It consists of a few key components: 
+- Expression: These objects contain a tree structure representing algebra expressions/equations, such as `3x^2`, `5+9`, and `sin(y)=14e^x`, as well as a method for producing a corresponding Tex/MathTex mobject.
+- Action: These objects contain methods to convert between expressions/equations, such as adding something to both sides, or substituting a variable for a value. This conversion can be static or animated.
+- Timeline: These objects contain an alternating sequence of expressions and actions, and methods for automatically determining these sequences, and animating them.
+
+
+## Expression
+
+There are many subclasses of Expression:
+```
+Expression
+├── Variable
+├── Number
+│   ├── Integer
+│   └── Real
+├── Combiner
+│   ├── Operation
+│   │   ├── Add
+│   │   ├── Sub
+│   │   ├── Mul
+│   │   ├── Div
+│   │   └── Pow
+│   ├── Relation
+│   │   ├── Equation
+│   │   ├── LessThan
+│   │   ├── ...
+│   └── Sequence
+├── Function
+└── Negative
+```
+Every Expression contains an attribute called children, which is a list. Sometimes this list is empty, such as for variables and numbers. But often this list contains other Expressions, such as for operations and functions.
+
+
+
+
+
+
+
+
+
+
+
+
+

mf_algebra-0.5.0/README.md

@@ -0,0 +1,45 @@
+## Introduction
+
+This is a ManimGL / ManimCE plugin (**still under construction**) for the automated animation of algebra. It consists of a few key components: 
+- Expression: These objects contain a tree structure representing algebra expressions/equations, such as `3x^2`, `5+9`, and `sin(y)=14e^x`, as well as a method for producing a corresponding Tex/MathTex mobject.
+- Action: These objects contain methods to convert between expressions/equations, such as adding something to both sides, or substituting a variable for a value. This conversion can be static or animated.
+- Timeline: These objects contain an alternating sequence of expressions and actions, and methods for automatically determining these sequences, and animating them.
+
+
+## Expression
+
+There are many subclasses of Expression:
+```
+Expression
+├── Variable
+├── Number
+│   ├── Integer
+│   └── Real
+├── Combiner
+│   ├── Operation
+│   │   ├── Add
+│   │   ├── Sub
+│   │   ├── Mul
+│   │   ├── Div
+│   │   └── Pow
+│   ├── Relation
+│   │   ├── Equation
+│   │   ├── LessThan
+│   │   ├── ...
+│   └── Sequence
+├── Function
+└── Negative
+```
+Every Expression contains an attribute called children, which is a list. Sometimes this list is empty, such as for variables and numbers. But often this list contains other Expressions, such as for operations and functions.
+
+
+
+
+
+
+
+
+
+
+
+

mf_algebra-0.5.0/pyproject.toml

@@ -0,0 +1,32 @@
+[tool.poetry]
+name = "MF-Algebra"
+version = "0.5.0"
+description = "Manim plugin which aims to make it much easier to meaningfully transform algebra expressions."
+authors = ["John Connell <johnconnelltutor@gmail.com>"]
+license = "None"
+repository = "https://github.com/TheMathematicFanatic/MF_Algebra"
+readme = "README.md"
+
+packages = [
+  { include = "MF_Algebra", from = "src" }
+]
+
+[tool.poetry.dependencies]
+python = ">=3.8"
+MF_Tools = ">=1.3.3"
+manim = { version = ">=0.17.0", optional = true }
+manimgl = { version = ">=1.7.0", optional = true }
+
+[tool.poetry.extras]
+manimce = ["manim"]
+manimgl = ["manimgl"]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+filterwarnings = [
+    "ignore::DeprecationWarning"
+]

mf_algebra-0.5.0/src/MF_Algebra/__init__.py

@@ -0,0 +1,7 @@
+__version__ = '0.5.0'
+__author__ = 'John Connell - The Mathematic Fanatic'
+__description__ = 'Manim plugin which aims to make it much easier to meaningfully transform algebra expressions.'
+
+from .expressions import *
+from .actions import *
+from .timelines import *

mf_algebra-0.5.0/src/MF_Algebra/actions/__init__.py

@@ -0,0 +1,5 @@
+from .action_core import *
+from .animations import *
+from .action_variants import *
+from .combinations import *
+from .action_common import *

mf_algebra-0.5.0/src/MF_Algebra/actions/action_common.py

@@ -0,0 +1,249 @@
+from .action_core import *
+from .action_variants import *
+from .combinations import *
+from ..expressions.operations import *
+from ..expressions.variables import *
+from ..expressions.relations import *
+from MF_Tools.dual_compatibility import PI, FadeIn
+
+
+class swap_children_(Action):
+    def __init__(self, preaddress='', mode="arc", arc_size=0.75*PI, **kwargs):
+        self.mode = mode
+        self.arc_size = arc_size
+        super().__init__(preaddress=preaddress,**kwargs)
+    
+    @preaddressfunc
+    def get_output_expression(self, input_expression=None):
+        assert len(input_expression.children) == 2, f"Cannot swap children of {input_expression}, must have two children."
+        return type(input_expression)(input_expression.children[1], input_expression.children[0])
+
+    @preaddressmap
+    def get_addressmap(self, input_expression=None):
+        if self.mode == "arc":
+            return [
+                ["0", "1", {"path_arc": self.arc_size}],
+                ["1", "0", {"path_arc": self.arc_size}]
+            ]
+        elif self.mode == "straight":
+            return [
+                ["0", "1"],
+                ["1", "0"]
+            ]
+        else:
+            raise ValueError(f"Invalid mode: {self.mode}. Must be 'arc' or 'straight'.")
+
+
+class apply_operation_(Action):
+    def __init__(self, OpClass, other, preaddress='', side="right", introducer=Write, **kwargs):
+        self.OpClass = OpClass
+        self.other = Smarten(other)
+        self.side = side
+        self.introducer = introducer
+        super().__init__(preaddress=preaddress,**kwargs)
+    
+    @preaddressfunc
+    def get_output_expression(self, input_expression):
+        if self.side == "right":
+            output_expression = self.OpClass(input_expression, self.other) # Putting a .copy() on the input expression fixes the problem. Try to understand this and then probably fold this into the decorator
+        elif self.side == "left":
+            output_expression = self.OpClass(self.other, input_expression)
+        else:
+            raise ValueError(f"Invalid side: {self.side}. Must be left or right.")
+        return output_expression
+
+    @preaddressmap
+    def get_addressmap(self, input_expression):
+        if self.side == "right":
+            return [
+                ["", "0"],
+                [self.introducer, "+", {"delay":0.5}],
+                [self.introducer, "1", {"delay":0.6}]
+            ]
+        elif self.side == "left":
+            return [
+                ["", "1"],
+                [self.introducer, "0", {"delay":0.5}],
+                [self.introducer, "+", {"delay":0.6}]
+            ]
+        else:
+            raise ValueError(f"Invalid side: {self.side}. Must be left or right.")
+    
+    def __repr__(self):
+        return type(self).__name__ + "(" + str(self.other) + ',' + self.preaddress + ")"
+
+class add_(apply_operation_):
+    def __init__(self, other, *args, **kwargs):
+        super().__init__(Add, other, *args, **kwargs)
+
+class sub_(apply_operation_):
+    def __init__(self, other, *args, **kwargs):
+        super().__init__(Sub, other, *args, **kwargs)
+
+class mul_(apply_operation_):
+    def __init__(self, other, *args, **kwargs):
+        super().__init__(Mul, other, *args, **kwargs)
+
+class div_(apply_operation_):
+    def __init__(self, other, *args, **kwargs):
+        super().__init__(Div, other, *args, **kwargs)
+
+class pow_(apply_operation_):
+    def __init__(self, other, *args, **kwargs):
+        super().__init__(Pow, other, *args, **kwargs)
+
+class equals_(apply_operation_):
+    def __init__(self, other, *args, **kwargs):
+        super().__init__(Equation, other, *args, **kwargs)
+
+
+class substitute_(Action):
+    def __init__(self, sub_dict, preaddress='', mode="transform", arc_size=PI, fade_shift=DOWN*0.2, lag=0, **kwargs):
+        self.sub_dict = sub_dict
+        self.preaddress = preaddress
+        self.mode = mode
+        self.arc_size = arc_size
+        self.fade_shift = fade_shift
+        self.lag = lag #usually looks like shit but can be cool sometimes
+        super().__init__(preaddress=preaddress,**kwargs)
+    
+    @preaddressfunc
+    def get_output_expression(self, input_expression=None):
+        return input_expression.substitute(self.sub_dict)
+
+    @preaddressmap
+    def get_addressmap(self, input_expression=None):
+        target_addresses = []
+        for var in self.sub_dict:
+            target_addresses += input_expression.get_subex(self.preaddress).get_addresses_of_subex(var)
+        addressmap = []
+        if self.mode == "transform":
+            for i,ad in enumerate(target_addresses):
+                addressmap.append([ad, ad, {"delay": self.lag*i}])
+            return addressmap
+        elif self.mode == "swirl":
+            for i,ad in enumerate(target_addresses):
+                addressmap.append([ad, ad, {"path_arc": self.arc_size, "delay": self.lag*i}])
+            return addressmap
+        elif self.mode == "fade":
+            for i,ad in enumerate(target_addresses):
+                addressmap.append([ad, FadeOut, {"shift": self.fade_shift, "delay": self.lag*i}])
+                addressmap.append([FadeIn, ad, {"shift": self.fade_shift, "delay": self.lag*i}])
+            return addressmap
+        
+    def __repr__(self):
+        return type(self).__name__ + "(" + str(self.sub_dict) + (',' + self.preaddress if self.preaddress else '') + ")"
+
+
+class substitute_into_(Action):
+    def __init__(self, outer_expression, substitution_variable=Variable('x'), **kwargs):
+        self.outer_expression = outer_expression
+        self.substitution_variable = substitution_variable
+        super().__init__(**kwargs)
+    
+    @preaddressfunc
+    def get_output_expression(self, input_expression=None):
+        return self.outer_expression.substitute({self.substitution_variable: input_expression})
+    
+    @preaddressmap
+    def get_addressmap(self, input_expression=None):
+        addressmap = []
+        sub_into_addresses = self.outer_expression.get_addresses_of_subex(self.substitution_variable)
+        for ad in sub_into_addresses:
+            if not input_expression.parentheses:
+                ad = ad + "_"
+            addressmap.append(['', ad])
+        return addressmap
+    
+    def get_animation(self, *args, **kwargs):
+        return super().get_animation(*args, auto_fade=True, auto_resolve_delay=0.75, **kwargs)
+
+
+class evaluate_(Action):
+    def __init__(self, preaddress='', mode="random leaf", **kwargs):
+        super().__init__(preaddress=preaddress,**kwargs)
+        # if mode == "random leaf":
+        #     leaf_addresses = input_expression.get_all_leaf_addresses()
+        #     leaf_address = np.random.choice(leaves)
+        #     self.preaddress = leaf_address
+
+    @preaddressfunc
+    def get_output_expression(self, input_expression=None):
+        return input_expression.evaluate()
+    
+    @preaddressmap
+    def get_addressmap(self, input_expression=None):
+        return [
+            ["", ""] #extension by preaddress is done by decorator!
+        ]
+    
+
+class distribute_(Action):
+       # Not done yet, multilayer does not work... this is so necessary but rather nontrivial... hm...
+    def __init__(self, preaddress='', mode="auto", multilayer=False, **kwargs):
+        self.mode = mode #"auto", "left", "right"
+        super().__init__(preaddress=preaddress,**kwargs)
+    
+    @preaddressfunc
+    def get_output_expression(self, input_expression=None):
+        if self.mode == "auto":
+            self.determine_direction(input_expression)
+        if self.mode == "left":
+            new_children = [
+                type(input_expression)(input_expression.children[0], child)
+                for child in input_expression.children[-1].children
+                ]
+            return type(input_expression.children[-1])(*new_children)
+        elif self.mode == "right":
+            new_children = [
+                type(input_expression)(child, input_expression.children[-1])
+                for child in input_expression.children[0].children
+                ]
+            return type(input_expression.children[0])(*new_children)
+
+    def determine_direction(self, input_expression=None):
+        if self.mode == "auto":
+            if isinstance(input_expression, Mul):
+                left_distributable = isinstance(input_expression.children[-1], (Add, Sub))
+                right_distributable = isinstance(input_expression.children[0], (Add, Sub))
+                if left_distributable and right_distributable:
+                    raise ValueError("Cannot auto-distribute if both sides are distributable, please set mode manually.")
+                elif left_distributable:
+                    self.mode = "left"
+                elif right_distributable:
+                    self.mode = "right"
+                else:
+                    raise ValueError("Cannot distribute, neither side is distributable.")
+            elif isinstance(input_expression, Div):
+                right_distributable = isinstance(input_expression.children[0], (Add, Sub))
+                if right_distributable:
+                    self.mode = "right"
+                else:
+                    raise ValueError("Cannot distribute, right side is not distributable.")
+            elif isinstance(input_expression, Pow):
+                right_distributable = isinstance(input_expression.children[0], (Mul, Div))
+                if right_distributable:
+                    self.mode = "right"
+                else:
+                    raise ValueError("Cannot distribute, right side is not distributable.")
+            else:
+                raise ValueError("Cannot auto-distribute, must be a multiplication or division.")
+
+    @preaddressmap
+    def get_addressmap(self, input_expression=None):
+        return [
+            ["", ""] #standin idk what the fuck im doing here
+        ]
+
+
+
+
+
+
+from .action_variants import AlgebraicAction
+a = Variable('a')
+b = Variable('b')
+c = Variable('c')
+
+square_binomial_ = AlgebraicAction((a+b)**2, a**2 + 2*a*b + b**2)
+

mf_algebra-0.5.0/src/MF_Algebra/actions/action_core.py

@@ -0,0 +1,186 @@
+# actions.py
+from MF_Tools.dual_compatibility import Write, FadeOut
+from ..expressions.expression_core import *
+from ..utils import *
+from .animations import TransformByAddressMap
+
+
+class Action:
+	"""
+		Transforms Expressions into other Expressions,
+		both as static objects and also with an animation.
+
+		An action is defined by two main things:
+		the get_output_expression method, which controls how it acts on static expressions,
+		and the get_addressmap method, which controls how it acts as an animation.
+		Both set attributes of the corresponding name and return them.
+
+		It may also have a preaddress parameter/attribute which will determine the subexpression
+		address at which the action is applied, and a few other attributes which may adjust some
+		specifics.
+
+		self.input_expression is set to None during __init__. It is critical that actions
+		can exist prior to being given expressions, so that they can be combined together.
+		When an input expression is received, this attribute is set, and the method
+		.get_output_expression is called, setting self.output_expression.
+		This is all that is required for static actions, no animations.
+
+		Now, to create the animation between these expressions:
+
+		get_addressmap is also unique to each action, and returns something like
+		[
+			["00", "01"],
+			["01", "00", {"path_arc":PI/2}],
+			[FadeIn, "1"],
+			["1", FadeOut]
+		]
+		which contains all the expression-agnostic information about the animation.
+		Often this will simply define and return this list with no computation.
+
+		get_glyphmap combines the input_expression, output_expression, and addressmap
+		to create a list like
+		[
+			([0,1,2], [5,6]),
+			([3,4,5], [1,2,3], {"path_arc":PI/2}),
+			(FadeIn, [8,9]),
+			([6], FadeOut)
+		]
+		which tells which glyphs of the mobjects to send to which others, and how.
+
+		get_animation then simply parses this glyphmap list to create a list of
+		animations, probably to be passed to AnimationGroup, like
+		[
+			ReplacementTransform(A[0][0,1,2], B[0][5,6]),
+			ReplacementTransform(A[0][3,4,5], B[0][1,2,3], path_arc=PI/2),
+			FadeIn(B[0][8,9]),
+			FadeOut(A[0][6]),
+			...
+		]
+		or something like that, the syntax is partially made up. The ... is
+		ReplacementTransforms of all the individual glyphs not mentioned in the glyphmap,
+		whose lengths have to exactly match.
+
+		Broadly speaking, that's that!
+	"""
+	def __init__(self,
+		introducer=Write,
+		remover=FadeOut,
+		preaddress=''
+	):
+		self.introducer = introducer
+		self.remover = remover
+		self.preaddress = preaddress
+
+	def get_output_expression(self, input_expression):
+  		# define in subclasses and decorate with @preaddressfunc
+		raise NotImplementedError
+
+	def get_addressmap(self, input_expression, **kwargs):
+		# define in subclasses and decorate with @preaddressmap
+		raise NotImplementedError
+
+	def get_animation(self, **kwargs):
+		def animation(input_exp, output_exp=None):
+			if output_exp is None:
+				output_exp = self.get_output_expression(input_exp)
+			return TransformByAddressMap(
+			input_exp,
+			output_exp,
+			*self.get_addressmap(input_exp),
+			default_introducer=self.introducer,
+			default_remover=self.remover,
+			**kwargs
+			)
+		return animation
+	
+	def __call__(self, expr1, expr2=None, **kwargs):
+		return self.get_animation(**kwargs)(expr1, expr2)
+
+	def __or__(self, other):
+		from .combinations import ParallelAction
+		if isinstance(other, ParallelAction):
+			return ParallelAction(self, *other.actions)
+		elif isinstance(other, Action):
+			return ParallelAction(self, other)
+		else:
+			raise ValueError("Can only use | with other ParallelAction or Action")
+	
+	def __rshift__(self, other):
+		other = Smarten(other)
+		from ..expressions.expression_core import Expression
+		from ..timelines.timeline_core import Timeline
+		if isinstance(other, Expression):
+			timeline = Timeline()
+			timeline.add_action_to_end(self).add_expression_to_end(other)
+			return timeline
+		elif isinstance(other, Action):
+			timeline = Timeline()
+			timeline.add_action_to_end(self).add_action_to_end(other)
+			return timeline
+		else:
+			return NotImplemented
+
+	def __rrshift__(self, other):
+		return Smarten(other).__rshift__(self)
+	
+	def __repr__(self):
+		return type(self).__name__ + "(" + self.preaddress + ")"
+	
+	def copy(self):
+		return deepcopy(self)
+	
+	@property
+	def both(self, number_of_sides=2):
+		# Intended to turn an action on an expression into an action done to both sides of an equation.
+		# Can be passed a number to apply to more than 2 sides for, say, a triple equation or inequality.
+		from .combinations import ParallelAction
+		actions = []
+		for i in range(number_of_sides):
+			action = self.copy()
+			action.preaddress = action.preaddress + str(i)
+			actions.append(action)
+		return ParallelAction(*actions)
+
+
+
+def preaddressfunc(func):
+	def wrapper(action, expr, *args, **kwargs):
+		expr = expr.copy()
+		preaddress = kwargs.get('preaddress', '') or action.preaddress
+		if len(preaddress)==0:
+			output_expression = func(action, expr)
+		else:
+			active_part = expr.get_subex(preaddress)
+			result = func(action, active_part)
+			output_expression = expr.substitute_at_address(result, preaddress)
+		output_expression.reset_parentheses()
+		return output_expression
+	return wrapper
+
+def preaddressmap(getmap):
+	def wrapper(action, expr, *args, **kwargs):
+		expr = expr.copy()
+		preaddress = kwargs.get('preaddress', '') or action.preaddress
+		addressmap = getmap(action, expr, *args, **kwargs)
+		if preaddress:
+			for entry in addressmap:
+				for i, ad in enumerate(entry):
+					if isinstance(ad, str):
+						entry[i] = preaddress + ad
+		return addressmap
+	return wrapper
+
+
+class IncompatibleExpression(Exception):
+	pass
+
+
+
+
+
+  
+
+
+
+
+ 

mf_algebra-0.5.0/src/MF_Algebra/actions/action_variants.py

@@ -0,0 +1,97 @@
+from .action_core import *
+from MF_Tools.dual_compatibility import AnimationGroup
+from MF_Tools import TransformByGlyphMap
+
+
+class AlgebraicAction(Action):
+    def __init__(self, template1, template2, var_kwarg_dict={}, **kwargs):
+        super().__init__(**kwargs)
+        self.template1 = template1
+        self.template2 = template2
+        self.var_kwarg_dict = var_kwarg_dict #{a:{"path_arc":PI}}
+    
+    def get_output_expression(self, input_expression=None):
+        var_dict = match_expressions(self.template1, input_expression)
+        return self.template2.substitute(var_dict)
+    
+    def get_addressmap(self, input_expression=None):
+        addressmap = []
+        def get_var_ad_dict(template):
+            template_leaves = {
+                template.get_subex(ad)
+                for ad in input_expression.get_all_leaf_addresses()
+                }
+            from ..expressions.variables import Variable
+            variables = [var for var in template_leaves if isinstance(var, Variable)]
+            return {var: template.get_addresses_of_subex(var) for var in variables}
+        self.template1_address_dict = get_var_ad_dict(self.template1)
+        self.template2_address_dict = get_var_ad_dict(self.template2)
+        variables = self.template1_address_dict.keys() | self.template2_address_dict.keys()
+        for var in variables:
+            kwargs = self.var_kwarg_dict.get(var, {})
+            if len(self.template1_address_dict[var]) == 1:
+                addressmap += [[self.template1_address_dict[var][0], t2ad, kwargs] for t2ad in self.template2_address_dict[var]]
+            elif len(self.template2_address_dict[var]) == 1:
+                addressmap += [[t1ad, self.template2_address_dict[var][0], kwargs] for t1ad in self.template1_address_dict[var]]
+            else:
+                raise ValueError("I don't know what to do when a variable appears more than once on both sides. Please set addressmap manually.")
+        return addressmap
+
+
+class AddressMapAction(Action):
+    def __init__(self, *address_map, extra_animations=[], **kwargs):
+        super().__init__(**kwargs)
+        self.address_map = address_map
+        self.extra_animations = extra_animations
+    
+    def get_animation(self, **kwargs):
+        def animation(input_exp, output_exp=None):
+            if output_exp is None:
+                output_exp = self.get_output_expression(input_exp)
+            return AnimationGroup(
+                TransformByAddressMap(
+                    input_exp,
+                    output_exp,
+                    *self.address_map,
+                    **kwargs
+                ),
+                *self.extra_animations
+            )
+        return animation
+
+
+class GlyphMapAction(Action):
+    def __init__(self, *glyph_map, extra_animations=[], show_indices=False, **kwargs):
+        super().__init__(**kwargs)
+        self.glyph_map = glyph_map
+        self.extra_animations = extra_animations
+        self.show_indices = show_indices
+    
+    def get_animation(self, **kwargs):
+        def animation(input_exp, output_exp=None):
+            if output_exp is None:
+                output_exp = self.get_output_expression(input_exp)
+            return AnimationGroup(
+                TransformByGlyphMap(
+                    input_exp.mob,
+                    output_exp.mob,
+                    *self.glyph_map,
+                    show_indices = self.show_indices,
+                    **kwargs
+                ),
+                *self.extra_animations
+            )
+        return animation
+
+
+class AnimationAction(Action):
+    def __init__(self, animation, **kwargs):
+        super().__init__(**kwargs)
+        self.animation = animation # callable on two mobjects
+    
+    def get_animation(self, **kwargs):
+        def animation(self, input_exp, output_exp=None):
+            if output_exp is None:
+                output_exp = self.get_output_expression(input_exp)
+            return self.animation(input_exp.mob, output_exp.mob, **kwargs)
+        return animation