Transform two functions into one, Review

[erwindenboer]

I have asked a question on Stack overflow. Unfortunatly, I haven't received any reaction whatsoever. I hope There are people here that can help me.

I want to use Manim to explain Amplitude Modulation. I have produced the following code:

from manim import *

 class SomeAnimations(Scene):
 def construct(self):

    cos_func = FunctionGraph(
       lambda t: np.cos(2 * t)+2.5,
       color=RED,
    )

    sin_func_1 = FunctionGraph(
        lambda t: np.sin(14 * t)-2.5,
        color=BLUE,
    )

    cos_sin_func_1 = FunctionGraph(
        lambda t: np.sin(14 * t) * np.cos(2*t) + np.sin(14 * t),
        color=ORANGE,
    )

   self.add(cos_func, sin_func_1)
   self.wait(1)
   self.play(Transform(cos_func, cos_sin_func_1), Transform(sin_func_1, cos_sin_func_1))
   self.wait(1)

As can be seen in the code, I use two different Transform classes. I was wondering if this can be narrowed down to one Transform class. Also, I want to know if instead of defining another Functiongraph there is another way to get the AM signal. I have tried to use the following code:

self.play(Transform(cos_func, (sin_func_1 * cos_func + cos_func)))

However, the compiler gives the following error:

TypeError: unsupported operand type(s) for *: 'FunctionGraph' and 'FunctionGraph'

I hope someone can give me feedback on this.

Thank you

[WampyCakes]

My bad. I thought that this issue was a PR (didn't realize I had clicked the issues tab). Though this is still a fine place to get an answer (perhaps better suited toward q&a).

[erwindenboer]

@WampyCakes Thank you, I didn't know there was a discussions tab. This is indeed a better place to get my answer.

[behackl]

Hey! As for your first question, you could do something like Transform(VGroup(cos_func, sin_func_1), cos_sin_func_1), which is a bit cleaner because you don't end up with two copies of cos_sin_func_1 in your scene. (But that's a technical detail and shouldn't matter much in practice.)

And as for your second question: What output do you expect to get from sin_func_1 * cos_func + cos_func? The graph corresponding to the function that is obtained by multiplying/adding the respective functions? Direct operations on the FunctionGraphs are currently not supported, as you have already found out.

[erwindenboer]

Thanks for your fast response. As you say, I already found out that the graphs can't be multiplied/added. What I expected from the sin_func_1 * cos_func + cos_func is that by doing so, I won't have to declare the graph called cos_sin_func_1.

Your first answer to my question helps solve a bit for maintainability. However, I still have to declare a separate graph for the multiplication. That is not the biggest problem. The biggest problem is that I have to type the same formula two times. One for its own graph and one for the multiplication. This is true for cos_func and sin_func_1. Is there a way where I can declare the
cos_sin_func_1 = FunctionGraph( lambda t: np.sin(14 * t) * np.cos(2*t) + np.sin(14 * t), color=ORANGE,)
into the following:
cos_sin_func_1 = FunctionGraph( lambda t: sin_func_1 *cos_func + sin_func_1, color=ORANGE,)

[behackl]

Does that even fit mathematically? In your example above, sin_func_1 is sin(14t) - 2.5, and cos_func is cos(2t) + 2.5; that doesn't really fit to np.sin(14 * t) * np.cos(2*t) + np.sin(14 * t).

Anyhow, we might add combination of plots graphs at some point, but for now I'd go for something along these lines:

f1 = lambda t: np.sin(14*t) - 2.5
f2 = lambda t: np.cos(2*t) + 2.5
f_product = lambda t: f1(t) * (1 + f2(t))

f1_graph = FunctionGraph(f1, color=RED)
f2_graph = FunctionGraph(f2, color=BLUE)
f_product_graph = FunctionGraph(f_product, color=ORANGE)

[erwindenboer]

The + and - components are used to split the two graphs into an upper and lower part. They are there just for an offset for better visibility. You're right that it doesn't fit mathematically. But that is not the objective here. Maybe you can also give me an example how to split those graphs better without including it in the mathematics.

Your suggestion with the two separate lambda functions is great. Thank you! I will use that in my code!

[behackl]

Function graphs can be positioned like any other object; if the y-axis doesn't really matter to you, then you could just f1_graph.shift(2*UP) etc -- or arrange all of them vertically, as VGroup(f1_graph, f2_graph, f_product_graph).arrange(DOWN).

There are lots of ways to do this though; have a look at the documentation and work with whatever feels most natural to you.

[erwindenboer]

Thanks for all your suggestions! You have helped me a lot!