vecfield 1.0.3
Module for working with vector and scalar fields
Requires Python: >=3.11
Keywords: python vectorifeld scalarfield

п»їРњРѕРґСѓР»СЊ РґР»СЏ СЂР°Р±РѕС‚С‹ СЃ РІРµРєС‚РѕСЂРЅС‹РјРё РїРѕР»СЏРјРё. Р Р°Р·СЂР°Р±РѕС‚Р°Р» РІ РєР°С‡РµСЃС‚РІРµ С€РєРѕР»СЊРЅРѕРіРѕ РїСЂРѕРµРєС‚Р°.

VectorField(\*comps, dim = None)

`	`Р’РµРєС‚РѕСЂРЅРѕРµ РїРѕР»Рµ РјРѕР¶РµС‚ Р±С‹С‚СЊ Р·Р°РґР°РЅРѕ СЃ РїРѕРјРѕС‰СЊСЋ

РїСЂРѕРµРєС†РёР№ РІРµРєС‚РѕСЂРѕРІ РІ РєР°Р¶РґРѕР№ С‚РѕС‡РєРµ РїРѕР»СЏ РЅР°

РЅРµРєРѕС‚РѕСЂС‹Рµ РєРѕРѕСЂРґРёРЅР°С‚РЅС‹Рµ РѕСЃРё.

\>>> x, y, z, t, p = sympy.symbols("x y z t p")

\>>> v = VectorField(x+y, y\*\*2, z\*y)

\>>> u = VectorField(t - p, p, dim=(t, p))

:param comps: РєРѕРјРїРѕРЅРµРЅС‚С‹ РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ - РѕР±СЉРµРєС‚С‹, РїРµСЂРµРІРѕРґРёРјС‹Рµ РІ sympy.Expr

:param dim: РєРѕСЂС‚РµР¶ РёР· РѕР±РѕР·РЅР°С‡РµРЅРёР№ РєРѕРѕСЂРґРёРЅР°С‚ РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ - РѕР±СЉРµРєС‚РѕРІ, РїРµСЂРµРІРѕРґРёРјС‹С… РІ sympy.Expr



VectorField.\_\_repr\_\_()

Р’РѕР·РІР°СЂР°С‰Р°РµС‚ СЃС‚СЂРѕРєСѓ РІ С„РѕСЂРјР°С‚Рµ (F1, F2, F3...),

РіРґРµ F1, F2, F3... - РїСЂРѕРµРєС†РёРё РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ

\>>> x, y, z = sympy.symbols("x y z")

\>>> v = VectorField(x+y, y\*\*2, z\*y)

\>>> print(v)

(x + y, y\*\*2, y\*z)



VectorField.visualize(image=None, scale=True, density=11, bounds=((-10, 10), (-10, 10), (-10, 10)),

description={"width": False, "length": False, "alpha": False, "color": False},

mode="A", width=0.005, length=1, alpha=1, color="black", imagesize=(10, 10), normalize=False, show=True)

`	`Р’РёР·СѓР°Р»РёР·РёСЂСѓРµС‚ РґРІСѓ- РёР»Рё С‚СЂС‘С…РјРµСЂРЅРѕРµ РІРµРєС‚РѕСЂРЅРѕРµ РїРѕР»Рµ СЃ РїРѕРјРѕС‰СЊСЋ matplotlib

\>>> x, y = sympy.symbols("x y")

\>>> v = VectorField(x+y, y\*\*2)

\>>> v.visualize(density = 30, color = "blue", width = 0.003)

:param image: РёР·РѕР±СЂР°Р¶РµРЅРёРµ (figure), РЅР° РєРѕС‚РѕСЂРѕРј Р±СѓРґРµС‚ РѕС‚СЂРёСЃРѕРІР°РЅРѕ РІРµРєС‚РѕСЂРЅРѕРµ РїРѕР»Рµ. РџРѕ СѓРјРѕР»С‡Р°РЅРёСЋ РІС‹РІРµРґРµС‚ РёР·РѕР±СЂР°Р¶РµРЅРёРµ РѕС‚РґРµР»СЊРЅРѕ

:param scale: СЃРјР°СЃС€С‚Р°Р±РёСЂРѕРІР°С‚СЊ РІРµРєС‚РѕСЂРЅРѕРµ РїРѕР»Рµ РЅР° РёР·РѕР±СЂР°Р¶РµРЅРёРµ

:param density: РїР»РѕС‚РЅРѕСЃС‚СЊ РѕС‚СЂРёСЃРѕРІРєРё СЃС‚СЂРµР»РѕРє/РїРѕС‚РѕРєРѕРІ.

:param bounds: РіСЂР°РЅРёС†С‹ РѕС‚СЂРёСЃРѕРІРєРё РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ

:param description: Р·Р°РґР°С‘С‚ РЅР°СЃС‚СЂРѕР№РєРё РѕС‚СЂРёСЃРѕРІРєРё: РґРёРЅР°РјРёС‡РµСЃРєР°СЏ С€РёСЂРёРЅР° РїРѕС‚РѕРєРѕРІ, РЅРѕСЂРјР°Р»РёР·Р°С†РёСЏ РґР»РёРЅ СЃС‚СЂРµР»РѕРє, РґРёРЅР°РјРёС‡РµСЃРєР°СЏ РїСЂРѕР·СЂР°С‡РЅРѕСЃС‚СЊ СЃС‚СЂРµР»РѕРє, РґРёРЅР°РјРёС‡РµСЃРєР°СЏ СЂР°СЃРєСЂР°СЃРєР°.

:param mode: Р РµР¶РёРј РѕС‚СЂРёСЃРѕРІРєРё РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ. Р РµР¶РёРј РѕС‚СЂРёСЃРѕРІРєРё "A": РїСЂРµРґСЃС‚Р°РІР»СЏРµС‚ РїРѕР»Рµ РІ РІРёРґРµ СЃС‚СЂРµР»РѕРє РІ РєР°Р¶РґРѕР№ С‚РѕС‡РєРµ РєРѕРѕСЂРґРёРЅР°С‚РЅРѕР№ РїР»РѕСЃРєРѕСЃС‚Рё/РїСЂРѕСЃС‚СЂР°РЅСЃС‚РІР°. Р РµР¶РёРј РѕС‚СЂРёСЃРѕРІРєРё "S": РїСЂРµРґСЃС‚Р°РІР»СЏРµС‚ РїРѕР»Рµ РІ РІРёРґРµ РїРѕС‚РѕРєРѕРІ (РѕС‚СЃС‚СѓС‚СЃРІСѓРµС‚ РґР»СЏ С‚СЂС‘С…РјРµСЂРЅС‹С… РІРµРєС‚РѕСЂРЅС‹С… РїРѕР»РµР№).

:param width: С€РёСЂРёРЅР° СЃС‚СЂРµР»РѕРє РёР»Рё РїРѕС‚РѕРєРѕРІ.

:param length: РґР»РёРЅР° СЃС‚СЂРµР»РѕРє.

:param alpha: РїСЂРѕР·СЂР°С‡РЅРѕСЃС‚СЊ СЃС‚СЂРµР»РѕРє

:param color: С†РІРµС‚ РѕС‚СЂРёСЃРѕРІРєРё СЃС‚СЂРµР»РѕРє, РїРѕС‚РѕРєРѕРІ.

:param imagesize: СЂР°Р·РјРµСЂС‹ РёР·РѕР±СЂР°Р¶РµРЅРёСЏ

:param normalize: РЅРѕСЂРјР°Р»РёР·Р°С†РёСЏ РґР»РёРЅ РІРµРєС‚РѕСЂРѕРІ РІ СЂРµР¶РёРјРµ СЃС‚СЂРµР»РѕРє. РџСЂРµРґСЃС‚Р°РІР»СЏРµС‚ РєР°Р¶РґС‹Р№ РІРµРєС‚РѕСЂ РІ РІРёРґРµ РµРґРёРЅРёС‡РЅРѕРіРѕ РІРµРєС‚РѕСЂР°, СЃРѕС…СЂР°РЅСЏСЏ С‚Р°РєРёРј РѕР±СЂР°Р·РѕРј РёРЅС„РѕСЂРјР°С†РёСЋ Р»РёС€СЊ Рѕ РЅР°СЂРїР°РІР»РµРЅРёРё РІРµРєС‚РѕСЂР°

`	`:param show: РїРѕРєР°Р·С‹РІР°С‚СЊ РёР»Рё РЅРµ РїРѕРєР°Р·С‹РІР°С‚СЊ РёР·РѕР±СЂР°Р¶РµРЅРёРµ



VectorField.\_\_add\_\_(self, other):

Р’РѕР·РІСЂР°С‰Р°РµС‚ VectorField, РєР°Р¶РґС‹Р№ РєРѕРјРїРѕРЅРµРЅС‚ РєРѕС‚РѕСЂРѕРіРѕ

СЏРІР»СЏРµС‚СЃСЏ СЃСѓРјРјРѕР№ СЃРѕРѕС‚РІРµС‚СЃС‚РІСѓСЋС‰РёС… РєРѕРјРїРѕРЅРµРЅС‚ РІС…РѕРґРЅС‹С…

РІРµРєС‚РѕСЂРЅС‹С… РїРѕР»РµР№. Р Р°Р·РјРµСЂРЅРѕСЃС‚Рё РІС…РѕРґРЅС‹С… РІРµРєС‚РѕСЂРЅС‹С… РїРѕР»РµР№

РѕР±СЏР·Р°РЅС‹ СЃРѕРІРїР°РґР°С‚СЊ

\>>> x, y, z = sympy.symbols("x y z")

\>>> v = VectorField(x+y, y\*\*2, z\*y)

\>>> u = VectorField(x-y, 1/y, z)

\>>> u + v

(2\*x, y\*\*2 + 1/y, y\*z + z)



VectorField.\_\_mul\_\_(self, other):

Р’ СЃР»СѓС‡Р°Рµ РµСЃР»Рё other РїСЂРµРґСЃС‚Р°РІР»РµРЅ С‡РёСЃР»РµРЅРЅС‹Рј С‚РёРїРѕРј РґР°РЅРЅС‹С…

РІРѕР·РІР°СЂР°С‰Р°РµС‚ VectorField, РєР°Р¶РґС‹Р№ РєРѕРјРїРѕРЅРµРЅС‚ РєРѕС‚РѕСЂРѕРіРѕ СЏРІР»СЏРµС‚СЃСЏ

РїСЂРѕРёР·РІРµРґРµРЅРёРµРј РєРѕРјРїРѕРЅРµРЅС‚С‹ self Рё РґР°РЅРЅРѕРіРѕ СЃРєР°Р»СЏСЂР°

\>>> x, y = sympy.symbols("x y")

\>>> v = VectorField(x, 1)

\>>> v \* 2

(2\*x, 2)

Р’ СЃР»СѓС‡Р°Рµ РµСЃР»Рё other РїСЂРµРґСЃС‚Р°РІР»РµРЅ VectorField

РІРѕР·РІСЂР°С‰Р°РµС‚ Expr, РєРѕС‚РѕСЂС‹Р№ РїСЂРµРґСЃС‚Р°РІР»СЏРµС‚ СЃРѕР±РѕР№

СЃРєР°Р»СЏСЂРЅРѕРµ РїСЂРѕРёР·РІРµРґРµРЅРёРµ РєРѕРјРїРѕРЅРµРЅС‚ self Рё other.

Р Р°Р·РјРµСЂРЅРѕСЃС‚Рё self Рё other РѕР±СЏР·Р°РЅС‹ СЃРѕРІРїР°РґР°С‚СЊ

\>>> x, y, z = sympy.symbols("x y z")

\>>> v = VectorField(x+y, y\*\*2, z\*y)

\>>> u = VectorField(x-y, 1/y, z)

\>>> u \* v

y\*z\*\*2 + y + (x - y)\*(x + y)



VectorField.\_\_eq\_\_(self, other):

VectorField СЂР°РІРµРЅ РґСЂСѓРіРѕРјСѓ VectorField С‚РѕРіРґР°,

РєРѕРіРґР° СЃРѕРІРїР°РґР°СЋС‚ РёС… РєРѕРјРїРѕРЅРµРЅС‚С‹ Рё СЂР°Р·РјРµСЂРЅРѕСЃС‚Рё

\>>> x, y = sympy.symbols("x y")

\>>> v = VectorField(x+y, y\*\*2)

\>>> u = VectorField(x+y, y\*\*2)

\>>> t = VectorField(x-y, 1/y)

\>>> u == v

True

\>>> u == t

False



VectorField.\_\_setitem\_\_(self, key, value):

РџРѕР·РІРѕР»СЏРµС‚ РІСЂСѓС‡РЅСѓСЋ Р·Р°РґР°С‚СЊ РєРѕРјРїРѕРЅРµРЅС‚Сѓ РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ

\>>> x, y = sympy.symbols("x y")

\>>> v = VectorField(x+y, y\*\*2)

\>>> v[x] = x\*y

\>>> v

(x\*y, y\*\*2)

:param key: РєРѕРѕСЂРґРёРЅР°С‚Р° РєРѕРјРїРѕРЅРµРЅС‚С‹ РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ РІ РІРёРґРµ sympy.Symbol

:param value: Р·Р°РґР°РІР°РµРјРѕРµ Р·РЅР°С‡РµРЅРёРµ РєРѕРјРїРѕРЅРµРЅС‚С‹ РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ - РѕР±СЉРµРєС‚Р°, РїРµСЂРµРІРѕРґРёРјРѕРіРѕ РІ sympy.Expr



VectorField.\_\_getitem\_\_(self, key):

РџРѕР·РІРѕР»СЏРµС‚ РїРѕР»СѓС‡РёС‚СЊ РєРѕРјРїРѕРЅРµРЅС‚Сѓ РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ РїРѕ

РєРѕРѕСЂРґРёРЅР°С‚Рµ РёР»Рё РїРѕ РёРЅРґРµРєСЃСѓ РІ self.\_comps

\>>> x, y = sympy.symbols("x y")

\>>> v = VectorField(x+y, y\*\*2)

\>>> v[x]

x + y

\>>> v[1]

y\*\*2

:param key: РєРѕРѕСЂРґРёРЅР°С‚Р° РєРѕРјРїРѕРЅРµРЅС‚С‹ РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ Р»РёР±Рѕ РІ РІРёРґРµ СЃС‚СЂРѕРєРё, Р»РёР±Рѕ РІ РІРёРґРµ С‡РёСЃР»Р° - РёРЅРґРµРєСЃР° РІ self.\_comps



VectorField.\_\_iter\_\_(self):

РџРѕР·РІРѕР»СЏРµС‚ РёСЃРїРѕР»СЊР·РѕРІР°С‚СЊ VectorField РІ С†РёРєР»Рµ for

РїСЂРё СЌС‚РѕРј РґРѕР»Р¶РЅС‹ РїРµСЂРµР±РёСЂР°РµС‚СЃСЏ РєРѕСЂС‚РµР¶Рё, СЃРѕСЃС‚РѕСЏС‰РёРµ РёР·

РґРІСѓС… РѕР±СЉРµРєС‚РѕРІ: РєРѕРѕСЂРґРёРЅР°С‚С‹ Рё РєРѕРјРїРѕРЅРµРЅС‚С‹

\>>> x, y = sympy.symbols("x y")

\>>> v = VectorField(x+y, y\*\*2)

\>>> for coordinate, component in v: print(coordinate, component)

x x + y

y y\*\*2



VectorField.\_\_len\_\_(self):

Р’РѕР·РІСЂР°С‰Р°РµС‚ РґР»РёРЅСѓ self.dim

\>>> x, y = sympy.symbols("x y")

\>>> v = VectorField(x+y, y\*\*2)

\>>> len(v)

2



vecfield.VectorField,subs(self, \*values):

РџРѕР·РІРѕР»СЏРµС‚ РїРѕРґСЃС‚Р°РІРёС‚СЊ С‡РёСЃР»Р° РІ РІРµРєС‚РѕСЂРЅРѕРµ РїРѕР»Рµ РІРјРµСЃС‚Рѕ РєРѕРѕСЂРґРёРЅР°С‚.

Р’РѕР·РІСЂР°С‰Р°РµС‚ РєРѕСЂС‚РµР¶ РёР· РєРѕРјРїРѕРЅРµРЅС‚ РїРѕСЃР»Рµ РїРѕРґСЃС‚Р°РЅРѕРІРєРё Р·РЅР°С‡РµРЅРёР№

\>>> x, y = sympy.symbols("x y")

\>>> v = VectorField(x+y, y\*\*2)

\>>> v.subs(1, 2)

(3, 4)

\>>> v.subs({x : y, y : x\*\*2})

(x\*\*2 + y, x\*\*4)

:param values: РІС‹СЂР°Р¶РµРЅРёСЏ, РїРѕРґСЃС‚Р°РІР»СЏРµРјС‹Рµ РІ РєРѕРјРїРѕРЅРµРЅС‚С‹ РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ РІРјРµСЃС‚Рѕ РєРѕРѕСЂРґРёРЅР°С‚. РљР°Р¶РґР°СЏ РєРѕРѕСЂРґРёРЅР°С‚Р° РёР· self.dim Р±СѓРґРµС‚ Р·Р°РјРµРЅРµРЅР° РЅР° СЃРѕРѕС‚РІРµС‚СЃС‚РІРµРЅРЅРѕРµ Р·РЅР°С‡РµРЅРёРµ РІ values, РєРѕС‚РѕСЂРѕРµ РјРѕР¶РµС‚ Р±С‹С‚СЊ РїСЂРµРґСЃС‚Р°РІР»РµРЅРѕ РєР°Рє РєРѕСЂС‚РµР¶РѕРј, С‚Р°Рє Рё СЃР»РѕРІР°СЂС‘Рј.



vecfield.VectorField,div(self):

Р’РѕР·РІСЂР°С‰Р°РµС‚ ScalarField, РєРѕС‚РѕСЂС‹Р№ РїСЂРµРґСЃС‚Р°РІР»СЏРµС‚ СЃРѕР±РѕР№

РґРёРІРµСЂРіРµРЅС†РёСЋ РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ

\>>> x, y = sympy.symbols("x y")

\>>> v = VectorField(x+y, y\*\*2)

\>>> v.div()

2\*y + 1



vecfield.VectorField,curl(self):

Р’РѕР·РІСЂР°С‰Р°РµС‚ VectorField, РєРѕС‚РѕСЂС‹Р№ СЏРІР»СЏРµС‚СЃСЏ СЂРѕС‚РѕСЂРѕРј РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ.

\>>> x, y, z = sympy.symbols("x y z")

\>>> v = VectorField(x+y, y\*\*2, z\*y)

\>>> v.curl()

(z, 0, -1)



vecfield.VectorField,work(self, curve, bounds, numerical=False):

Р’РѕР·РІСЂР°С‰Р°РµС‚ РєСЂРёРІРѕР»РёРЅРµР№РЅС‹Р№ РёРЅС‚РµРіСЂР°Р» РІС‚РѕСЂРѕРіРѕ СЂРѕРґР° РІРґРѕР»СЊ РєСЂРёРІРѕР№.

Р”СЂСѓРіРёРјРё СЃР»РѕРІР°РјРё, РІРѕР·РІСЂР°С‰Р°РµС‚ СЂР°Р±РѕС‚Сѓ, РєРѕС‚РѕСЂСѓСЋ СЃРѕРІРµСЂС€Р°РµС‚ СЃРёР»Р°,

РїСЂРµРґСЃС‚Р°РІР»РµРЅРЅР°СЏ РІРµРєС‚РѕСЂРЅС‹Рј РїРѕР»РµРј, РїСЂРё РїСЂРѕС…РѕР¶РґРµРЅРёРё РњРў РІРґРѕР»СЊ РєСЂРёРІРѕР№.

\>>> x, y, t = sympy.symbols("x y t")

\>>> v = VectorField(0, -10)

\>>> v.work((t\*\*2-1, t), (t, 0, 4))

- 40

:param curve: РєСЂРёРІР°СЏ, Р·Р°РґР°РЅРЅР°СЏ РїР°СЂР°РјРµС‚СЂРёС‡РµСЃРєРё. Р—Р°РґР°С‘С‚СЃСЏ РєРѕСЂС‚РµР¶РѕРј РёР· С„СѓРЅРєС†РёР№ РѕС‚ РїР°СЂР°РјРµС‚СЂР° - РѕР±СЉРµРєС‚РѕРІ, РїРµСЂРµРІРѕРґРёРјС‹С… РІ sympy.Expr.

:param bounds: РіСЂР°РЅРёС†С‹ РёРЅС‚РµРіСЂРёСЂРѕРІР°РЅРёСЏ РїРѕ РєСЂРёРІРѕР№. Р—Р°РґР°С‘С‚СЃСЏ РєРѕСЂС‚РµР¶РѕРј РёР· РїРµСЂРµРјРµРЅРЅРѕР№ Рё РїСЂРµРґРµР»РѕРІ РёРЅС‚РµРіСЂРёСЂРѕРІР°РЅРёСЏ

:param numerical: С‡РёСЃР»РµРЅРЅРѕРµ СЂРµС€РµРЅРёРµ РёР»Рё Р°РЅР°Р»РёС‚РёС‡РµСЃРєРѕРµ



vecfield.VectorField,flux(self, region, \*bounds, numerical=True):

Р’РѕР·РІСЂР°С‰Р°РµС‚ РїРѕРІРµСЂС…РЅРѕСЃС‚РЅС‹Р№ РёРЅС‚РµРіСЂР°Р» РІС‚РѕСЂРѕРіРѕ СЂРѕРґР° РїРѕ РїРѕРІРµСЂС…РЅРѕСЃС‚Рё.

Р”СЂСѓРіРёРјРё СЃР»РѕРІР°РјРё, РІРѕР·РІСЂР°С‰Р°РµС‚ РєРѕР»РёС‡РµСЃС‚РІРѕ Р¶РёРґРєРѕСЃС‚Рё, РєРѕС‚РѕСЂРѕРµ РїСЂРѕС‚РµС‡С‘С‚

С‡РµСЂРµР· РїРѕРІРµСЂС…РЅРѕСЃС‚СЊ, Р·Р°РґР°РЅРЅРѕР№ region, РїРѕР»Рµ СЃРєРѕСЂРѕСЃС‚РµР№ РєРѕС‚РѕСЂРѕР№ Р·Р°РґР°РЅРѕ

РІРµРєС‚РѕСЂРЅС‹Рј РїРѕР»РµРј Р·Р° РµРґРёРЅРёС†Сѓ РІСЂРµРјРµРЅРё

\>>> x, y, z, t, p = sympy.symbols("x y z t p")

\>>> v = VectorField(2, 0, 0)

\>>> v.flux((1, t, p), (t, -2, 2), (p, -2, 2))

32

:param region: РєСЂРёРІР°СЏ/РїРѕРІРµСЂС…РЅРѕСЃС‚СЊ, Р·Р°РґР°РЅРЅР°СЏ РїР°СЂР°РјРµС‚СЂРёС‡РµСЃРєРё. Р—Р°РґР°С‘С‚СЃСЏ РєРѕСЂС‚РµР¶РѕРј РёР· Р·Р°РІРёСЃСЏС‰РёС… РѕС‚ РЅРµСЃРєРѕР»СЊРєРёС… РїР°СЂР°РјРµС‚СЂРѕРІ С„СѓРЅРєС†РёР№ - РѕР±СЉРµРєС‚РѕРІ, РїРµСЂРµРІРѕРґРёРјС‹С… РІ sympy.Expr.

:param bounds: РіСЂР°РЅРёС†С‹ РёРЅС‚РµРіСЂРёСЂРѕРІР°РЅРёСЏ РїРѕ РєСЂРёРІРѕР№/РїРѕРІРµСЂС…РЅРѕСЃС‚Рё. Р—Р°РґР°СЋС‚СЃСЏ РЅРµСЃРєРѕР»СЊРєРёРјРё РєРѕСЂС‚РµР¶Р°РјРё, РєРѕС‚РѕСЂС‹Рµ СЃРѕРґРµСЂР¶Р°С‚ РїРµСЂРµРјРµРЅРЅСѓСЋ Рё РїСЂРµРґРµР»С‹ РёРЅС‚РµРіСЂРёСЂРѕРІР°РЅРёСЏ.

:param numerical: С‡РёСЃР»РµРЅРЅРѕРµ СЂРµС€РµРЅРёРµ РёР»Рё Р°РЅР°Р»РёС‚РёС‡РµСЃРєРѕРµ



vecfield.VectorField,potential(self):

Р’РѕР·РІСЂР°С‰Р°РµС‚ РїРѕС‚РµРЅС†РёР°Р» РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ, РµСЃР»Рё РѕРЅ РёРјРµРµС‚СЃСЏ.

Р•СЃР»Рё РїРѕР»Рµ РЅРµ РїРѕС‚РµРЅС†РёР°Р»СЊРЅРѕ, Р±СѓРґРµС‚ РІС‹Р·РІР°РЅРѕ РёСЃРєР»СЋС‡РµРЅРёРµ.

\>>> x, y = sympy.symbols("x y")

\>>> v = VectorField(-x, 0)

\>>> v.potential()

- x\*\*2/2



vecfield.VectorField,is\_potential(self):

Р’РѕР·РІСЂР°С‰Р°РµС‚ True, РµСЃР»Рё РїРѕР»Рµ РїРѕС‚РµРЅС†РёР°Р»СЊРЅРѕ,

Рё False РІ РїСЂРѕС‚РёРІРЅРѕРј СЃР»СѓС‡Р°Рµ

\>>> x, y = sympy.symbols("x y")

\>>> v = VectorField(-x, 0)

\>>> v.is\_potential()

True

\>>> u = VectorField(y, -x)

\>>> u.is\_potential()

False



vecfield.VectorField,is\_solenoid(self):

Р’РѕР·РІСЂР°С‰Р°РµС‚ True, РµСЃР»Рё РїРѕР»Рµ СЃРѕР»РµРЅРѕРёРґР°Р»СЊРЅРѕ,

Рё False РІ РїСЂРѕС‚РёРІРЅРѕРј СЃР»СѓС‡Р°Рµ

\>>> x, y = sympy.symbols("x y")

\>>> v = VectorField(x, y)

\>>> v.is\_solenoid()

False

\>>> u = VectorField(y, x)

\>>> u.is\_solenoid()

True





vecfield.ScalarField.\_\_init\_\_(self, func=0, dim=None):

РЎРєР°Р»СЏСЂРЅРѕРµ РїРѕР»Рµ РјРѕР¶РµС‚ Р±С‹С‚СЊ Р·Р°РґР°РЅРѕ СЃ РїРѕРјРѕС‰СЊСЋ С„СѓРЅРєС†РёРё

РЅРµСЃРєРѕР»СЊРєРёС… РїРµСЂРµРјРµРЅРЅС‹С…, СЏРІР»СЏСЋС‰РёС…СЃСЏ РєРѕРѕСЂРґРёРЅР°С‚Р°РјРё С‚РѕС‡РєРё.

\>>> x, y, z, v, t = sympy.symbols("x y z v t")

\>>> s = ScalarField(x\*\*2 + y\*\*2 + z\*\*2)

\>>> p = ScalarField(v + t, dim=(t, v))

:param func: С„СѓРЅРєС†РёСЏ РЅРµСЃРєРѕР»СЊРєРёС… РїРµСЂРµРјРµРЅРЅС‹С…, Р·Р°РґР°СЋС‰Р°СЏ СЃРєР°Р»СЏСЂРЅРѕРµ РїРѕР»Рµ - РѕР±СЉРµРєС‚, РїРµСЂРµРІРѕРґРёРјС‹Р№ РІ sympy.Expr.

:param dim: РєРѕСЂС‚РµР¶ РёР· РѕР±РѕР·РЅР°С‡РµРЅРёР№ РєРѕРѕСЂРґРёРЅР°С‚ СЃРєР°Р»СЏСЂРЅРѕРіРѕ РїРѕР»СЏ - РѕР±СЉРµРєС‚РѕРІ, РїРµСЂРµРІРѕРґРёРјС‹С… РІ sympy.Expr.



vecfield.ScalarField.\_\_repr\_\_(self):

Р’РѕР·РІР°СЂР°С‰Р°РµС‚ СЃС‚СЂРѕРєСѓ, СЃРѕРґРµСЂР¶Р°С‰СѓСЋ С„СѓРЅРєС†РёСЋ ScalarField

\>>> x, y = sympy.symbols("x y")

\>>> s = ScalarField(x\*\*2 + y\*\*2)

\>>> print(s)

x\*\*2 + y\*\*2



vecfield.ScalarField.visualize(self,

image=None,

scale=True,

bounds=((-10, 10), (-10, 10), None),

density=256,

levels=10,

mode="G",

color=None,

showgrid=True,

show=True,

imagesize=(10, 10)):

Р’РёР·СѓР°Р»РёР·РёСЂСѓРµС‚ РѕРґРЅРѕ- РёР»Рё РґРІСѓРјРµСЂРЅРѕРµ СЃРєР°Р»СЏСЂРЅРѕРµ РїРѕР»Рµ СЃ РїРѕРјРѕС‰СЊСЋ matplotlib

\>>> x, y = sympy.symbols("x y")

\>>> s = ScalarField(x\*\*2 + y\*\*2)

\>>> s.visualize()

:param image: РёР·РѕР±СЂР°Р¶РµРЅРёРµ (figure), РЅР° РєРѕС‚РѕСЂРѕРј Р±СѓРґРµС‚ РѕС‚СЂРёРѕСЃРІР°РЅРѕ РІРµРєС‚РѕСЂРЅРѕРµ РїРѕР»Рµ

:param scale: СЃРјР°СЃС€С‚Р°Р±РёСЂРѕРІР°С‚СЊ СЃРєР°Р»СЏСЂРЅРѕРµ РїРѕР»Рµ РЅР° РёР·РѕР±СЂР°Р¶РµРЅРёРµ

:param bounds: РіСЂР°РЅРёС†С‹ РѕС‚СЂРёСЃРѕРІРєРё СЃРєР°Р»СЏСЂРЅРѕРіРѕ РїРѕР»СЏ

:param density: С‚РѕС‡РЅРѕСЃС‚СЊ РїСЂРѕСЂРёСЃРѕРІРєРё СЃРєР°Р»СЏСЂРЅРѕРіРѕ РїРѕР»СЏ

:param levels: РєРѕР»РёС‡РµСЃС‚РІРѕ СЌРєРІРёРїРѕС‚РµРЅС†РёР°Р»СЊРЅС‹С… РїРѕРІРµСЂС…РЅРѕСЃС‚РµР№ РІ СЂРµР¶РёРјРµ СЌРєРІРёРїРѕС‚РµРЅС†РёР°Р»СЊРЅС‹С… РїРѕРІРµСЂС…РЅРѕСЃС‚РµР№

:param mode: СЂРµР¶РёРј РѕС‚СЂРёСЃРѕРІРєРё СЃРєР°Р»СЏСЂРЅРѕРіРѕ РїРѕР»СЏ. Р’ СЂРµР¶РёРјРµ "G" РѕС‚СЂРёСЃРѕРІС‹РІР°РµС‚ СЃРєР°Р»СЏСЂРЅРѕРµ РїРѕР»Рµ РєР°Рє РіСЂР°С„РёРє. Р’ СЂРµР¶РёРјРµ "S" РѕС‚СЂРёСЃРѕРІС‹РІР°РµС‚ СЃРєР°Р»СЏСЂРЅРѕРµ РїРѕР»Рµ СЃ РїРѕРјРѕС‰СЊСЋ СЌРєРІРёРїРѕС‚РµРЅС†РёР°Р»СЊРЅС‹С… РїРѕРІРµСЂС…РЅРѕСЃС‚РµР№. РћС‚СЃСѓС‚СЃС‚РІСѓРµС‚ РґР»СЏ РѕРґРЅРѕРјРµСЂРЅС‹С… СЃРєР°Р»СЏСЂРЅС‹С… РїРѕР»РµР№.

:param color: С†РІРµС‚ РѕС‚СЂРёСЃРѕРІРєРё РіСЂР°С„РёРєР° СЃРєР°Р»СЏСЂРЅРѕРіРѕ РїРѕР»СЏ. Р’ СЂРµР¶РёРјРµ СЌРєРІРёРїРѕС‚РµРЅС†РёР°Р»СЊРЅС‹С… РїРѕРІРµСЂС…РЅРѕСЃС‚РµР№ РјРѕР¶РµС‚ РїСЂРёРЅРёРјР°С‚СЊ РѕСЃРѕР±РѕРµ Р·РЅР°С‡РµРЅРёРµ "D". Р’ С‚Р°РєРѕРј СЃР»СѓС‡Р°Рµ РєР°Р¶РґС‹Р№ СѓСЂРѕРІРµРЅСЊ Р±СѓРґРµС‚ РёРјРµС‚СЊ СЃРІРѕР№ С†РІРµС‚ РІ Р·Р°РІРёСЃРёРјРѕСЃС‚Рё РѕС‚ Р·РЅР°С‡РµРЅРёСЏ С„СѓРЅРєС†РёРё РЅР° СЌС‚РѕРј СѓСЂРѕРІРЅРµ.

:param showgrid: РѕС‚СЂРёСЃРѕРІРєР° СЃРµС‚РєРё РґР»СЏ РєРѕРѕСЂРґРёРЅР°С‚РЅРѕР№ РїР»РѕСЃРєРѕСЃС‚Рё.

:param imagesize: СЂР°Р·РјРµСЂС‹ РёР·РѕР±СЂР°Р¶РµРЅРёСЏ



vecfield.ScalarField.\_\_add\_\_(self, other):

Р’РѕР·РІСЂР°С‰Р°РµС‚ ScalarField, С„СѓРЅРєС†РёСЏ РєРѕС‚РѕСЂРѕРіРѕ СЏРІР»СЏРµС‚СЃСЏ

СЃСѓРјРјРѕР№ С„СѓРЅРєС†РёР№ self Рё other. Р Р°Р·РјРµСЂРЅРѕСЃС‚Рё СЃРєР°Р»СЏСЂРЅС‹С…

РїРѕР»РµР№ РґРѕР»Р¶РЅС‹ СЃРѕРІРїР°РґР°С‚СЊ

\>>> x, y = sympy.symbols("x y")

\>>> s = ScalarField(x\*\*2 + y\*\*2)

\>>> p = ScalarField(x - y\*\*2)

\>>> s + p

x\*\*2 + x



vecfield.ScalarField.\_\_mul\_\_(self, other):

Р’РѕР·РІСЂР°С‰Р°РµС‚ ScalarField, С„СѓРЅРєС†РёСЏ РєРѕС‚РѕСЂРѕРіРѕ СЏРІР»СЏРµС‚СЃСЏ

РїСЂРѕРёР·РІРґРµРЅРёРµРј С„СѓРЅРєС†РёРё self Рё other. other РїСЂРё РїРѕРјРµС‰РµРЅРёРё

РІ sympify() РѕР±СЏР·Р°РЅ РІРѕР·РІСЂР°С‰Р°С‚СЊ РѕР±СЉРµРєС‚ РєР»Р°СЃСЃР° Expr

\>>> x, y = sympy.symbols("x y")

\>>> s = ScalarField(x + y)

\>>> s \* 2

2\*x + 2\*y

\>>> s \* x

x\*(x + y)



vecfield.ScalarField.\_\_eq\_\_(self, other):

ScalarField СЂР°РІРµРЅ РґСЂСѓРіРѕРјСѓ ScalarField С‚РѕРіРґР°

РєРѕРіРґР°, РєРѕРіРґР° С„СѓРЅРєС†РёСЏ РїРµСЂРІРѕРіРѕ ScalarField

СЂР°РІРЅР° С„СѓРЅРєС†РёРё РІС‚РѕСЂРѕРіРѕ ScalarField

\>>> x, y = sympy.symbols("x y")

\>>> s = ScalarField(x\*\*2 + y\*\*2)

\>>> i = ScalarField(y\*\*2 + x\*\*2)

\>>> s == i

True

\>>> p = ScalarField(x + y)

\>>> s == p

False



vecfield.ScalarField.\_\_len\_\_(self):

Р’РѕР·РІСЂР°С‰Р°РµС‚ РґР»РёРЅСѓ СЂР°Р·РјРµСЂРЅРѕСЃС‚Рё РІРµРєС‚РѕСЂРЅРѕРіРѕ РїРѕР»СЏ

\>>> x, y = sympy.symbols("x y")

\>>> s = ScalarField(x\*\*2 + y\*\*2)

\>>> len(s)

2



vecfield.ScalarField.subs(self, \*values):

РџРѕРґСЃС‚Р°РІР»СЏРµС‚ РІ С„СѓРЅРєС†РёСЋ СЃРєР°Р»СЏСЂРЅРѕРіРѕ РїРѕР»СЏ Р·РЅР°С‡РµРЅРёСЏ

\>>> x, y = sympy.symbols("x y")

\>>> s = ScalarField(x\*\*2 + y\*\*2)

\>>> s.subs(2, 2)

8

:param values: РІС‹СЂР°Р¶РµРЅРёСЏ, РїРѕРґСЃС‚Р°РІР»СЏРµРјС‹Рµ РІ РєРѕРјРїРѕРЅРµРЅС‚С‹ СЃРєР°Р»СЏСЂРЅРѕРіРѕ РїРѕР»СЏ РІРјРµСЃС‚Рѕ РєРѕРѕСЂРґРёРЅР°С‚. РљР°Р¶РґР°СЏ РєРѕРѕСЂРґРёРЅР°С‚Р° РёР· self.dim Р±СѓРґРµС‚ Р·Р°РјРµРЅРµРЅР° РЅР° СЃРѕРѕС‚РІРµС‚СЃС‚РІРµРЅРЅРѕРµ Р·РЅР°С‡РµРЅРёРµ РІ values, РєРѕС‚РѕСЂРѕРјРµ РјРѕР¶РµС‚ Р±С‹С‚СЊ РїСЂРµРґСЃС‚Р°РІР»РµРЅРѕ РєР°Рє РєРѕСЂС‚РµР¶РѕРј, С‚Р°Рє Рё СЃР»РѕРІР°СЂС‘Рј.



vecfield.ScalarField.work(self, curve, bounds, numerical=False):

Р’РѕР·РІСЂР°С‰Р°РµС‚ РєСЂРёРІРѕР»РёРЅРµР№РЅС‹Р№ РёРЅС‚РµРіСЂР°Р» РІС‚РѕСЂРѕРіРѕ СЂРѕРґР° РІРґРѕР»СЊ РєСЂРёРІРѕР№.

Р”СЂСѓРіРёРјРё СЃР»РѕРІР°РјРё, РІРѕР·РІСЂР°С‰Р°РµС‚ СЂР°Р±РѕС‚Сѓ, РєРѕС‚РѕСЂСѓСЋ СЃРѕРІРµСЂС€Р°РµС‚ СЃРёР»Р°,

РїСЂРµРґСЃС‚Р°РІР»РµРЅРЅР°СЏ РІРµРєС‚РѕСЂРЅС‹Рј РїРѕР»РµРј, РїСЂРё РїСЂРѕС…РѕР¶РґРµРЅРёРё РњРў РІРґРѕР»СЊ РєСЂРёРІРѕР№.

\>>> x, y, t = sympy.symbols("x y t")

\>>> v = ScalarField(x+y)

\>>> v.work((t, 0), (t, 0, 2))

2

:param curve: РєСЂРёРІР°СЏ, Р·Р°РґР°РЅРЅР°СЏ РїР°СЂР°РјРµС‚СЂРёС‡РµСЃРєРё. Р—Р°РґР°С‘С‚СЃСЏ РєРѕСЂС‚РµР¶РѕРј РёР· С„СѓРЅРєС†РёР№ РѕС‚ РїР°СЂР°РјРµС‚СЂР° - РѕР±СЉРµРєС‚РѕРІ, РїРµСЂРµРІРѕРґРёРјС‹С… РІ sympy.Expr.

:param bounds: РіСЂР°РЅРёС†С‹ РёРЅС‚РµРіСЂРёСЂРѕРІР°РЅРёСЏ РїРѕ РєСЂРёРІРѕР№. Р—Р°РґР°С‘С‚СЃСЏ РєРѕСЂС‚РµР¶РѕРј РёР· РїРµСЂРµРјРµРЅРЅРѕР№ Рё РїСЂРµРґРµР»РѕРІ РёРЅС‚РµРіСЂРёСЂРѕРІР°РЅРёСЏ

:param numerical: С‡РёСЃР»РµРЅРЅРѕРµ СЂРµС€РµРЅРёРµ РёР»Рё Р°РЅР°Р»РёС‚РёС‡РµСЃРєРѕРµ



vecfield.ScalarField.grad(self):

Р’РѕР·РІСЂР°С‰Р°РµС‚ VectorField, СЏРІР»СЏСЋС‰РёР№СЃСЏ РіСЂР°РґРёРµРЅС‚РѕРј

СЃРєР°Р»СЏСЂРЅРѕРіРѕ РїРѕР»СЏ

\>>> x, y = sympy.symbols("x y")

\>>> s = ScalarField(x\*\*2/2 + y\*\*2/2)

\>>> s.grad()

(x, y)



vecfield.ScalarField.ordiff(self, \*vector):

Р’РѕР·РІСЂР°С‰Р°РµС‚ Р·РЅР°С‡РµРЅРёРµ РїСЂРѕРёР·РІРѕРґРЅРѕР№ РїРѕ РЅР°РїСЂР°РІР»РµРЅРёСЋ РІ

РєР°Р¶РґРѕР№ С‚РѕС‡РєРµ СЃРєР°Р»СЏСЂРЅРѕРіРѕ РїРѕР»СЏ

\>>> x, y = sympy.symbols("x y")

\>>> s = ScalarField(x\*\*2 + y\*\*2)

\>>> s.ordiff(3, 4)

1. 2\*x + 1.6\*y

:param vector: РІРµРєС‚РѕСЂ, Р·Р°РґР°СЋС‰РёР№ РЅР°РїСЂР°РІР»РµРЅРёРµ РїСЂРѕРёР·РІРѕРґРЅРѕР№, СЃРѕСЃС‚РѕСЏС‰РёР№ РёР· РѕР±СЉРµРєС‚РѕРІ, РїРµСЂРµРІРѕРґРёРјС‹С… РІ sympy.Expr.