allowing NaN in FunctionGraph() and Axes.plot()

[uwezi]

When plotting functions which might exceed the vertical range of a FunctionGraph() or Axes.plot() there is currently no way to clip the function graph. In matplotlib this can be achieved by returning function values in the form of float("nan") or numpy.nan, in Manim this currently results in an error message.

As an example from the Discord discussions - it would be nice if code like this would work:

class FunctionLesson(Scene):
    def construct(self):
        ax = Axes(x_range = [-7, 7], y_range = [-8, 8]).add_coordinates()
        g = ax.plot(lambda x: np.log(x**2+3*x+2) if x < -2 or x >-1 else float("nan"), x_range=[-7, +7,0.001], dt=0.001, color = RED)
        label = MathTex(r'\ln(x^2+3x+2)').to_edge(UL)
        self.add(ax)
        self.play(Create(g), Write(label))
        self.wait(3)

[MrDiver]

You have two options for that, either if your function has varying different sizes of unreachable states just make them in to a group and split up the function parts that you can plot.

        g = VGroup(
            ax.plot(
                f,
                x_range=[-7, -2.01, 0.001],
                dt=0.001,
                color=RED,
            ),
            ax.plot(
                f,
                x_range=[-0.99, 7, 0.001],
                dt=0.001,
                color=RED,
            ),
        )

But for this example i would rather choose to explicitly name the discontinuities like follows:

class FunctionLesson(Scene):
    def construct(self):
        ax = Axes(x_range=[-7, 7], y_range=[-8, 8]).add_coordinates()
        f = lambda x: np.log(x**2 + 3 * x + 2)

        g = ax.plot(f, x_range=[-7, 7], discontinuities=[-1.5], dt=0.51, color=BLUE)

        label = MathTex(r"\ln(x^2+3x+2)").to_edge(UL)
        self.add(ax)
        self.play(Create(g), Write(label))

It would be nice to have something with Nans working but it is a little more difficult because that would need an algorithm which can calculate discontinuties on the fly. Which could be an experimental feature enabled with a named parameter but this would probably result in a lot of weird plot artifacts in some cases. So i would always prefer manually splitting.

But if you have a proposal for a robust splitting algorithm which can deal with those kinds of plots i would be happy to implement it as an experimental feature!

[uwezi]

Yes, the first method is the method I used, but this does not solve the problem that .plot() does not crop curves that are out of the screen either. So for me that means that I manually also have to split curves which are exceeding some top-values. If there was an automatism in Manim (as it is in matplotlib) to ignore/split the curves automatically at NaN values, the handling of this from my side would be to just put the function evaluation into a ternary clause x**2 if x**2 < 6 else np.NaN
I am almost at the point to write a wrapper function around .plot() which does the splitting into partitions automatically...
Alternatively I would prefer the handling of discontinuities not by giving a point, but a range in which the function should not be evaluated. Here the current way of just having one dt value is not flexible enough for me, because my functions might exceed the screen for different dt-ranges over the x-domain.

[MrDiver]

Oh yes i misunderstood your issue i suppose, so you're right that it is a simple implementation with having a ternary expression which just checks for that, but the problem is that you have a huge performance impact depending on the resolution of the function. So i would rather opt for a numpy based Solution which can filter out the values, because vectorized plotting would not be compatible with a ternary operator but more the choose function.

But i suppose we could implement the draw call such that it doesn't care about infinity and nan. Which may result in less Performance impact.