СКОЛЬКО БЕД ПРИНЕСЛИ ПЕРЕХОДНЫЕ ПРОЦЕССЫ ПРИ ПЕРЕМЕЖАЮЩЕЙСЯ ДУГЕ , ВОЗНИКАЮЩЕЙ В МОМЕНТ ПОВРЕЖДЕНИЯ ВЫСОКОВОЛЬТНОЙ КАБЕЛЬНОЙ ЛИНИИ . ПОДСТРОИТЬ ИНДУКТИВНОСТИ КАТУШКИ В ЁМКОСТИ ЭЛЕКТРИЧЕСКИ СВЯЗАННОЙ СЕТИ НЕВОЗМОЖНО!. ПЕРЕНАПРЯЖЕНИЯ НА РЕГИСТРАТОРЕ ФИКСИРОВАЛИСЬ ДО 6, 7 ФАЗНЫХ.

Код шейдера маски: Shader "Custom/Mask" { Properties { _Color("Color", Color) = (1,1,1,1) _MainTex("Albedo (RGB)", 2D) = "white" {} _Glossiness ("Smoothness", Range(0,1)) = 0.5 _Metallic("Metallic", Range(0,1)) = 0.0 } SubShader { Tags { "RenderType" = "Opaque" "Queue" = "Geometry-1" // меняем очередь рендеринга, чтобы данный шейдер создавался раньше шейдера объекта за маской. } Blend Zero One // чтобы цвет возвращаемый шейдером игнорировался, а использовался цвет полученный перед этим ZWrite Off // Выключение записи в Zbuffer, чтобы наш невидимый объект никого не перекрывал Pass { Stencil { Ref 1 // ставим тут значение как в шейдере объекта(который должен быть виден из маски) Comp always // чтобы stencil тест проходил всегда независимо от Ref или значения буфера // Добавим stencil операцию(что сделать в случае прохождения теста): Pass replace // Эта операция возьмёт Ref-значение и запишет его в буфер } CGPROGRAM #pragma vertex vert #pragma fragment frag #include "UnityCG.cginc" struct appdata_t { float4 vertex : POSITION; }; struct v2f { float4 vertex : SV_POSITION; }; fixed4 _Color; v2f vert(appdata_t v) { v2f o; o.vertex = UnityObjectToClipPos(v.vertex); return o; } half4 frag(v2f i) : SV_Target { return _Color; } ENDCG } } Fallback "Diffuse" }

Код шейдера объекта: // Create -> shader -> unlit shader то есть тот который не реагирует на освещение Shader "Custom/Object" { Properties { _Color("Color", Color) = (1,1,1,1) _MainTex("Albedo (RGB)", 2D) = "white" {} } SubShader { Tags { "Queue" = "Geometry" "RenderType" = "Opaque" } Stencil // примеры чтения из буфера и сравнения значения в буфферере с REF { /* // Объект виден: Ref 0 // помечает значения буфера с которым мы будем работать от 0 до 255 Comp Equal // операция сравнения для stencil теста */ // Объект НЕ виден: Ref 1 // помечает значения буфера с которым мы будем работать от 0 до 255 Comp Equal // операция сравнения для stencil теста } Blend SrcAlpha OneMinusSrcAlpha Pass { CGPROGRAM #pragma vertex vert #pragma fragment frag #include "UnityCG.cginc" struct appdata_t { float4 vertex : POSITION; float2 uv : TEXCOORD0; }; struct v2f { float4 vertex : SV_POSITION; half2 uv : TEXCOORD0; }; fixed4 _Color; sampler2D _MainTex; v2f vert(appdata_t v) { v2f o; o.vertex = UnityObjectToClipPos(v.vertex); o.uv = v.uv; return o; } half4 frag(v2f i) : SV_Target { fixed4 c = tex2D(_MainTex, i.uv) * _Color; return c; } ENDCG } } Fallback "Diffuse" }

Работает только с глобальным путем. Локальный никак не хочет воспринимать. Но все равно спасибо за ролик!)

Как я тут оказался?)

Визуал хорош, только хотелось бы не просто подставлять значения в формулу а понимать откуда она взялась как выводиться и т.д.

завтра на экзамене проверю полученную информацию =)

Кстати, это же задача линейной регрессии и признаков, то есть иксов обычно сильно больше, чем один Вот здесь рассказывают, как с этим жить, досаточно простой вывод. ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%BD%D0%B0%D0%B8%D0%BC%D0%B5%D0%BD%D1%8C%D1%88%D0%B8%D1%85_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%BE%D0%B2

🔥 как всегда

В ролике используются прикольные анимации, созданные через python, библиотека Manim. Привожу их код: 😁

Код программы по поиску собственных значений: ```python import numpy as np import math # Выбрали начальное приближение: x = 3.6 y = 2.6 # Находим delt_X, delt_Y: delt = np.array([500,500]) # заранее инициализируем приращения tolerance = 0.0000000001 # желаемая точность i = 0 while max(delt) > tolerance: print("-"*40, f"iteration: {i}") # Уже для новых X и Y вычисляем приращения deltaX и delta Y: m1 = np.array([[4*x-y-5, -x], [1+3/x, -2*y]]) m2 = np.array([2*x**2 - x*y -5*x + 1, x + 3*math.log(x)-y**2]) # Основная формула: delt = - np.linalg.inv(m1) @ m2 # np.linalg.inv(m1) - обратная матрица print(f"delt_x: {delt[0]} delt_y: {delt[1]} ") # Корректируем значения: x += delt[0] y += delt[1] print(f"x: {round(x,4)},\ty: {round(y,4)} ") print(f"ERROR: {abs(max(delt))}") i += 1 #print("Решение:", f"({x}, {y})") ```

Помогите разобраться, почему падающие шарики не бьются о преграды на пути :((((

from manim import * from manim_physics import * from manim.utils.color import random_color import random class NormalDistributionVisualisation(SpaceScene): def construct(self): # Create 40 small circles inside the cone btw = RIGHT/3 num_circles = 12 circles = VGroup() for i in range(num_circles): for j in range(20): # вертикальная составляющая количества выкидываемых шаров circle = Circle(radius=0.08).shift(4*UP + UP*j - num_circles/2*btw + i*btw) circle.set_fill(random_color(), 1) circles.add(circle) self.add(circles) # Create the cone width = 8 height = 3.8 otverstie = 0.31 wall1 = Line([-width, height, 0], [-otverstie, 0.65, 0]) wall2 = Line([width, height, 0], [otverstie, 0.65, 0]) walls = VGroup(wall1, wall2).shift(UP*2) self.add(walls) # Create the obstacles obstacles = VGroup() btw_X = RIGHT*0.8 btw_Y = DOWN*0.8 H = 3 W = 14 for i in range(-H, H-2): for j in range(-W, W+1): r = Square().shift(btw_X * j, btw_Y * i).rotate(PI/4).scale(0.1) r.set_fill(GREY, 1) obstacles.add(r) obstacles.scale(0.7) self.add(obstacles) # Create the "Ш"-shaped container container = VGroup() container_width = 14 container_height = 4.4 container_left = Line([-container_width / 2, -container_height / 2, 0], [-container_width / 2, container_height / 2, 0]) container_right = Line([container_width / 2, -container_height / 2, 0], [container_width / 2, container_height / 2, 0]) container_bottom = Line([-container_width / 2, -container_height / 2, 0], [container_width / 2, -container_height / 2, 0]) n = 49 # количество отсеков step = container_width/n for i in range(0,n): x_from = -container_width / 2 + step*i y_from = -container_height / 2 x_to = -container_width / 2 + step*i y_to = container_height / 2 middle_line = Line([x_from, y_from, 0], [x_to, y_to, 0]) container.add(middle_line) container.add(container_left) container.add(container_right) container.add(container_bottom) container.shift(DOWN*2) self.add(container) # Add physics simulation self.make_rigid_body(*circles) self.make_static_body(obstacles) self.make_static_body(walls) self.make_static_body(container) self.wait(30) """ from manim import * from manim_physics import * # use a SpaceScene to utilize all specific rigid-mechanics methods class TwoObjectsFalling(SpaceScene): def construct(self): circle = Circle().shift(UP).scale(0.1) circle.set_fill(RED, 1) circle.shift(DOWN + RIGHT) wall1 = Line([-4, 3.5, 0], [0, 0, 0]) wall2 = Line([4, 3.5, 0], [0, 0, 0]) walls = VGroup(wall1, wall2) self.add(walls) self.play( DrawBorderThenFill(circle), ) self.make_rigid_body(circle) # Mobjects will move with gravity self.make_static_body(walls) # Mobjects will stay in place self.wait(5) # during wait time, the circle and rect would move according to the simulate updater """

Команды для генерации анимации: manim main.py play_whole_scenario - полный рендер manim main.py -pql - быстрый рендер

Python Manim скрипт, с помощью которого созданы некоторые анимации: from manim import * import math from math import cos from math import sin class MethodYacoby(MovingCameraScene): def construct(self): A = np.array([[1, 2, -1], [2, 3, 4], [-1, 4, 5]]) eps = 0.0001 # точность n = 3 eigenvalues = np.zeros(n) # Инициализируем вектор собственных значений #- self.play( Write(Text("Матрицы А:").to_corner(UL).scale(0.5)), Write(Text("Матрицы H:").to_corner(UR).scale(0.5)) ) #- # Повторяем вращения Якоби, пока не достигнем требуемой точности iteration = 0 while True: # Находим наибольший по модулю внедиагональный элемент max_off_diag = 0 p = q = 0 for i in range(n): for j in range(i+1, n): if abs(A[i, j]) > max_off_diag: max_off_diag = abs(A[i, j]) p, q = i, j #- _A = Matrix(A.round(2)).scale(0.6).move_to(LEFT*4.7 + DOWN*3*iteration) matrix_label = Text(f"Матрица A:",font=BOLD, font_size=13).next_to(_A, UP) i = Text(f"Итерация: {iteration}",font=BOLD, font_size=13).next_to(_A, LEFT).rotate(PI/2) self.play(Write(i)) self.play(Write(matrix_label)) self.play(Write(_A)) #- # Если внедиагональные элементы пренебрежимо малы, мы достигли сходимости if max_off_diag < eps: eigenvalues = np.diag(A) break # Вычисляем угол вращения Якоби theta = 0.5 * math.atan2(2 * A[p, q], A[p, p] - A[q, q]) #- inf_label = Text(f"Индексы максимального недиагонального элемента p = max_i = {p} q = max_j = {q} Максимальный недиагональный элемент: {max_off_diag}", font=BOLD, font_size=13).move_to(DOWN*3*iteration + UP/2) self.play(Write(inf_label)) #- #- ang_label = Text(f"Угол поворота = {round(theta, 2)} [радиан]",font=BOLD, font_size=13).next_to(inf_label, DOWN) self.play(Write(ang_label)) #- #- error_label = Text(f"Погрешность: {max_off_diag}, Требуемая точность: {eps}",font=BOLD, font_size=13).next_to(ang_label, DOWN) self.play(Write(error_label)) #- # Строим матрицу вращения H H = np.eye(n) # ? """ H = np.eye(3) = [[1, 0, 0], [0, 1, 0], [0, 0, 1]] """ H[p, p] = H[q, q] = math.cos(theta) H[p, q] = -math.sin(theta) H[q, p] = math.sin(theta) #- _H = Matrix(H.round(2)).scale(0.65).move_to(RIGHT*5.5 + DOWN*3*iteration) matrix_label = Text(f"Матрица поворота H:",font=BOLD, font_size=13).next_to(_H, UP) self.play(Write(matrix_label)) self.play(Write(_H)) #- self.play( self.camera.frame.animate.move_to(DOWN*3*(iteration+1)) ) # Применяем вращение к матрице A A = H.T @ A @ H iteration += 1 eigenvalues[0] eigenvalues[1] eigenvalues[2]

Алгоритм Якоби python: ```python import numpy as np import math def jacobi_eigenvalues_H(A, eps=1e-10): n = 3 eigenvalues = np.zeros(n) # Инициализируем вектор собственных значений iteration = 0 # Повторяем вращения Якоби, пока не достигнем требуемой точности while True: # Находим наибольший по модулю внедиагональный элемент max_off_diag = 0 p = q = 0 for i in range(n): for j in range(i+1, n): if abs(A[i, j]) > max_off_diag: max_off_diag = abs(A[i, j]) p, q = i, j # Если внедиагональные элементы пренебрежимо малы, мы достигли сходимости if max_off_diag < eps: eigenvalues = np.diag(A) break # Вычисляем угол вращения Якоби theta = 0.5 * math.atan2(2 * A[p, q], A[p, p] - A[q, q]) # Строим матрицу вращения H H = np.eye(n) # ? H[p, p] = H[q, q] = math.cos(theta) H[p, q] = -math.sin(theta) H[q, p] = math.sin(theta) print("Матрица поворота:") print(H) # Применяем вращение к матрице A A = H.T @ A @ H iteration += 1 return eigenvalues A = np.array([[1, 2, -1], [2, 3, 4], [-1, 4, 5]]) eigenvalues = jacobi_eigenvalues_H(A) print("Собственные значения:", eigenvalues) ```

Код python, библиотека manim: from manim import * import numpy as np class HalfIntervalMethod(MovingCameraScene): def construct(self): # Определение уравнения def f(x): return x**3 - 3*x**2 - 4 # Начальные границы интервала a = -5 b = 5 # Создание осей self.axes = Axes( x_range=[-5, 5, 1], y_range=[-50, 50, 10], x_length=10, y_length=10, x_axis_config={"numbers_to_include": np.arange(-5, 5, 1)}, y_axis_config={"numbers_to_include": np.arange(-50, 50, 10)}, tips=True, ).move_to(DOWN).scale(0.55) # Добавление подписей осей x_label = self.axes.get_x_axis_label("x").scale(0.6) y_label = self.axes.get_y_axis_label("f(x)").scale(0.6) # Добавление текста с постановкой задачи task_text = VGroup( MathTex("f(x) = x^3 - 3x^2 - 4"), MathTex("f(x) = 0").move_to(DOWN), MathTex("x = ?").move_to(DOWN*2) ).scale(0.75) self.play(Write(task_text)) self.wait(2) self.play(task_text.animate.scale(0.6).to_corner(UL)) # Построение графика функции graph = self.axes.plot(f, color=BLUE) self.play(Create(self.axes), run_time=2) self.play(Create(x_label), Create(y_label)) self.play(Create(graph)) # Вычисление решения методом половинного деления iterations = 0 tolerance = 0.4

Один из самых крутых преподов в вузе 🔥🔥🔥

Code Snippet: from manim import * from math import log2 class MovingAndZoomingCamera(MovingCameraScene): def construct(self): self.camera.frame.save_state() # 1. Построение графика и осей: axes = Axes( x_range=[-11, 11, 1], y_range=[-11, 11, 1], x_length = 7, y_length = 7, axis_config={"color": BLUE}, ).move_to(LEFT*3) labels = axes.get_axis_labels(x_label="x", y_label="y") graph = axes.plot(lambda x: (x/2)**3, x_range=[-4, 4], color=GREEN) self.play(Create(axes, run_time = 4)) self.play(Write(labels)) self.play(Create(graph)) # показываем что мы ищем: reshenie_dot = Dot(axes.coords_to_point(0,0), color = PINK).scale(0.8) podpis = MathTex("x^*", color = PINK).move_to(reshenie_dot.get_center() + LEFT/2.5 + UP/2.5).scale(0.8) self.play( Create(reshenie_dot), Write(podpis), run_time = 2 ) self.wait() # 2. Построение крайних значений функции: # -------------------------------------------------------- Rpoint = Dot().move_to(axes.coords_to_point(4, 8)) self.play(Create(Rpoint)) # * self.wait() R_point_proecsia = Dot().move_to(axes.coords_to_point(4, 0)) # точка проекц на ось Х. R_point_proecsia.scale(0.5) R_Dline = DashedLine( # пунктирная линия Rpoint.get_center(), R_point_proecsia.get_center() ) # -------------------------------------------------------- Lpoint = Dot().move_to(axes.coords_to_point(-4, -8)) self.play(Create(Lpoint)) # * self.wait() L_point_proecsia = Dot().move_to(axes.coords_to_point(-4, 0)) # точка проекц на ось Х. L_point_proecsia.scale(0.5) L_Dline = DashedLine( # пунктирная линия Lpoint.get_center(), L_point_proecsia.get_center() ) self.play(Create(L_Dline), Create(L_point_proecsia), Create(R_Dline), Create(R_point_proecsia)) self.wait() # -------------------------------------------------------- # 3. Подписываем крайние точки: L_label = MathTex("x_{a}").move_to(L_point_proecsia.get_center() + UP/3).scale(0.6) R_label = MathTex("x_{b}").move_to(R_point_proecsia.get_center() + DOWN/3).scale(0.6) self.play(Create(L_label), Create(R_label)) self.wait() # 4. Проводим касаетльную #- R_label_new = MathTex("x_{0}", color = RED).move_to(R_point_proecsia.get_center() + DOWN/3).scale(0.6) self.play(Transform(R_label, R_label_new), Flash(R_label_new, flash_radius=0.25), run_time = 3) #- target_point = Dot().move_to(axes.coords_to_point(2.667, 0)).scale(0.5) casatelnaya = Line( axes.coords_to_point(4, 8), target_point.get_center(), color = BLUE ) x1_text = MathTex("x_{1}", color = RED).move_to(target_point.get_center() + DOWN/3).scale(0.5) # self.play(self.camera.frame.animate.move_to(casatelnaya).set(width=10)) self.play(Create(casatelnaya), Create(target_point)) self.play(Create(x1_text)) self.wait() # 5. Начинаем писать формулу: angle = Angle( axes.x_axis, # направление 1 Line(axes.coords_to_point(2.667, 0), axes.coords_to_point(4, 8)), # направление 2 radius=0.2, color = ORANGE ) value = MathTex(r"\alpha", color = ORANGE).move_to(angle.get_center() + UP/5 + RIGHT/7).scale(0.7) self.play(Create(angle), Create(value)) L1 = MathTex( "x_1 - x_0", " = ", "-", r"AB", r"\cdot", r"\cos(", r"\alpha", ")" ).move_to([4,3,0]) L1[0].color = RED L1[2].color = RED L1[3].color = BLUE L1[6].color = ORANGE # 6. Обозначения для касательно A = Text("A", color=BLUE).move_to(x1_text.get_center()).scale(0.6) B = Text("B", color=BLUE).move_to(Rpoint.get_center()+UP/3+RIGHT/6).scale(0.6) self.play(Write(L1)) self.play( ReplacementTransform(x1_text, A), # не используй Transform!!!! Flash(x1_text, flash_radius=0.25), run_time = 3 ) self.play(Create(B)) self.wait() self.play(Wiggle( VGroup( A, B, casatelnaya, L1[3] ) ), run_time = 2) self.wait()

Ролик создан с использованием библиотеки manim python. Вот код: from manim import * class MyScene(Scene): def construct(self): """FILM:""" #self.showGrid() title = Text( "Метод простой итерации для систем линейных алгебраических уравнений.", font_size=20, font = ITALIC ).move_to(UP*3.5) self.play(Write(title)) self.wait(2) MainPosition = LEFT*4 + UP system1 = self.createSystem( MathTex(r"10x_1 + 3x_2 + 3x_3 = 9,"), MathTex(r"x_1 + 20x_2 + x_3 = 2,"), MathTex(r"3x_1 - 8x_2 + 30x_3 = 1;") ).move_to(MainPosition) self.play(FadeIn(system1)) self.wait() title1 = Text( "Строим итерационную последовательность: (для этого выразим x1,x2,x3 из 1,2 и 3 уравнений системы)", font_size=18, font = ITALIC ).move_to(system1.get_corner(UP) + UP/2 + RIGHT) self.play(Write(title1)) self.wait(2) system2 = self.createSystem( MathTex(r"x_1 = 0.9 - 0.3x_3 - 0.3x_2,"), MathTex(r"x_2 = 0.1 - 0.05x_1 - 0.05x_3,"), MathTex(r"x_3 = \frac{1}{30} - 0.1x_1 + \frac{8}{30}x_2;") ).move_to(MainPosition).scale(0.7) self.play(Transform(system1, system2)) arrow = MathTex(r"\Rightarrow", font_size = 50) arrow.move_to(UP*1) self.play(Create(arrow)) title3 = Text( "Наша итерационная последовательность:", font_size=18, font = ITALIC ).move_to(RIGHT*3.5 + UP*2.5) self.play(Write(title3)) system3 = self.createSystem( MathTex(r"x_1^{k+1} = 0.9 - 0.3x_3^{k} - 0.3x_2^{k},"), MathTex(r"x_2^{k+1} = 0.1 - 0.05x_1^{k} - 0.05x_3^{k},"), MathTex(r"x_3^{k+1} = \frac{1}{30} - 0.1x_1^{k} + \frac{8}{30}x_2^{k};") ).move_to(RIGHT*3.5 + UP).scale(0.7) self.play(FadeIn(system3)) title4 = Text( "k - это номер текущей итерации.", font_size=20, font = ITALIC ).move_to(RIGHT*3.5 - UP) self.play(Write(title4)) self.wait(2) self.play(FadeOut(title4)) title2 = Text( "Теперь заполняем таблицу:", font_size=18, font = ITALIC ).move_to(system2.get_corner(DOWN) + DOWN/2) self.play(Write(title2)) table = Table( [ ["0", "0", "0", "-"], ["0.9","0.1","1/30", "0.9"], ["0.86", "0.053", "-0,03", "0,063"], ], row_labels=[Text("1"), Text("2"), Text("3")], col_labels=[MathTex(r"x_1"), MathTex(r"x_2"), MathTex(r"x_3"), Text("точность")], top_left_entry=Text("k(итерация)"), include_outer_lines=True ) table.move_to(LEFT*3 + DOWN*1.6) table.scale(0.4) #self.play(table.create()) lg = [ Text( "На 1 итерации произвольно выбираем x1, x2, x3. И подставляем их в правую часть нашей системы. Тем самым находим новые значения x1, x2, x3.(Более точные)", font_size = 17, color = YELLOW, font = ITALIC ).move_to(RIGHT*2.8 + DOWN*2), ] lg[0][93:130].color = BLUE # Анимация построчного заполнения таблицы rows = table.get_rows() for i, row in enumerate(rows,0): for j, cell in enumerate(row, 0): self.play(Write(cell)) if (i == 2) and (j == len(row)-1): env = VGroup( SurroundingRectangle(rows[2][4], color=BLUE), Text("точность = max{ |0.9 - 0| , |0,1 - 0|, |1/30 - 0| } = 0,9", font_size=15, color=BLUE).move_to(RIGHT*2.5 + DOWN*2.4) ) self.play(Create(env)) self.wait() self.play(FadeOut(env)) if (i == 3) and (j == len(row)-1): env = VGroup( SurroundingRectangle(rows[3][4], color=BLUE), Text("точность = max{ |0.86 - 0.9| , |0.053 - 0.1|, |-0.03 - 1/30| } = 0.063", font_size=15, color=BLUE).move_to(RIGHT*1 + DOWN*3) ) self.play(Create(env)) self.wait() self.play(FadeOut(env)) if (i == 1): env = VGroup( SurroundingRectangle(row[1:4]), SurroundingRectangle(rows[2][1:4], color=BLUE), Rectangle(height=2, width=0.7, color=BLUE).move_to(Point([1.6,1,0])), Rectangle(height=2, width=3.45, color=YELLOW).move_to(Point([4.19,1,0])), lg[0] ) self.play(FadeIn(env)) self.wait(2) self.play(FadeOut(env)) if (i == 2): env = VGroup( SurroundingRectangle(row[1:4]), SurroundingRectangle(rows[3][1:4], color=BLUE), Rectangle(height=2, width=0.7, color=BLUE).move_to(Point([1.6,1,0])), Rectangle(height=2, width=3.45, color=YELLOW).move_to(Point([4.19,1,0])), Text( "Подставляем x1, x2, x3 в правую часть нашей системы. Тем самым находим новые значения x1, x2, x3.(Более точные)", font_size = 19, color = YELLOW, font = ITALIC ).move_to(RIGHT*3 + DOWN*3), ) self.play(FadeIn(env)) self.wait(2) self.play(FadeOut(env)) title5 = Text( "Как только достигаем необходимой точности, записываем ответ.", color=GREEN, font_size=20, font = ITALIC ).move_to(table.get_corner(DOWN)+ DOWN/2 + RIGHT*1.5) self.play(Write(title5)) self.wait(4) all = VGroup(arrow, title1, title2, title3, system2, system3, title4, title5, table) attantion_svg = SVGMobject("Useful resourses/attantion.svg").move_to(system1.get_corner(RIGHT) + RIGHT*1).scale(0.2) self.play(Transform(all, attantion_svg)) title1 = Text( "Возвращаем исходную систему:", font_size=18, font = ITALIC ).move_to(system1.get_corner(UP) + UP/2) self.play(Write(title1)) self.wait() syst = self.createSystem( MathTex(r"10x_1 + 3x_2 + 3x_3 = 9,"), MathTex(r"x_1 + 20x_2 + x_3 = 2,"), MathTex(r"3x_1 - 8x_2 + 30x_3 = 1;") ).move_to(MainPosition) self.play(Transform(system2, syst), Transform(system1, syst)) title2 = Text( "Условие сходимости метода:", font_size=18, font = ITALIC ).move_to(attantion_svg.get_corner(RIGHT) + RIGHT*2) self.play(Write(title2)) title3 = Text( "ДИАГОНАЛЬНОЕ ПРЕОБЛАДАНИЕ МАТРИЦЫ СИСТЕМЫ. В математике квадратная матрица считается диагонально-преобладающей, если для каждой строки матрицы значение элементов на главной диагонали больше или равно сумме значений всех остальных (не принадлежащих главной диагонали) элементов в этой строке.", font_size=17, font=ITALIC ).move_to(DOWN+LEFT/3) self.play(Write(title3)) self.wait(2) formula = MathTex( r"\mid a_{ii} \mid \geq \sum_{i eq j} \mid a_{ij} \mid, \forall i=1,..,n for A_{nn}" ) formula.move_to(title3.get_corner(DOWN) + DOWN*1.5) self.play(Write(formula)) self.wait(2) title100 = Text( "В нашем случае: |10| >= |3| + |3| |20| >= |1| + |1| |30| >= |3| + |-8| У нас система с дианональным преобладанием.", font_size=16, font=ITALIC ).move_to(attantion_svg.get_corner(DOWN) + DOWN/1.5 + RIGHT*3) self.play(Write(title100)) self.wait(9) Быстрый рендер: manim main.py -pql Нормальный рендер: manim main.py play_whole_scenario

Ролик создан с использованием библиотеки manim python. Вот код: from manim import * class MyScene(Scene): def construct(self): # self.showGrid() # Постановка задачи: Zadanie = Text( "Имея измеренное расстояние от Земли до Луны, необходимо вычислить абсолютную и относительную погрешность измерения. Предположим, что при измерении расстояния использовался лазерный измерительный прибор, который при попадании луча на Луну отразил его обратно на Землю, но из-за неблагоприятных атмосферных условий (например, плотный туман) произошло искажение измерений.", font_size=15, font="Comic Sans MS" ).move_to(UP*3.2) self.play(Write(Zadanie), run_time = 4) self.wait() # Задаем POINTS: start = np.array([-5.5,-2.5,0]) end = np.array([-4,2,0]) mid = (start + end)/2 # Загрузка .svg файлов для Земли и Луны earth_svg = SVGMobject("Useful resourses/earth.svg").move_to(start) moon_svg = SVGMobject("Useful resourses/moon.svg").move_to(end).scale(0.5) creatig_pivot = Point() line_svg = SVGMobject("Useful resourses/line.svg").move_to(creatig_pivot).scale(0.25) # Показываем Землю и Луну: self.play(FadeIn(earth_svg), FadeIn(moon_svg)) self.wait() # Показываем линейку: self.play(FadeIn(line_svg)) self.wait() # Перемещаем линейку: target_pivot = mid + RIGHT/2 self.play(line_svg.animate.move_to(target_pivot)) self.play(line_svg.animate.rotate(PI/2.5,about_point=target_pivot)) # Подпись у линейки: a = MathTex( r" vert d_{measured} vert = 384'400 km", font_size = 20 ).move_to(mid + UP + LEFT) self.play(Write(a)) # Предисловие решения: dist_formula = MathTex(r" vert d_{measured} vert = 384'400 km") wrong_formula = MathTex(r"\Delta d = 100 km") predislovie = self.WriteMathTextGPT( np.array([1,2.5,0], dtype=np.float32), mathematical_text = [ Text("Пусть измеренное расстояние от земли до Луны составляет:"), dist_formula, Text("Предположим, что дополнительная погрешность измерения составляет:"), wrong_formula, Text("из-за атмосферных условий."), ], text_size = 18) self.wait() b = MathTex( r"\pm 100 km", font_size = 20 ).move_to(end + RIGHT) self.play(Write(b)) self.wait() # Красивый эффект обводки2: framebox1 = SurroundingRectangle(dist_formula, buff=0.05) framebox2 = SurroundingRectangle(a, buff=0.05) self.play(FadeIn(framebox1), FadeIn(framebox2)) self.wait() self.play(FadeOut(framebox1), FadeOut(framebox2)) # Красивый эффект обводки2: framebox1 = SurroundingRectangle(wrong_formula, buff=0.05) framebox2 = SurroundingRectangle(b, buff=0.05) self.play(FadeIn(framebox1), FadeIn(framebox2)) self.wait() self.play(FadeOut(framebox1), FadeOut(framebox2)) # Вычисляем абсолютную погрешность: abs_wrong_formula = MathTex(r"\Delta d = vert d_{measured} - d_{accurate} vert = vert 384'400 - 384'500 vert = 100 km") text = self.WriteMathTextGPT( np.array([2,0,0], dtype=np.float32), mathematical_text = [ Text("1. Абсолютная погрешность - это разница между измеренным значением и точным значением."), abs_wrong_formula ], text_size = 20 ) self.wait() # Красивый эффект обводки3: framebox1 = Rectangle(width=1.4, height=0.5, color=BLUE).move_to(np.array([1,-0.5,0])) self.play(FadeIn(framebox1)) self.play(Write(Text( "точное значение расстояния", color=BLUE, font_size=15 ).move_to(np.array([1, -1.4, 0])))) self.wait() # Вычисляем относительную погрешность: text = self.WriteMathTextGPT( np.array([2,-1.9,0], dtype=np.float32), mathematical_text = [ Text("2. Относительная погрешность - это отношение абсолютной погрешности к точному значению."), MathTex(r"\varepsilon &= \frac{\Delta d}{d_{\text{accurate}}} \times 100\% = \frac{100\text{km}}{384'500\text{ km}} \times 100\% \approx 0.026\%") ], text_size = 20 ) framebox2 = Rectangle(width=1.4, height=0.475, color=BLUE).move_to(np.array([-0.9,-2.7,0])) self.play(FadeIn(framebox2)) self.wait(8) def WriteMathTextGPT(self, position : Point, mathematical_text : list, text_size : int): # Задаем начальную позицию # position = np.array([4, 0, 0]) assert text_size >= 5 # Отрисовываем каждую строку текста for i, item in enumerate(mathematical_text): if (type(item) == MathTex): item.font_size = text_size*1.7 elif (type(item) == Text): item.font_size = text_size-4 else: raise Exception("Непонятный формат(тип) элемента!!!") item.move_to(position) self.play(Write(item)) # отрисовка! self.wait(0.5) # задержка! # Перемещаем следующий элемент под текущим if i < len(mathematical_text) - 1: position += np.array([0, -text_size/38, 0], dtype=np.float32) # Явное преобразование типа данных в int32 # аналог: +DOWN v = VGroup() for stroka in mathematical_text: v.add(stroka) return v def showGrid(self): # Создаем сетку grid = NumberPlane() grid.set_opacity(0.5) # Устанавливаем прозрачность сетки # Добавляем координаты около каждой точки сетки for x in range(-7, 8): # Итерируем по x-координатам for y in range(-4, 5): # Итерируем по y-координатам text = Text(f"({x}, {y})").scale(0.3) # Создаем текст с координатами text.next_to(grid.coords_to_point(x, y), DOWN, buff=0.1) # Размещаем текст около точки сетки self.add(text) # Добавляем текст на сцену # Отображаем сетку и координаты self.add(grid) Быстрый рендер: manim main.py -pql Нормальный рендер: manim main.py play_whole_scenario

Чегоооооооо😮😮😮😮😮😮😮😮😮😮😮

Нельзя снять шедевр на 1 минуту 10 секунд Так же эта имба:

отличное интро

Ролик создан с использованием библиотеки manim python. Вот код: from manim import * class SlantsExample(Scene): def construct(self): # Название видео вверху экрана: init = Text( "Приведем пример, когда ошибки округления сильно влияют на ответ:", slant=ITALIC, font_size=24, ).to_corner(UP) # a[0:14].set_color(BLUE) self.play(Write(init), run_time=2) self.wait(2) # Показываем 1ую систему: preview = Text( "Рассмотрим систему:", slant=ITALIC, font_size=24, ).shift(LEFT+UP) self.play(Write(preview), run_time=2) eq1 = MathTex("3x - 7,0001y = 0,9998") eq2 = MathTex("3x - 7y = 1") grp1 = VGroup(eq1, eq2).arrange(DOWN, aligned_edge=LEFT) b1 = Brace(grp1, direction=LEFT) self.play(Write(b1)) self.play(Write(grp1)) calc = Text( "Решение:", slant=ITALIC, font_size=24, ).next_to(eq1, RIGHT*2 + UP) self.play(Write(calc)) # Результат: r1 = MathTex("x = 5,") r2 = MathTex("y = 2;") grp2 = VGroup(r1, r2).arrange(DOWN, aligned_edge=LEFT).next_to(calc, DOWN) b2 = Brace(grp2, direction=LEFT) self.play(Write(b2)) self.play(Write(grp2)) self.wait(1) # переход от 1 системе ко 2ой: S1 = VGroup(preview, grp1, b1, grp2, b2, calc) self.play(S1.animate.scale(0.5)) self.play(S1.animate.shift(UP*2)) S2 = S1.copy() self.play(S2.animate.shift(DOWN*2)) self.play(S2.animate.scale(2)) # Заменяем коэффициенты в S2: new_text = Text("Немного изменим коэффициенты системы:", font_size=24).shift(UP+LEFT) self.play(ReplacementTransform(S2[0], new_text)) self.wait(2) one = MathTex("1") first_equalation = S2[1][0].get_center() one.move_to(first_equalation + RIGHT*1.3) # Устанавливаем позицию для one new_text = Text("Слегка изменим коэффициенты системы:", font_size=24) self.play(ReplacementTransform(S2[1][0][0][-6:], one)) self.wait(3) # Тогда и решение поменяется: new_x = MathTex(r"\frac{1}{3}") new_y = MathTex(r"0") grp2 = S2[3] r1 = grp2[0][0] # 1ое ураынение r2 = grp2[1][0] # 2ое ураынение # задаем позицию для появления нового X: new_x.move_to(r1.get_center() + RIGHT/2) new_x.scale(0.5) # Увеличиваем размер шрифта в 2 раза # задаем позицию для появления нового Y: new_y.move_to(r2.get_center() + RIGHT/2) self.play(ReplacementTransform(r1[-2:], new_x)) self.play(ReplacementTransform(r2[-2:], new_y)) self.wait(3) # Добавляются подвижные рамки """calc = S2[-1] self.play(calc.animate.shift(UP/6))""" grp2_old = S1[3] grp2_new = S2[3] framebox1 = SurroundingRectangle(grp2_old, buff=.05, color=BLUE) framebox2 = SurroundingRectangle(grp2_new, buff=.05, color=BLUE) grp1_old = S1[1][0][0][-6:] grp1_new = S2[1][0][0][-1:] framebox3 = SurroundingRectangle(grp1_old, buff=.05, color=RED) framebox4 = SurroundingRectangle(grp1_new, buff=.05, color=RED) self.play(Create(framebox1), Create(framebox2), Create(framebox3), Create(framebox4)) self.wait(3) # Финальная часть: preview = Text( "При малейшем изменении коэффициентов системы, мы получили совершенно другое решение. Бывает так, что при малейшем изменении коэффициентов, система становится НЕрешаемой.", slant=ITALIC, font_size=20, color = BLUE ).shift(DOWN*2) self.play(Write(preview), run_time=4) self.remove(FadeOut(framebox1), FadeOut(framebox2), FadeOut(framebox3), FadeOut(framebox4)) self.wait(8) Быстрый рендер: manim main.py -pql Нормальный рендер: manim main.py play_whole_scenario

Ролик создан с использованием библиотеки manim python. Вот код: from manim import * class SlantsExample(Scene): def construct(self): a = Text( "Значащей цифрой называют 1-ую слева, отличную от нуля цифру и все последующие за ней.", slant=ITALIC, font_size=24, ).shift(UP*2 + LEFT) a[0:14].set_color(BLUE) self.play(Write(a), run_time=6) self.wait(1) b = Text( "Пример:", slant=ITALIC, font_size=24 ).to_corner(LEFT) # .next_to(a, DOWN) b.shift(UP) self.play(Write(b)) self.wait(1) equation1 = MathTex("0,0", "7231",) equation2 = MathTex("1,23").next_to(equation1, DOWN) equation3 = MathTex("0,00", "720").next_to(equation2, DOWN) self.play(Write(equation1)) self.play(Write(equation2)) self.play(Write(equation3)) framebox1 = SurroundingRectangle(equation1[1], buff=.05, color=BLUE) framebox2 = SurroundingRectangle(equation2[0], buff=.05, color=BLUE) framebox3 = SurroundingRectangle(equation3[1], buff=.05, color=BLUE) # Создается анимация self.play(Create(framebox1)) # с созданием рамки self.play(Create(framebox2)) # с созданием рамки self.play(Create(framebox3)) # с созданием рамки n = Text( "Значащие цифры.", slant=ITALIC, color=BLUE, font_size=16, ).next_to(equation2, RIGHT) self.play(Write(n)) self.wait(7) Быстрый рендер: manim main.py -pql Нормальный рендер: manim main.py play_whole_scenario

А можно ссылку на задачу?

Во музончик поставил )

блин, ты даже в праздники продолжаешь выкладывать видео😳 балуешь нас слишком

это математика в асмр🤩👂🏻

у тебя очень приятный голос😍

я давно слежу за твоим каналом, благодаря тебе стала преподавателем математики, спасибо!!

1 часть - habr.com/ru/articles/557424/

Очень интересно. С удовольствием подписался и поставил лайк. Кстати, я ваш 92-ой подписчик. Удачи и успехов.

В формуле ошибка, пишу правильный вариант: sin(in) = i sh(n), где sh(n) - гиперболический синус

Pdf: drive.google.com/drive/folders/15fMKIGWm8PXWPKNZqNQ2zireVBnH1miy

PDF: конспекта drive.google.com/drive/folders/15fMKIGWm8PXWPKNZqNQ2zireVBnH1miy

я 1й

PDF версия: drive.google.com/drive/folders/15fMKIGWm8PXWPKNZqNQ2zireVBnH1miy

PDF версия: drive.google.com/drive/folders/15fMKIGWm8PXWPKNZqNQ2zireVBnH1miy

Pdf версия: drive.google.com/drive/folders/15fMKIGWm8PXWPKNZqNQ2zireVBnH1miy

00:25 секунда «из-за того что Один из корней характеристического уравнения совпал С КОЭФФИЦИЕНТОМ В АРГУМЕНТЕ ГИПЕРБОЛИЧЕСКОГО СИНУСА, в исходном уравнении», мы и домножаем на икс.. На видео забыл сказать это 😕

Привет. Можете записать как с excel читать данные и записывать данные через winforms?

работает на 0 процентов ..по крайней мере у меня

Эх, а в плюсах move семантика))

Надо было ещё окружность на плоскости XoY нарисовать и показать как функция выглядит без ограничений. А так все супер 👍

Почему видео ускорено?

Мне кажется лучше объединять короткие видосы и делать тайм-коды