MF-Algebra 0.5.0__py3-none-any.whl

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/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/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/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/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

MF_Algebra/actions/animations.py

@@ -0,0 +1,23 @@
+from MF_Tools.transforms import TransformByGlyphMap
+
+
+
+class TransformByAddressMap(TransformByGlyphMap):
+    def __init__(self, expA, expB, *addressmap, **kwargs):
+        glyphmap = self.addressmap_to_glyphmap(expA, expB, addressmap)
+        super().__init__(expA.mob, expB.mob, *glyphmap, **kwargs)
+    
+    def addressmap_to_glyphmap(self, expA, expB, addressmap):
+        glyphmap = [
+            (
+                expA.get_glyphs(entry[0]) if isinstance(entry[0], str) else entry[0],
+                expB.get_glyphs(entry[1]) if isinstance(entry[1], str) else entry[1],
+                entry[2] if len(entry) > 2 else {}
+            )
+            for entry in addressmap
+        ]
+        return glyphmap
+
+
+
+

MF_Algebra/actions/combinations.py

@@ -0,0 +1,72 @@
+from .action_core import *
+
+
+class ParallelAction(Action):
+    def __init__(self, *actions, **kwargs):
+        self.actions = actions
+        super().__init__(**kwargs)
+    
+    def get_output_expression(self, input_expression=None):
+        expr = input_expression
+        for action in self.actions:
+            expr = action.get_output_expression(expr)
+        return expr
+    
+    def get_addressmap(self, input_expression=None):
+        return sum([action.get_addressmap(input_expression) for action in self.actions], [])
+    
+    def __or__(self, other):
+        if isinstance(other, ParallelAction):
+            return ParallelAction(*self.actions, *other.actions)
+        elif isinstance(other, Action):
+            return ParallelAction(*self.actions, other)
+        else:
+            raise ValueError("Can only use | with other ParallelAction or Action")
+    
+    def __ror__(self, other):
+        if isinstance(other, Action):
+            return ParallelAction(other, *self.actions)
+        else:
+            return NotImplemented
+
+
+
+class SequentialAction(Action):
+    def __init__(self, *actions, **kwargs):
+        self.actions = list(actions)
+        super().__init__(**kwargs)
+    
+    def get_output_expression(self, input_expression=None):
+        expr = input_expression
+        for action in self.actions:
+            expr = action.get_output_expression(expr)
+        return expr
+
+    def get_animations(self):
+        return [action.get_animation() for action in self.actions]
+    
+    def get_animation(self, i):
+        return self.actions[i].get_animation()
+        
+    def __rshift__(self, other):
+        if isinstance(other, SequentialAction):
+            return SequentialAction(*self.actions, *other.actions)
+        elif isinstance(other, Action):
+            return SequentialAction(*self.actions, other)
+        else:
+            return ValueError("Can only use >> with other SequentialAction or Action")
+    
+    def __rrshift__(self, other):
+        if isinstance(other, SequentialAction):
+            return SequentialAction(*other.actions, *self.actions)
+        elif isinstance(other, Action):
+            return SequentialAction(other, *self.actions)
+        else:
+            return ValueError("Can only use >> with other SequentialAction or Action")
+    
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            return self.actions[key]
+        elif isinstance(key, slice):
+            return SequentialAction(*self.actions[key])
+

MF_Algebra/expressions/__init__.py

@@ -0,0 +1,8 @@
+from .expression_core import *
+from .operations import *
+from .numbers import *
+from .variables import *
+from .functions import *
+from .sequences import *
+from .relations import *
+from .expression_common import *