A weird bug about ArrowVectorField

[argb]

Description of bug / unexpected behavior

Expected behavior

This is a bug.

How to reproduce the issue

class BasicVectorFieldUsage(Scene):
    def construct(self):
        av = ArrowVectorField(lambda pos: pos)
        self.add(av)

this code don't work

change "lambda pos: pos" to "lambda pos: pos*1", then it works.

I can't find the reason.

Code for reproducing the problem

Paste your code here.

Additional media files

Images/GIFs

Logs

Terminal output

PASTE HERE OR PROVIDE LINK TO https://pastebin.com/ OR SIMILAR

System specifications

System Details

• OS (with version, e.g., Windows 10 v2004 or macOS 10.15 (Catalina)):
• RAM:
• Python version (python/py/python3 --version):
• Installed modules (provide output from pip list):

PASTE HERE

LaTeX details

• LaTeX distribution (e.g. TeX Live 2020):
• Installed LaTeX packages:

FFMPEG

Output of ffmpeg -version:

PASTE HERE

Additional comments

[uwezi]

I would not necessarily call it a bug, since it seems to be outside of Manim's influence and controlled by the behavior of python when it comes to lambda functions....

[Ben-Taarit]

I would not necessarily call it a bug, since it seems to be outside of Manim's influence and controlled by the behavior of python when it comes to lambda functions....

I've zero experience with Manim (just started looking at it today), but what your comment suggests is that Python Lambda functions are buggy (really..😒)
@argb, could you please provide a minimal reproducible example

[uwezi]

OK, I had a look into the source code and I found the cause for the observed behavior:

        output = np.asarray(self.func(point))
        norm = np.linalg.norm(output)
        if norm != 0:
            output *= self.length_func(norm) / norm
        vect = Vector(output, **self.vector_config)
        vect.shift(point)

obviously it is the vect.shift(point) operation which fails, since all vectors are still located close to the origin in the case of ArrowVectorField(lambda pos : pos):

Why is this the case?
The argument of the function evaluated in the ArrowVectorField is a numpy ndarray with all points. The function is supposed to calculate a direction of the vector field at all these points. However, the function lambda pos: pos returns not a new, calculated value for each element in the list, it just returns the list/ndarray object itself.

So from that stage on output and point link to the same object in memory, the original list of all coordinate points.

In the next step the lengths of all vectors is supposed to be normalized, so that everything fits nicely onto the screen. However, since output and point refer to the very same list, now also the point coordinates themselves are normalized and all vectors end up in a circle with radius 1 around the origin.

So, yes, the cause of the problem is the behavior of the python lambda function, returning the same object if asked for it pos=pos rather than creating a new list of new values.

It would be quite easy to circumvent this behavior with a minor change in the source code, by just adding the multiplication by 1 fix into the source code:

        output = 1 * np.asarray(self.func(point))
        norm = np.linalg.norm(output)

[chopan050]

Another solution might be using np.array instead of np.asarray.
np.array by default copies the values of its argument into a new ndarray, although this behavior can be modified with the copy parameter.
np.asarray is essentially a call to np.array with copy=False. This is useful when you want to avoid unnecessary copying if the argument was already a NumPy array... although, as you can see, this is not what you want here at all.

This should work:

        output = np.array(self.func(point))
        norm = np.linalg.norm(output)

[behackl]

Fixed via #3282