From 66cbc413aa8cd45db7f3167d53d21d13427e0c1b Mon Sep 17 00:00:00 2001 From: Somnath Pandit Date: Wed, 17 Jun 2020 23:45:18 +0530 Subject: update --- .../file2_grad_of_scalar_function.gif | Bin 0 -> 6913246 bytes .../vector-fields/file2_grad_of_scalar_function.py | 320 +++++++++++++++++++++ 2 files changed, 320 insertions(+) create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.gif create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.py (limited to 'FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields') diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.gif new file mode 100644 index 0000000..c1ab66a Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.gif differ diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.py new file mode 100644 index 0000000..231b15c --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.py @@ -0,0 +1,320 @@ +from manimlib.imports import * + +class GradOfScalarFunc(ThreeDScene): + + CONFIG = { + "axes_config": { + "x_min": -3, + "x_max": 3, + "y_min": -3, + "y_max": 3, + "z_min": 0, + "z_max": 3, + "a":-3 ,"b": 3, "c":-3 , "d":3, + "axes_shift": ORIGIN+IN+LEFT, + "x_axis_config": { + "tick_frequency": 1, + # "include_tip": False, + }, + "y_axis_config": { + "tick_frequency": 1, + # "include_tip": False, + }, + "z_axis_config": { + "tick_frequency": 1, + # "include_tip": False, + }, + "num_axis_pieces": 1, + }, + "default_graph_style": { + "stroke_width": 2, + "stroke_color": WHITE, + }, + "default_vector_field_config": { + "delta_x": .5, + "delta_y": .5, + "x_min": -3, + "x_max": 3, + "y_min": -3, + "y_max": 3, + "min_magnitude": 0, + "max_magnitude": 2, + "colors": [BLUE,GREEN,GREEN,ORANGE,RED], + "length_func": lambda norm : .45*sigmoid(norm), + "opacity": 1.0, + "vector_config": { + "stroke_width":6 + }, + }, + "default_surface_config": { + "fill_opacity": 0.5, + "checkerboard_colors": [BLUE_D], + "stroke_width": .5, + "stroke_color": WHITE, + "stroke_opacity": 0.2, + }, + } + + + def construct(self): + + self.setup_axes() + axes=self.axes + + self.set_camera_orientation(distance=35, + phi=80 * DEGREES, + theta=-80 * DEGREES, + ) + + scalar_fn_text=TexMobject("f(x,y)=","\cos(xy)").set_color(BLUE) + scalar_fn_text.to_corner(UR,buff=.6) + + operator=TexMobject("\\vec\\nabla").next_to( + scalar_fn_text,LEFT,buff=.2 + ).set_color(GOLD) + + grad_text=TexMobject(r"\dfrac{\partial f}{\partial x} \hat i+\dfrac{\partial f}{\partial y} \hat j+\dfrac{\partial f}{\partial z} \hat k").set_color(GOLD) + grad_text.next_to(scalar_fn_text,DOWN).scale(.9) + + VGroup( + grad_text[0][1], + grad_text[0][9], + grad_text[0][17] + ).set_color(BLUE) + VGroup( + grad_text[0][5:8], + grad_text[0][13:16], + grad_text[0][21:23] + ).set_color(WHITE) + + vector_field_text=TexMobject( + r"\vec F&=-y\sin(xy)\hat i\\ &-x\sin(xy)\hat j" + ).set_color_by_gradient( + *self.default_vector_field_config["colors"] + ) + vector_field_text.next_to(scalar_fn_text,DOWN) + + + '''always generate the scalar field first''' + s_field=self.get_scalar_field( + func= lambda x ,y : np.cos(x*y/2), + dn=.25 + ) + v_field=self.get_vector_field( + lambda v: np.array([ + -(v[1]-axes.c2p(0,0,0)[1])*np.sin((v[0]-axes.c2p(0,0,0)[0])*(v[1]-axes.c2p(0,0,0)[1])), + -(v[0]-axes.c2p(0,0,0)[0])*np.sin((v[0]-axes.c2p(0,0,0)[0])*(v[1]-axes.c2p(0,0,0)[1])), + 0, + ]), + on_surface=True, + ) + + self.add_fixed_in_frame_mobjects(scalar_fn_text) + + self.begin_ambient_camera_rotation(rate=.2) + self.play(Write(s_field),run_time=2) + self.wait(4) + self.stop_ambient_camera_rotation() + + self.add_fixed_in_frame_mobjects(operator) + self.play(Write(operator),FadeOut(scalar_fn_text[1])) + self.add_fixed_in_frame_mobjects(grad_text) + self.play(Write(grad_text)) + self.wait(1.5) + + self.play(FadeOut(grad_text)) + self.add_fixed_in_frame_mobjects(vector_field_text) + show_vec_field=[ + FadeIn(v_field), + Write(vector_field_text), + ] + # self.play(*show_vec_field,run_time=.5) + self.begin_ambient_camera_rotation(rate=.2) + self.move_camera( + # distance=20, + phi=50 * DEGREES, + added_anims=show_vec_field, + run_time=3 + ) + + self.wait(5) + self.stop_ambient_camera_rotation() + + fadeout= [FadeOut(s_field)] + # self.play(*fadeout) + self.move_camera( + # distance=20, + phi=0 * DEGREES, + theta=-90 * DEGREES, + added_anims=fadeout, + run_time=2 + ) + self.wait(2) + + + + + + def get_scalar_field(self,func,dn=.5): + surface= self.get_surface( + lambda x , y: + func(x,y), + ) + + self.surface_points=self.get_points(func,dn) + return surface + + def get_points(self,func,dn): + axes=self.axes + + x_vals=np.arange(axes.a,axes.b,dn) + y_vals=np.arange(axes.c,axes.d,dn) + points=[] + for x_val in x_vals: + for y_val in y_vals: + points+=[axes.c2p(x_val,y_val,func(x_val,y_val)+.05)] + return points + + def get_vector_field(self,func,on_surface=True,**kwargs): + config = dict() + config.update(self.default_vector_field_config) + config.update(kwargs) + vector_field= VectorField(func,**config) + vector_field.move_to(self.axes.c2p(0,0,0)) + self.vector_field=vector_field + + if on_surface: + vector_field=self.get_vectors_on_surface() + + return vector_field + + + + def get_vectors_on_surface(self): + vectors_on_surface = VGroup(*[ + self.vector_field.get_vector(point) + for point in self.surface_points + ]) + + return vectors_on_surface + + + def get_surface(self, func, **kwargs): + axes=self.axes + config = { + "u_min": axes.a, + "u_max": axes.b, + "v_min": axes.c, + "v_max": axes.d, + "resolution": ( + 4*(axes.y_max - axes.y_min) // axes.y_axis.tick_frequency, + 4*(axes.x_max - axes.x_min) // axes.x_axis.tick_frequency, + ), + } + + config.update(self.default_surface_config) + config.update(kwargs) + return ParametricSurface( + lambda x,y : axes.c2p( + x, y, func(x, y) + ), + **config + ) + + +#------------------------------------------------------- + #customize 3D axes + def get_three_d_axes(self, include_labels=True, include_numbers=False, **kwargs): + config = dict(self.axes_config) + config.update(kwargs) + axes = ThreeDAxes(**config) + axes.set_stroke(width=2) + self.axes=axes + + if include_numbers: + self.add_axes_numbers(axes) + + if include_labels: + self.add_axes_labels(axes) + + # Adjust axis orientation + axes.x_axis.rotate( + -90 * DEGREES, LEFT, + about_point=axes.c2p(0, 0, 0), + ) + axes.y_axis.rotate( + 90 * DEGREES, UP, + about_point=axes.c2p(0, 0, 0), + ) + + return axes + + + def setup_axes(self): + axes = self.get_three_d_axes(include_labels=True) + axes.scale(1) + # axes.center() + axes.shift(axes.axes_shift) + + self.add(axes) + self.axes = axes + + def add_axes_numbers(self, axes): + x_axis = axes.x_axis + y_axis = axes.y_axis + tex_vals_x = [ + + ("1", axes.b), + ("-1", axes.a), + ] + tex_vals_y=[ + + ("1", axes.d) + ] + x_labels = VGroup() + y_labels = VGroup() + for tex, val in tex_vals_x: + label = TexMobject(tex) + label.scale(1) + label.next_to(x_axis.n2p(val), DOWN) + # label.rotate(180 * DEGREES) + x_labels.add(label) + x_axis.add(x_labels) + x_axis.numbers = x_labels + + for tex, val in tex_vals_y: + label = TexMobject(tex) + label.scale(1) + label.next_to(y_axis.n2p(val), LEFT) + label.rotate(90 * DEGREES) + y_labels.add(label) + + y_axis.add(y_labels) + y_axis.numbers = y_labels + + return axes + + def add_axes_labels(self, axes): + x_label = TexMobject("x") + x_label.next_to(axes.x_axis.get_end(), RIGHT) + axes.x_axis.label = x_label + + y_label = TextMobject("y") + y_label.rotate(90 * DEGREES, OUT) + y_label.next_to(axes.y_axis.get_end(), UP) + axes.y_axis.label = y_label + + z_label = TextMobject("z") + z_label.rotate(90 * DEGREES, RIGHT) + z_label.next_to(axes.z_axis.get_zenith(), LEFT) + axes.z_axis.label = z_label + for axis in axes: + axis.add(axis.label) + return axes + + + + #uploaded by Somnath Pandit. FSF2020_Vector_fields + + + -- cgit From f4e9b0f92f0e2af217e133dd928b12421ace28b6 Mon Sep 17 00:00:00 2001 From: Somnath Pandit Date: Fri, 19 Jun 2020 00:37:29 +0530 Subject: new animation --- .../vector-fields/README.md | 8 ++ .../file3_constructing_vector_field.gif | Bin 0 -> 847326 bytes .../file3_constructing_vector_field.py | 134 +++++++++++++++++++++ 3 files changed, 142 insertions(+) create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py (limited to 'FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields') diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md new file mode 100644 index 0000000..ef58bb1 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md @@ -0,0 +1,8 @@ + + +**file2_grad_of_scalar_function** +![file2_grad_of_scalar_function](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.gif) + +**file3_constructing_vector_field** +![file3_constructing_vector_field](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif) + diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif new file mode 100644 index 0000000..a3ac7ed Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif differ diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py new file mode 100644 index 0000000..f90705a --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py @@ -0,0 +1,134 @@ +from manimlib.imports import * + + +class VectorFields(GraphScene): + CONFIG = { + "x_min" : -2, + "x_max" : 2, + "y_min" : -2, + "y_max" : 2, + "graph_origin": ORIGIN+2.5*LEFT, + "x_axis_width": 7, + "y_axis_height": 7, + "x_tick_frequency": 1, + "y_tick_frequency": 1, + "default_vector_field_config": { + "delta_x": .5, + "delta_y": .5, + "min_magnitude": 0, + "max_magnitude": 4, + "colors": [GREEN,GREEN,YELLOW,RED], + "length_func": lambda norm : .6*sigmoid(norm), + "opacity": .75, + "vector_config": { + "stroke_width":6, + "max_stroke_width_to_length_ratio":6 + }, + }, + + "a":-1.5 ,"b": 2, "c": -1.5 ,"d": 2, + } + + def construct(self): + X = RIGHT*self.x_axis_width/(self.x_max- self.x_min) + Y = UP*self.y_axis_height/(self.y_max- self.y_min) + self.X=X ;self.Y=Y + + self.setup_axes(animate=False) + + vector_field=self.get_vector_field( + lambda v: np.array([ + (v[0]-self.graph_origin[0])*(v[1]-self.graph_origin[1]), + -(v[0]-self.graph_origin[0]), + 0, + ]) + ) + + self.show_points() + self.show_func_machine() + self.produce_vectors(vector_field) + self.wait(2) + + + + + def show_points(self): + dn=.5 + x_vals=np.arange(self.a,self.b,dn) + y_vals=np.arange(self.c,self.d,dn) + dots=VGroup() + for x_val in x_vals: + for y_val in y_vals: + dot=Dot( + self.coords_to_point(x_val,y_val), + radius=.05, + color=TEAL, + ) + dots.add(dot) + self.play(ShowCreation(dots, run_time=1)) + self.dots=dots + + def show_func_machine(self): + machine=RoundedRectangle( + height=2, + width=3.5, + color=PURPLE, + stroke_width=8 + ).to_edge(RIGHT, buff=.4) + + machine_label=TexMobject( + r"\vec F=xy\hat i-x\hat j", + stroke_width=1.5, + ).set_color_by_gradient( + *self.default_vector_field_config["colors"] + ).next_to(machine,IN) + self.add(machine,machine_label) + + self.func_machine=machine + + + def produce_vectors(self,vector_field): + count,i=3,0 + self.run_time=1 + for dot in self.dots: + if i==count: + self.run_time=.05 + position=dot.get_center() + vect= vector_field.get_vector(position) + self.go_to_machine(dot) + self.take_vec_from_machine(vect,position) + i+=1 + + def go_to_machine(self,dot): + self.play(ApplyMethod( + dot.move_to, + self.func_machine, + ), + run_time=self.run_time + ) + self.play(FadeOut(dot),run_time=self.run_time) + + def take_vec_from_machine(self,vect,position): + vect.next_to(self.func_machine,DL,buff=-.4) + self.play(ApplyMethod( + vect.move_to,position + ), + run_time=self.run_time + ) + + def get_vector_field(self,func,**kwargs): + config = dict() + config.update(self.default_vector_field_config) + config.update(kwargs) + vector_field= VectorField(func,**config) + + return vector_field + + + + + +#uploaded by Somnath Pandit. FSF2020_Vector_fields + + + -- cgit From dd361296965480c0c94b6ae035e7bdd898b112a4 Mon Sep 17 00:00:00 2001 From: Somnath Pandit Date: Fri, 19 Jun 2020 21:16:20 +0530 Subject: new animation --- .../vector-fields/file1_vector_fields.gif | Bin 0 -> 5384744 bytes .../vector-fields/file1_vector_fields.py | 350 +++++++++++++++++++++ 2 files changed, 350 insertions(+) create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file1_vector_fields.gif create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file1_vector_fields.py (limited to 'FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields') diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file1_vector_fields.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file1_vector_fields.gif new file mode 100644 index 0000000..96e50ac Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file1_vector_fields.gif differ diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file1_vector_fields.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file1_vector_fields.py new file mode 100644 index 0000000..6b1b686 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file1_vector_fields.py @@ -0,0 +1,350 @@ +from manimlib.imports import * + +class VectorFields(ThreeDScene): + + CONFIG = { + "axes_config": { + "x_min": -4, + "x_max": 4, + "y_min": -4, + "y_max": 4, + "z_min": -3, + "z_max": 3, + "a":-4 ,"b": 4, "c":-4 , "d":4, + "axes_shift": ORIGIN+2*LEFT, + "x_axis_config": { + "tick_frequency": 1, + # "include_tip": False, + }, + "y_axis_config": { + "tick_frequency": 1, + # "include_tip": False, + }, + "z_axis_config": { + "tick_frequency": 1, + # "include_tip": False, + }, + "num_axis_pieces": 10, + }, + "default_graph_style": { + "stroke_width": 2, + "stroke_color": WHITE, + }, + "default_vector_field_config": { + "delta_x": .5, + "delta_y": .5, + "x_min": -3, + "x_max": 3, + "y_min": -3, + "y_max": 3, + "min_magnitude": 0, + "max_magnitude": 4, + "colors": [BLUE,GREEN,ORANGE,RED], + "length_func": lambda norm : .45*sigmoid(norm), + "opacity": 1.0, + "vector_config": { + "stroke_width":3.5, + "max_tip_length_to_length_ratio": 0.35, + "max_stroke_width_to_length_ratio": 8, + }, + }, + + } + + + def construct(self): + + self.setup_axes() + axes=self.axes + + self.set_camera_orientation(distance=35, + phi=0 * DEGREES, + theta=-90 * DEGREES, + ) + self.move_camera(frame_center=axes.c2p(0,0,0)) + + self.show_2d_field() + self.wait(3) + + self.show_3d_field() + self.begin_ambient_camera_rotation(rate=-.3,) + self.wait(1.5) + axes.x_axis.rotate( + -90 * DEGREES, LEFT, + about_point=axes.c2p(0, 0, 0), + ), + axes.y_axis.rotate( + 90 * DEGREES, UP, + about_point=axes.c2p(0, 0, 0), + ), + self.move_camera( + # distance=20, + phi=85 * DEGREES, + rate_func=linear, + run_time=8 + ) + self.wait(5) + + + def show_2d_field(self): + d2_field_text=TexMobject( + r"\vec F(x,y)=-y\hat i+x\hat j", + stroke_width=1.5 + ).set_color_by_gradient( + *self.default_vector_field_config["colors"] + ) + d2_field_text.to_corner(UR,buff=.5) + + d2_field = self.get_vector_field( + lambda v: np.array([ + -v[1], + v[0], + 0 + ]), + ) + self.add_fixed_in_frame_mobjects(d2_field_text) + # self.add(d2_field) + self.play(Write(d2_field_text)) + self.play(FadeIn(d2_field)) + + self.d2_field=d2_field + self.d2_field_text=d2_field_text + + def show_3d_field(self): + d3_field_text=TexMobject( + r"\vec F(x,y,z)=-y\hat i+x\hat j+0 \hat k", + stroke_width=1.5 + ).set_color_by_gradient( + *self.default_vector_field_config["colors"] + ) + d3_field_text.to_corner(UR,buff=.5) + + d3_field= self.get_vector_field( + lambda v: np.array([ + -v[1], + v[0], + 0 + # v[0]*v[2] + ]), + z_min=-2, + z_max= 2, + delta_x= 1, + delta_y= 1, + delta_z= 1, + length_func=lambda norm : .5*sigmoid(norm), + opacity= 1, + ThreeD=True + ) + + self.remove(self.d2_field,self.d2_field_text) + self.add_fixed_in_frame_mobjects(d3_field_text) + # self.add(d3_field) + self.play(Write(d3_field_text)) + self.play(FadeIn(d3_field)) + + def get_vector_field(self,func,ThreeD=False,**kwargs): + config = dict() + config.update(self.default_vector_field_config) + config.update(kwargs) + if ThreeD: + vector_field= VectorField3D(func,**config) + else: + vector_field= VectorField(func,**config) + + vector_field.move_to(self.axes.c2p(0,0,0)) + self.vector_field=vector_field + + return vector_field + + + +#------------------------------------------------------- + #customize 3D axes + def get_three_d_axes(self, include_labels=True, include_numbers=False, **kwargs): + config = dict(self.axes_config) + config.update(kwargs) + axes = ThreeDAxes(**config) + axes.set_stroke(width=2) + self.axes=axes + + if include_numbers: + self.add_axes_numbers(axes) + + if include_labels: + self.add_axes_labels(axes) + + # Adjust axis orientation + axes.x_axis.rotate( + -0 * DEGREES, LEFT, + about_point=axes.c2p(0, 0, 0), + ) + axes.y_axis.rotate( + 0 * DEGREES, UP, + about_point=axes.c2p(0, 0, 0), + ) + + return axes + + + def setup_axes(self): + axes = self.get_three_d_axes(include_labels=True) + axes.scale(1) + # axes.center() + axes.shift(axes.axes_shift) + + self.add(axes) + self.axes = axes + + def add_axes_numbers(self, axes): + x_axis = axes.x_axis + y_axis = axes.y_axis + tex_vals_x = [ + + ("1", axes.b), + ] + tex_vals_y=[ + + ("1", axes.d) + ] + x_labels = VGroup() + y_labels = VGroup() + for tex, val in tex_vals_x: + label = TexMobject(tex) + label.scale(1) + label.next_to(x_axis.n2p(val), DOWN) + # label.rotate(180 * DEGREES) + x_labels.add(label) + x_axis.add(x_labels) + x_axis.numbers = x_labels + + for tex, val in tex_vals_y: + label = TexMobject(tex) + label.scale(1) + label.next_to(y_axis.n2p(val), LEFT) + label.rotate(90 * DEGREES) + y_labels.add(label) + + y_axis.add(y_labels) + y_axis.numbers = y_labels + + return axes + + def add_axes_labels(self, axes): + x_label = TexMobject("x") + x_label.next_to(axes.x_axis.get_end(), RIGHT) + axes.x_axis.label = x_label + + y_label = TextMobject("y") + y_label.rotate(90 * DEGREES, OUT) + y_label.next_to(axes.y_axis.get_end(), UP) + axes.y_axis.label = y_label + + z_label = TextMobject("z") + z_label.rotate(90 * DEGREES, RIGHT) + z_label.next_to(axes.z_axis.get_zenith(), LEFT) + axes.z_axis.label = z_label + for axis in axes: + axis.add(axis.label) + return axes + +#----------------------------------------------------------- + +class VectorField3D(VGroup): + CONFIG = { + "delta_x": 1, + "delta_y": 1, + "delta_z": 1, + "x_min": int(np.floor(-FRAME_WIDTH / 2)), + "x_max": int(np.ceil(FRAME_WIDTH / 2)), + "y_min": int(np.floor(-FRAME_HEIGHT / 2)), + "y_max": int(np.ceil(FRAME_HEIGHT / 2)), + "z_min":-1, + "z_max": 1, + "min_magnitude": 0, + "max_magnitude": 4, + "colors": DEFAULT_SCALAR_FIELD_COLORS, + # Takes in actual norm, spits out displayed norm + "length_func": lambda norm: 0.45 * sigmoid(norm), + "opacity": 1.0, + "vector_config": {}, + } + '''Position of the tip of vector to be fixed''' + def __init__(self, func, **kwargs): + VGroup.__init__(self, **kwargs) + self.func = func + self.rgb_gradient_function = get_rgb_gradient_function( + self.min_magnitude, + self.max_magnitude, + self.colors, + flip_alphas=False + ) + x_range = np.arange( + self.x_min, + self.x_max + self.delta_x, + self.delta_x + ) + y_range = np.arange( + self.y_min, + self.y_max + self.delta_y, + self.delta_y + ) + z_range = np.arange( + self.z_min, + self.z_max + self.delta_z, + self.delta_z + ) + for x, y, z in it.product(x_range, y_range, z_range): + point = x * RIGHT + y * UP + z * OUT + # print(point) + self.add(self.get_vector(point)) + self.set_opacity(self.opacity) + + def get_vector(self, point, **kwargs): + output = np.array(self.func(point)) + norm = get_norm(output) + if norm == 0: + output *= 0 + else: + output *= self.length_func(norm) / norm + # norm=np.linalg.norm(output) + vector_config = dict(self.vector_config) + vector_config.update(kwargs) + + vect = Vector( + output, + **vector_config + ) + vect_perp=vect.copy().rotate(PI/2, axis=output) + vect= VGroup(vect,vect_perp) + # vect= self.position_vector(vect,point,output,norm) + vect.shift(point) + fill_color = rgb_to_color( + self.rgb_gradient_function(np.array([norm]))[0] + ) + vect.set_color(fill_color) + return vect + + '''def position_vector(self,vect,point,output,norm): + theta,phi=self.get_theta_phi(output,norm) + vect.rotate(PI-phi, axis=RIGHT) + vect.rotate(theta, axis=IN) + # or apply rotation matrix? + return vect + + def get_theta_phi(self,output,norm): + if norm==0: + phi,theta=0,0 + else: + phi= np.arccos(output[-1]/norm) + if output[0]!=0: + theta= np.arccos(output[0]/(norm*np.sin(phi))) + else: + theta= 0 + return phi,theta''' + + + + #uploaded by Somnath Pandit. FSF2020_Vector_fields + + + -- cgit From 97c037a7a22fc31083ad48e6faa661645dfbcd40 Mon Sep 17 00:00:00 2001 From: Somnath Pandit Date: Fri, 19 Jun 2020 23:36:15 +0530 Subject: update positions --- .../file3_constructing_vector_field.gif | Bin 847326 -> 969466 bytes .../file3_constructing_vector_field.py | 7 ++++--- 2 files changed, 4 insertions(+), 3 deletions(-) (limited to 'FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields') diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif index a3ac7ed..cc10583 100644 Binary files a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif and b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif differ diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py index f90705a..1fce3da 100644 --- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py @@ -45,7 +45,9 @@ class VectorFields(GraphScene): ) self.show_points() + self.wait(.5) self.show_func_machine() + self.wait(1) self.produce_vectors(vector_field) self.wait(2) @@ -102,14 +104,14 @@ class VectorFields(GraphScene): def go_to_machine(self,dot): self.play(ApplyMethod( dot.move_to, - self.func_machine, + self.func_machine,[0,1,0], ), run_time=self.run_time ) self.play(FadeOut(dot),run_time=self.run_time) def take_vec_from_machine(self,vect,position): - vect.next_to(self.func_machine,DL,buff=-.4) + vect.next_to(self.func_machine,DOWN,buff=-.4) self.play(ApplyMethod( vect.move_to,position ), @@ -131,4 +133,3 @@ class VectorFields(GraphScene): #uploaded by Somnath Pandit. FSF2020_Vector_fields - -- cgit From 08734b800bc04c6936e8f4a97617d2dffd2c1776 Mon Sep 17 00:00:00 2001 From: Somnath Pandit Date: Fri, 19 Jun 2020 23:43:09 +0530 Subject: Update README.md --- .../integrals-of-multivariable-functions/vector-fields/README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields') diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md index ef58bb1..7a8df11 100644 --- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md @@ -1,4 +1,5 @@ - +**file1_vector_fields** +![file1_vector_fields](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file1_vector_fields.gif) **file2_grad_of_scalar_function** ![file2_grad_of_scalar_function](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.gif) -- cgit From 07ddf72082f5907f441ed73b15642c8d82dec80f Mon Sep 17 00:00:00 2001 From: Somnath Pandit Date: Tue, 23 Jun 2020 21:11:09 +0530 Subject: update as per review --- .../file3_constructing_vector_field.gif | Bin 969466 -> 615613 bytes .../file3_constructing_vector_field.py | 40 ++++++++++++++++----- 2 files changed, 31 insertions(+), 9 deletions(-) (limited to 'FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields') diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif index cc10583..e165a15 100644 Binary files a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif and b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif differ diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py index 1fce3da..13211e9 100644 --- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py @@ -102,20 +102,41 @@ class VectorFields(GraphScene): i+=1 def go_to_machine(self,dot): - self.play(ApplyMethod( - dot.move_to, - self.func_machine,[0,1,0], + if self.run_time>.5: + self.play(ApplyMethod( + dot.next_to, + self.func_machine,4*UP, ), - run_time=self.run_time - ) - self.play(FadeOut(dot),run_time=self.run_time) + run_time=self.run_time + ) + self.dot=dot def take_vec_from_machine(self,vect,position): - vect.next_to(self.func_machine,DOWN,buff=-.4) - self.play(ApplyMethod( + vect.next_to(self.func_machine,DOWN,buff=.1) + if self.run_time>.5: + self.play( + ApplyMethod( + self.dot.shift,DOWN, + run_time=self.run_time + )), + self.play( + FadeOut(self.dot), + run_time=.2 + ) + self.play( + FadeIn(vect), + run_time=.4 + ) + else: + self.remove(self.dot) + self.add(vect) + self.wait(.1) + + self.play( + ApplyMethod( vect.move_to,position ), - run_time=self.run_time + run_time=self.run_time ) def get_vector_field(self,func,**kwargs): @@ -133,3 +154,4 @@ class VectorFields(GraphScene): #uploaded by Somnath Pandit. FSF2020_Vector_fields + -- cgit From 0dee2b48260041c5bffe471af4160a7ab515a99b Mon Sep 17 00:00:00 2001 From: Somnath Pandit Date: Sat, 27 Jun 2020 14:40:33 +0530 Subject: slopefield --- .../vector-fields/file4_slope_field.py | 211 +++++++++++++++++++++ 1 file changed, 211 insertions(+) create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.py (limited to 'FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields') diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.py new file mode 100644 index 0000000..853bf9e --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.py @@ -0,0 +1,211 @@ +from manimlib.imports import * + + +class SlopeFields(GraphScene): + CONFIG = { + "x_min" : -2, + "x_max" : 2, + "y_min" : -2, + "y_max" : 2, + "graph_origin": ORIGIN+2.5*LEFT, + "x_axis_width": 7, + "y_axis_height": 7, + "x_tick_frequency": 1, + "y_tick_frequency": 1, + "default_slope_field_config": { + "delta_x": .25, + "delta_y": .25, + "min_magnitude": -PI, + "max_magnitude": PI, + "colors": [BLUE_B,GREEN_B,YELLOW,ORANGE], + "length_func": lambda norm : .6*sigmoid(norm), + "opacity": .75, + "slope_config": { + "stroke_width":6, + "max_stroke_width_to_length_ratio":6 + }, + }, + + "a":-3 ,"b": 3, "c": -3 ,"d": 3, + } + + def construct(self): + X = RIGHT*self.x_axis_width/(self.x_max- self.x_min) + Y = UP*self.y_axis_height/(self.y_max- self.y_min) + self.X=X ;self.Y=Y + + self.setup_axes(animate=False) + + slope_field=self.get_slope_field( + lambda x,y:-2*(x-self.graph_origin[0])*(y-self.graph_origin[1]), + x_min=self.a-2.5, + x_max=self.b-2.5, + y_min=self.c, + y_max=self.d, + ) + self.add(slope_field) + '''self.show_points() + self.wait(.5) + self.show_func_machine() + self.wait(1) + self.produce_slopes(slope_field)''' + self.wait(2) + + + + + def show_points(self): + dn=1 + x_vals=np.arange(self.a,self.b,dn) + y_vals=np.arange(self.c,self.d,dn) + dots=VGroup() + for x_val in x_vals: + for y_val in y_vals: + dot=Dot( + self.coords_to_point(x_val,y_val), + radius=.05, + color=TEAL, + ) + dots.add(dot) + self.play(ShowCreation(dots, run_time=1)) + self.dots=dots + + def show_func_machine(self): + machine=RoundedRectangle( + height=3, + width=4, + color=PURPLE, + stroke_width=8 + ).to_edge(RIGHT, buff=.4) + + machine_label=TextMobject( + r"Line segment\\ with slope\\"," $y'=-2xy$", + stroke_width=1.2, + color=BLUE + ).next_to(machine,IN) + machine_label[1].set_color_by_gradient( + *self.default_slope_field_config["colors"] + ) + self.add(machine, machine_label) + + self.func_machine = machine + + + def produce_slopes(self,slope_field): + count,i=1,0 + self.run_time=1 + for dot in self.dots: + if i==count: + self.run_time=.05 + position=dot.get_center() + line= slope_field.get_slope(position) + self.go_to_machine(dot) + self.take_line_from_machine(line,position) + i+=1 + + def go_to_machine(self,dot): + if self.run_time>.5: + self.play(ApplyMethod( + dot.next_to, + self.func_machine,4*UP, + ), + run_time=self.run_time + ) + self.dot=dot + + def take_line_from_machine(self,vect,position): + vect.next_to(self.func_machine,DOWN,buff=.1) + if self.run_time>.5: + self.play( + ApplyMethod( + self.dot.shift,DOWN, + run_time=self.run_time + )), + self.play( + FadeOut(self.dot), + run_time=.2 + ) + self.play( + FadeIn(vect), + run_time=.4 + ) + else: + self.remove(self.dot) + self.add(vect) + self.wait(.1) + + self.play( + ApplyMethod( + vect.move_to,position + ), + run_time=self.run_time + ) + + def get_slope_field(self,func,**kwargs): + config = dict() + config.update(self.default_slope_field_config) + config.update(kwargs) + slope_field= SlopeField(func,**config) + + return slope_field + + +class SlopeField(VGroup): + CONFIG = { + "delta_x": 0.5, + "delta_y": 0.5, + "x_min": int(np.floor(-FRAME_WIDTH / 2)), + "x_max": int(np.ceil(FRAME_WIDTH / 2)), + "y_min": int(np.floor(-FRAME_HEIGHT / 2)), + "y_max": int(np.ceil(FRAME_HEIGHT / 2)), + "min_magnitude": 0, + "max_magnitude": 2, + "slope_length_factor": .2, + "colors": DEFAULT_SCALAR_FIELD_COLORS, + "opacity": 1.0, + "line_config": {}, + } + + def __init__(self, func, **kwargs): + VGroup.__init__(self, **kwargs) + self.func = func + self.rgb_gradient_function = get_rgb_gradient_function( + self.min_magnitude, + self.max_magnitude, + self.colors, + flip_alphas=False + ) + x_range = np.arange( + self.x_min, + self.x_max + self.delta_x, + self.delta_x + ) + y_range = np.arange( + self.y_min, + self.y_max + self.delta_y, + self.delta_y + ) + for x, y in it.product(x_range, y_range): + point = x * RIGHT + y * UP + self.add(self.get_slope(point)) + self.set_opacity(self.opacity) + + def get_slope(self, point, **kwargs): + slope = self.func(*point[:2]) + line_config = dict(self.line_config) + line_config.update(kwargs) + line = Line(ORIGIN,self.slope_length_factor*RIGHT, **line_config) + line.move_to(point).rotate(np.arctan(slope)) + fill_color = rgb_to_color( + self.rgb_gradient_function(np.array([slope]))[0] + ) + line.set_color(fill_color) + return line + + + + +#uploaded by Somnath Pandit. FSF2020_Vector_fields + + + -- cgit From 58b9da3540c18794cd10562971c4841df3e98527 Mon Sep 17 00:00:00 2001 From: Somnath Pandit Date: Sat, 27 Jun 2020 18:15:53 +0530 Subject: slope field --- .../vector-fields/README.md | 2 + .../vector-fields/file4_slope_field.gif | Bin 0 -> 1860382 bytes .../vector-fields/file4_slope_field.py | 134 +++++++++++++-------- 3 files changed, 87 insertions(+), 49 deletions(-) create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.gif (limited to 'FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields') diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md index 7a8df11..ffab976 100644 --- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md @@ -7,3 +7,5 @@ **file3_constructing_vector_field** ![file3_constructing_vector_field](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif) +**file4_slope_field** +![file4_slope_field](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.gif) diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.gif new file mode 100644 index 0000000..c39ec54 Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.gif differ diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.py index 853bf9e..8ebb6f5 100644 --- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.py +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.py @@ -13,20 +13,17 @@ class SlopeFields(GraphScene): "x_tick_frequency": 1, "y_tick_frequency": 1, "default_slope_field_config": { - "delta_x": .25, - "delta_y": .25, - "min_magnitude": -PI, - "max_magnitude": PI, - "colors": [BLUE_B,GREEN_B,YELLOW,ORANGE], - "length_func": lambda norm : .6*sigmoid(norm), - "opacity": .75, - "slope_config": { - "stroke_width":6, - "max_stroke_width_to_length_ratio":6 + "delta_x": .2, + "delta_y": .2, + "opacity": 1, + "color": BLUE_A, + "slope_length_factor": .2, + "line_config": { + "stroke_width":2.5, }, }, - "a":-3 ,"b": 3, "c": -3 ,"d": 3, + "a":-1.9 ,"b": 2, "c": -1.9 ,"d": 2, } def construct(self): @@ -37,25 +34,28 @@ class SlopeFields(GraphScene): self.setup_axes(animate=False) slope_field=self.get_slope_field( - lambda x,y:-2*(x-self.graph_origin[0])*(y-self.graph_origin[1]), - x_min=self.a-2.5, - x_max=self.b-2.5, - y_min=self.c, - y_max=self.d, + lambda x,y:-2.0*(x-self.graph_origin[0])*(y-self.graph_origin[1]), + x_min=self.graph_origin[0]+self.a, + x_max=self.graph_origin[0]+self.b, + y_min=self.graph_origin[1]+self.c, + y_max=self.graph_origin[1]+self.d, + color= GREEN_B ) - self.add(slope_field) - '''self.show_points() + + self.show_points() self.wait(.5) self.show_func_machine() self.wait(1) - self.produce_slopes(slope_field)''' + self.produce_slopes(slope_field) + # self.add(slope_field) + self.glimpse_of_solutions() self.wait(2) def show_points(self): - dn=1 + dn=1.0/5 x_vals=np.arange(self.a,self.b,dn) y_vals=np.arange(self.c,self.d,dn) dots=VGroup() @@ -63,7 +63,7 @@ class SlopeFields(GraphScene): for y_val in y_vals: dot=Dot( self.coords_to_point(x_val,y_val), - radius=.05, + radius=.04, color=TEAL, ) dots.add(dot) @@ -83,16 +83,15 @@ class SlopeFields(GraphScene): stroke_width=1.2, color=BLUE ).next_to(machine,IN) - machine_label[1].set_color_by_gradient( - *self.default_slope_field_config["colors"] - ) - self.add(machine, machine_label) + machine_label[1].set_color(GREEN) + machine=VGroup(machine, machine_label) + self.play(FadeIn(machine)) self.func_machine = machine def produce_slopes(self,slope_field): - count,i=1,0 + count,i=3,0 self.run_time=1 for dot in self.dots: if i==count: @@ -114,8 +113,9 @@ class SlopeFields(GraphScene): self.dot=dot def take_line_from_machine(self,vect,position): - vect.next_to(self.func_machine,DOWN,buff=.1) + if self.run_time>.5: + vect.next_to(self.func_machine,DOWN,buff=.1) self.play( ApplyMethod( self.dot.shift,DOWN, @@ -129,17 +129,17 @@ class SlopeFields(GraphScene): FadeIn(vect), run_time=.4 ) - else: - self.remove(self.dot) - self.add(vect) - self.wait(.1) - - self.play( + self.play( ApplyMethod( vect.move_to,position ), run_time=self.run_time ) + else: + self.remove(self.dot) + self.add(vect) + vect.move_to(position) + def get_slope_field(self,func,**kwargs): config = dict() @@ -147,7 +147,52 @@ class SlopeFields(GraphScene): config.update(kwargs) slope_field= SlopeField(func,**config) - return slope_field + return slope_field + + def glimpse_of_solutions(self): + sol_text= TextMobject( + r"The solution curves\\ seem to be like...", + color= BLUE, + stroke_width=1.2 + ) + sol_text.to_corner(UR, buff=1) + condition_text= TextMobject( + r"for different\\ initial conditions", + color= GOLD, + stroke_width=1.1 + ) + condition_text.next_to(sol_text,DOWN,buff=1) + solution1 = self.get_graph( + lambda x : np.exp(-x**2), + x_min = self.a, + x_max = self.b, + color = PINK) + solution2 = self.get_graph( + lambda x : .5*np.exp(-x**2), + x_min = self.a, + x_max = self.b, + color = YELLOW) + solution3 = self.get_graph( + lambda x : 1.5*np.exp(-x**2), + x_min = self.a, + x_max = self.b, + color = BLUE) + solution4 = self.get_graph( + lambda x : -np.exp(-x**2), + x_min = self.a, + x_max = self.b, + color = RED_E) + + self.play(FadeOut(self.func_machine)) + self.play(Write(sol_text)) + self.wait(.6) + self.play(ShowCreation(solution1)) + self.play(Write(condition_text)) + self.play(ShowCreation(solution2)) + self.wait(.5) + self.play(ShowCreation(solution3)) + self.wait(.5) + self.play(ShowCreation(solution4)) class SlopeField(VGroup): @@ -158,23 +203,16 @@ class SlopeField(VGroup): "x_max": int(np.ceil(FRAME_WIDTH / 2)), "y_min": int(np.floor(-FRAME_HEIGHT / 2)), "y_max": int(np.ceil(FRAME_HEIGHT / 2)), - "min_magnitude": 0, - "max_magnitude": 2, - "slope_length_factor": .2, - "colors": DEFAULT_SCALAR_FIELD_COLORS, "opacity": 1.0, + "color": WHITE, + "slope_length_factor": .25, "line_config": {}, } def __init__(self, func, **kwargs): VGroup.__init__(self, **kwargs) self.func = func - self.rgb_gradient_function = get_rgb_gradient_function( - self.min_magnitude, - self.max_magnitude, - self.colors, - flip_alphas=False - ) + x_range = np.arange( self.x_min, self.x_max + self.delta_x, @@ -195,11 +233,9 @@ class SlopeField(VGroup): line_config = dict(self.line_config) line_config.update(kwargs) line = Line(ORIGIN,self.slope_length_factor*RIGHT, **line_config) - line.move_to(point).rotate(np.arctan(slope)) - fill_color = rgb_to_color( - self.rgb_gradient_function(np.array([slope]))[0] - ) - line.set_color(fill_color) + line.move_to(point).rotate(np.arctan(slope/3.2)) + + line.set_color(self.color) return line -- cgit From c5c9807d2b6262a2805054c036a7486f57e766df Mon Sep 17 00:00:00 2001 From: Somnath Pandit Date: Tue, 30 Jun 2020 01:43:11 +0530 Subject: extended animation --- .../file3_constructing_vector_field.gif | Bin 615613 -> 3838142 bytes .../file3_constructing_vector_field.py | 81 +++++++++++++++------ 2 files changed, 60 insertions(+), 21 deletions(-) (limited to 'FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields') diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif index e165a15..6a57cab 100644 Binary files a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif and b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif differ diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py index 13211e9..fc56306 100644 --- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.py @@ -3,10 +3,10 @@ from manimlib.imports import * class VectorFields(GraphScene): CONFIG = { - "x_min" : -2, - "x_max" : 2, - "y_min" : -2, - "y_max" : 2, + "x_min" : -4, + "x_max" : 4, + "y_min" : -4, + "y_max" : 4, "graph_origin": ORIGIN+2.5*LEFT, "x_axis_width": 7, "y_axis_height": 7, @@ -18,15 +18,15 @@ class VectorFields(GraphScene): "min_magnitude": 0, "max_magnitude": 4, "colors": [GREEN,GREEN,YELLOW,RED], - "length_func": lambda norm : .6*sigmoid(norm), + "length_func": lambda n: n/2.5, "opacity": .75, "vector_config": { "stroke_width":6, - "max_stroke_width_to_length_ratio":6 + "max_stroke_width_to_length_ratio":4 }, }, - "a":-1.5 ,"b": 2, "c": -1.5 ,"d": 2, + "a":-3.5 ,"b": 4, "c": -3.5 ,"d": 4, } def construct(self): @@ -35,27 +35,30 @@ class VectorFields(GraphScene): self.X=X ;self.Y=Y self.setup_axes(animate=False) - - vector_field=self.get_vector_field( - lambda v: np.array([ + vector_function = lambda v: np.array([ (v[0]-self.graph_origin[0])*(v[1]-self.graph_origin[1]), -(v[0]-self.graph_origin[0]), 0, ]) - ) + + vector_field=self.get_vector_field( + vector_function, + colors= [GREEN] + ) self.show_points() self.wait(.5) self.show_func_machine() self.wait(1) self.produce_vectors(vector_field) + self.wait(.5) + self.scale_down_vectors(vector_function) self.wait(2) - def show_points(self): - dn=.5 + dn=1 x_vals=np.arange(self.a,self.b,dn) y_vals=np.arange(self.c,self.d,dn) dots=VGroup() @@ -84,7 +87,9 @@ class VectorFields(GraphScene): ).set_color_by_gradient( *self.default_vector_field_config["colors"] ).next_to(machine,IN) - self.add(machine,machine_label) + + machine=VGroup(machine,machine_label) + self.add(machine) self.func_machine=machine @@ -92,6 +97,7 @@ class VectorFields(GraphScene): def produce_vectors(self,vector_field): count,i=3,0 self.run_time=1 + non_scaled_vectors=VGroup() for dot in self.dots: if i==count: self.run_time=.05 @@ -99,8 +105,11 @@ class VectorFields(GraphScene): vect= vector_field.get_vector(position) self.go_to_machine(dot) self.take_vec_from_machine(vect,position) + non_scaled_vectors.add(vect) i+=1 + self.non_scaled_vectors=non_scaled_vectors + def go_to_machine(self,dot): if self.run_time>.5: self.play(ApplyMethod( @@ -113,14 +122,19 @@ class VectorFields(GraphScene): def take_vec_from_machine(self,vect,position): vect.next_to(self.func_machine,DOWN,buff=.1) + if self.run_time>.5: + point_coord=TexMobject( + "(x_i,y_i)" + ).next_to(self.dot,RIGHT,buff= .01).scale(.75) + input_point=VGroup(point_coord, self.dot) self.play( ApplyMethod( - self.dot.shift,DOWN, + input_point.shift,DOWN, run_time=self.run_time )), self.play( - FadeOut(self.dot), + FadeOut(input_point), run_time=.2 ) self.play( @@ -130,15 +144,40 @@ class VectorFields(GraphScene): else: self.remove(self.dot) self.add(vect) - self.wait(.1) + self.wait(1.0/15) self.play( - ApplyMethod( - vect.move_to,position - ), + vect.move_to,position, run_time=self.run_time ) - + + def scale_down_vectors(self,vector_function): + scale_down_text=TextMobject( + r"Vectors are rescaled\\ for clarity\\ and \\", + r"colors are used to \\ indicate magnitudes", + stroke_width=1.2 + ) + scale_down_text[0][:7].set_color(BLUE) + scale_down_text[1].set_color_by_gradient( + *self.default_vector_field_config["colors"] + ) + scale_down_text.to_corner(UR).shift(DOWN) + scaled_vector_field= self.get_vector_field( + vector_function, + length_func= lambda norm : .75*sigmoid(norm) + ) + for vector in self.non_scaled_vectors: + scaled_vect= scaled_vector_field.get_vector(vector.get_center()) + vector.target= scaled_vect + + self.play(FadeOut(self.func_machine)) + self.play(Write(scale_down_text)) + self.wait(1.2) + self.play(LaggedStartMap( + MoveToTarget, self.non_scaled_vectors, + run_time=3 + )) + def get_vector_field(self,func,**kwargs): config = dict() config.update(self.default_vector_field_config) -- cgit From 5820cb0fa508c71902a7c9183a773b5d7409eab8 Mon Sep 17 00:00:00 2001 From: Somnath Pandit Date: Wed, 8 Jul 2020 20:25:53 +0530 Subject: added gifs folder,updated README s --- .../vector-fields/README.md | 8 ++++---- .../vector-fields/file1_vector_fields.gif | Bin 5384744 -> 0 bytes .../vector-fields/file2_grad_of_scalar_function.gif | Bin 6913246 -> 0 bytes .../vector-fields/file3_constructing_vector_field.gif | Bin 3838142 -> 0 bytes .../vector-fields/file4_slope_field.gif | Bin 1860382 -> 0 bytes .../vector-fields/gifs/file1_vector_fields.gif | Bin 0 -> 5384744 bytes .../gifs/file2_grad_of_scalar_function.gif | Bin 0 -> 6913246 bytes .../gifs/file3_constructing_vector_field.gif | Bin 0 -> 3838142 bytes .../vector-fields/gifs/file4_slope_field.gif | Bin 0 -> 1860382 bytes 9 files changed, 4 insertions(+), 4 deletions(-) delete mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file1_vector_fields.gif delete mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.gif delete mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif delete mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.gif create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file1_vector_fields.gif create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file2_grad_of_scalar_function.gif create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file3_constructing_vector_field.gif create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file4_slope_field.gif (limited to 'FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields') diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md index ffab976..456cc5f 100644 --- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md @@ -1,11 +1,11 @@ **file1_vector_fields** -![file1_vector_fields](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file1_vector_fields.gif) +![file1_vector_fields](gifs/file1_vector_fields.gif) **file2_grad_of_scalar_function** -![file2_grad_of_scalar_function](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.gif) +![file2_grad_of_scalar_function](gifs/file2_grad_of_scalar_function.gif) **file3_constructing_vector_field** -![file3_constructing_vector_field](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif) +![file3_constructing_vector_field](gifs/file3_constructing_vector_field.gif) **file4_slope_field** -![file4_slope_field](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.gif) +![file4_slope_field](gifs/vector-fields/file4_slope_field.gif) diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file1_vector_fields.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file1_vector_fields.gif deleted file mode 100644 index 96e50ac..0000000 Binary files a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file1_vector_fields.gif and /dev/null differ diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.gif deleted file mode 100644 index c1ab66a..0000000 Binary files a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file2_grad_of_scalar_function.gif and /dev/null differ diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif deleted file mode 100644 index 6a57cab..0000000 Binary files a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file3_constructing_vector_field.gif and /dev/null differ diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.gif deleted file mode 100644 index c39ec54..0000000 Binary files a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/file4_slope_field.gif and /dev/null differ diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file1_vector_fields.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file1_vector_fields.gif new file mode 100644 index 0000000..96e50ac Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file1_vector_fields.gif differ diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file2_grad_of_scalar_function.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file2_grad_of_scalar_function.gif new file mode 100644 index 0000000..c1ab66a Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file2_grad_of_scalar_function.gif differ diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file3_constructing_vector_field.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file3_constructing_vector_field.gif new file mode 100644 index 0000000..6a57cab Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file3_constructing_vector_field.gif differ diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file4_slope_field.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file4_slope_field.gif new file mode 100644 index 0000000..c39ec54 Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/gifs/file4_slope_field.gif differ -- cgit From ee347c3f62fcd989fb97982c848919630bfc0b4d Mon Sep 17 00:00:00 2001 From: Somnath Pandit Date: Wed, 8 Jul 2020 20:43:35 +0530 Subject: added gifs folder,updated README s --- .../integrals-of-multivariable-functions/vector-fields/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields') diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md index 456cc5f..d8c0956 100644 --- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/vector-fields/README.md @@ -8,4 +8,4 @@ ![file3_constructing_vector_field](gifs/file3_constructing_vector_field.gif) **file4_slope_field** -![file4_slope_field](gifs/vector-fields/file4_slope_field.gif) +![file4_slope_field](gifs/file4_slope_field.gif) -- cgit