SymPy 1.13 中文文件（十五）
原文：
docs.sympy.org/latest/index.html
物理
原文：
docs.sympy.org/latest/reference/public/physics/index.html
一個幫助解決物理問題的模組。
目錄
-
氫波函式
-
矩陣
-
泡利代數
-
一維量子諧振子
-
三維量子諧振子
-
二次量子化
-
Wigner 符號
-
單位系統
-
單位系統背後的哲學
-
更多例子
-
維度與維度系統
-
單位字首
-
單位與單位系統
-
物理量
-
-
高能物理
-
物理向量模組
-
向量與參考框架
-
向量：運動學
-
物理/向量模組的潛在問題/高階主題/未來功能
-
標量和向量場功能
-
物理向量 API
-
基礎課程
-
運動學（文件字串）
-
列印（文件字串）
-
基本函式（文件字串）
-
基本場函式的文件字串
-
-
-
經典力學
-
物理/力學中的質量、慣性、粒子和剛體
-
凱恩力學中的方法
-
拉格朗日力學中的方法
-
物理/力學中的關節框架
-
物理/力學中的符號系統
-
物理/力學中的線性化
- 非最小座標擺
-
物理/力學示例
-
滾動盤
-
使用 Kane 方法的滾動盤
-
滾動盤，使用 Kane 方法和約束力
-
使用 Lagrange 方法的滾動盤
-
-
腳踏車
-
非最小座標擺
-
多自由度完整系統
-
四杆連桿
-
-
物理/力學中的潛在問題/高階主題/未來特性
-
物理/力學參考
-
Autolev 解析器
-
SymPy 力學對 Autolev 使用者
-
力學 API 參考
-
物體、慣性、載荷及其他函式（文件字串）
-
Kane 方法與 Lagrange 方法（文件字串）
-
關節框架（文件字串）
-
系統（文件字串）
-
線性化（文件字串）
-
表示式操作（文件字串）
-
列印（文件字串）
-
路徑（文件字串）
-
致動器（文件字串）
-
包裝幾何（文件字串）
-
已棄用類（文件字串）
-
-
-
生物力學
-
生物力學 API 參考
-
肌腱肌腱（文件字串）
-
啟用（文件字串）
-
曲線（文件字串）
-
-
-
量子力學
-
反對易子
-
Clebsch-Gordan 係數
-
對易子
-
常數
-
達格爾算符
-
內積
-
張量積
-
笛卡爾算符和態
-
希爾伯特空間
-
算符
-
算符/態輔助函式
-
Qapply
-
表示
-
自旋
-
狀態
-
電路繪圖
-
門
-
格羅弗演算法
-
傅立葉變換
-
量子位元
-
肖爾演算法
-
盒中的粒子
-
-
光學模組
-
高斯光學
-
介質
-
偏振
-
實用工具
-
波
-
-
控制模組
-
控制
-
控制 API
-
控制系統圖
-
-
連續介質力學
-
梁（文件字串）
-
使用奇異函式解決梁彎曲問題
-
桁架（文件字串）
-
電纜（文件字串）
-
氫波函式
原文連結：
docs.sympy.org/latest/modules/physics/hydrogen.html
sympy.physics.hydrogen.E_nl(n, Z=1)
返回狀態 (n, l) 的能量，以 Hartree 原子單位表示。
能量不依賴於“l”。
引數：
n : 整數
主量子數，是一個整數，可能的取值為 1, 2, 3, 4,…
Z :
原子序數（氫為 1，氦為 2，…）
示例
>>> from sympy.physics.hydrogen import E_nl
>>> from sympy.abc import n, Z
>>> E_nl(n, Z)
-Z**2/(2*n**2)
>>> E_nl(1)
-1/2
>>> E_nl(2)
-1/8
>>> E_nl(3)
-1/18
>>> E_nl(3, 47)
-2209/18
sympy.physics.hydrogen.E_nl_dirac(n, l, spin_up=True, Z=1, c=137.035999037000)
返回狀態（n, l, 自旋）的相對論能量，以 Hartree 原子單位表示。
能量是透過狄拉克方程計算的。未包括靜止質能。
引數：
n : 整數
主量子數，是一個整數，可能的取值為 1, 2, 3, 4,…
l : 整數
l是角動量量子數，其取值範圍從 0 到n-1。
spin_up :
如果電子自旋為向上（預設），則為真；否則為向下。
Z :
原子序數（氫為 1，氦為 2，…）
c :
光速，以原子單位表示。預設值為 137.035999037，取自
arxiv.org/abs/1012.3627
示例
>>> from sympy.physics.hydrogen import E_nl_dirac
>>> E_nl_dirac(1, 0)
-0.500006656595360
>>> E_nl_dirac(2, 0)
-0.125002080189006
>>> E_nl_dirac(2, 1)
-0.125000416028342
>>> E_nl_dirac(2, 1, False)
-0.125002080189006
>>> E_nl_dirac(3, 0)
-0.0555562951740285
>>> E_nl_dirac(3, 1)
-0.0555558020932949
>>> E_nl_dirac(3, 1, False)
-0.0555562951740285
>>> E_nl_dirac(3, 2)
-0.0555556377366884
>>> E_nl_dirac(3, 2, False)
-0.0555558020932949
sympy.physics.hydrogen.Psi_nlm(n, l, m, r, phi, theta, Z=1)
返回氫波函式 psi_{nlm}。它是徑向波函式 R_{nl} 和球諧函式 Y_{l}^{m} 的乘積。
引數：
n : 整數
主量子數，是一個整數，可能的取值為 1, 2, 3, 4,…
l : 整數
l是角動量量子數，其取值範圍從 0 到n-1。
m : 整數
m是磁量子數，其取值範圍從-l到l。
r :
徑向座標
phi :
方位角
theta :
極角
Z :
原子序數（氫為 1，氦為 2，…）
所有單位均為 Hartree 原子單位。
示例
>>> from sympy.physics.hydrogen import Psi_nlm
>>> from sympy import Symbol
>>> r=Symbol("r", positive=True)
>>> phi=Symbol("phi", real=True)
>>> theta=Symbol("theta", real=True)
>>> Z=Symbol("Z", positive=True, integer=True, nonzero=True)
>>> Psi_nlm(1,0,0,r,phi,theta,Z)
Z**(3/2)*exp(-Z*r)/sqrt(pi)
>>> Psi_nlm(2,1,1,r,phi,theta,Z)
-Z**(5/2)*r*exp(I*phi)*exp(-Z*r/2)*sin(theta)/(8*sqrt(pi))
對氫波函式 psi_{nlm} 的絕對平方積分得到 1。
氫波函式 Psi_nlm 的歸一化為：
>>> from sympy import integrate, conjugate, pi, oo, sin
>>> wf=Psi_nlm(2,1,1,r,phi,theta,Z)
>>> abs_sqrd=wf*conjugate(wf)
>>> jacobi=r**2*sin(theta)
>>> integrate(abs_sqrd*jacobi, (r,0,oo), (phi,0,2*pi), (theta,0,pi))
1
sympy.physics.hydrogen.R_nl(n, l, r, Z=1)
返回氫原子徑向波函式 R_{nl}。
引數：
n : 整數
主量子數，是一個整數，可能的取值為 1, 2, 3, 4,…
l : 整數
l是角動量量子數，其取值範圍從 0 到n-1。
r :
徑向座標。
Z :
原子序數（氫為 1，氦為 2，…）
所有單位均為 Hartree 原子單位。
示例
>>> from sympy.physics.hydrogen import R_nl
>>> from sympy.abc import r, Z
>>> R_nl(1, 0, r, Z)
2*sqrt(Z**3)*exp(-Z*r)
>>> R_nl(2, 0, r, Z)
sqrt(2)*(-Z*r + 2)*sqrt(Z**3)*exp(-Z*r/2)/4
>>> R_nl(2, 1, r, Z)
sqrt(6)*Z*r*sqrt(Z**3)*exp(-Z*r/2)/12
對於氫原子，你可以使用 Z=1 的預設值：
>>> R_nl(1, 0, r)
2*exp(-r)
>>> R_nl(2, 0, r)
sqrt(2)*(2 - r)*exp(-r/2)/4
>>> R_nl(3, 0, r)
2*sqrt(3)*(2*r**2/9 - 2*r + 3)*exp(-r/3)/27
對於銀原子，你可以使用 Z=47：
>>> R_nl(1, 0, r, Z=47)
94*sqrt(47)*exp(-47*r)
>>> R_nl(2, 0, r, Z=47)
47*sqrt(94)*(2 - 47*r)*exp(-47*r/2)/4
>>> R_nl(3, 0, r, Z=47)
94*sqrt(141)*(4418*r**2/9 - 94*r + 3)*exp(-47*r/3)/27
徑向波函式的歸一化為：
>>> from sympy import integrate, oo
>>> integrate(R_nl(1, 0, r)**2 * r**2, (r, 0, oo))
1
>>> integrate(R_nl(2, 0, r)**2 * r**2, (r, 0, oo))
1
>>> integrate(R_nl(2, 1, r)**2 * r**2, (r, 0, oo))
1
對於任意原子序數成立：
>>> integrate(R_nl(1, 0, r, Z=2)**2 * r**2, (r, 0, oo))
1
>>> integrate(R_nl(2, 0, r, Z=3)**2 * r**2, (r, 0, oo))
1
>>> integrate(R_nl(2, 1, r, Z=4)**2 * r**2, (r, 0, oo))
1
矩陣
原文連結：
docs.sympy.org/latest/modules/physics/matrices.html
與物理相關的已知矩陣
sympy.physics.matrices.mdft(n)
自版本 1.9 起棄用：請改用 sympy.matrices.expressions.fourier 中的 DFT。
要獲得與 mdft(n) 相同的行為，請使用 DFT(n).as_explicit()。
sympy.physics.matrices.mgamma(mu, lower=False)
返回標準（Dirac）表示中的 Dirac 伽馬矩陣 (\gamma^\mu)。
解釋
如果你想要 (\gamma_\mu)，使用 gamma(mu, True)。
我們使用一個約定：
(\gamma⁵ = i \cdot \gamma⁰ \cdot \gamma¹ \cdot \gamma² \cdot \gamma³)
(\gamma_5 = i \cdot \gamma_0 \cdot \gamma_1 \cdot \gamma_2 \cdot \gamma_3 = - \gamma⁵)
示例
>>> from sympy.physics.matrices import mgamma
>>> mgamma(1)
Matrix([
[ 0, 0, 0, 1],
[ 0, 0, 1, 0],
[ 0, -1, 0, 0],
[-1, 0, 0, 0]])
參考文獻
[R737]
en.wikipedia.org/wiki/Gamma_matrices
sympy.physics.matrices.msigma(i)
返回具有 (i=1,2,3) 的 Pauli 矩陣 (\sigma_i)。
示例
>>> from sympy.physics.matrices import msigma
>>> msigma(1)
Matrix([
[0, 1],
[1, 0]])
參考文獻
[R738]
en.wikipedia.org/wiki/Pauli_matrices
sympy.physics.matrices.pat_matrix(m, dx, dy, dz)
返回平行軸定理矩陣，以便將慣性矩陣沿 ((dx, dy, dz)) 距離轉換為質量為 m 的物體。
示例
要將質量為 2 單位的物體沿 (x)-軸移動 1 單位的距離進行翻譯，我們得到：
>>> from sympy.physics.matrices import pat_matrix
>>> pat_matrix(2, 1, 0, 0)
Matrix([
[0, 0, 0],
[0, 2, 0],
[0, 0, 2]])
Pauli 代數
原文：
docs.sympy.org/latest/modules/physics/paulialgebra.html
該模組透過子類化符號實現了Pauli 代數。僅使用了 Pauli 矩陣的代數性質（我們不使用 Matrix 類）。
請參閱 Pauli 類的文件獲取示例。
參考資料
[R748]
en.wikipedia.org/wiki/Pauli_matrices
sympy.physics.paulialgebra.evaluate_pauli_product(arg)
幫助函式，用於評估與符號物件的 Pauli 矩陣乘積。
引數：
arg: 包含 Pauli 矩陣的符號表示式
示例
>>> from sympy.physics.paulialgebra import Pauli, evaluate_pauli_product
>>> from sympy import I
>>> evaluate_pauli_product(I*Pauli(1)*Pauli(2))
-sigma3
>>> from sympy.abc import x
>>> evaluate_pauli_product(x**2*Pauli(2)*Pauli(1))
-I*x**2*sigma3
一維量子諧振子
原文：
docs.sympy.org/latest/modules/physics/qho_1d.html
sympy.physics.qho_1d.E_n(n, omega)
返回一維諧振子的能量。
引數：
n：
“節點”量子數。
omega：
諧振子的角頻率。
注意
返回值的單位與 hw 的單位匹配，因為能量的計算為：
E_n = hbar * omega*(n + 1/2)
示例
>>> from sympy.physics.qho_1d import E_n
>>> from sympy.abc import x, omega
>>> E_n(x, omega)
hbar*omega*(x + 1/2)
sympy.physics.qho_1d.coherent_state(n, alpha)
返回 1D 諧振子相干態的 <n|alpha>。參見 en.wikipedia.org/wiki/Coherent_states
引數：
n：
“節點”量子數。
alpha：
湮滅算符的本徵值。
sympy.physics.qho_1d.psi_n(n, x, m, omega)
返回一維諧振子的波函式 psi_{n}。
引數：
n：
“節點”量子數。對應于波函式中的節點數。
n >= 0
x：
x 座標。
m：
粒子的質量。
omega：
振子的角頻率。
示例
>>> from sympy.physics.qho_1d import psi_n
>>> from sympy.abc import m, x, omega
>>> psi_n(0, x, m, omega)
(m*omega)**(1/4)*exp(-m*omega*x**2/(2*hbar))/(hbar**(1/4)*pi**(1/4))
三維量子諧振子
原文連結：
docs.sympy.org/latest/modules/physics/sho.html
sympy.physics.sho.E_nl(n, l, hw)
返回各向同性諧振子的能量。
引數：
n：
"節點"量子數。
l：
軌道角動量。
hw：
諧振子引數。
注意事項
返回值的單位與hw的單位相匹配，因為能量計算公式為：
( E_{nl} = (2n + l + \frac{3}{2}) \cdot hw )
示例
>>> from sympy.physics.sho import E_nl
>>> from sympy import symbols
>>> x, y, z = symbols('x, y, z')
>>> E_nl(x, y, z)
z*(2*x + y + 3/2)
sympy.physics.sho.R_nl(n, l, nu, r)
返回三維各向同性諧振子的徑向波函式 ( R_{nl} ) 。
引數：
n：
"節點"量子數。對應于波函式中的節點數。
n >= 0
l：
軌道角動量的量子數。
nu：
質量標度頻率：( \nu = \frac{m \cdot \omega}{2 \cdot \hbar} )，其中 ( m ) 是質量， ( \omega ) 是振盪器的頻率。（在原子單位中， ( \nu == \frac{\omega}{2} ) ）
r：
徑向座標。
示例
>>> from sympy.physics.sho import R_nl
>>> from sympy.abc import r, nu, l
>>> R_nl(0, 0, 1, r)
2*2**(3/4)*exp(-r**2)/pi**(1/4)
>>> R_nl(1, 0, 1, r)
4*2**(1/4)*sqrt(3)*(3/2 - 2*r**2)*exp(-r**2)/(3*pi**(1/4))
l、nu 和 r 可能是符號變數：
>>> R_nl(0, 0, nu, r)
2*2**(3/4)*sqrt(nu**(3/2))*exp(-nu*r**2)/pi**(1/4)
>>> R_nl(0, l, 1, r)
r**l*sqrt(2**(l + 3/2)*2**(l + 2)/factorial2(2*l + 1))*exp(-r**2)/pi**(1/4)
徑向波函式的歸一化為：
>>> from sympy import Integral, oo
>>> Integral(R_nl(0, 0, 1, r)**2*r**2, (r, 0, oo)).n()
1.00000000000000
>>> Integral(R_nl(1, 0, 1, r)**2*r**2, (r, 0, oo)).n()
1.00000000000000
>>> Integral(R_nl(1, 1, 1, r)**2*r**2, (r, 0, oo)).n()
1.00000000000000
二次量子化
原文：
docs.sympy.org/latest/modules/physics/secondquant.html
玻色子的二次量子化算符和狀態。
這遵循費特和韋勒克的《多粒子系統的量子理論》的表述。
class sympy.physics.secondquant.AnnihilateBoson(k)
玻色子湮滅算符。
Examples
>>> from sympy.physics.secondquant import B
>>> from sympy.abc import x
>>> B(x)
AnnihilateBoson(x)
apply_operator(state)
如果 self 不是符號化的且 state 是 FockStateKet，則將 state 應用於 self，否則將 self 乘以 state。
Examples
>>> from sympy.physics.secondquant import B, BKet
>>> from sympy.abc import x, y, n
>>> B(x).apply_operator(y)
y*AnnihilateBoson(x)
>>> B(0).apply_operator(BKet((n,)))
sqrt(n)*FockStateBosonKet((n - 1,))
class sympy.physics.secondquant.AnnihilateFermion(k)
費米子湮滅算符。
apply_operator(state)
如果 self 不是符號化的且 state 是 FockStateKet，則將 state 應用於 self，否則將 self 乘以 state。
Examples
>>> from sympy.physics.secondquant import B, Dagger, BKet
>>> from sympy.abc import x, y, n
>>> Dagger(B(x)).apply_operator(y)
y*CreateBoson(x)
>>> B(0).apply_operator(BKet((n,)))
sqrt(n)*FockStateBosonKet((n - 1,))
property is_only_q_annihilator
總是銷燬一個準粒子嗎？（湮滅空穴或湮滅粒子）
Examples
>>> from sympy import Symbol
>>> from sympy.physics.secondquant import F
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> F(a).is_only_q_annihilator
True
>>> F(i).is_only_q_annihilator
False
>>> F(p).is_only_q_annihilator
False
property is_only_q_creator
總是建立一個準粒子嗎？（建立空穴或建立粒子）
Examples
>>> from sympy import Symbol
>>> from sympy.physics.secondquant import F
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> F(a).is_only_q_creator
False
>>> F(i).is_only_q_creator
True
>>> F(p).is_only_q_creator
False
property is_q_annihilator
我們能夠銷燬一個準粒子嗎？（湮滅空穴或湮滅粒子）如果可以，那麼這會在費米麵之上還是之下？
Examples
>>> from sympy import Symbol
>>> from sympy.physics.secondquant import F
>>> a = Symbol('a', above_fermi=1)
>>> i = Symbol('i', below_fermi=1)
>>> p = Symbol('p')
>>> F(a).is_q_annihilator
1
>>> F(i).is_q_annihilator
0
>>> F(p).is_q_annihilator
1
property is_q_creator
我們能夠建立一個準粒子嗎？（建立空穴或建立粒子）如果可以，那麼這會在費米麵之上還是之下？
Examples
>>> from sympy import Symbol
>>> from sympy.physics.secondquant import F
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> F(a).is_q_creator
0
>>> F(i).is_q_creator
-1
>>> F(p).is_q_creator
-1
class sympy.physics.secondquant.AntiSymmetricTensor(symbol, upper, lower)
將上下標儲存在單獨的 Tuple 中。
每組指標假定為反對稱。
Examples
>>> from sympy import symbols
>>> from sympy.physics.secondquant import AntiSymmetricTensor
>>> i, j = symbols('i j', below_fermi=True)
>>> a, b = symbols('a b', above_fermi=True)
>>> AntiSymmetricTensor('v', (a, i), (b, j))
AntiSymmetricTensor(v, (a, i), (b, j))
>>> AntiSymmetricTensor('v', (i, a), (b, j))
-AntiSymmetricTensor(v, (a, i), (b, j))
如您所見，指標會自動排序為規範形式。
property lower
返回較低的指標。
Examples
>>> from sympy import symbols
>>> from sympy.physics.secondquant import AntiSymmetricTensor
>>> i, j = symbols('i,j', below_fermi=True)
>>> a, b = symbols('a,b', above_fermi=True)
>>> AntiSymmetricTensor('v', (a, i), (b, j))
AntiSymmetricTensor(v, (a, i), (b, j))
>>> AntiSymmetricTensor('v', (a, i), (b, j)).lower
(b, j)
property symbol
返回張量的符號。
Examples
>>> from sympy import symbols
>>> from sympy.physics.secondquant import AntiSymmetricTensor
>>> i, j = symbols('i,j', below_fermi=True)
>>> a, b = symbols('a,b', above_fermi=True)
>>> AntiSymmetricTensor('v', (a, i), (b, j))
AntiSymmetricTensor(v, (a, i), (b, j))
>>> AntiSymmetricTensor('v', (a, i), (b, j)).symbol
v
property upper
返回較高的指標。
Examples
>>> from sympy import symbols
>>> from sympy.physics.secondquant import AntiSymmetricTensor
>>> i, j = symbols('i,j', below_fermi=True)
>>> a, b = symbols('a,b', above_fermi=True)
>>> AntiSymmetricTensor('v', (a, i), (b, j))
AntiSymmetricTensor(v, (a, i), (b, j))
>>> AntiSymmetricTensor('v', (a, i), (b, j)).upper
(a, i)
sympy.physics.secondquant.B
別名為AnnihilateBoson
sympy.physics.secondquant.BBra
別名為FockStateBosonBra
sympy.physics.secondquant.BKet
別名為FockStateBosonKet
sympy.physics.secondquant.Bd
別名為CreateBoson
class sympy.physics.secondquant.BosonicBasis
玻色子 Fock 態基礎集合的基類。
class sympy.physics.secondquant.Commutator(a, b)
交換子：[A, B] = AB - BA
根據.cmp()對引數進行排序。
Examples
>>> from sympy import symbols
>>> from sympy.physics.secondquant import Commutator
>>> A, B = symbols('A,B', commutative=False)
>>> Commutator(B, A)
-Commutator(A, B)
使用.doit()評估交換子。
>>> comm = Commutator(A,B); comm
Commutator(A, B)
>>> comm.doit()
A*B - B*A
對於兩個二次量子化算符，交換子立即計算：
>>> from sympy.physics.secondquant import Fd, F
>>> a = symbols('a', above_fermi=True)
>>> i = symbols('i', below_fermi=True)
>>> p,q = symbols('p,q')
>>> Commutator(Fd(a),Fd(i))
2*NO(CreateFermion(a)*CreateFermion(i))
但對於更復雜的表示式，透過呼叫.doit()來觸發評估。
>>> comm = Commutator(Fd(p)*Fd(q),F(i)); comm
Commutator(CreateFermion(p)*CreateFermion(q), AnnihilateFermion(i))
>>> comm.doit(wicks=True)
-KroneckerDelta(i, p)*CreateFermion(q) +
KroneckerDelta(i, q)*CreateFermion(p)
doit(**hints)
啟用計算複雜表示式。
Examples
>>> from sympy.physics.secondquant import Commutator, F, Fd
>>> from sympy import symbols
>>> i, j = symbols('i,j', below_fermi=True)
>>> a, b = symbols('a,b', above_fermi=True)
>>> c = Commutator(Fd(a)*F(i),Fd(b)*F(j))
>>> c.doit(wicks=True)
0
classmethod eval(a, b)
交換子[A, B]在 A < B 時處於規範形式。
Examples
>>> from sympy.physics.secondquant import Commutator, F, Fd
>>> from sympy.abc import x
>>> c1 = Commutator(F(x), Fd(x))
>>> c2 = Commutator(Fd(x), F(x))
>>> Commutator.eval(c1, c2)
0
class sympy.physics.secondquant.CreateBoson(k)
玻色子產生算符。
apply_operator(state)
如果 self 不是符號化的且 state 是 FockStateKet，則將 state 應用於 self，否則將 self 乘以 state。
Examples
>>> from sympy.physics.secondquant import B, Dagger, BKet
>>> from sympy.abc import x, y, n
>>> Dagger(B(x)).apply_operator(y)
y*CreateBoson(x)
>>> B(0).apply_operator(BKet((n,)))
sqrt(n)*FockStateBosonKet((n - 1,))
class sympy.physics.secondquant.CreateFermion(k)
費米子產生算符。
apply_operator(state)
如果 self 不是符號化的且 state 是 FockStateKet，則將 state 應用於 self，否則將 self 乘以 state。
Examples
>>> from sympy.physics.secondquant import B, Dagger, BKet
>>> from sympy.abc import x, y, n
>>> Dagger(B(x)).apply_operator(y)
y*CreateBoson(x)
>>> B(0).apply_operator(BKet((n,)))
sqrt(n)*FockStateBosonKet((n - 1,))
property is_only_q_annihilator
總是銷燬一個準粒子嗎？（湮滅空穴或湮滅粒子）
Examples
>>> from sympy import Symbol
>>> from sympy.physics.secondquant import Fd
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> Fd(a).is_only_q_annihilator
False
>>> Fd(i).is_only_q_annihilator
True
>>> Fd(p).is_only_q_annihilator
False
property is_only_q_creator
總是建立一個準粒子嗎？（建立空穴或建立粒子）
Examples
>>> from sympy import Symbol
>>> from sympy.physics.secondquant import Fd
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> Fd(a).is_only_q_creator
True
>>> Fd(i).is_only_q_creator
False
>>> Fd(p).is_only_q_creator
False
property is_q_annihilator
我們能夠銷燬一個準粒子嗎？（湮滅空穴或湮滅粒子）如果可以，那麼這會在費米麵之上還是之下？
Examples
>>> from sympy import Symbol
>>> from sympy.physics.secondquant import Fd
>>> a = Symbol('a', above_fermi=1)
>>> i = Symbol('i', below_fermi=1)
>>> p = Symbol('p')
>>> Fd(a).is_q_annihilator
0
>>> Fd(i).is_q_annihilator
-1
>>> Fd(p).is_q_annihilator
-1
property is_q_creator
我們能夠建立一個準粒子嗎？（建立空穴或建立粒子）如果可以，那麼這會在費米麵之上還是之下？
Examples
>>> from sympy import Symbol
>>> from sympy.physics.secondquant import Fd
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> Fd(a).is_q_creator
1
>>> Fd(i).is_q_creator
0
>>> Fd(p).is_q_creator
1
class sympy.physics.secondquant.Dagger(arg)
建立/湮滅算符的厄米共軛。
示例。
>>> from sympy import I
>>> from sympy.physics.secondquant import Dagger, B, Bd
>>> Dagger(2*I)
-2*I
>>> Dagger(B(0))
CreateBoson(0)
>>> Dagger(Bd(0))
AnnihilateBoson(0)
classmethod eval(arg)
評估 Dagger 例項。
示例。
>>> from sympy import I
>>> from sympy.physics.secondquant import Dagger, B, Bd
>>> Dagger(2*I)
-2*I
>>> Dagger(B(0))
CreateBoson(0)
>>> Dagger(Bd(0))
AnnihilateBoson(0)
自動呼叫 eval() 方法。
sympy.physics.secondquant.F
AnnihilateFermion 的別名。
sympy.physics.secondquant.FBra
FockStateFermionBra 的別名。
sympy.physics.secondquant.FKet
FockStateFermionKet 的別名。
sympy.physics.secondquant.Fd
CreateFermion 的別名。
class sympy.physics.secondquant.FixedBosonicBasis(n_particles, n_levels)
固定粒子數的基組。
示例。
>>> from sympy.physics.secondquant import FixedBosonicBasis
>>> b = FixedBosonicBasis(2, 2)
>>> state = b.state(1)
>>> b
[FockState((2, 0)), FockState((1, 1)), FockState((0, 2))]
>>> state
FockStateBosonKet((1, 1))
>>> b.index(state)
1
index(state)
返回基礎中狀態的索引。
示例。
>>> from sympy.physics.secondquant import FixedBosonicBasis
>>> b = FixedBosonicBasis(2, 3)
>>> b.index(b.state(3))
3
state(i)
返回在基礎中索引為 i 的態。
示例。
>>> from sympy.physics.secondquant import FixedBosonicBasis
>>> b = FixedBosonicBasis(2, 3)
>>> b.state(3)
FockStateBosonKet((1, 0, 1))
class sympy.physics.secondquant.FockState(occupations)
具有一系列佔據數的多粒子 Fock 態。
在任何可以有 FockState 的地方，也可以有 S.Zero。所有程式碼必須檢查這一點！
代表 FockStates 的基類。
class sympy.physics.secondquant.FockStateBosonBra(occupations)
描述了一組 BosonBra 粒子。
示例。
>>> from sympy.physics.secondquant import BBra
>>> BBra([1, 2])
FockStateBosonBra((1, 2))
class sympy.physics.secondquant.FockStateBosonKet(occupations)
具有一系列佔據數的多粒子 Fock 態。
佔據數可以是任何大於等於 0 的整數。
示例。
>>> from sympy.physics.secondquant import BKet
>>> BKet([1, 2])
FockStateBosonKet((1, 2))
class sympy.physics.secondquant.FockStateBra(occupations)
左矢的表示。
class sympy.physics.secondquant.FockStateFermionBra(occupations, fermi_level=0)
示例。
>>> from sympy.physics.secondquant import FBra
>>> FBra([1, 2])
FockStateFermionBra((1, 2))
另請參見。
FockStateFermionKet
class sympy.physics.secondquant.FockStateFermionKet(occupations, fermi_level=0)
具有一系列佔據軌道的多粒子 Fock 態。
解釋。
每個狀態只能有一個粒子，因此我們選擇儲存一組佔據軌道而不是具有佔據數（零和一）的元組。
費米麵以下的態被稱為空穴，並且在佔據列表中用負標籤表示。
對於符號態標籤，費米麵限制了允許的空穴態數。
示例。
>>> from sympy.physics.secondquant import FKet
>>> FKet([1, 2])
FockStateFermionKet((1, 2))
class sympy.physics.secondquant.FockStateKet(occupations)
右矢的表示。
class sympy.physics.secondquant.InnerProduct(bra, ket)
一個未評估的左矢和右矢之間的內積。
解釋。
目前該類只將事物簡化為 Kronecker Delta 的乘積。將來，我們可以引入像 |a> 和 |b> 這樣的抽象態，並將內積保持為未評估狀態 <a|b>。
property bra
返回態的左矢部分。
property ket
返回態的右矢部分。
class sympy.physics.secondquant.KroneckerDelta(i, j, delta_range=None)
離散或 Kronecker Delta 函式。
引數：
i：數字，符號
Delta 函式的第一個索引。
j：數字，符號
Delta 函式的第二個索引。
解釋。
一個函式，接受兩個整數 (i) 和 (j)。如果 (i) 和 (j) 不相等，則返回 (0)，如果相等，則返回 (1)。
示例。
具有整數索引的示例：
>>> from sympy import KroneckerDelta
>>> KroneckerDelta(1, 2)
0
>>> KroneckerDelta(3, 3)
1
符號索引：
>>> from sympy.abc import i, j, k
>>> KroneckerDelta(i, j)
KroneckerDelta(i, j)
>>> KroneckerDelta(i, i)
1
>>> KroneckerDelta(i, i + 1)
0
>>> KroneckerDelta(i, i + 1 + k)
KroneckerDelta(i, i + k + 1)
另請參見。
eval，DiracDelta
參考文獻。
[R771]
en.wikipedia.org/wiki/Kronecker_delta
classmethod eval(i, j, delta_range=None)
評估離散 Delta 函式。
示例。
>>> from sympy import KroneckerDelta
>>> from sympy.abc import i, j, k
>>> KroneckerDelta(i, j)
KroneckerDelta(i, j)
>>> KroneckerDelta(i, i)
1
>>> KroneckerDelta(i, i + 1)
0
>>> KroneckerDelta(i, i + 1 + k)
KroneckerDelta(i, i + k + 1)
間接的 doctest。
property indices_contain_equal_information
返回 True，如果指標要麼都在費米能級上，要麼都在費米能級下。
示例
>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, q).indices_contain_equal_information
True
>>> KroneckerDelta(p, q+1).indices_contain_equal_information
True
>>> KroneckerDelta(i, p).indices_contain_equal_information
False
property is_above_fermi
如果 Delta 在費米能級上方可以非零，則為真。
示例
>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, a).is_above_fermi
True
>>> KroneckerDelta(p, i).is_above_fermi
False
>>> KroneckerDelta(p, q).is_above_fermi
True
另請參閱
is_below_fermi, is_only_below_fermi, is_only_above_fermi
property is_below_fermi
如果 Delta 在費米能級下方可以非零，則為真。
示例
>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, a).is_below_fermi
False
>>> KroneckerDelta(p, i).is_below_fermi
True
>>> KroneckerDelta(p, q).is_below_fermi
True
另請參閱
is_above_fermi, is_only_above_fermi, is_only_below_fermi
property is_only_above_fermi
如果 Delta 受限於費米能級上方，則為真。
示例
>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, a).is_only_above_fermi
True
>>> KroneckerDelta(p, q).is_only_above_fermi
False
>>> KroneckerDelta(p, i).is_only_above_fermi
False
另請參閱
is_above_fermi, is_below_fermi, is_only_below_fermi
property is_only_below_fermi
如果 Delta 受限於費米能級下方，則為真。
示例
>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, i).is_only_below_fermi
True
>>> KroneckerDelta(p, q).is_only_below_fermi
False
>>> KroneckerDelta(p, a).is_only_below_fermi
False
另請參閱
is_above_fermi, is_below_fermi, is_only_above_fermi
property killable_index
返回在最終表示式中要替換的首選指標。
解釋
要替換的指標是在費米能級方面具有較少資訊的指標。如果指標包含相同資訊，則‘a’優於‘b’。
示例
>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> j = Symbol('j', below_fermi=True)
>>> p = Symbol('p')
>>> KroneckerDelta(p, i).killable_index
p
>>> KroneckerDelta(p, a).killable_index
p
>>> KroneckerDelta(i, j).killable_index
j
另請參閱
preferred_index
property preferred_index
返回在最終表示式中要保留的首選指標。
解釋
首選指標是在費米能級方面具有更多資訊的指標。如果指標包含相同資訊，則‘a’優於‘b’。
示例
>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> j = Symbol('j', below_fermi=True)
>>> p = Symbol('p')
>>> KroneckerDelta(p, i).preferred_index
i
>>> KroneckerDelta(p, a).preferred_index
a
>>> KroneckerDelta(i, j).preferred_index
i
另請參閱
killable_index
class sympy.physics.secondquant.NO(arg)
該物件用於表示正規順序括號。
即 {abcd} 有時寫作 🔡
解釋
對一個引數應用 NO(arg)函式意味著假設引數中的所有算符均反對易，並且具有消失的收縮。這允許在物件建立時立即重新排序為規範形式。
例子
>>> from sympy import symbols
>>> from sympy.physics.secondquant import NO, F, Fd
>>> p,q = symbols('p,q')
>>> NO(Fd(p)*F(q))
NO(CreateFermion(p)*AnnihilateFermion(q))
>>> NO(F(q)*Fd(p))
-NO(CreateFermion(p)*AnnihilateFermion(q))
注意
如果您想生成一個表示式的正規順序等價物，則應使用 wicks()函式。此類僅指示括號內的所有算符均反對易，並具有消失的收縮。不多不少。
doit(**hints)
要麼去掉括號或在其引數中啟用複雜計算。
例子
>>> from sympy.physics.secondquant import NO, Fd, F
>>> from textwrap import fill
>>> from sympy import symbols, Dummy
>>> p,q = symbols('p,q', cls=Dummy)
>>> print(fill(str(NO(Fd(p)*F(q)).doit())))
KroneckerDelta(_a, _p)*KroneckerDelta(_a,
_q)*CreateFermion(_a)*AnnihilateFermion(_a) + KroneckerDelta(_a,
_p)*KroneckerDelta(_i, _q)*CreateFermion(_a)*AnnihilateFermion(_i) -
KroneckerDelta(_a, _q)*KroneckerDelta(_i,
_p)*AnnihilateFermion(_a)*CreateFermion(_i) - KroneckerDelta(_i,
_p)*KroneckerDelta(_i, _q)*AnnihilateFermion(_i)*CreateFermion(_i)
get_subNO(i)
返回在索引 i 處沒有 FermionicOperator 的 NO()。
例子
>>> from sympy import symbols
>>> from sympy.physics.secondquant import F, NO
>>> p, q, r = symbols('p,q,r')
>>> NO(F(p)*F(q)*F(r)).get_subNO(1)
NO(AnnihilateFermion(p)*AnnihilateFermion(r))
property has_q_annihilators
如果第一個引數的最右邊引數不是 q 湮滅算符，則返回 0，否則如果其在費米麵上方則返回 1，如果在費米麵下方則返回-1。
例子
>>> from sympy import symbols
>>> from sympy.physics.secondquant import NO, F, Fd
>>> a = symbols('a', above_fermi=True)
>>> i = symbols('i', below_fermi=True)
>>> NO(Fd(a)*Fd(i)).has_q_annihilators
-1
>>> NO(F(i)*F(a)).has_q_annihilators
1
>>> NO(Fd(a)*F(i)).has_q_annihilators
0
property has_q_creators
如果第一個引數的最左邊引數不是 q 創造算符，則返回 0，否則如果其在費米麵上方則返回 1，如果在費米麵下方則返回-1。
例子
>>> from sympy import symbols
>>> from sympy.physics.secondquant import NO, F, Fd
>>> a = symbols('a', above_fermi=True)
>>> i = symbols('i', below_fermi=True)
>>> NO(Fd(a)*Fd(i)).has_q_creators
1
>>> NO(F(i)*F(a)).has_q_creators
-1
>>> NO(Fd(i)*F(a)).has_q_creators
0
iter_q_annihilators()
迭代湮滅算符。
例子
>>> from sympy import symbols
>>> i, j = symbols('i j', below_fermi=True)
>>> a, b = symbols('a b', above_fermi=True)
>>> from sympy.physics.secondquant import NO, F, Fd
>>> no = NO(Fd(a)*F(i)*F(b)*Fd(j))
>>> no.iter_q_creators()
<generator object... at 0x...>
>>> list(no.iter_q_creators())
[0, 1]
>>> list(no.iter_q_annihilators())
[3, 2]
iter_q_creators()
迭代建立算符。
例子
>>> from sympy import symbols
>>> i, j = symbols('i j', below_fermi=True)
>>> a, b = symbols('a b', above_fermi=True)
>>> from sympy.physics.secondquant import NO, F, Fd
>>> no = NO(Fd(a)*F(i)*F(b)*Fd(j))
>>> no.iter_q_creators()
<generator object... at 0x...>
>>> list(no.iter_q_creators())
[0, 1]
>>> list(no.iter_q_annihilators())
[3, 2]
class sympy.physics.secondquant.PermutationOperator(i, j)
表示指數置換算符 P(ij)。
P(ij)f(i)g(j) = f(i)g(j) - f(j)g(i)
get_permuted(expr)
返回具有置換指數的-expr。
解釋
>>> from sympy import symbols, Function
>>> from sympy.physics.secondquant import PermutationOperator
>>> p,q = symbols('p,q')
>>> f = Function('f')
>>> PermutationOperator(p,q).get_permuted(f(p,q))
-f(q, p)
class sympy.physics.secondquant.VarBosonicBasis(n_max)
一個單態、變粒子數的基組。
例子
>>> from sympy.physics.secondquant import VarBosonicBasis
>>> b = VarBosonicBasis(5)
>>> b
[FockState((0,)), FockState((1,)), FockState((2,)),
FockState((3,)), FockState((4,))]
index(state)
返回基礎中狀態的索引。
例子
>>> from sympy.physics.secondquant import VarBosonicBasis
>>> b = VarBosonicBasis(3)
>>> state = b.state(1)
>>> b
[FockState((0,)), FockState((1,)), FockState((2,))]
>>> state
FockStateBosonKet((1,))
>>> b.index(state)
1
state(i)
單一基組的狀態。
例子
>>> from sympy.physics.secondquant import VarBosonicBasis
>>> b = VarBosonicBasis(5)
>>> b.state(3)
FockStateBosonKet((3,))
sympy.physics.secondquant.apply_operators(e)
以 SymPy 表示式和算符為引數，應用這些算符。
例子
>>> from sympy.physics.secondquant import apply_operators
>>> from sympy import sympify
>>> apply_operators(sympify(3)+4)
7
sympy.physics.secondquant.contraction(a, b)
計算 Fermionic 算符 a 和 b 的收縮。
例子
>>> from sympy import symbols
>>> from sympy.physics.secondquant import F, Fd, contraction
>>> p, q = symbols('p,q')
>>> a, b = symbols('a,b', above_fermi=True)
>>> i, j = symbols('i,j', below_fermi=True)
收縮僅在準創造算符位於準湮滅算符右側時才非零：
>>> contraction(F(a),Fd(b))
KroneckerDelta(a, b)
>>> contraction(Fd(i),F(j))
KroneckerDelta(i, j)
對於一般指標，非零結果將限制指標位於費米麵以下/以上：
>>> contraction(Fd(p),F(q))
KroneckerDelta(_i, q)*KroneckerDelta(p, q)
>>> contraction(F(p),Fd(q))
KroneckerDelta(_a, q)*KroneckerDelta(p, q)
兩個建立算符或兩個湮滅算符總是消失的：
>>> contraction(F(p),F(q))
0
>>> contraction(Fd(p),Fd(q))
0
sympy.physics.secondquant.evaluate_deltas(e)
我們在表示式中假設按照愛因斯坦求和約定評估 KroneckerDelta 符號。
解釋
如果一個指標重複，則對其求和，並實際上用另一個指標代替它。如果兩個指標都重複，則根據首選指標進行替換。這由 KroneckerDelta.preferred_index 和 KroneckerDelta.killable_index 決定。
如果沒有可能的替換或者替換會導致資訊丟失，則不進行任何操作。
如果一個指標出現在多個 KroneckerDelta 中，則結果的替換取決於因子的順序。由於排序依賴於平臺，因此從此函式得到的文字表達可能難以預測。
例子
我們假設以下情況：
>>> from sympy import symbols, Function, Dummy, KroneckerDelta
>>> from sympy.physics.secondquant import evaluate_deltas
>>> i,j = symbols('i j', below_fermi=True, cls=Dummy)
>>> a,b = symbols('a b', above_fermi=True, cls=Dummy)
>>> p,q = symbols('p q', cls=Dummy)
>>> f = Function('f')
>>> t = Function('t')
根據 KroneckerDelta，這些指標的優先順序是(a, b, i, j, p, q)。
簡單的情況：
>>> evaluate_deltas(KroneckerDelta(i,j)*f(i)) # d_ij f(i) -> f(j)
f(_j)
>>> evaluate_deltas(KroneckerDelta(i,j)*f(j)) # d_ij f(j) -> f(i)
f(_i)
>>> evaluate_deltas(KroneckerDelta(i,p)*f(p)) # d_ip f(p) -> f(i)
f(_i)
>>> evaluate_deltas(KroneckerDelta(q,p)*f(p)) # d_qp f(p) -> f(q)
f(_q)
>>> evaluate_deltas(KroneckerDelta(q,p)*f(q)) # d_qp f(q) -> f(p)
f(_p)
更有趣的情況：
>>> evaluate_deltas(KroneckerDelta(i,p)*t(a,i)*f(p,q))
f(_i, _q)*t(_a, _i)
>>> evaluate_deltas(KroneckerDelta(a,p)*t(a,i)*f(p,q))
f(_a, _q)*t(_a, _i)
>>> evaluate_deltas(KroneckerDelta(p,q)*f(p,q))
f(_p, _p)
最後，這裡有一些不做任何操作的情況，因為那將意味著資訊的丟失：
>>> evaluate_deltas(KroneckerDelta(i,p)*f(q))
f(_q)*KroneckerDelta(_i, _p)
>>> evaluate_deltas(KroneckerDelta(i,p)*f(i))
f(_i)*KroneckerDelta(_i, _p)
sympy.physics.secondquant.matrix_rep(op, basis)
查詢算符在基組中的表示。
例子
>>> from sympy.physics.secondquant import VarBosonicBasis, B, matrix_rep
>>> b = VarBosonicBasis(5)
>>> o = B(0)
>>> matrix_rep(o, b)
Matrix([
[0, 1, 0, 0, 0],
[0, 0, sqrt(2), 0, 0],
[0, 0, 0, sqrt(3), 0],
[0, 0, 0, 0, 2],
[0, 0, 0, 0, 0]])
sympy.physics.secondquant.simplify_index_permutations(expr, permutation_operators)
透過引入適當的置換算符來執行簡化。
解釋
示意性地：
[abij] - [abji] - [baij] + [baji] -> P(ab)P(ij)[abij]
permutation_operators 是要考慮的置換算符列表。
如果 permutation_operators=[P(ab),P(ij)]，我們將嘗試在表示式中引入排列運算元 P(ij)和 P(ab)。如果還有其他可能的簡化，我們將忽略它們。
>>> from sympy import symbols, Function
>>> from sympy.physics.secondquant import simplify_index_permutations
>>> from sympy.physics.secondquant import PermutationOperator
>>> p,q,r,s = symbols('p,q,r,s')
>>> f = Function('f')
>>> g = Function('g')
>>> expr = f(p)*g(q) - f(q)*g(p); expr
f(p)*g(q) - f(q)*g(p)
>>> simplify_index_permutations(expr,[PermutationOperator(p,q)])
f(p)*g(q)*PermutationOperator(p, q)
>>> PermutList = [PermutationOperator(p,q),PermutationOperator(r,s)]
>>> expr = f(p,r)*g(q,s) - f(q,r)*g(p,s) + f(q,s)*g(p,r) - f(p,s)*g(q,r)
>>> simplify_index_permutations(expr,PermutList)
f(p, r)*g(q, s)*PermutationOperator(p, q)*PermutationOperator(r, s)
sympy.physics.secondquant.substitute_dummies(expr, new_indices=False, pretty_indices={})
透過替換虛擬變數來收集項。
解釋
此例程允許簡化包含僅因虛擬變數而不同的項的 Add 表示式。
這個想法是根據項的結構一致地替換所有虛擬變數。對於每個項，我們獲得一個所有虛擬變數的序列，其中順序由索引範圍、索引所屬的因子以及其在每個因子中的位置決定。有關虛擬變數排序的更多資訊，請參閱 _get_ordered_dummies()。然後在每個項中一致地進行替換。
示例
>>> from sympy import symbols, Function, Dummy
>>> from sympy.physics.secondquant import substitute_dummies
>>> a,b,c,d = symbols('a b c d', above_fermi=True, cls=Dummy)
>>> i,j = symbols('i j', below_fermi=True, cls=Dummy)
>>> f = Function('f')
>>> expr = f(a,b) + f(c,d); expr
f(_a, _b) + f(_c, _d)
由於 a、b、c 和 d 是等效的求和索引，因此表示式可以簡化為單一項（其中虛擬指數仍然被求和）
>>> substitute_dummies(expr)
2*f(_a, _b)
控制輸出：
預設情況下，將在表示式中已經存在的虛擬符號重新用於不同的排列。然而，如果 new_indices=True，則會生成並插入新的虛擬符號。“pretty_indices”關鍵字可用於控制此新符號的生成。
預設情況下，新的虛擬符號將以 i_1、i_2、a_1 等形式生成。如果您提供一個鍵值對字典，形式為：
這些字母將用作新虛擬符號的標籤。index_groups 必須是“above”、“below”或“general”之一。
>>> expr = f(a,b,i,j)
>>> my_dummies = { 'above':'st', 'below':'uv' }
>>> substitute_dummies(expr, new_indices=True, pretty_indices=my_dummies)
f(_s, _t, _u, _v)
如果我們用完了字母，或者某些 index_group 沒有關鍵字，則預設的虛擬生成器將作為後備：
>>> p,q = symbols('p q', cls=Dummy) # general indices
>>> expr = f(p,q)
>>> substitute_dummies(expr, new_indices=True, pretty_indices=my_dummies)
f(_p_0, _p_1)
sympy.physics.secondquant.wicks(e, **kw_args)
使用 Wick 定理返回表示式的正常排序等效物。
示例
>>> from sympy import symbols, Dummy
>>> from sympy.physics.secondquant import wicks, F, Fd
>>> p, q, r = symbols('p,q,r')
>>> wicks(Fd(p)*F(q))
KroneckerDelta(_i, q)*KroneckerDelta(p, q) + NO(CreateFermion(p)*AnnihilateFermion(q))
預設情況下，表示式被展開：
>>> wicks(F(p)*(F(q)+F(r)))
NO(AnnihilateFermion(p)*AnnihilateFermion(q)) + NO(AnnihilateFermion(p)*AnnihilateFermion(r))
使用關鍵字“keep_only_fully_contracted=True”，僅返回完全收縮的項。
根據請求，結果可以按以下順序簡化：
– KroneckerDelta 函式被評估 – 虛擬變數在各項中一致地替換
>>> p, q, r = symbols('p q r', cls=Dummy)
>>> wicks(Fd(p)*(F(q)+F(r)), keep_only_fully_contracted=True)
KroneckerDelta(_i, _q)*KroneckerDelta(_p, _q) + KroneckerDelta(_i, _r)*KroneckerDelta(_p, _r)
Wigner 符號
原文：
docs.sympy.org/latest/modules/physics/wigner.html
Wigner、Clebsch-Gordan、Racah 和 Gaunt 係數
集合函式用於精確計算 Wigner 3j、6j、9j、Clebsch-Gordan、Racah 以及 Gaunt 係數，所有的計算結果都是有理數乘以有理數的平方根[Rasch03]。
請參閱個別函式的描述以獲取更多詳細資訊和示例。
參考文獻
[Regge58] (1,2)
‘Clebsch-Gordan 係數的對稱性質’, T. Regge, Nuovo Cimento, 卷 10, pp. 544 (1958)
[Regge59]
‘Racah 係數的對稱性質’, T. Regge, Nuovo Cimento, 卷 11, pp. 116 (1959)
[Edmonds74] (1,2,3,4,5,6,7,8,9,10)
A. R. Edmonds. Angular momentum in quantum mechanics. Investigations in physics, 4.; Investigations in physics, no. 4. Princeton, N.J., Princeton University Press, 1957.
[Rasch03] (1,2,3,4,5,6,7,8,9)
J. Rasch 和 A. C. H. Yu, ‘為預先計算的 Wigner 3j、6j 和 Gaunt 係數提供高效儲存方案’, SIAM J. Sci. Comput. 卷 25, 期 4, pp. 1416-1428 (2003)
[Liberatodebrito82]
‘FORTRAN 程式計算三個球面諧波的積分’, A. Liberato de Brito, Comput. Phys. Commun., 卷 25, pp. 81-85 (1982)
[Homeier96] (1,2)
‘一些真實球面諧波耦合係數的性質及其與 Gaunt 係數的關係’, H. H. H. Homeier 和 E. O. Steinborn J. Mol. Struct., 卷 368, pp. 31-37 (1996)
Credits and Copyright
這段程式碼取自 Sage，經過了所有作者的允許：
groups.google.com/forum/#!topic/sage-devel/M4NZdu-7O38
作者
-
Jens Rasch (2009-03-24): Sage 的初始版本
-
Jens Rasch (2009-05-31): updated to sage-4.0
-
Oscar Gerardo Lazo Arjona (2017-06-18): added Wigner D matrices
-
Phil Adam LeMaitre (2022-09-19): 新增了真實的 Gaunt 係數
版權所有 (C) 2008 Jens Rasch jyr2000@gmail.com
sympy.physics.wigner.clebsch_gordan(j_1, j_2, j_3, m_1, m_2, m_3)
計算 Clebsch-Gordan 係數。 (\left\langle j_1 m_1 ; j_2 m_2 | j_3 m_3 \right\rangle)。
這個函式的參考資料是[Edmonds74]。
Parameters:
j_1, j_2, j_3, m_1, m_2, m_3 :
整數或半整數。
返回：
有理數乘以有理數的平方根。
示例
>>> from sympy import S
>>> from sympy.physics.wigner import clebsch_gordan
>>> clebsch_gordan(S(3)/2, S(1)/2, 2, S(3)/2, S(1)/2, 2)
1
>>> clebsch_gordan(S(3)/2, S(1)/2, 1, S(3)/2, -S(1)/2, 1)
sqrt(3)/2
>>> clebsch_gordan(S(3)/2, S(1)/2, 1, -S(1)/2, S(1)/2, 0)
-sqrt(2)/2
註記
Clebsch-Gordan 係數將透過其與 Wigner 3j 符號的關係進行評估：
[\left\langle j_1 m_1 ; j_2 m_2 | j_3 m_3 \right\rangle =(-1)^{j_1-j_2+m_3} \sqrt{2j_3+1} \operatorname{Wigner3j}(j_1,j_2,j_3,m_1,m_2,-m_3)]
檢視 Wigner 3j 符號的文件，它展示了比 Clebsch-Gordan 係數更高的對稱關係。
Authors
- Jens Rasch（2009-03-24）：初始版本
sympy.physics.wigner.dot_rot_grad_Ynm(j, p, l, m, theta, phi)
返回球面諧波的旋轉梯度的點積。
解釋
此函式返回以下表示式的右側：
[\vec{R}Y{j^{p}} \cdot \vec{R}Y{l^{m}} = (-1)^{m+p} \sum\limits{l+j}Y{_k{m+p}} * \alpha * \frac{1}{2} (k²-j²-l²+k-j-l)]
引數
j, p, l, m …. 球面諧波的指數（表示式或整數）theta, phi …. 球面諧波的角度引數
示例
>>> from sympy import symbols
>>> from sympy.physics.wigner import dot_rot_grad_Ynm
>>> theta, phi = symbols("theta phi")
>>> dot_rot_grad_Ynm(3, 2, 2, 0, theta, phi).doit()
3*sqrt(55)*Ynm(5, 2, theta, phi)/(11*sqrt(pi))
sympy.physics.wigner.gaunt(l_1, l_2, l_3, m_1, m_2, m_3, prec=None)
計算高斯係數。
引數：
l_1, l_2, l_3, m_1, m_2, m_3 :
整數。
prec - 精度，預設為 None。
提供精度可以大大加快計算速度。
返回：
有理數乘以有理數的平方根
(如果 prec=None)，或者如果指定了精度，則為實數。
解釋
高斯係數定義為三個球面諧波的積分：
[\begin{split}\begin{aligned} \operatorname{Gaunt}(l_1,l_2,l_3,m_1,m_2,m_3) &=\int Y_{l_1,m_1}(\Omega) Y_{l_2,m_2}(\Omega) Y_{l_3,m_3}(\Omega) ,d\Omega \ &=\sqrt{\frac{(2l_1+1)(2l_2+1)(2l_3+1)}{4\pi}} \operatorname{Wigner3j}(l_1,l_2,l_3,0,0,0) \operatorname{Wigner3j}(l_1,l_2,l_3,m_1,m_2,m_3) \end{aligned}\end{split}]
示例
>>> from sympy.physics.wigner import gaunt
>>> gaunt(1,0,1,1,0,-1)
-1/(2*sqrt(pi))
>>> gaunt(1000,1000,1200,9,3,-12).n(64)
0.006895004219221134484332976156744208248842039317638217822322799675
在 (l) 和 (m) 的非整數值上使用是錯誤的：
sage: gaunt(1.2,0,1.2,0,0,0)
Traceback (most recent call last):
...
ValueError: l values must be integer
sage: gaunt(1,0,1,1.1,0,-1.1)
Traceback (most recent call last):
...
ValueError: m values must be integer
註記
高斯係數遵循以下對稱規則：
-
在列的任何排列下不變
[\begin{split}\begin{aligned} Y(l_1,l_2,l_3,m_1,m_2,m_3) &=Y(l_3,l_1,l_2,m_3,m_1,m_2) \ &=Y(l_2,l_3,l_1,m_2,m_3,m_1) \ &=Y(l_3,l_2,l_1,m_3,m_2,m_1) \ &=Y(l_1,l_3,l_2,m_1,m_3,m_2) \ &=Y(l_2,l_1,l_3,m_2,m_1,m_3) \end{aligned}\end{split}]
-
在空間反射下不變，即
[Y(l_1,l_2,l_3,m_1,m_2,m_3) =Y(l_1,l_2,l_3,-m_1,-m_2,-m_3)]
-
對於 (3j) 符號的 72 個 Regge 對稱性，關於對稱：
-
對於不滿足三角關係的 (l_1), (l_2), (l_3) 為零
-
違反條件之一為零：(l_1 \ge |m_1|), (l_2 \ge |m_2|), (l_3 \ge |m_3|)
-
僅對 (l_i) 的偶數和 (L = l_1 + l_2 + l_3 = 2n) 的 (n \in \mathbb{N}) 非零
演算法
此函式使用[Liberatodebrito82]的演算法精確計算 Gaunt 係數的值。注意，該公式包含大階乘的交替求和，因此不適合有限精度算術，只適用於計算代數系統[Rasch03]。
作者
Jens Rasch（2009-03-24）：Sage 的初始版本。
sympy.physics.wigner.racah(aa, bb, cc, dd, ee, ff, prec=None)
計算 Racah 符號 (W(a,b,c,d;e,f))。
引數：
a, …, f :
整數或半整數。
prec :
精度，預設為
None。提供精度可以大大加快計算速度。
返回：
有理數乘以有理數的平方根
(如果 prec=None)，或者如果指定了精度，則為實數。
示例
>>> from sympy.physics.wigner import racah
>>> racah(3,3,3,3,3,3)
-1/14
註記
Racah 符號與 Wigner 6j 符號相關：
[\operatorname{Wigner6j}(j_1,j_2,j_3,j_4,j_5,j_6) =(-1)^{j_1+j_2+j_4+j_5} W(j_1,j_2,j_5,j_4,j_3,j_6)]
請參閱 6j 符號，瞭解其更豐富的對稱性和其他屬性。
演算法
此函式使用[Edmonds74]的演算法來精確計算 6j 符號的值。請注意，該公式包含大因子的交錯和，因此不適合有限精度算術，只適用於計算代數系統[Rasch03]。
作者
- Jens Rasch（2009-03-24）：初始版本
sympy.physics.wigner.real_gaunt(l_1, l_2, l_3, m_1, m_2, m_3, prec=None)
計算實高斯係數。
引數：
l_1, l_2, l_3, m_1, m_2, m_3：
整數。
prec - 精度，預設：None。
提供精度可以顯著加快計算速度。
返回：
有理數乘以有理數的平方根。
解釋
實高斯係數被定義為對三個實球諧函式的積分：
[\begin{split}\begin{aligned} \operatorname{RealGaunt}(l_1,l_2,l_3,m_1,m_2,m_3) &=\int Z^{m_1}{l_1}(\Omega) Z^{m_2}(\Omega) Z^{m_3}_{l_3}(\Omega) ,d\Omega \ \end{aligned}\end{split}]
或者，可以透過將實球諧函式與標準球諧函式透過酉變換 (U) 關聯來定義，即 (Z{m}_{l}(\Omega)=\sum_{m'}U{m'}Y^{m'}(\Omega)) [Homeier96]。則實高斯係數被定義為
[\begin{split}\begin{aligned} \operatorname{RealGaunt}(l_1,l_2,l_3,m_1,m_2,m_3) &=\int Z^{m_1}{l_1}(\Omega) Z^{m_2}(\Omega) Z^{m_3}{l_3}(\Omega) ,d\Omega \ &=\sum{m'_1 m'_2 m'3} U{m_1}_{m'_1}U{m'2}U^{m_3} \operatorname{Gaunt}(l_1,l_2,l_3,m'_1,m'_2,m'_3) \end{aligned}\end{split}]
酉矩陣 (U) 的分量為
[\begin{aligned} U^m_{m'} = \delta_{|m||m'|}(\delta_{m'0}\delta_{m0} + \frac{1}{\sqrt{2}}\big[\Theta(m) \big(\delta_{m'm}+(-1){m'}\delta_{m'-m}\big)+i\Theta(-m)\big((-1) \delta_{m'-m}-\delta_{m'm}(-1)^{m'-m}\big)\big]) \end{aligned}]
其中 (\delta_{ij}) 是克羅內克 δ 符號，(\Theta) 是定義為的階躍函式
[\begin{split}\begin{aligned} \Theta(x) = \begin{cases} 1 ,\text{for}, x > 0 \ 0 ,\text{for}, x \leq 0 \end{cases} \end{aligned}\end{split}]
例子
>>> from sympy.physics.wigner import real_gaunt
>>> real_gaunt(2,2,4,-1,-1,0)
-2/(7*sqrt(pi))
>>> real_gaunt(10,10,20,-9,-9,0).n(64)
-0.00002480019791932209313156167176797577821140084216297395518482071448
對於 (l) 和 (m) 的非整數值使用是錯誤的::
real_gaunt(2.8,0.5,1.3,0,0,0) 追溯到（最近的呼叫）... ValueError: l values must be integer real_gaunt(2,2,4,0.7,1,-3.4) 追溯到（最近的呼叫）... ValueError: m values must be integer
注意
實高斯係數繼承自標準高斯係數，在對 ((l_i, m_i)) 對的任意置換下不變，並要求 (l_i) 的和為偶數以產生非零值。它還遵循以下對稱規則：
-
若 (l_1), (l_2), (l_3) 未滿足條件 (l_1 \in {l_{\text{max}}, l_{\text{max}}-2, \ldots, l_{\text{min}}}), 其中 (l_{\text{max}} = l_2+l_3), 則為零
[\begin{split}\begin{aligned} l_{\text{min}} = \begin{cases} \kappa(l_2, l_3, m_2, m_3) & \text{if}, \kappa(l_2, l_3, m_2, m_3) + l_{\text{max}}, \text{is even} \ \kappa(l_2, l_3, m_2, m_3)+1 & \text{if}, \kappa(l_2, l_3, m_2, m_3) + l_{\text{max}}, \text{is odd}\end{cases} \end{aligned}\end{split}]
並且 (\kappa(l_2, l_3, m_2, m_3) = \max{\big(|l_2-l_3|, \min{\big(|m_2+m_3|, |m_2-m_3|\big)}\big)})
-
負 (m_i) 的個數為奇數時為零
演算法
該函式精確計算實數 Gaunt 係數的值，使用了 [Homeier96] 和 [Rasch03] 的演算法。注意，[Rasch03] 中使用的公式包含大階乘的交替和，因此不適合有限精度算術，僅適用於計算機代數系統 [Rasch03]。然而，該函式原則上可以使用計算 Gaunt 係數的任何演算法，因此在計算 Gaunt 係數的演算法適用於有限精度算術的情況下也是合適的。
sympy.physics.wigner.wigner_3j(j_1, j_2, j_3, m_1, m_2, m_3)
計算 Wigner 3j 符號 (\operatorname{Wigner3j}(j_1,j_2,j_3,m_1,m_2,m_3))。
引數：
j_1, j_2, j_3, m_1, m_2, m_3 :
整數或半整數。
返回：
有理數乘以有理數的平方根。
例子
>>> from sympy.physics.wigner import wigner_3j
>>> wigner_3j(2, 6, 4, 0, 0, 0)
sqrt(715)/143
>>> wigner_3j(2, 6, 4, 0, 0, 1)
0
如果引數不是整數或半整數值，則出錯：
sage: wigner_3j(2.1, 6, 4, 0, 0, 0)
Traceback (most recent call last):
...
ValueError: j values must be integer or half integer
sage: wigner_3j(2, 6, 4, 1, 0, -1.1)
Traceback (most recent call last):
...
ValueError: m values must be integer or half integer
註釋
Wigner 3j 符號遵循以下對稱性規則：
-
在列的任何置換下不變（除了在 (J:=j_1+j_2+j_3) 處的符號變化）
[\begin{split}\begin{aligned} \operatorname{Wigner3j}(j_1,j_2,j_3,m_1,m_2,m_3) &=\operatorname{Wigner3j}(j_3,j_1,j_2,m_3,m_1,m_2) \ &=\operatorname{Wigner3j}(j_2,j_3,j_1,m_2,m_3,m_1) \ &=(-1)^J \operatorname{Wigner3j}(j_3,j_2,j_1,m_3,m_2,m_1) \ &=(-1)^J \operatorname{Wigner3j}(j_1,j_3,j_2,m_1,m_3,m_2) \ &=(-1)^J \operatorname{Wigner3j}(j_2,j_1,j_3,m_2,m_1,m_3) \end{aligned}\end{split}]
-
對於空間反射是不變的，即
[\operatorname{Wigner3j}(j_1,j_2,j_3,m_1,m_2,m_3) =(-1)^J \operatorname{Wigner3j}(j_1,j_2,j_3,-m_1,-m_2,-m_3)]
-
對稱於基於 [Regge58] 的其他 72 種對稱性
-
若 (j_1), (j_2), (j_3) 不滿足三角關係，則為零
-
若 (m_1 + m_2 + m_3 \neq 0), 則為零
-
違反任何一個條件均為零
(m_1 \in {-|j_1|, \ldots, |j_1|}), (m_2 \in {-|j_2|, \ldots, |j_2|}), (m_3 \in {-|j_3|, \ldots, |j_3|})
演算法
該函式使用 [Edmonds74] 的演算法精確計算 3j 符號的值。注意，該公式包含大階乘的交替和，因此不適合有限精度算術，僅適用於計算機代數系統 [Rasch03]。
作者
- Jens Rasch (2009-03-24): 初始版本
sympy.physics.wigner.wigner_6j(j_1, j_2, j_3, j_4, j_5, j_6, prec=None)
計算 Wigner 6j 符號 (\operatorname{Wigner6j}(j_1,j_2,j_3,j_4,j_5,j_6))。
引數：
j_1, …, j_6 :
整數或半整數。
prec :
精度，預設為
None。提供精度可以大大加快計算速度。
返回：
有理數乘以有理數的平方根
（如果prec=None），或者如果給出精度，則為實數。
例子
>>> from sympy.physics.wigner import wigner_6j
>>> wigner_6j(3,3,3,3,3,3)
-1/14
>>> wigner_6j(5,5,5,5,5,5)
1/52
引數必須是整數或半整數值，並滿足三角關係，否則將出錯：
sage: wigner_6j(2.5,2.5,2.5,2.5,2.5,2.5)
Traceback (most recent call last):
...
ValueError: j values must be integer or half integer and fulfill the triangle relation
sage: wigner_6j(0.5,0.5,1.1,0.5,0.5,1.1)
Traceback (most recent call last):
...
ValueError: j values must be integer or half integer and fulfill the triangle relation
注意事項
Wigner 6j 符號與 Racah 符號有關，但展示了更多的對稱性，如下所述。
[\operatorname{Wigner6j}(j_1,j_2,j_3,j_4,j_5,j_6) =(-1)^{j_1+j_2+j_4+j_5} W(j_1,j_2,j_5,j_4,j_3,j_6)]
Wigner 6j 符號遵循以下對稱規則：
-
Wigner 6j 符號在列的任何排列下都是左不變的：
[\begin{split}\begin{aligned} \operatorname{Wigner6j}(j_1,j_2,j_3,j_4,j_5,j_6) &=\operatorname{Wigner6j}(j_3,j_1,j_2,j_6,j_4,j_5) \ &=\operatorname{Wigner6j}(j_2,j_3,j_1,j_5,j_6,j_4) \ &=\operatorname{Wigner6j}(j_3,j_2,j_1,j_6,j_5,j_4) \ &=\operatorname{Wigner6j}(j_1,j_3,j_2,j_4,j_6,j_5) \ &=\operatorname{Wigner6j}(j_2,j_1,j_3,j_5,j_4,j_6) \end{aligned}\end{split}]
-
它們在每兩列中交換上下引數的情況下是不變的，即
[\operatorname{Wigner6j}(j_1,j_2,j_3,j_4,j_5,j_6) =\operatorname{Wigner6j}(j_1,j_5,j_6,j_4,j_2,j_3) =\operatorname{Wigner6j}(j_4,j_2,j_6,j_1,j_5,j_3) =\operatorname{Wigner6j}(j_4,j_5,j_3,j_1,j_2,j_6)]
-
附加 6 種對稱性[Regge59]總共產生 144 種對稱性
-
僅在任意三個(j)的三元組滿足三角關係時非零
演算法
該函式使用[Edmonds74]的演算法精確計算 6j 符號的值。請注意，公式包含大量階乘的交錯和，因此不適合有限精度算術，僅適用於計算代數系統[Rasch03]。
sympy.physics.wigner.wigner_9j(j_1, j_2, j_3, j_4, j_5, j_6, j_7, j_8, j_9, prec=None)
計算 Wigner 9j 符號 (\operatorname{Wigner9j}(j_1,j_2,j_3,j_4,j_5,j_6,j_7,j_8,j_9))。
引數：
j_1, …, j_9 :
整數或半整數。
prec : 精度，預設
None. 提供精度可以大大加快計算速度。
返回：
有理數乘以有理數的平方根
（如果prec=None），或者如果給出精度，則為實數。
例子
>>> from sympy.physics.wigner import wigner_9j
>>> wigner_9j(1,1,1, 1,1,1, 1,1,0, prec=64)
0.05555555555555555555555555555555555555555555555555555555555555555
>>> wigner_9j(1/2,1/2,0, 1/2,3/2,1, 0,1,1, prec=64)
0.1666666666666666666666666666666666666666666666666666666666666667
引數必須是整數或半整數值，並滿足三角關係，否則將出錯：
sage: wigner_9j(0.5,0.5,0.5, 0.5,0.5,0.5, 0.5,0.5,0.5,prec=64)
Traceback (most recent call last):
...
ValueError: j values must be integer or half integer and fulfill the triangle relation
sage: wigner_9j(1,1,1, 0.5,1,1.5, 0.5,1,2.5,prec=64)
Traceback (most recent call last):
...
ValueError: j values must be integer or half integer and fulfill the triangle relation
演算法
該函式使用[Edmonds74]的演算法精確計算 3j 符號的值。請注意，公式包含大量階乘的交錯和，因此不適合有限精度算術，僅適用於計算代數系統[Rasch03]。
sympy.physics.wigner.wigner_d(J, alpha, beta, gamma)
返回角動量 J 的 Wigner D 矩陣。
返回：
代表相應的尤拉角旋轉矩陣（在基礎上
(J_z)的特徵向量）。
[\mathcal{D}_{\alpha \beta \gamma} = \exp\big( \frac{i\alpha}{\hbar} J_z\big) \exp\big( \frac{i\beta}{\hbar} J_y\big) \exp\big( \frac{i\gamma}{\hbar} J_z\big)]
這些分量是用通用形式計算的[Edmonds74]，
方程 4.1.12。
解釋
J：
表示被旋轉角動量空間的總角動量的整數、半整數或 SymPy 符號。
alpha, beta, gamma - 表示尤拉旋轉角的實數。
環繞所謂的垂直線、節點線和圖形軸的旋轉角。參見[Edmonds74]。
例子
最簡單的例子：
>>> from sympy.physics.wigner import wigner_d
>>> from sympy import Integer, symbols, pprint
>>> half = 1/Integer(2)
>>> alpha, beta, gamma = symbols("alpha, beta, gamma", real=True)
>>> pprint(wigner_d(half, alpha, beta, gamma), use_unicode=True)
⎡ ⅈ⋅α ⅈ⋅γ ⅈ⋅α -ⅈ⋅γ ⎤
⎢ ─── ─── ─── ───── ⎥
⎢ 2 2 ⎛β⎞ 2 2 ⎛β⎞ ⎥
⎢ ℯ ⋅ℯ ⋅cos⎜─⎟ ℯ ⋅ℯ ⋅sin⎜─⎟ ⎥
⎢ ⎝2⎠ ⎝2⎠ ⎥
⎢ ⎥
⎢ -ⅈ⋅α ⅈ⋅γ -ⅈ⋅α -ⅈ⋅γ ⎥
⎢ ───── ─── ───── ───── ⎥
⎢ 2 2 ⎛β⎞ 2 2 ⎛β⎞⎥
⎢-ℯ ⋅ℯ ⋅sin⎜─⎟ ℯ ⋅ℯ ⋅cos⎜─⎟⎥
⎣ ⎝2⎠ ⎝2⎠⎦
sympy.physics.wigner.wigner_d_small(J, beta)
返回角動量 J 的小 Wigner d 矩陣。
返回：
表示對應尤拉角旋轉的矩陣
的特徵向量的整數(J_z)）。
[\mathcal{d}_{\beta} = \exp\big( \frac{i\beta}{\hbar} J_y\big)]
這些分量是用通用形式計算的[Edmonds74]，
方程 4.1.15。
解釋
J 表示被旋轉角動量空間的總角動量的整數、半整數或 SymPy 符號。
被旋轉角動量空間的角動量。
beta 表示尤拉角的實數。
所謂的節點線。參見[Edmonds74]。
例子
>>> from sympy import Integer, symbols, pi, pprint
>>> from sympy.physics.wigner import wigner_d_small
>>> half = 1/Integer(2)
>>> beta = symbols("beta", real=True)
>>> pprint(wigner_d_small(half, beta), use_unicode=True)
⎡ ⎛β⎞ ⎛β⎞⎤
⎢cos⎜─⎟ sin⎜─⎟⎥
⎢ ⎝2⎠ ⎝2⎠⎥
⎢ ⎥
⎢ ⎛β⎞ ⎛β⎞⎥
⎢-sin⎜─⎟ cos⎜─⎟⎥
⎣ ⎝2⎠ ⎝2⎠⎦
>>> pprint(wigner_d_small(2*half, beta), use_unicode=True)
⎡ 2⎛β⎞ ⎛β⎞ ⎛β⎞ 2⎛β⎞ ⎤
⎢ cos ⎜─⎟ √2⋅sin⎜─⎟⋅cos⎜─⎟ sin ⎜─⎟ ⎥
⎢ ⎝2⎠ ⎝2⎠ ⎝2⎠ ⎝2⎠ ⎥
⎢ ⎥
⎢ ⎛β⎞ ⎛β⎞ 2⎛β⎞ 2⎛β⎞ ⎛β⎞ ⎛β⎞⎥
⎢-√2⋅sin⎜─⎟⋅cos⎜─⎟ - sin ⎜─⎟ + cos ⎜─⎟ √2⋅sin⎜─⎟⋅cos⎜─⎟⎥
⎢ ⎝2⎠ ⎝2⎠ ⎝2⎠ ⎝2⎠ ⎝2⎠ ⎝2⎠⎥
⎢ ⎥
⎢ 2⎛β⎞ ⎛β⎞ ⎛β⎞ 2⎛β⎞ ⎥
⎢ sin ⎜─⎟ -√2⋅sin⎜─⎟⋅cos⎜─⎟ cos ⎜─⎟ ⎥
⎣ ⎝2⎠ ⎝2⎠ ⎝2⎠ ⎝2⎠ ⎦
從表 4 中[Edmonds74]
>>> pprint(wigner_d_small(half, beta).subs({beta:pi/2}), use_unicode=True)
⎡ √2 √2⎤
⎢ ── ──⎥
⎢ 2 2 ⎥
⎢ ⎥
⎢-√2 √2⎥
⎢──── ──⎥
⎣ 2 2 ⎦
>>> pprint(wigner_d_small(2*half, beta).subs({beta:pi/2}),
... use_unicode=True)
⎡ √2 ⎤
⎢1/2 ── 1/2⎥
⎢ 2 ⎥
⎢ ⎥
⎢-√2 √2 ⎥
⎢──── 0 ── ⎥
⎢ 2 2 ⎥
⎢ ⎥
⎢ -√2 ⎥
⎢1/2 ──── 1/2⎥
⎣ 2 ⎦
>>> pprint(wigner_d_small(3*half, beta).subs({beta:pi/2}),
... use_unicode=True)
⎡ √2 √6 √6 √2⎤
⎢ ── ── ── ──⎥
⎢ 4 4 4 4 ⎥
⎢ ⎥
⎢-√6 -√2 √2 √6⎥
⎢──── ──── ── ──⎥
⎢ 4 4 4 4 ⎥
⎢ ⎥
⎢ √6 -√2 -√2 √6⎥
⎢ ── ──── ──── ──⎥
⎢ 4 4 4 4 ⎥
⎢ ⎥
⎢-√2 √6 -√6 √2⎥
⎢──── ── ──── ──⎥
⎣ 4 4 4 4 ⎦
>>> pprint(wigner_d_small(4*half, beta).subs({beta:pi/2}),
... use_unicode=True)
⎡ √6 ⎤
⎢1/4 1/2 ── 1/2 1/4⎥
⎢ 4 ⎥
⎢ ⎥
⎢-1/2 -1/2 0 1/2 1/2⎥
⎢ ⎥
⎢ √6 √6 ⎥
⎢ ── 0 -1/2 0 ── ⎥
⎢ 4 4 ⎥
⎢ ⎥
⎢-1/2 1/2 0 -1/2 1/2⎥
⎢ ⎥
⎢ √6 ⎥
⎢1/4 -1/2 ── -1/2 1/4⎥
⎣ 4 ⎦
單位制度
原文：
docs.sympy.org/latest/modules/physics/units/index.html
此模組將單位制度整合到 SymPy 中，允許使用者在計算時選擇使用的系統，並提供顯示和轉換單位的實用工具。
單位（如米、磅、秒）和常數（如光年、玻爾茲曼常數）都被視為量。Quantity物件定義了單位和物理常數（儘管它的子類PhysicalConstant可能更適合物理常數）。
數量之間的關係由它們的維度和至少另一個相同維度的量的比例因子定義。這兩種型別的關係通常在UnitSystem物件內定義，除了在每個單位制度中都有效的屬性。例如，1 千米在所有單位制度中都等於 1000 米，其維度在所有維度系統中都是長度。另一方面，在 SI 單位制度中，光速等於 299792458 米每秒，而在自然單位中，光速等於 1（無單位）。在 SI 和自然單位中，光速的維度為速度，但在自然單位的維度系統中，速度是無維度的，因為長度和時間是等效的。類似地，在 SI 單位制度和 CGS 及高斯單位制度之間，在電磁量的維度和比例因子中存在差異，因為後兩種單位制度不認為電流是一個基本維度。
與其他庫中的實現相比，此實現的優勢在於，它以不同的方式處理單位制度之間的關係，而不受 SI 單位制度對單位和物理常數關係的假設限制。
示例
單位模組中最重要的函式是convert_to，它允許將給定的量重新表示為某些目標量的冪的乘積。例如，要用米和秒錶示光速：
>>> from sympy.physics.units import speed_of_light, meter, second
>>> from sympy.physics.units import convert_to
>>> convert_to(speed_of_light, [meter, second])
299792458*meter/second
如果無法用目標單位表示給定的量，將原樣返回給定的量：
>>> convert_to(speed_of_light, [meter])
speed_of_light
數量之間的關係取決於單位制度。因此，convert_to接受一個可選的第三個引數，表示單位制度，預設為SI。根據所選的單位制度，轉換可能返回不同的結果，例如，在cgs_gauss單位制度中，電流不是一個基本維度，而是可以表示為長度、時間和質量的組合：
>>> from sympy.physics.units.systems.si import SI
>>> from sympy.physics.units.systems.cgs import cgs_gauss
>>> from sympy.physics.units import ampere, gram, second
>>> convert_to(ampere, [meter, gram, second], SI)
ampere
>>> convert_to(ampere, [meter, gram, second], cgs_gauss)
149896229*sqrt(gram)*meter**(3/2)/(50*second**2)
相同維度的量不會自動簡化，例如如果你將米除以千米，你會得到一個表示兩個單位之間除法的物件。為了簡化這類表示式，你可以呼叫.simplify()方法或匯入quantity_simplify()函式，後者還可以接受一個單位系統作為可選引數。
>>> from sympy.physics.units.util import quantity_simplify
>>> from sympy.physics.units import kilometer
>>> meter/kilometer
meter/kilometer
>>> (meter/kilometer).simplify()
1/1000
>>> quantity_simplify(meter/kilometer)
1/1000
更多
有關未來發展的想法可以在Github wiki中找到。
-
單位制背後的哲學
-
更多例子
-
維度和維度系統
-
單位字首
-
單位和單位制度
-
物理量
單位制背後的哲學
原文連結：
docs.sympy.org/latest/modules/physics/units/philosophy.html
維度
介紹
單位制背後的根源是維度系統，其結構主要決定了單位系統的結構。我們的定義可能看起來粗略，但對於我們的目的來說已經足夠了。
維度被定義為可測量的並分配給特定現象的屬性。在這個意義上，維度與純數不同，因為它們具有一些額外的意義，因此不能將兩個不同的維度相加。例如，時間或長度是維度，但對於我們有意義的任何其他事物，如角度、粒子數（摩爾...）或資訊（位元...）也是如此。
從這個角度來看，唯一真正無量綱的量是純數。無量綱的概念非常依賴於系統，正如在((c, \hbar, G))中所見的那樣，所有單位在通常的常識中似乎都是無量綱的。這在通用單位系統的可計算性上是不可避免的（但最終我們可以告訴程式什麼是無量綱的）。
透過取其乘積或其比率（在下文中定義）可以將維度組合在一起。例如，速度定義為長度除以時間，或者我們可以將長度看作速度乘以時間，取決於我們認為哪個更基本：一般來說，我們可以選擇一組基礎維度，從中我們可以描述所有其他維度。
群結構
在這個簡短的介紹之後，旨在從直觀的角度介紹維度之後，我們描述了數學結構。具有(n)個獨立維度({d_i}_{i=1,\ldots,n})的維度系統由乘法群(G)描述：
-
存在一個純數對應的單位元素(1)；
-
兩個元素(D_1, D_2 \in G)的乘積(D_3 = D_1 D_2)也在(G)中；
-
任何元素(D \in G)都有逆元(D^{-1} \in G)。
我們表示
[D^n = \underbrace{D \times \cdots \times D}_{\text{\(n\) times}},]
並且按定義(D⁰ = 1)。稱為群生成元的({d_i}_{i=1,\ldots,n})，因為群中的任何元素(D \in G)都可以表示為生成元的冪的乘積：
[D = \prod_{i=1}^n d_i^{a_i}, \qquad a_i \in \mathbf{Z}.]
對於(a_i = 0, \forall i)給出了單位元，而對於(a_i = 1, a_j = 0, \forall j \neq i)我們恢復了生成元(d_i)。該群具有以下特性：
-
阿貝爾的，因為生成元交換，([d_i, d_j] = 0)；
-
可數（無限但離散），因為元素按生成元的冪進行索引[1]。
可以透過取舊生成元的某些組合來改變維度基({d'i})：
[d'i = \prod^n d_j^{P_{ij}}.]
線性空間表示
可以使用線性空間 (\mathbf{Z}^n) 作為群的表示，因為冪次係數 (a_i) 包含了所需的所有資訊（我們不區分群的元素和其表示）：
[\begin{split}(d_i)j = \delta, \qquad D = \begin{pmatrix} a_1 \ \vdots \ a_n \end{pmatrix}.\end{split}]
到 (d'i) 的基變換遵循線性空間的通常基變換規則，矩陣由新向量的係數 (P) 給出，這些係數簡單地是舊基礎下新向量的係數：
[d'i = P d_j.]
我們將在演算法中使用這個最後的解決方案。
一個例子
為了說明所有這些形式主義，我們用一個具體例子來結束本節，即 MKSA 系統（m, kg, s），其維度為 (L: length, M: mass, T: time)。它們表示為（我們將始終按字母順序排列向量）
[\begin{split}L = \begin{pmatrix} 1 \ 0 \ 0 \end{pmatrix}, \qquad M = \begin{pmatrix} 0 \ 1 \ 0 \end{pmatrix}, \qquad T = \begin{pmatrix} 0 \ 0 \ 1 \end{pmatrix}.\end{split}]
其他維度可以匯出，例如速度 (V) 或作用量 (A)
[\begin{split}V = L T^{-1}, \qquad A = M L² T^{-2},\ V = \begin{pmatrix} 1 \ 0 \ -1 \end{pmatrix}, \qquad A = \begin{pmatrix} 2 \ 1 \ -2 \end{pmatrix}.\end{split}]
我們可以轉換基礎以轉向自然系統 ((m, c, \hbar))，其維度為 (L: length, V: velocity, A: action) [2]。在此基礎上，生成器為
[\begin{split}A = \begin{pmatrix} 1 \ 0 \ 0 \end{pmatrix}, \qquad L = \begin{pmatrix} 0 \ 1 \ 0 \end{pmatrix}, \qquad V = \begin{pmatrix} 0 \ 0 \ 1 \end{pmatrix},\end{split}]
而質量和時間分別由
[\begin{split}T = L V^{-1}, \qquad M = A V^{-2},\ T = \begin{pmatrix} 0 \ 1 \ -1 \end{pmatrix}, \qquad M = \begin{pmatrix} 1 \ 0 \ -2 \end{pmatrix}.\end{split}]
最終逆變換基矩陣 (P^{-1}) 透過將在舊基礎下表達的向量粘合在一起而得到：
[\begin{split}P^{-1} = \begin{pmatrix} 2 & 1 & 1 \ 1 & 0 & 0 \ -2 & 0 & -1 \end{pmatrix}.\end{split}]
要找到基矩陣的變換，我們只需取其逆
[\begin{split}P = \begin{pmatrix} 0 & 1 & 0 \ 1 & 0 & 1 \ 0 & -2 & -1 \end{pmatrix}.\end{split}]
數量
一個量由其名稱、維度和到相同維度的規範量的因子定義。規範量是單位模組的內部參考，不應影響終端使用者。單位和物理常數都是數量。
單位
單位，如米、秒和千克，通常是人們選擇的參考量，用於引用其他數量。
定義了幾種不同維度的單位後，我們可以形成一個單位制度，這基本上是一個帶有比例概念的維度系統。
常數
物理常數只是數量。它們表明我們以前並不理解兩個維度實際上是相同的。例如，我們看到光速不是 1，因為我們沒有意識到時間和空間是相同的（這是因為我們的感官；但在基本層面上它們是不同的）。例如，曾經有一個“熱常數”，它允許在焦耳和卡路里之間進行轉換，因為人們不知道熱是能量。一旦他們理解了這一點，他們把這個常數固定為 1（這是一個非常簡略的故事）。
現在我們固定國際單位制中基本常數的值，這表明它們是單位（我們用它們來定義其他常用單位）。
參考需求
不可能從頭定義單位和單位系統：我們需要定義一些參考點，然後在它們上面建立其他內容。換句話說，我們需要一個刻度起源來定義我們單位的尺度（即一個因子為 1 的單位），並確保所有給定維度的單位都以一致的方式定義，這可以發生在我們希望在另一個系統中使用一個派生單位作為基本單位時：我們不應將其定義為具有比例 1，因為即使在系統內部是不一致的，我們也無法將其轉換為第一個系統，因為從我們的角度來看，我們有兩個不同單位的相同比例（這意味著它們在計算機中是相等的）。
我們將說，在系統外定義的維度和刻度是規範的，因為我們用它們進行所有計算。另一方面，相對於系統得到的維度和刻度稱為物理的，因為它們最終帶有一種意義。
讓我們舉一個具體（而且重要）的例子：質量單位的情況。我們希望將克定義為起點。我們希望將克定義為質量的規範起點，因此我們賦予它一個比例 1。然後我們可以定義一個系統（例如化學系統），將其作為基本單位。MKS 系統更喜歡使用千克；一個簡單的選擇是給它一個比例為 1 的標度，因為它是一個基本單位，但我們看到我們無法將其轉換為化學系統，因為克和千克都被賦予了相同的因子。因此，我們需要把千克定義為 1000 克，然後才能在 MKS 系統中使用它作為基礎。但是一旦我們問“千克在 MKS 中的因子是多少？”，我們得到的答案是 1，因為它是一個基本單位。
因此，我們將定義所有的計算而不涉及任何系統，在最後一步我們才將結果插入到系統中，以給出我們感興趣的上下文。
文獻
[Page52]
C. H. Page，SI 單位的類別，物理學美國雜誌，20 卷，1 期（1952 年）：1。
[Page78]
C. H. Page，物理學中的單位與維度，物理學美國雜誌，46 卷，1 期（1978 年）：78。
[deBoer79]
J. de Boer, 量和單位的群屬性, Am. J. of Phys. 47, 9 (1979): 818.
[LevyLeblond77]
J.-M. Lévy-Leblond, 關於物理常數的概念性質, La Rivista Del Nuovo Cimento 7, no. 2 (1977): 187-214.
[NIST]
NIST 常數、單位和不確定性的參考.
腳註
更多例子
原文連結：
docs.sympy.org/latest/modules/physics/units/examples.html
在接下來的幾節中，我們將提供一些可以使用此模組完成的示例。
尺寸分析
我們將從牛頓第二定律開始
[m a = F]
其中 (m, a) 和 (F) 分別是質量、加速度和力。知道 (m) ((M)) 和 (a) ((L T^{-2})) 的維度後，我們將確定 (F) 的維度；顯然，我們將發現它是一個力：(M L T^{-2})。
從那裡我們將使用質量為 (m) 的粒子和質量為 (M) 的物體之間的引力表示式，距離為 (r)。
[F = \frac{G m M}{r²}]
以確定牛頓引力常數 (G) 的維度。結果應為 (L³ M^{-1} T^{-2})。
>>> from sympy import symbols >>> from sympy.physics.units.systems import SI >>> from sympy.physics.units import length, mass, acceleration, force >>> from sympy.physics.units import gravitational_constant as G >>> from sympy.physics.units.systems.si import dimsys_SI >>> F = mass*acceleration >>> F Dimension(acceleration*mass) >>> dimsys_SI.get_dimensional_dependencies(F) {Dimension(length): 1, Dimension(mass, M): 1, Dimension(time): -2} >>> dimsys_SI.get_dimensional_dependencies(force) {Dimension(length): 1, Dimension(mass): 1, Dimension(time): -2}儘管在國際單位制中它們相同，但尺寸不能直接比較：
>>> F == force False尺寸系統物件提供了測試尺寸等效性的方法：
>>> dimsys_SI.equivalent_dims(F, force) True>>> m1, m2, r = symbols("m1 m2 r") >>> grav_eq = G * m1 * m2 / r**2 >>> F2 = grav_eq.subs({m1: mass, m2: mass, r: length, G: G.dimension}) >>> F2 Dimension(mass*length*time**-2) >>> F2.get_dimensional_dependencies() {'length': 1, 'mass': 1, 'time': -2}
注意應先解方程，然後用尺寸進行替換。
具有數量的方程
使用開普勒第三定律
[\frac{T²}{a³} = \frac{4 \pi²}{GM}]
我們可以使用從維基百科獲取的其他變數的已知值來找到金星的軌道週期。結果應為 224.701 天。
>>> from sympy import solve, symbols, pi, Eq >>> from sympy.physics.units import Quantity, length, mass >>> from sympy.physics.units import day, gravitational_constant as G >>> from sympy.physics.units import meter, kilogram >>> T = symbols("T") >>> a = Quantity("venus_a")在國際單位制中指定維度和比例：
>>> SI.set_quantity_dimension(a, length) >>> SI.set_quantity_scale_factor(a, 108208000e3*meter)新增太陽質量作為量：
>>> M = Quantity("solar_mass") >>> SI.set_quantity_dimension(M, mass) >>> SI.set_quantity_scale_factor(M, 1.9891e30*kilogram)現在是開普勒定律：
>>> eq = Eq(T**2 / a**3, 4*pi**2 / G / M) >>> eq Eq(T**2/venus_a**3, 4*pi**2/(gravitational_constant*solar_mass)) >>> q = solve(eq, T)[1] >>> q 2*pi*venus_a**(3/2)/(sqrt(gravitational_constant)*sqrt(solar_mass))
要轉換為天數，使用 convert_to 函式（可能需要近似結果）：
>>> from sympy.physics.units import convert_to
>>> convert_to(q, day)
71.5112118495813*pi*day
>>> convert_to(q, day).n()
224.659097795948*day
我們也可以使用來自天體物理系統的太陽質量和日子作為單位，但我們想展示如何建立一個所需的單位。
我們可以看到在這個例子中，中間維度可能不明確，比如 sqrt(G)，但應檢查最終結果 - 當所有維度組合在一起時 - 是否明確定義。
維度和維度系統
原文：
docs.sympy.org/latest/modules/physics/units/dimensions.html
物理維度的定義。
單位制將建立在這些維度之上。
文件中的大多數示例使用 MKS 系統，並且從計算機的角度來看：從人類的角度來看，在 MKS 中將長度新增到時間是不合法的，但在自然系統中是合法的；對於計算機在自然系統中不存在時間維度（而是速度維度代替）- 在基礎中 - 因此將時間新增到長度的問題毫無意義。
class sympy.physics.units.dimensions.Dimension(name, symbol=None)
此類表示物理量的維度。
Dimension 建構函式以名稱和可選符號作為引數。
例如，在經典力學中，我們知道時間與溫度不同，並且維度使得這種差異明顯（但它們不提供這些量的任何測量。
>>> from sympy.physics.units import Dimension
>>> length = Dimension('length')
>>> length
Dimension(length)
>>> time = Dimension('time')
>>> time
Dimension(time)
可以使用乘法、除法和指數運算（乘以數）來組合維度，以生成新的維度。僅當兩個物件為相同維度時才定義加法和減法。
>>> velocity = length / time
>>> velocity
Dimension(length/time)
可以使用維度系統物件獲取維度的維度依賴性，例如，可以使用 SI 單位約定中使用的維度系統：
>>> from sympy.physics.units.systems.si import dimsys_SI
>>> dimsys_SI.get_dimensional_dependencies(velocity)
{Dimension(length, L): 1, Dimension(time, T): -1}
>>> length + length
Dimension(length)
>>> l2 = length**2
>>> l2
Dimension(length**2)
>>> dimsys_SI.get_dimensional_dependencies(l2)
{Dimension(length, L): 2}
has_integer_powers(dim_sys)
檢查維度物件是否僅具有整數冪。
所有維度冪應為整數，但在中間步驟中可能出現有理數冪。此方法可用於檢查最終結果是否定義良好。
class sympy.physics.units.dimensions.DimensionSystem(base_dims, derived_dims=(), dimensional_dependencies={})
DimensionSystem 表示一組一致的維度。
建構函式接受三個引數：
-
基礎維度；
-
派生維度：這些是以基礎維度定義的（例如，速度是透過長度除以時間定義的）；
-
維度依賴性：派生維度如何依賴於基礎維度。
可選地，derived_dims 或 dimensional_dependencies 可能會被省略。
property can_transf_matrix
無用的方法，保持與先前版本的相容性。
請勿使用。
返回從規範到基礎維度基礎的規範變換矩陣。
它是使用 inv_can_transf_matrix() 計算的矩陣的逆。
property dim
無用的方法，保持與先前版本的相容性。
請勿使用。
給出系統的維度。
這是返回形成基礎的維度數量。
dim_can_vector(dim)
無用的方法，保持與先前版本的相容性。
請勿使用。
以規範基礎維度表示的維度。
dim_vector(dim)
無用的方法，保持與先前版本的相容性。
請勿使用。
以基礎維度表示的向量。
property inv_can_transf_matrix
無用的方法，保持與先前版本的相容性。
請勿使用。
計算從基礎到規範維度基礎的逆變換矩陣。
它對應於矩陣，其中列是規範基礎維度的向量。
這個矩陣幾乎不會被使用，因為維度總是相對於規範基定義的，因此不需要額外工作來在此基礎上獲取它們。儘管如此，如果此矩陣不是方陣（或不可逆），這意味著我們選擇了一個不好的基。
property is_consistent
這個方法無用，僅為了與之前版本相容而保留。
請勿使用。
檢查系統是否定義良好。
is_dimensionless(dimension)
檢查維度物件是否確實具有維度。
維度應該至少有一個具有非零冪的分量。
property list_can_dims
這個方法無用，僅為了與之前版本相容而保留。
請勿使用。
列出所有規範維度名稱。
print_dim_base(dim)
給出維度的字串表示式，用基本符號表示。
單位字首
原文：
docs.sympy.org/latest/modules/physics/units/prefixes.html
定義單位字首類和一些常數的模組。
SI 和二進位制字首的常數字典被定義為 PREFIXES 和 BIN_PREFIXES。
class sympy.physics.units.prefixes.Prefix(name, abbrev, exponent, base=10, latex_repr=None)
這個類表示字首，帶有它們的名稱、符號和因子。
字首用於從給定單位建立匯出單位。它們應始終封裝到單位中。
該因子是從一個基數（預設為 10）構造到某個冪，並給出總倍數或分數。例如，千米 km 是從米（因子 1）和千（10 的 3 次方，即 1000）構造而成。基數可以更改以允許例如二進位制字首。
一個字首乘以另一個物件總是返回另一個物件乘以這個因子的乘積，除非另一個物件：
-
是一個字首，它們可以組合成一個新的字首；
-
定義與字首的乘法（這是單位類的情況）。
單位和單位制度
原文連結：
docs.sympy.org/latest/modules/physics/units/unitsystem.html
物理量的單位制；包括常數的定義。
class sympy.physics.units.unitsystem.UnitSystem(base_units, units=(), name='', descr='', dimension_system=None, derived_units: Dict[Dimension, Quantity] = {})
UnitSystem 表示一個連貫的單位集合。
單位系統基本上是一個具有比例概念的維度系統。許多方法都以相同的方式定義。
如果所有基本單位都有符號，那就更好了。
property dim
給出系統的維度。
這是返回形成基礎的單位數量。
extend(base, units=(), name='', description='', dimension_system=None, derived_units: Dict[Dimension, Quantity] = {})
將當前系統擴充套件到一個新系統。
取當前系統的基本和標準單位，將它們與引數中給出的基本和標準單位合併。如果未提供，則名稱和描述被覆蓋為空字串。
get_units_non_prefixed() → Set[Quantity]
返回該系統中沒有字首的單位。
property is_consistent
檢查底層維度系統是否一致。
物理量
原文：
docs.sympy.org/latest/modules/physics/units/quantities.html
物理量。
class sympy.physics.units.quantities.Quantity(name, abbrev=None, latex_repr=None, pretty_unicode_repr=None, pretty_ascii_repr=None, mathml_presentation_repr=None, is_prefixed=False, **assumptions)
物理數量：可以是測量單位、常量或通用數量。
property abbrev
表示單位名稱的符號。
如果定義了縮寫詞，則在字首符號之前加上縮寫詞。
convert_to(other, unit_system='SI')
將數量轉換為具有相同維度的另一個數量。
示例
>>> from sympy.physics.units import speed_of_light, meter, second
>>> speed_of_light
speed_of_light
>>> speed_of_light.convert_to(meter/second)
299792458*meter/second
>>> from sympy.physics.units import liter
>>> liter.convert_to(meter**3)
meter**3/1000
property free_symbols
返回數量的無返回符號。
property is_prefixed
數量是否帶有字首。例如，(kilogram) 帶有字首，但 (gram) 沒有。
property scale_factor
相對於規範單位的整體數量。
set_global_relative_scale_factor(scale_factor, reference_quantity)
設定在所有單位系統中都有效的比例因子。
量之間的轉換
幾種簡化涉及單位物件的表示式的方法。
sympy.physics.units.util.convert_to(expr, target_units, unit_system='SI')
將 expr 轉換為其所有單位和數量表示為 target_units 的因子的相同表示式，只要維度相容。
target_units 可以是單個單位/數量，也可以是單位/數量的集合。
示例
>>> from sympy.physics.units import speed_of_light, meter, gram, second, day
>>> from sympy.physics.units import mile, newton, kilogram, atomic_mass_constant
>>> from sympy.physics.units import kilometer, centimeter
>>> from sympy.physics.units import gravitational_constant, hbar
>>> from sympy.physics.units import convert_to
>>> convert_to(mile, kilometer)
25146*kilometer/15625
>>> convert_to(mile, kilometer).n()
1.609344*kilometer
>>> convert_to(speed_of_light, meter/second)
299792458*meter/second
>>> convert_to(day, second)
86400*second
>>> 3*newton
3*newton
>>> convert_to(3*newton, kilogram*meter/second**2)
3*kilogram*meter/second**2
>>> convert_to(atomic_mass_constant, gram)
1.660539060e-24*gram
轉換為多個單位：
>>> convert_to(speed_of_light, [meter, second])
299792458*meter/second
>>> convert_to(3*newton, [centimeter, gram, second])
300000*centimeter*gram/second**2
轉換為普朗克單位：
>>> convert_to(atomic_mass_constant, [gravitational_constant, speed_of_light, hbar]).n()
7.62963087839509e-20*hbar**0.5*speed_of_light**0.5/gravitational_constant**0.5
高能物理
原文：
docs.sympy.org/latest/modules/physics/hep/index.html
伽瑪矩陣
處理表示為張量物件的伽瑪矩陣的模組。
示例
>>> from sympy.physics.hep.gamma_matrices import GammaMatrix as G, LorentzIndex
>>> from sympy.tensor.tensor import tensor_indices
>>> i = tensor_indices('i', LorentzIndex)
>>> G(i)
GammaMatrix(i)
請注意，四維空間中已經存在一個 GammaMatrixHead 例項：GammaMatrix，它只需宣告為
>>> from sympy.physics.hep.gamma_matrices import GammaMatrix
>>> from sympy.tensor.tensor import tensor_indices
>>> i = tensor_indices('i', LorentzIndex)
>>> GammaMatrix(i)
GammaMatrix(i)
訪問度規張量
>>> LorentzIndex.metric
metric(LorentzIndex,LorentzIndex)
sympy.physics.hep.gamma_matrices.extract_type_tens(expression, component)
從 TensExpr 中提取所有具有 (component) 的張量。
返回兩個張量表示式：
-
第一個包含所有
Tensor具有 (component)。 -
第二個包含所有其餘。
sympy.physics.hep.gamma_matrices.gamma_trace(t)
一行伽瑪矩陣的痕跡
示例
>>> from sympy.physics.hep.gamma_matrices import GammaMatrix as G, gamma_trace, LorentzIndex
>>> from sympy.tensor.tensor import tensor_indices, tensor_heads
>>> p, q = tensor_heads('p, q', [LorentzIndex])
>>> i0,i1,i2,i3,i4,i5 = tensor_indices('i0:6', LorentzIndex)
>>> ps = p(i0)*G(-i0)
>>> qs = q(i0)*G(-i0)
>>> gamma_trace(G(i0)*G(i1))
4*metric(i0, i1)
>>> gamma_trace(ps*ps) - 4*p(i0)*p(-i0)
0
>>> gamma_trace(ps*qs + ps*ps) - 4*p(i0)*p(-i0) - 4*p(i0)*q(-i0)
0
sympy.physics.hep.gamma_matrices.kahane_simplify(expression)
此函式取消四維伽瑪矩陣乘積中的收縮元素，導致一個等於給定表示式的表示式，沒有收縮的伽瑪矩陣。
引數：
expression 包含要簡化的伽瑪矩陣的張量表示式。
注意事項
如果給出旋量指標，則矩陣必須按照乘積中給定的順序給出。
演算法
該演算法背後的思想是使用一些眾所周知的身份，即用於包圍偶數個 (\gamma) 矩陣的收縮
(\gamma^\mu \gamma_{a_1} \cdots \gamma_{a_{2N}} \gamma_\mu = 2 (\gamma_{a_{2N}} \gamma_{a_1} \cdots \gamma_{a_{2N-1}} + \gamma_{a_{2N-1}} \cdots \gamma_{a_1} \gamma_{a_{2N}} ))
對於奇數個 (\gamma) 矩陣
(\gamma^\mu \gamma_{a_1} \cdots \gamma_{a_{2N+1}} \gamma_\mu = -2 \gamma_{a_{2N+1}} \gamma_{a_{2N}} \cdots \gamma_{a_{1}})
而不是重複應用這些身份來取消所有收縮的指數，可以識別這種操作將導致的連結，因此問題簡化為自由伽瑪矩陣的簡單重新排列。
示例
使用時，請記住原始表示式的係數必須單獨處理
>>> from sympy.physics.hep.gamma_matrices import GammaMatrix as G, LorentzIndex
>>> from sympy.physics.hep.gamma_matrices import kahane_simplify
>>> from sympy.tensor.tensor import tensor_indices
>>> i0, i1, i2 = tensor_indices('i0:3', LorentzIndex)
>>> ta = G(i0)*G(-i0)
>>> kahane_simplify(ta)
Matrix([
[4, 0, 0, 0],
[0, 4, 0, 0],
[0, 0, 4, 0],
[0, 0, 0, 4]])
>>> tb = G(i0)*G(i1)*G(-i0)
>>> kahane_simplify(tb)
-2*GammaMatrix(i1)
>>> t = G(i0)*G(-i0)
>>> kahane_simplify(t)
Matrix([
[4, 0, 0, 0],
[0, 4, 0, 0],
[0, 0, 4, 0],
[0, 0, 0, 4]])
>>> t = G(i0)*G(-i0)
>>> kahane_simplify(t)
Matrix([
[4, 0, 0, 0],
[0, 4, 0, 0],
[0, 0, 4, 0],
[0, 0, 0, 4]])
如果沒有收縮，將返回相同的表示式
>>> tc = G(i0)*G(i1)
>>> kahane_simplify(tc)
GammaMatrix(i0)*GammaMatrix(i1)
參考文獻
[1] 降低伽瑪矩陣收縮乘積的演算法，Joseph Kahane，數學物理學雜誌，第 9 卷，第 10 期，1968 年 10 月。
sympy.physics.hep.gamma_matrices.simplify_gpgp(ex, sort=True)
簡化乘積 G(i)*p(-i)*G(j)*p(-j) -> p(i)*p(-i)
示例
>>> from sympy.physics.hep.gamma_matrices import GammaMatrix as G, LorentzIndex, simplify_gpgp
>>> from sympy.tensor.tensor import tensor_indices, tensor_heads
>>> p, q = tensor_heads('p, q', [LorentzIndex])
>>> i0,i1,i2,i3,i4,i5 = tensor_indices('i0:6', LorentzIndex)
>>> ps = p(i0)*G(-i0)
>>> qs = q(i0)*G(-i0)
>>> simplify_gpgp(ps*qs*qs)
GammaMatrix(-L_0)*p(L_0)*q(L_1)*q(-L_1)
物理向量模組
原文：
docs.sympy.org/latest/modules/physics/vector/index.html
物理/向量參考資料
[WikiDyadics]
“Dyadics.” Wikipedia, the Free Encyclopedia. Web. 05 Aug. 2011. <en.wikipedia.org/wiki/Dyadics>.
[WikiDyadicProducts]
“Dyadic Product.” Wikipedia, the Free Encyclopedia. Web. 05 Aug. 2011. <en.wikipedia.org/wiki/Dyadic_product>.
[Likins1973]
Likins, Peter W. Elements of Engineering Mechanics. McGraw-Hill, Inc. 1973. Print.
向量指南
-
向量與參考系
-
向量：運動學
-
物理/向量模組的潛在問題/高階主題/未來功能
-
標量和向量場功能
-
物理向量 API
-
基本類
-
運動學（文件字串）
-
列印（文件字串）
-
基本函式（文件字串）
-
基本場函式文件字串
-
向量與參考框架
原文連結：
docs.sympy.org/latest/modules/physics/vector/vectors.html
在sympy.physics.vector中，向量和參考框架是動態系統的“基礎”。本文件將從數學角度描述它們，並說明如何在此模組的程式碼中使用它們。
Vector
向量是具有大小（或長度）和方向的幾何物件。在紙上，三維空間中的向量通常表示為：
向量代數
向量代數是首要討論的主題。
如果兩個向量具有相同的大小和方向，則它們被稱為相等。
Vector Operations
可以對向量進行多種代數操作：向量之間的加法，標量乘法和向量乘法。
向量加法是基於平行四邊形法則。
向量加法也是可交換的：
[\begin{split}\mathbf{a} + \mathbf{b} &= \mathbf{b} + \mathbf{a} \ (\mathbf{a} + \mathbf{b}) + \mathbf{c} &= \mathbf{a} + (\mathbf{b} + \mathbf{c})\end{split}]
標量乘法是向量與標量的乘積；結果是一個方向相同但大小按標量縮放的向量。注意，乘以-1 相當於圍繞垂直於向量平面的任意軸旋轉向量 180 度。
單位向量簡單地說是其大小等於 1 的向量。對於任意向量(\mathbf{v})，我們可以定義一個單位向量：
[\mathbf{\hat{n}_v} = \frac{\mathbf{v}}{\Vert \mathbf{v} \Vert}]
注意，每個向量都可以寫成標量和單位向量的乘積。
在sympy.physics.vector中實現了三種向量積：點積、叉積和外積。
點積運算將兩個向量對映到一個標量。它的定義如下：
[\begin{split}\mathbf{a} \cdot \mathbf{b} = \Vert \mathbf{a} \Vert \Vert \mathbf{b} \Vert \cos(\theta)\\end{split}]
其中(\theta)為(\mathbf{a})和(\mathbf{b})之間的角度。
兩個單位向量的點積代表了共同方向的大小；對於其他向量，它是共同方向的大小和兩個向量大小的乘積。兩個垂直向量的點積為零。下圖顯示了一些示例：
點乘是交換的：
[\mathbf{a} \cdot \mathbf{b} = \mathbf{b} \cdot \mathbf{a}]
兩個向量的叉乘向量乘法操作返回一個向量：
[\mathbf{a} \times \mathbf{b} = \mathbf{c}]
向量 (\mathbf{c}) 具有以下特性：它的方向與 (\mathbf{a}) 和 (\mathbf{b}) 垂直，其大小定義為 (\Vert \mathbf{c} \Vert = \Vert \mathbf{a} \Vert \Vert \mathbf{b} \Vert \sin(\theta))（其中 (\theta) 是 (\mathbf{a}) 和 (\mathbf{b}) 之間的角度），並且其方向由右手法則定義在 (\Vert \mathbf{a} \Vert \Vert \mathbf{b} \Vert) 之間。下圖顯示如下：
叉乘具有以下屬性：
它不是交換的：
[\begin{split}\mathbf{a} \times \mathbf{b} &\neq \mathbf{b} \times \mathbf{a} \ \mathbf{a} \times \mathbf{b} &= - \mathbf{b} \times \mathbf{a}\end{split}]
並非可結合的：
[(\mathbf{a} \times \mathbf{b} ) \times \mathbf{c} \neq \mathbf{a} \times (\mathbf{b} \times \mathbf{c})]
兩個平行向量的叉積為零。
兩個向量的外積不在此討論，而是在慣性部分（使用的地方）。其他有用的向量性質和關係包括：
[\begin{split}\alpha (\mathbf{a} + \mathbf{b}) &= \alpha \mathbf{a} + \alpha \mathbf{b}\ \mathbf{a} \cdot (\mathbf{b} + \mathbf{c}) &= \mathbf{a} \cdot \mathbf{b} + \mathbf{a} \cdot \mathbf{c}\ \mathbf{a} \times (\mathbf{b} + \mathbf{c}) &= \mathbf{a} \times \mathbf{b} + \mathbf{a} \times \mathbf{b}\ (\mathbf{a} \times \mathbf{b}) \cdot \mathbf{c} & \textrm{ 給出標量三重積。}\ \mathbf{a} \times (\mathbf{b} \cdot \mathbf{c}) & \textrm{ 不起作用，因為不能對向量和標量進行叉乘。}\ (\mathbf{a} \times \mathbf{b}) \cdot \mathbf{c} &= \mathbf{a} \cdot (\mathbf{b} \times \mathbf{c})\ (\mathbf{a} \times \mathbf{b}) \cdot \mathbf{c} &= (\mathbf{b} \times \mathbf{c}) \cdot \mathbf{a} = (\mathbf{c} \times \mathbf{a}) \cdot \mathbf{b}\ (\mathbf{a} \times \mathbf{b}) \times \mathbf{c} &= \mathbf{b}(\mathbf{a} \cdot \mathbf{c}) - \mathbf{a}(\mathbf{b} \cdot \mathbf{c})\ \mathbf{a} \times (\mathbf{b} \times \mathbf{c}) &= \mathbf{b}(\mathbf{a} \cdot \mathbf{c}) - \mathbf{c}(\mathbf{a} \cdot \mathbf{b})\\end{split}]
替代表示
如果我們有三個非共面的單位向量 (\mathbf{\hat{n}_x},\mathbf{\hat{n}_y},\mathbf{\hat{n}_z})，我們可以將任意向量 (\mathbf{a}) 表示為 (\mathbf{a} = a_x \mathbf{\hat{n}_x} + a_y \mathbf{\hat{n}_y} + a_z \mathbf{\hat{n}_z})。在這種情況下，(\mathbf{\hat{n}_x},\mathbf{\hat{n}_y},\mathbf{\hat{n}_z}) 被稱為基底。(a_x, a_y, a_z) 被稱為測量數。通常單位向量是相互垂直的，這時我們可以稱它們為正交基，通常是右手的。
現在我們可以透過以下方式測試兩個向量的相等性。對於向量：
[\begin{split}\mathbf{a} &= a_x \mathbf{\hat{n}_x} + a_y \mathbf{\hat{n}_y} + a_z \mathbf{\hat{n}_z}\ \mathbf{b} &= b_x \mathbf{\hat{n}_x} + b_y \mathbf{\hat{n}_y} + b_z \mathbf{\hat{n}_z}\\end{split}]
我們可以在以下情況下宣稱相等：(a_x = b_x, a_y = b_y, a_z = b_z)。
同樣的兩個向量的向量加法表示為：
[\mathbf{a} + \mathbf{b} = (a_x + b_x)\mathbf{\hat{n}_x} + (a_y + b_y) \mathbf{\hat{n}_y} + (a_z + b_z) \mathbf{\hat{n}_z}]
現在定義乘法運算如下：
[\begin{split}\alpha \mathbf{b} &= \alpha b_x \mathbf{\hat{n}_x} + \alpha b_y \mathbf{\hat{n}_y} + \alpha b_z \mathbf{\hat{n}_z}\ \mathbf{a} \cdot \mathbf{b} &= a_x b_x + a_y b_y + a_z b_z\ \mathbf{a} \times \mathbf{b} &= \textrm{det }\begin{bmatrix} \mathbf{\hat{n}_x} & \mathbf{\hat{n}_y} & \mathbf{\hat{n}_z} \ a_x & a_y & a_z \ b_x & b_y & b_z \end{bmatrix}\ (\mathbf{a} \times \mathbf{b}) \cdot \mathbf{c} &= \textrm{det }\begin{bmatrix} a_x & a_y & a_z \ b_x & b_y & b_z \ c_x & c_y & c_z \end{bmatrix}\\end{split}]
要在給定的基礎上寫出一個向量，我們可以這樣做：
[\begin{split}\mathbf{a} = (\mathbf{a}\cdot\mathbf{\hat{n}_x})\mathbf{\hat{n}_x} + (\mathbf{a}\cdot\mathbf{\hat{n}_y})\mathbf{\hat{n}_y} + (\mathbf{a}\cdot\mathbf{\hat{n}_z})\mathbf{\hat{n}_z}\\end{split}]
Examples
Some numeric examples of these operations follow:
[\begin{split}\mathbf{a} &= \mathbf{\hat{n}_x} + 5 \mathbf{\hat{n}_y}\ \mathbf{b} &= \mathbf{\hat{n}_y} + \alpha \mathbf{\hat{n}_z}\ \mathbf{a} + \mathbf{b} &= \mathbf{\hat{n}_x} + 6 \mathbf{\hat{n}_y} + \alpha \mathbf{\hat{n}_z}\ \mathbf{a} \cdot \mathbf{b} &= 5\ \mathbf{a} \cdot \mathbf{\hat{n}_y} &= 5\ \mathbf{a} \cdot \mathbf{\hat{n}_z} &= 0\ \mathbf{a} \times \mathbf{b} &= 5 \alpha \mathbf{\hat{n}_x} - \alpha \mathbf{\hat{n}_y} + \mathbf{\hat{n}_z}\ \mathbf{b} \times \mathbf{a} &= -5 \alpha \mathbf{\hat{n}_x} + \alpha \mathbf{\hat{n}_y} - \mathbf{\hat{n}_z}\\end{split}]
Vector Calculus
處理帶有移動物體的向量微積分，我們必須引入參考框架的概念。一個經典的例子是火車沿著軌道執行，你和朋友都在裡面。如果你和朋友都坐著，那麼你們之間的相對速度為零。從火車外部的觀察者來看，你們兩個都會有速度。
我們現在將更嚴格地應用這一定義。一個參考框架是我們選擇從中觀察向量量的虛擬“平臺”。如果我們有一個參考框架(\mathbf{N})，向量(\mathbf{a})在框架(\mathbf{N})中被認為是固定的，如果從(\mathbf{N})觀察時它的任何特性都不會改變。我們通常會為每個參考框架分配一個固定的正交基向量集；(\mathbf{N})將具有(\mathbf{\hat{n}_x}, \mathbf{\hat{n}_y},\mathbf{\hat{n}_z})作為其基向量。
Derivatives of Vectors
一個在參考框架中不固定的向量，因此在從該框架觀察時具有不同的特性。微積分是研究變化的學科，為了處理不同參考框架中固定和不固定向量的特殊性，我們需要在定義上更加明確。
在上圖中，我們有向量 (\mathbf{c,d,e,f})。如果我們對 (\mathbf{e}) 求關於 (\theta) 的導數：
[\frac{d \mathbf{e}}{d \theta}]
目前尚不清楚導數是什麼。如果你是從框架 (\mathbf{A}) 觀察的話，導數顯然不為零。如果你是從框架 (\mathbf{B}) 觀察的話，導數為零。因此，我們將引入框架作為導數符號的一部分：
[\begin{split}\frac{^{\mathbf{A}} d \mathbf{e}}{d \theta} &\neq 0 \textrm{，在參考框架 } \mathbf{A} \textrm{ 中，} \mathbf{e} \textrm{ 對 } \theta \textrm{ 的導數不為零。}\ \frac{^{\mathbf{B}} d \mathbf{e}}{d \theta} &= 0 \textrm{，在參考框架 } \mathbf{B} \textrm{ 中，} \mathbf{e} \textrm{ 對 } \theta \textrm{ 的導數為零。}\ \frac{^{\mathbf{A}} d \mathbf{c}}{d \theta} &= 0 \textrm{，在參考框架 } \mathbf{A} \textrm{ 中，} \mathbf{c} \textrm{ 對 } \theta \textrm{ 的導數為零。}\ \frac{^{\mathbf{B}} d \mathbf{c}}{d \theta} &\neq 0 \textrm{，在參考框架 } \mathbf{B} \textrm{ 中，} \mathbf{c} \textrm{ 對 } \theta \textrm{ 的導數不為零。}\\end{split}]
下面是特定參考框架中向量導數的一些額外性質：
[\begin{split}\frac{^{\mathbf{A}} d}{dt}(\mathbf{a} + \mathbf{b}) &= \frac{^{\mathbf{A}} d\mathbf{a}}{dt} + \frac{^{\mathbf{A}} d\mathbf{b}}{dt}\ \frac{^{\mathbf{A}} d}{dt}\gamma \mathbf{a} &= \frac{ d \gamma}{dt}\mathbf{a} + \gamma\frac{^{\mathbf{A}} d\mathbf{a}}{dt}\ \frac{^{\mathbf{A}} d}{dt}(\mathbf{a} \times \mathbf{b}) &= \frac{^{\mathbf{A}} d\mathbf{a}}{dt} \times \mathbf{b} + \mathbf{a} \times \frac{^{\mathbf{A}} d\mathbf{b}}{dt}\\end{split}]
關聯基向量集合
現在我們需要定義兩個不同參考框架之間的關係；或者如何將一個框架的基向量與另一個框架的基向量相關聯。我們可以使用方向餘弦矩陣（DCM）來實現這一點。方向餘弦矩陣將一個框架的基向量與另一個框架的基向量相關聯，如下所示：
[\begin{split}\begin{bmatrix} \mathbf{\hat{a}_x} \ \mathbf{\hat{a}_y} \ \mathbf{\hat{a}_z} \ \end{bmatrix} = \begin{bmatrix} ^{\mathbf{A}} \mathbf{C}^{\mathbf{B}} \end{bmatrix} \begin{bmatrix} \mathbf{\hat{b}_x} \ \mathbf{\hat{b}_y} \ \mathbf{\hat{b}_z} \ \end{bmatrix}\end{split}]
當兩個框架（比如 (\mathbf{A}) 和 (\mathbf{B})）最初對齊時，其中一個框架的所有基向量圍繞與一個基向量對齊的軸旋轉，我們稱這些框架透過簡單旋轉相關聯。下圖展示了這一點：
上述旋轉是繞 Z 軸簡單旋轉，角度為 (\theta)。請注意，在旋轉後，基向量 (\mathbf{\hat{a}_z}) 和 (\mathbf{\hat{b}_z}) 仍然對齊。
這個旋轉可以由以下方向餘弦矩陣來表徵：
[\begin{split}{\mathbf{A}}\mathbf{C}{\mathbf{B}} = \begin{bmatrix} \cos(\theta) & - \sin(\theta) & 0\ \sin(\theta) & \cos(\theta) & 0\ 0 & 0 & 1\ \end{bmatrix}\end{split}]
簡單的繞 X 和 Y 軸的旋轉由以下方式定義：
[ \begin{align}\begin{aligned}\begin{split}\textrm{繞 x 軸旋轉的 DCM: } \begin{bmatrix} 1 & 0 & 0\ 0 & \cos(\theta) & -\sin(\theta)\ 0 & \sin(\theta) & \cos(\theta) \end{bmatrix}\end{split}\\begin{split}\textrm{繞 y 軸旋轉的 DCM: } \begin{bmatrix} \cos(\theta) & 0 & \sin(\theta)\ 0 & 1 & 0\ -\sin(\theta) & 0 & \cos(\theta)\ \end{bmatrix}\end{split}\end{aligned}\end{align} ]
正方向的旋轉透過右手規則定義。
方向餘弦矩陣還涉及到基向量組之間點積的定義。如果我們有兩個帶有關聯基向量的參考座標系，它們的方向餘弦矩陣可以定義為：
[\begin{split}\begin{bmatrix} C_{xx} & C_{xy} & C_{xz}\ C_{yx} & C_{yy} & C_{yz}\ C_{zx} & C_{zy} & C_{zz}\ \end{bmatrix} = \begin{bmatrix} \mathbf{\hat{a}_x}\cdot\mathbf{\hat{b}_x} & \mathbf{\hat{a}_x}\cdot\mathbf{\hat{b}_y} & \mathbf{\hat{a}_x}\cdot\mathbf{\hat{b}_z}\ \mathbf{\hat{a}_y}\cdot\mathbf{\hat{b}_x} & \mathbf{\hat{a}_y}\cdot\mathbf{\hat{b}_y} & \mathbf{\hat{a}_y}\cdot\mathbf{\hat{b}_z}\ \mathbf{\hat{a}_z}\cdot\mathbf{\hat{b}_x} & \mathbf{\hat{a}_z}\cdot\mathbf{\hat{b}_y} & \mathbf{\hat{a}_z}\cdot\mathbf{\hat{b}_z}\ \end{bmatrix}\end{split}]
此外，方向餘弦矩陣是正交的，即：
[\begin{split}{\mathbf{A}}\mathbf{C}{\mathbf{B}} = ({\mathbf{B}}\mathbf{C}{\mathbf{A}})^{-1}\ = ({\mathbf{B}}\mathbf{C}{\mathbf{A}})^T\\end{split}]
如果我們有參考座標系 (\mathbf{A}) 和 (\mathbf{B})，在這個例子中經歷了簡單的繞 Z 軸旋轉，旋轉角度為 (\theta)，我們將會有兩組基向量。然後我們可以定義兩個向量：(\mathbf{a} = \mathbf{\hat{a}_x} + \mathbf{\hat{a}_y} + \mathbf{\hat{a}_z}) 和 (\mathbf{b} = \mathbf{\hat{b}_x} + \mathbf{\hat{b}_y} + \mathbf{\hat{b}_z})。如果我們希望在 (\mathbf{A}) 座標系中表達 (\mathbf{b})，我們執行以下操作：
[\begin{split}\mathbf{b} &= \mathbf{\hat{b}_x} + \mathbf{\hat{b}_y} + \mathbf{\hat{b}_z}\ \mathbf{b} &= \begin{bmatrix}\mathbf{\hat{a}_x}\cdot (\mathbf{\hat{b}_x} + \mathbf{\hat{b}_y} + \mathbf{\hat{b}_z})\end{bmatrix} \mathbf{\hat{a}_x} + \begin{bmatrix}\mathbf{\hat{a}_y}\cdot (\mathbf{\hat{b}_x} + \mathbf{\hat{b}_y} + \mathbf{\hat{b}_z})\end{bmatrix} \mathbf{\hat{a}_y} + \begin{bmatrix}\mathbf{\hat{a}_z}\cdot (\mathbf{\hat{b}_x} + \mathbf{\hat{b}_y} + \mathbf{\hat{b}_z})\end{bmatrix} \mathbf{\hat{a}_z}\ \mathbf{b} &= (\cos(\theta) - \sin(\theta))\mathbf{\hat{a}_x} + (\sin(\theta) + \cos(\theta))\mathbf{\hat{a}_y} + \mathbf{\hat{a}_z}\end{split}]
如果我們希望在B中表示(\mathbf{a})，我們可以這樣做：
[\begin{split}\mathbf{a} &= \mathbf{\hat{a}_x} + \mathbf{\hat{a}_y} + \mathbf{\hat{a}_z}\ \mathbf{a} &= \begin{bmatrix}\mathbf{\hat{b}_x}\cdot (\mathbf{\hat{a}_x} + \mathbf{\hat{a}_y} + \mathbf{\hat{a}_z})\end{bmatrix} \mathbf{\hat{b}_x} + \begin{bmatrix}\mathbf{\hat{b}_y}\cdot (\mathbf{\hat{a}_x} + \mathbf{\hat{a}_y} + \mathbf{\hat{a}_z})\end{bmatrix} \mathbf{\hat{b}_y} + \begin{bmatrix}\mathbf{\hat{b}_z}\cdot (\mathbf{\hat{a}_x} + \mathbf{\hat{a}_y} + \mathbf{\hat{a}_z})\end{bmatrix} \mathbf{\hat{b}_z}\ \mathbf{a} &= (\cos(\theta) + \sin(\theta))\mathbf{\hat{b}_x} + (-\sin(\theta)+\cos(\theta))\mathbf{\hat{b}_y} + \mathbf{\hat{b}_z}\end{split}]
多個參考系下的導數
如果我們有參考系A和B，我們將會有兩組基向量。然後我們可以定義兩個向量：(\mathbf{a} = a_x\mathbf{\hat{a}_x} + a_y\mathbf{\hat{a}_y} + a_z\mathbf{\hat{a}_z}) 和 (\mathbf{b} = b_x\mathbf{\hat{b}_x} + b_y\mathbf{\hat{b}_y} + b_z\mathbf{\hat{b}_z})。如果我們想要在參考系A中對(\mathbf{b})進行導數運算，我們必須首先在A中表示它，然後對測量數字進行導數運算：
[\frac{^{\mathbf{A}} d\mathbf{b}}{dx} = \frac{d (\mathbf{b}\cdot \mathbf{\hat{a}_x} )}{dx} \mathbf{\hat{a}_x} + \frac{d (\mathbf{b}\cdot \mathbf{\hat{a}_y} )}{dx} \mathbf{\hat{a}_y} + \frac{d (\mathbf{b}\cdot \mathbf{\hat{a}_z} )}{dx} \mathbf{\hat{a}_z} +]
向量微積分的示例
一個向量微積分的例子：
在本例中，我們有兩個物體，每個物體都有一個附加的參考框架。我們將(\theta)和(x)視為時間的函式。我們希望知道向量(\mathbf{c})在(\mathbf{A})和(\mathbf{B})框架中的時間導數。
首先，我們需要定義(\mathbf{c})；(\mathbf{c}=x\mathbf{\hat{b}_x}+l\mathbf{\hat{b}_y})。這在(\mathbf{B})框架中提供了一個定義。現在我們可以執行以下操作：
[\begin{split}\frac{^{\mathbf{B}} d \mathbf{c}}{dt} &= \frac{dx}{dt} \mathbf{\hat{b}_x} + \frac{dl}{dt} \mathbf{\hat{b}_y}\ &= \dot{x} \mathbf{\hat{b}_x}\end{split}]
要在(\mathbf{A})框架中進行導數運算，我們必須首先將這兩個框架聯絡起來：
[\begin{split}^{\mathbf{A}} \mathbf{C} ^{\mathbf{B}} = \begin{bmatrix} \cos(\theta) & 0 & \sin(\theta)\ 0 & 1 & 0\ -\sin(\theta) & 0 & \cos(\theta)\ \end{bmatrix}\end{split}]
現在我們可以執行以下操作：
[\begin{split}\frac{^{\mathbf{A}} d \mathbf{c}}{dt} &= \frac{d (\mathbf{c} \cdot \mathbf{\hat{a}_x})}{dt} \mathbf{\hat{a}_x} + \frac{d (\mathbf{c} \cdot \mathbf{\hat{a}_y})}{dt} \mathbf{\hat{a}_y} + \frac{d (\mathbf{c} \cdot \mathbf{\hat{a}_z})}{dt} \mathbf{\hat{a}_z}\ &= \frac{d (\cos(\theta) x)}{dt} \mathbf{\hat{a}_x} + \frac{d (l)}{dt} \mathbf{\hat{a}_y} + \frac{d (-\sin(\theta) x)}{dt} \mathbf{\hat{a}_z}\ &= (-\dot{\theta}\sin(\theta)x + \cos(\theta)\dot{x}) \mathbf{\hat{a}_x} + (\dot{\theta}\cos(\theta)x + \sin(\theta)\dot{x}) \mathbf{\hat{a}_z}\end{split}]
注意，這是(\mathbf{A})框架中(\mathbf{c})的時間導數，並以(\mathbf{A})框架表達。然而，我們也可以在(\mathbf{B})框架中表達它，並且表示式仍然有效：
[\begin{split}\frac{^{\mathbf{A}} d \mathbf{c}}{dt} &= (-\dot{\theta}\sin(\theta)x + \cos(\theta)\dot{x}) \mathbf{\hat{a}_x} + (\dot{\theta}\cos(\theta)x + \sin(\theta)\dot{x}) \mathbf{\hat{a}_z}\ &= \dot{x}\mathbf{\hat{b}_x} - \theta x \mathbf{\hat{b}_z}\\end{split}]
注意兩種表達形式在複雜度上的差異。它們是等價的，但其中一種要簡單得多。這是一個非常重要的概念，因為在更復雜的形式中定義向量可能會大大減慢動力學方程的制定並增加其長度，有時甚至無法在螢幕上顯示。
使用向量和參考框架
在所有相關數學關係被定義之後，我們才引入程式碼。這是由於向量的形成方式。在開始任何問題之前，必須定義一個參考框架（記得首先匯入sympy.physics.vector）：
>>> from sympy.physics.vector import *
>>> N = ReferenceFrame('N')
現在我們已經建立了一個參考框架(\mathbf{N})。要訪問任何基向量，首先需要建立一個參考框架。現在我們已經建立了表示(\mathbf{N})的物件，我們可以訪問它的基向量：
>>> N.x
N.x
>>> N.y
N.y
>>> N.z
N.z
物理向量中的向量代數
現在我們可以對這些向量進行基本的代數運算。
>>> N.x == N.x
True
>>> N.x == N.y
False
>>> N.x + N.y
N.x + N.y
>>> 2 * N.x + N.y
2*N.x + N.y
記住，不要將標量數量新增到向量中（N.x + 5）；這將引發錯誤。在此時，我們將在我們的向量中使用 SymPy 的符號。在處理符號時，請記住參考 SymPy 的陷阱和問題。
>>> from sympy import Symbol, symbols
>>> x = Symbol('x')
>>> x * N.x
x*N.x
>>> x*(N.x + N.y)
x*N.x + x*N.y
在sympy.physics.vector中，已經實現了多個介面來進行向量乘法，包括運算子級別、方法級別和函式級別。向量點乘可以如下工作：
>>> N.x.dot(N.x)
1
>>> N.x.dot(N.y)
0
>>> dot(N.x, N.x)
1
>>> dot(N.x, N.y)
0
“官方”介面是函式介面；這是所有示例中將使用的內容。這是為了避免混淆，使屬性和方法彼此緊鄰，並且在運算子操作優先順序的情況下。在sympy.physics.vector中用於向量乘法的運算子沒有正確的操作順序；這可能導致錯誤。在使用運算子表示向量乘法時，需要注意括號。
叉乘是另一種將討論的向量乘法。它提供了與點乘類似的介面，並伴隨著相同的警告。
>>> N.x.cross(N.x)
0
>>> N.x.cross(N.z)
- N.y
>>> cross(N.x, N.y)
N.z
>>> cross(N.x, (N.y + N.z))
- N.y + N.z
向量還可以進行兩種額外的操作：將向量歸一化為長度 1，以及獲取其大小。操作如下進行：
>>> (N.x + N.y).normalize()
sqrt(2)/2*N.x + sqrt(2)/2*N.y
>>> (N.x + N.y).magnitude()
sqrt(2)
向量通常以矩陣形式表達，特別是在數值計算中。由於矩陣形式不包含向量所定義的參考框架的任何資訊，因此必須提供參考框架以從向量中提取測量數。有一個方便的函式可以實現這一點：
>>> (x * N.x + 2 * x * N.y + 3 * x * N.z).to_matrix(N)
Matrix([
[ x],
[2*x],
[3*x]])
物理向量中的向量微積分
我們已經介紹了我們的第一個參考框架。如果我們願意，我們可以在該框架中立即進行微分：
>>> (x * N.x + N.y).diff(x, N)
N.x
SymPy 有一個diff函式，但它目前無法與sympy.physics.vector中的向量一起使用，請使用Vector的diff方法。原因在於，在對Vector進行微分時，除了對什麼進行微分外，還必須指定參考座標系；SymPy 的diff函式不適合這種情況。
更有趣的情況出現在多個參考框架中。如果我們引入第二個參考框架(\mathbf{A})，我們現在有了兩個框架。請注意，此時我們可以新增(\mathbf{N})和(\mathbf{A})的分量，但不能執行向量乘法，因為尚未定義兩個框架之間的關係。
>>> A = ReferenceFrame('A')
>>> A.x + N.x
N.x + A.x
如果我們想進行向量乘法，首先必須定義一個方向。ReferenceFrame的orient方法提供了這個功能。
>>> A.orient(N, 'Axis', [x, N.y])
透過簡單的繞 Y 軸旋轉的方式，將(\mathbf{A})框架相對於(\mathbf{N})框架進行定位，旋轉量為 x。這兩個框架之間的方向餘弦矩陣可以隨時透過dcm方法檢視：A.dcm(N)給出了方向餘弦矩陣 (^{\mathbf{A}} \mathbf{C} ^{\mathbf{N}})。
其他更復雜的旋轉型別包括體旋轉、空間旋轉、四元數和任意軸旋轉。體和空間旋轉等效於連續進行三個簡單旋轉，每個旋轉圍繞新框架中的基向量。以下是一個例子：
>>> N = ReferenceFrame('N')
>>> Bp = ReferenceFrame('Bp')
>>> Bpp = ReferenceFrame('Bpp')
>>> B = ReferenceFrame('B')
>>> q1,q2,q3 = symbols('q1 q2 q3')
>>> Bpp.orient(N,'Axis', [q1, N.x])
>>> Bp.orient(Bpp,'Axis', [q2, Bpp.y])
>>> B.orient(Bp,'Axis', [q3, Bp.z])
>>> N.dcm(B)
Matrix([
[ cos(q2)*cos(q3), -sin(q3)*cos(q2), sin(q2)],
[sin(q1)*sin(q2)*cos(q3) + sin(q3)*cos(q1), -sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), -sin(q1)*cos(q2)],
[sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3), sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2)]])
>>> B.orient(N,'Body',[q1,q2,q3],'XYZ')
>>> N.dcm(B)
Matrix([
[ cos(q2)*cos(q3), -sin(q3)*cos(q2), sin(q2)],
[sin(q1)*sin(q2)*cos(q3) + sin(q3)*cos(q1), -sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), -sin(q1)*cos(q2)],
[sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3), sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2)]])
空間方向與體方向類似，但是應用於從框架到體。體和空間旋轉可以涉及兩個或三個軸：‘XYZ’適用，‘YZX’、‘ZXZ’、‘YXY’等也適用。關鍵在於每個簡單旋轉是圍繞不同軸進行的，與前一個不同；‘ZZX’不能完全定向一個三維空間的基向量集。
有時，建立一個新的參考框架並在一步中相對於現有框架進行定向會更方便。orientnew方法允許此功能，並且本質上包裝了orient方法。在orient中可以做的所有事情，在orientnew中也可以做到。
>>> C = N.orientnew('C', 'Axis', [q1, N.x])
四元數（或尤拉引數）使用 4 個值來描述框架的方向。這些內容以及任意軸旋轉可以在orient和orientnew方法的幫助下找到，或者在參考文獻[Kane1983]中瞭解。
最後，在開始多框架計算操作之前，我們將介紹另一個sympy.physics.vector工具：dynamicsymbols。dynamicsymbols是在 SymPy 中建立時間未定義函式的快捷方式。這樣一個‘dynamicsymbol’的導數如下所示。
>>> from sympy import diff
>>> q1, q2, q3 = dynamicsymbols('q1 q2 q3')
>>> diff(q1, Symbol('t'))
Derivative(q1(t), t)
上面的‘dynamicsymbol’列印結果不太清晰；我們還將在這裡介紹其他一些工具。在非互動式會話中，我們可以使用vprint代替 print。
>>> q1
q1(t)
>>> q1d = diff(q1, Symbol('t'))
>>> vprint(q1)
q1
>>> vprint(q1d)
q1'
對於互動式會話，請使用init_vprinting。SymPy 的vprint、vpprint、latex和vlatex也存在類似的模擬。
>>> from sympy.physics.vector import init_vprinting
>>> init_vprinting(pretty_print=False)
>>> q1
q1
>>> q1d
q1'
在sympy.physics.vector中，任何時間變化的量都應使用‘dynamicsymbol’來表示，無論是座標、變化的位置還是力量。‘dynamicsymbol’的主要用途是用於速度和座標（在文件的運動學部分將有更多討論）。
現在我們將用一個‘dynamicsymbol’定義我們新框架的方向，並且可以輕鬆地進行導數和時間導數。以下是一些例子。
>>> N = ReferenceFrame('N')
>>> B = N.orientnew('B', 'Axis', [q1, N.x])
>>> (B.y*q2 + B.z).diff(q2, N)
B.y
>>> (B.y*q2 + B.z).dt(N)
(-q1' + q2')*B.y + q2*q1'*B.z
注意，輸出向量保持了它們提供時所在的框架不變。對於由多個框架的基向量組成分量的向量，這一點仍然成立：
>>> (B.y*q2 + B.z + q2*N.x).diff(q2, N)
N.x + B.y
向量的編碼方式
接下來是如何在sympy.physics.vector中的程式碼中定義向量的簡要說明。這是為了那些想要了解此部分如何工作的人提供的，不需要閱讀它就可以使用此模組；除非您想了解如何實現此模組，否則不要閱讀它。
每個Vector的主要資訊儲存在args屬性中，該屬性為每個相關幀中的每個基向量儲存三個測量數。在建立ReferenceFrame之前，程式碼中不存在向量。此時，參考框架的x、y和z屬性是不可變的Vector，其測量數分別為[1,0,0]、[0,1,0]和[0,0,1]。一旦可以訪問這些向量，可以透過使用基向量進行代數運算來建立新向量。向量可以具有多個幀的分量。這就是為什麼args是一個列表的原因；它的列表長度等於其元件中唯一ReferenceFrames的數量，即如果我們的新向量中有A和B幀基向量，則args的長度為 2；如果它有A、B和C幀基向量，則args的長度為 3。
args列表中的每個元素都是一個 2 元組；第一個元素是 SymPy Matrix（儲存每組基向量的測量數），第二個元素是ReferenceFrame，用於將這些測量數與之關聯。
ReferenceFrame儲存了幾個東西。首先，它儲存您在建立時提供的名稱（name屬性）。它還儲存方向餘弦矩陣，使用orientnew方法在建立時定義，或在建立後呼叫orient方法。方向餘弦矩陣由 SymPy 的Matrix表示，並且是一個字典的一部分，其中鍵是ReferenceFrame，值是Matrix；這些設定是雙向的；當您將A定向到N時，您設定了A的方向字典，以包括N及其Matrix，但您也設定了N的方向字典，以包括A及其Matrix（該 DCM 是另一個的轉置）。
向量：運動學
原文連結：
docs.sympy.org/latest/modules/physics/vector/kinematics.html
本文將為描述系統運動學背景及如何在sympy.physics.vector中表示運動學提供一些數學背景。
運動學介紹
第一個主題是剛體運動學。剛體是具有質量和轉動慣量的物理物件的理想化表示。顯然，剛體不是柔軟的。我們可以將剛體運動分解為平移運動和旋轉運動（在處理粒子時，我們只有平移運動）。旋轉運動可以進一步分解為簡單旋轉和一般旋轉。
剛體的平移是指在運動過程中，物體的方向不會改變；或者在運動過程中，任何線段在運動開始時都將保持平行於自身。
簡單旋轉是指物體的方向可能會改變，但總有一條線段在運動開始時保持平行於自身。
一般旋轉是指在運動開始時並不總有一條線段平行於自身。
角速度
剛體的角速度是指其方向變化率。剛體的角速度寫為：({\mathbf{N}}\mathbf{\omega}{\mathbf{B}})，或者是(\mathbf{B})在(\mathbf{N})中的角速度，它是一個向量。請注意，這裡使用了剛體這個術語，但參考系也可以有角速度。在描述程式碼表示時，稍後將進一步討論剛體和參考系之間的區別。
角速度被定義為引起方向角增加的方向上為正（對於簡單旋轉或一系列簡單旋轉）。
角速度向量表示方向的時間導數。作為時間導數向量量，就像向量和參考框架文件中所涵蓋的那些一樣，這個量（角速度）需要在一個參考框架中定義。這就是上述角速度定義中的 (\mathbf{N})；角速度在其中定義的框架。
(\mathbf{N}) 中的 (\mathbf{B}) 的角速度也可以定義為：
[{\mathbf{N}}\mathbf{\omega}{\mathbf{B}} = (\frac{^{\mathbf{N}}d \mathbf{\hat{b}_y}}{dt}\cdot\mathbf{\hat{b}_z} )\mathbf{\hat{b}_x} + (\frac{^{\mathbf{N}}d \mathbf{\hat{b}_z}}{dt}\cdot \mathbf{\hat{b}_x})\mathbf{\hat{b}_y} + (\frac{^{\mathbf{N}}d \mathbf{\hat{b}_x}}{dt}\cdot\mathbf{\hat{b}_y})\mathbf{\hat{b}_z}]
一個物體的角速度通常也可以寫成：
[{\mathbf{N}}\mathbf{\omega}{\mathbf{B}} = w_x \mathbf{\hat{b}_x} + w_y \mathbf{\hat{b}_y} + w_z \mathbf{\hat{b}_z}]
關於角速度還有一些額外重要的點。首先是角速度的加法定理，一種關聯多個物體和參考系角速度的方式。該定理如下：
[{\mathbf{N}}\mathbf{\omega}{\mathbf{D}} = {\mathbf{N}}\mathbf{\omega}{\mathbf{A}} + {\mathbf{A}}\mathbf{\omega}{\mathbf{B}} + {\mathbf{B}}\mathbf{\omega}{\mathbf{C}} + {\mathbf{C}}\mathbf{\omega}{\mathbf{D}}]
這也可以在以下示例中看到：
[\begin{split}{\mathbf{N}}\mathbf{\omega}{\mathbf{A}} &= 0\ {\mathbf{A}}\mathbf{\omega}{\mathbf{B}} &= \dot{q_1} \mathbf{\hat{a}_x}\ {\mathbf{B}}\mathbf{\omega}{\mathbf{C}} &= - \dot{q_2} \mathbf{\hat{b}_z}\ {\mathbf{C}}\mathbf{\omega}{\mathbf{D}} &= \dot{q_3} \mathbf{\hat{c}_y}\ {\mathbf{N}}\mathbf{\omega}{\mathbf{D}} &= \dot{q_1} \mathbf{\hat{a}_x} - \dot{q_2} \mathbf{\hat{b}_z} + \dot{q_3} \mathbf{\hat{c}_y}\\end{split}]
注意角速度定義中使用的符號，這些符號與在這種情況下如何定義位移角有關。
該定理使得定義多體系統的角速度變得更加簡單，因為鏈中每個體的角速度只需相對於前一個體定義即可（並且第一個體需要在所需的參考系中定義）。下圖展示了使用該定理可以簡化問題的示例。
在這裡，我們可以輕鬆地寫出物體(\mathbf{D})在第一個物體(\mathbf{A})的參考系中的角速度：
[\begin{split}\mathbf{A}\mathbf{\omega}\mathbf{D} = w_1 \mathbf{\hat{p_1}} + w_2 \mathbf{\hat{p_2}} + w_3 \mathbf{\hat{p_3}}\\end{split}]
記住，只能用於角速度；不能用於點的速度。
還有一個常用的定理：導數定理。它提供了一種替代方法（可能更容易）來計算參考系中向量的時間導數：
[\frac{^{\mathbf{N}} d \mathbf{v}}{dt} = \frac{^{\mathbf{B}} d \mathbf{v}}{dt} + {\mathbf{N}}\mathbf{\omega}{\mathbf{B}} \times \mathbf{v}]
向量(\mathbf{v})可以是任何向量量：位置向量，速度向量，角速度向量等。而不是在(\mathbf{N})中取向量的時間導數，我們在(\mathbf{B})中取它，其中(\mathbf{B})可以是任何參考系或物體，通常是在其中容易對(\mathbf{v})取導數的一個。然後我們加上我們新參考系的角速度的叉乘積，({\mathbf{N}}\mathbf{\omega}{\mathbf{B}}) 和我們的向量量(\mathbf{v})。同樣，你可以為此選擇任何替代參考系。以下是例子：
角加速度
角加速度指的是角速度向量的時間變化率。正如角速度向量是對於一個物體的，並且在一個參考系中指定一樣，角加速度向量也是對於一個物體的，並且在一個參考系中指定：({\mathbf{N}}\mathbf{\alpha}{\mathbf{B}})，或者是(\mathbf{B})在(\mathbf{N})中的角加速度，這是一個向量。
計算角加速度相對直接了當：
[{\mathbf{N}}\mathbf{\alpha}{\mathbf{B}} = \frac{^{\mathbf{N}} d {\mathbf{N}}\mathbf{\omega}{\mathbf{B}}}{dt}]
注意，可以用導數定理計算這個，當角速度在一個固定於物體的參考系中定義時，變得相當簡單：
[ \begin{align}\begin{aligned}\begin{split}{\mathbf{N}}\mathbf{\alpha}{\mathbf{B}} &= \frac{^{\mathbf{N}} d {\mathbf{N}}\mathbf{\omega}{\mathbf{B}}}{dt}\\end{split}\\begin{split}{\mathbf{N}}\mathbf{\alpha}{\mathbf{B}} &= \frac{^{\mathbf{B}} d {\mathbf{N}}\mathbf{\omega}{\mathbf{B}}}{dt} + {\mathbf{N}}\mathbf{\omega}{\mathbf{B}} \times {\mathbf{N}}\mathbf{\omega}{\mathbf{B}}\\end{split}\\begin{split}\textrm{如果 } {\mathbf{N}}\mathbf{\omega}{\mathbf{B}} &= w_x \mathbf{\hat{b}_x} + w_y \mathbf{\hat{b}_y} + w_z \mathbf{\hat{b}z}\\end{split}\\begin{split}\textrm{那麼 } {\mathbf{N}}\mathbf{\alpha}{\mathbf{B}} &= \frac{^{\mathbf{B}} d {\mathbf{N}}\mathbf{\omega}{\mathbf{B}}}{dt} + \underbrace{{\mathbf{N}}\mathbf{\omega}{\mathbf{B}} \times {\mathbf{N}}\mathbf{\omega}{\mathbf{B}}}{ \textrm{根據定義，這是 0}}\\end{split}\\begin{split}{\mathbf{N}}\mathbf{\alpha}{\mathbf{B}}&=\frac{d w_x}{dt}\mathbf{\hat{b}_x} + \frac{d w_y}{dt}\mathbf{\hat{b}_y} + \frac{d w_z}{dt}\mathbf{\hat{b}_z}\\end{split}\\begin{split}{\mathbf{N}}\mathbf{\alpha}{\mathbf{B}}&= \dot{w_x}\mathbf{\hat{b}_x} + \dot{w_y}\mathbf{\hat{b}_y} + \dot{w_z}\mathbf{\hat{b}_z}\\end{split}\end{aligned}\end{align} ]
再次強調，這僅適用於身體固定分量定義了角速度的情況。
點速度與加速度
考慮一個點 (P)：我們可以定義該點的一些特性。首先，我們可以定義從其他點到 (P) 的位置向量。其次，我們可以定義 (P) 在我們選擇的參考系中的速度向量。第三，我們可以定義 (P) 在我們選擇的參考系中的加速度向量。
這三個量讀作：
[\begin{split}\mathbf{r}^{OP} \textrm{，從 } O \textrm{ 到 } P \textrm{ 的位置向量}\ {\mathbf{N}}\mathbf{v}P \textrm{，點 } P \textrm{ 在參考系 } \mathbf{N} \textrm{ 中的速度}\ {\mathbf{N}}\mathbf{a}P \textrm{，點 } P \textrm{ 在參考系 } \mathbf{N} \textrm{ 中的加速度}\\end{split}]
注意，位置向量沒有與之關聯的參考系；這是因為與速度和加速度向量不同，它沒有涉及時間導數。
對於一個簡單的例子，我們可以輕鬆找到這些量。
[\begin{split}\textrm{Let's define: } \mathbf{r}^{OP} &= q_x \mathbf{\hat{n}_x} + q_y \mathbf{\hat{n}_y}\ {\mathbf{N}}\mathbf{v}P &= \frac{^{\mathbf{N}} d \mathbf{r}^{OP}}{dt}\ \textrm{then we can calculate: } {\mathbf{N}}\mathbf{v}P &= \dot{q}_x\mathbf{\hat{n}_x} + \dot{q}_y\mathbf{\hat{n}_y}\ \textrm{and :} {\mathbf{N}}\mathbf{a}P &= \frac{^{\mathbf{N}} d {\mathbf{N}}\mathbf{v}P}{dt}\ {\mathbf{N}}\mathbf{a}P &= \ddot{q}_x\mathbf{\hat{n}_x} + \ddot{q}_y\mathbf{\hat{n}_y}\\end{split}]
- 上述例子中，理解點 (O) 在參考系 (\mathbf{N}) 中固定是至關重要的。對於平移速度沒有加法定理；後續將討論替代方法。同時注意，不一定需要定義每個點的位置向量來形成動力學運動方程。當你不想定義一個點的位置向量時，可以先定義速度向量。對於上述例子：
[\begin{split}\textrm{我們可以將速度向量定義為： } {\mathbf{N}}\mathbf{v}P &= u_x \mathbf{\hat{n}_x} + u_y \mathbf{\hat{n}_y}\ \textrm{那麼加速度可以寫為： } {\mathbf{N}}\mathbf{a}P &= \dot{u}_x \mathbf{\hat{n}_x} + \dot{u}_y \mathbf{\hat{n}_y}\\end{split}]
- 通常情況下，我們需要一個點的速度，同時已知相關點的速度。對於剛體上兩個固定點的情況，我們使用 2 點定理：
假設我們知道點(S)的速度和物體(\mathbf{B})的角速度，兩者均定義在參考系(\mathbf{N})中。我們可以計算點(P)在(\mathbf{N})中的速度和加速度如下：
[\begin{split}{\mathbf{N}}\mathbf{v}P &= \mathbf{N}\mathbf{v}S + \mathbf{N}\mathbf{\omega}\mathbf{B} \times \mathbf{r}^{SP}\ {\mathbf{N}}\mathbf{a}P &= \mathbf{N}\mathbf{a}S + \mathbf{N}\mathbf{\alpha}\mathbf{B} \times \mathbf{r}^{SP} + \mathbf{N}\mathbf{\omega}\mathbf{B} \times (\mathbf{N}\mathbf{\omega}\mathbf{B} \times \mathbf{r}^{SP})\\end{split}]
當兩點中只有一個固定在物體上時，使用 1 點定理。
在這裡，點(S)的速度在參考系(\mathbf{N})中已知，(\mathbf{B})的角速度在(\mathbf{N})中已知，並且點(P)在與剛體(\mathbf{B})相關聯的參考系中的速度也已知。因此，我們可以寫出點(P)在(\mathbf{N})中的速度和加速度：
[ \begin{align}\begin{aligned}\begin{split}{\mathbf{N}}\mathbf{v}P &= \mathbf{B}\mathbf{v}P + \mathbf{N}\mathbf{v}S + \mathbf{N}\mathbf{\omega}\mathbf{B} \times \mathbf{r}{SP}\\end{split}\\begin{split}{\mathbf{N}}\mathbf{a}^P &= \mathbf{B}\mathbf{a}S + \mathbf{N}\mathbf{a}O + \mathbf{N}\mathbf{\alpha}\mathbf{B} \times \mathbf{r}^{SP} + \mathbf{N}\mathbf{\omega}\mathbf{B} \times (\mathbf{N}\mathbf{\omega}\mathbf{B} \times \mathbf{r}^{SP}) + 2 \mathbf{N}\mathbf{\omega}\mathbf{B} \times ^\mathbf{B} \mathbf{v}^P \\end{split}\end{aligned}\end{align} ]
應用一點定理和二點定理的示例。
本例中，一個圓盤在平面內進行平移和旋轉。我們可以很容易地定義身體(\mathbf{B})的角速度和點(O)的速度：
[\begin{split}\mathbf{N}\mathbf{\omega}\mathbf{B} &= u_3 \mathbf{\hat{n}_z} = u_3 \mathbf{\hat{b}_z}\ \mathbf{N}\mathbf{v}O &= u_1 \mathbf{\hat{n}_x} + u_2 \mathbf{\hat{n}_y}\\end{split}]
並且加速度可以寫成：
[\begin{split}\mathbf{N}\mathbf{\alpha}\mathbf{B} &= \dot{u_3} \mathbf{\hat{n}_z} = \dot{u_3} \mathbf{\hat{b}_z}\ \mathbf{N}\mathbf{a}O &= \dot{u_1} \mathbf{\hat{n}_x} + \dot{u_2} \mathbf{\hat{n}_y}\\end{split}]
現在我們可以使用兩點定理來計算點(P)的速度和加速度。
[\begin{split}\mathbf{r}^{OP} &= R \mathbf{\hat{b}_x}\ \mathbf{N}\mathbf{v}P &= \mathbf{N}\mathbf{v}O + \mathbf{N}\mathbf{\omega}\mathbf{B} \times \mathbf{r}^{OP}\ \mathbf{N}\mathbf{v}P &= u_1 \mathbf{\hat{n}_x} + u_2 \mathbf{\hat{n}_y} + u_3 \mathbf{\hat{b}_z} \times R \mathbf{\hat{b}_x} = u_1 \mathbf{\hat{n}_x} + u_2 \mathbf{\hat{n}_y} + u_3 R \mathbf{\hat{b}_y}\ {\mathbf{N}}\mathbf{a}P &= \mathbf{N}\mathbf{a}O + \mathbf{N}\mathbf{\alpha}\mathbf{B} \times \mathbf{r}^{OP} + \mathbf{N}\mathbf{\omega}\mathbf{B} \times (\mathbf{N}\mathbf{\omega}\mathbf{B} \times \mathbf{r}^{OP})\ {\mathbf{N}}\mathbf{a}P &= \dot{u_1} \mathbf{\hat{n}_x} + \dot{u_2} \mathbf{\hat{n}_y} + \dot{u_3}\mathbf{\hat{b}_z}\times R \mathbf{\hat{b}_x} +u_3\mathbf{\hat{b}_z}\times(u_3\mathbf{\hat{b}_z}\times R\mathbf{\hat{b}_x})\ {\mathbf{N}}\mathbf{a}P &= \dot{u_1} \mathbf{\hat{n}_x} + \dot{u_2} \mathbf{\hat{n}_y} + R\dot{u_3}\mathbf{\hat{b}_y} - R u_3² \mathbf{\hat{b}_x}\\end{split}]
在這個例子中，我們有一個雙擺。我們可以在這裡兩次使用兩點定理來找到點 (Q) 和 (P) 的速度；點 (O) 在 (\mathbf{N}) 中的速度為零。
[\begin{split}\mathbf{r}^{OQ} &= l \mathbf{\hat{b}_x}\ \mathbf{r}^{QP} &= l \mathbf{\hat{c}_x}\ \mathbf{N}\mathbf{\omega}\mathbf{B} &= u_1 \mathbf{\hat{b}_z}\ \mathbf{N}\mathbf{\omega}\mathbf{C} &= u_2 \mathbf{\hat{c}_z}\ \mathbf{N}\mathbf{v}Q &= \mathbf{N}\mathbf{v}O + \mathbf{N}\mathbf{\omega}\mathbf{B} \times \mathbf{r}^{OQ}\ \mathbf{N}\mathbf{v}Q &= u_1 l \mathbf{\hat{b}_y}\ \mathbf{N}\mathbf{v}P &= \mathbf{N}\mathbf{v}Q + \mathbf{N}\mathbf{\omega}\mathbf{C} \times \mathbf{r}^{QP}\ \mathbf{N}\mathbf{v}Q &= u_1 l \mathbf{\hat{b}_y} +u_2 \mathbf{\hat{c}_z} \times l \mathbf{\hat{c}_x}\ \mathbf{N}\mathbf{v}Q &= u_1 l\mathbf{\hat{b}_y}+u_2 l\mathbf{\hat{c}_y}\\end{split}]
在這個例子中，我們有一個粒子在環上運動；環由一個可以繞著(\mathbf{\hat{n}_x})軸旋轉的杆支援。首先我們使用兩點定理來找到環的中心點(Q)的速度，然後使用單點定理來找到環上粒子的速度。
[\begin{split}\mathbf{N}\mathbf{\omega}\mathbf{C} &= u_1 \mathbf{\hat{n}_x}\ \mathbf{r}^{OQ} &= -l \mathbf{\hat{c}_z}\ \mathbf{N}\mathbf{v}Q &= u_1 l \mathbf{\hat{c}_y}\ \mathbf{r}^{QP} &= R(cos(q_2) \mathbf{\hat{c}_x} + sin(q_2) \mathbf{\hat{c}_y} )\ \mathbf{C}\mathbf{v}P &= R u_2 (-sin(q_2) \mathbf{\hat{c}_x} + cos(q_2) \mathbf{\hat{c}_y} )\ \mathbf{N}\mathbf{v}P &= \mathbf{C}\mathbf{v}P +\mathbf{N}\mathbf{v}Q + \mathbf{N}\mathbf{\omega}\mathbf{C} \times \mathbf{r}^{QP}\ \mathbf{N}\mathbf{v}P &= R u_2 (-sin(q_2) \mathbf{\hat{c}_x} + cos(q_2) \mathbf{\hat{c}_y} ) + u_1 l \mathbf{\hat{c}_y} + u_1 \mathbf{\hat{c}_x} \times R(cos(q_2) \mathbf{\hat{c}_x} + sin(q_2) \mathbf{\hat{c}_y}\ \mathbf{N}\mathbf{v}P &= - R u_2 sin(q_2) \mathbf{\hat{c}_x} + (R u_2 cos(q_2)+u_1 l)\mathbf{\hat{c}_y} + R u_1 sin(q_2) \mathbf{\hat{c}_z}\\end{split}]
描述點速度的最後一個主題是滾動，或者更確切地說，是不打滑地滾動。如果兩個物體在另一個參考系中接觸點的速度相同，則稱它們是不打滑地滾動。參見下圖：
這裡是 SVG 標籤中文字框的內容。
這通常用於形成一個物體上的點在另一個固定物體上滾動的速度，例如以下示例：
物理學中的運動學
現在應該清楚，這裡的運動學主題主要描述了正確操作向量以表示點的速度的方式。在sympy.physics.vector中，有方便的方法來儲存這些與參考系和點相關的速度。我們現在將重新訪問上述示例，並展示如何在sympy中表示它們。
參考系建立的主題已經涵蓋過了。但是，當建立ReferenceFrame時，它會自動使用 DCM 的時間導數和角速度定義來計算參考系的角速度。
>>> from sympy import Symbol, sin, cos
>>> from sympy.physics.vector import *
>>> init_vprinting(pretty_print=False)
>>> N = ReferenceFrame('N')
>>> q1 = dynamicsymbols('q1')
>>> A = N.orientnew('A', 'Axis', [q1, N.x])
>>> A.ang_vel_in(N)
q1'*N.x
注意，角速度可以以另一種方式定義：
>>> B = ReferenceFrame('B')
>>> u1 = dynamicsymbols('u1')
>>> B.set_ang_vel(N, u1 * B.y)
>>> B.ang_vel_in(N)
u1*B.y
>>> N.ang_vel_in(B)
- u1*B.y
在orientnew期間建立參考系和呼叫set_ang_vel時，如上所示，角速度在涉及的兩個參考系中都設定了。
這裡我們有多個與彼此相關聯的角速度定義的物體。這被編碼為：
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> B = ReferenceFrame('B')
>>> C = ReferenceFrame('C')
>>> D = ReferenceFrame('D')
>>> u1, u2, u3 = dynamicsymbols('u1 u2 u3')
>>> A.set_ang_vel(N, 0)
>>> B.set_ang_vel(A, u1 * A.x)
>>> C.set_ang_vel(B, -u2 * B.z)
>>> D.set_ang_vel(C, u3 * C.y)
>>> D.ang_vel_in(N)
u1*A.x - u2*B.z + u3*C.y
在 sympy.physics.vector 中，在查詢角速度時使用兩個框架之間的最短路徑。這意味著，如果我們回去並設定：
>>> D.set_ang_vel(N, 0)
>>> D.ang_vel_in(N)
0
剛剛定義的路徑是使用的路徑。然而，這可能會導致問題，因為現在角速度的定義不一致。建議避免這樣做。
Points 是與旋轉 ReferenceFrame 對應的平移模擬。建立一個 Point 可以透過兩種方式完成，就像 ReferenceFrame 一樣：
>>> O = Point('O')
>>> P = O.locatenew('P', 3 * N.x + N.y)
>>> P.pos_from(O)
3*N.x + N.y
>>> Q = Point('Q')
>>> Q.set_pos(P, N.z)
>>> Q.pos_from(P)
N.z
>>> Q.pos_from(O)
3*N.x + N.y + N.z
類似於 ReferenceFrame，兩點之間的位置向量是透過它們之間的最短路徑（中間點的數量）找到的。與旋轉運動不同的是，點的速度沒有加法定理。為了在 ReferenceFrame 中有一個 Point 的速度，您必須設定該值。
>>> O = Point('O')
>>> O.set_vel(N, u1*N.x)
>>> O.vel(N)
u1*N.x
對於平移和旋轉加速度，值是透過取適當速度的時間導數來計算的，除非使用者另行設定。
>>> O.acc(N)
u1'*N.x
>>> O.set_acc(N, u2*u1*N.y)
>>> O.acc(N)
u1*u2*N.y
接下來是關於 sympy 中使用的兩點和一點定理的描述。
首先是翻譯、旋轉的碟片。
>>> N = ReferenceFrame('N')
>>> u1, u2, u3 = dynamicsymbols('u1 u2 u3')
>>> R = Symbol('R')
>>> B = ReferenceFrame('B')
>>> O = Point('O')
>>> O.set_vel(N, u1 * N.x + u2 * N.y)
>>> P = O.locatenew('P', R * B.x)
>>> B.set_ang_vel(N, u3 * B.z)
>>> P.v2pt_theory(O, N, B)
u1*N.x + u2*N.y + R*u3*B.y
>>> P.a2pt_theory(O, N, B)
u1'*N.x + u2'*N.y - R*u3**2*B.x + R*u3'*B.y
我們還將涵蓋 1 點定理的實現。
這是粒子再次在一個環上運動。
>>> N = ReferenceFrame('N')
>>> u1, u2 = dynamicsymbols('u1 u2')
>>> q1, q2 = dynamicsymbols('q1 q2')
>>> l = Symbol('l')
>>> R = Symbol('R')
>>> C = N.orientnew('C', 'Axis', [q1, N.x])
>>> C.set_ang_vel(N, u1 * N.x)
>>> O = Point('O')
>>> O.set_vel(N, 0)
>>> Q = O.locatenew('Q', -l * C.z)
>>> P = Q.locatenew('P', R * (cos(q2) * C.x + sin(q2) * C.y))
>>> P.set_vel(C, R * u2 * (-sin(q2) * C.x + cos(q2) * C.y))
>>> Q.v2pt_theory(O, N, C)
l*u1*C.y
>>> P.v1pt_theory(Q, N, C)
- R*u2*sin(q2)*C.x + (R*u2*cos(q2) + l*u1)*C.y + R*u1*sin(q2)*C.z
物理學中的潛在問題/高階主題/未來功能/向量模組
原文連結：
docs.sympy.org/latest/modules/physics/vector/advanced.html
本文將描述此模組提供但不是“官方”介面的一些更高階功能。此外，將涵蓋一些將來將實施的功能，以及關於正確功能的未解答問題。還將討論常見問題及其解決方案。
二元向量
在 sympy.physics.mechanics 中，二元用於表示慣性 ([Kane1985], [WikiDyadics], [WikiDyadicProducts])。二元是由分量單位二元的線性多項式，類似於向量是由分量單位向量的線性多項式。二元是兩個向量的外積，返回一個新的量，表示這兩個向量的並置。例如：
[\begin{split}\mathbf{\hat{a}_x} \otimes \mathbf{\hat{a}_x} &= \mathbf{\hat{a}_x} \mathbf{\hat{a}_x}\ \mathbf{\hat{a}_x} \otimes \mathbf{\hat{a}_y} &= \mathbf{\hat{a}_x} \mathbf{\hat{a}_y}\\end{split}]
其中 (\mathbf{\hat{a}_x}\mathbf{\hat{a}_x}) 和 (\mathbf{\hat{a}_x}\mathbf{\hat{a}_y}) 是透過將左側作為列向量乘以右側作為行向量獲得的外積。注意順序很重要。
一些二元向量的額外屬性包括：
[\begin{split}(x \mathbf{v}) \otimes \mathbf{w} &= \mathbf{v} \otimes (x \mathbf{w}) = x (\mathbf{v} \otimes \mathbf{w})\ \mathbf{v} \otimes (\mathbf{w} + \mathbf{u}) &= \mathbf{v} \otimes \mathbf{w} + \mathbf{v} \otimes \mathbf{u}\ (\mathbf{v} + \mathbf{w}) \otimes \mathbf{u} &= \mathbf{v} \otimes \mathbf{u} + \mathbf{w} \otimes \mathbf{u}\\end{split}]
參考系中的向量可以表示為 (\begin{bmatrix}a\b\c\end{bmatrix}) 或 (a \mathbf{\hat{i}} + b \mathbf{\hat{j}} + c \mathbf{\hat{k}})。類似地，二元可以用張量形式表示：
[\begin{split}\begin{bmatrix} a_{11} & a_{12} & a_{13} \ a_{21} & a_{22} & a_{23} \ a_{31} & a_{32} & a_{33} \end{bmatrix}\\end{split}]
或以二元形式：
[\begin{split}a_{11} \mathbf{\hat{a}_x}\mathbf{\hat{a}x} + a \mathbf{\hat{a}_x}\mathbf{\hat{a}y} + a \mathbf{\hat{a}_x}\mathbf{\hat{a}z} + a \mathbf{\hat{a}_y}\mathbf{\hat{a}x} + a \mathbf{\hat{a}_y}\mathbf{\hat{a}y} + a \mathbf{\hat{a}_y}\mathbf{\hat{a}z} + a \mathbf{\hat{a}_z}\mathbf{\hat{a}x} + a \mathbf{\hat{a}_z}\mathbf{\hat{a}y} + a \mathbf{\hat{a}_z}\mathbf{\hat{a}_z}\\end{split}]
就像向量一樣，後續的表示使得可以跟蹤張量與哪些參考系有關。此外，張量每項的兩個分量不必在同一個參考系中。以下是有效的：
[\mathbf{\hat{a}_x} \otimes \mathbf{\hat{b}_y} = \mathbf{\hat{a}_x} \mathbf{\hat{b}_y}]
二階張量也可以與向量進行叉乘和點乘；再次強調順序的重要性：
[\begin{split}\mathbf{\hat{a}_x}\mathbf{\hat{a}_x} \cdot \mathbf{\hat{a}_x} &= \mathbf{\hat{a}_x}\ \mathbf{\hat{a}_y}\mathbf{\hat{a}_x} \cdot \mathbf{\hat{a}_x} &= \mathbf{\hat{a}_y}\ \mathbf{\hat{a}_x}\mathbf{\hat{a}_y} \cdot \mathbf{\hat{a}_x} &= 0\ \mathbf{\hat{a}_x} \cdot \mathbf{\hat{a}_x}\mathbf{\hat{a}_x} &= \mathbf{\hat{a}_x}\ \mathbf{\hat{a}_x} \cdot \mathbf{\hat{a}_x}\mathbf{\hat{a}_y} &= \mathbf{\hat{a}_y}\ \mathbf{\hat{a}_x} \cdot \mathbf{\hat{a}_y}\mathbf{\hat{a}_x} &= 0\ \mathbf{\hat{a}_x} \times \mathbf{\hat{a}_y}\mathbf{\hat{a}_x} &= \mathbf{\hat{a}_z}\mathbf{\hat{a}_x}\ \mathbf{\hat{a}_x} \times \mathbf{\hat{a}_x}\mathbf{\hat{a}_x} &= 0\ \mathbf{\hat{a}_y}\mathbf{\hat{a}_x} \times \mathbf{\hat{a}_z} &= - \mathbf{\hat{a}_y}\mathbf{\hat{a}_y}\\end{split}]
你也可以對二階張量進行時間導數，或者在不同參考系中表示它們，就像對向量一樣。
常見問題
在這裡，可能會出現與數值積分程式碼、座標和速度表示的 dynamicsymbols 選擇、列印、微分和替換相關的問題。
列印
預設的列印選項是對Vector和Dyadic測量數使用排序，並且從vprint、vpprint和vlatex函式有未排序的輸出。如果要列印大量內容，請使用這些函式之一，因為排序可能會將列印時間從幾秒鐘增加到幾分鐘。
替換
替換到大表示式中可能會很慢，並且需要幾分鐘的時間。
點的加速度
至少，點需要定義它們的速度，因為加速度可以透過在相同參考系中對速度的時間導數來計算。如果使用一點或兩點定理來計算速度，那麼速度表示式的時間導數很可能比使用一級和二級定理來計算的更復雜。使用加速度級別的方法可以在這一點上導致較短的表示式，這將在形成 Kane 方程時導致較短的表示式。
高階介面
這裡我們將涵蓋ReferenceFrame、dynamicsymbols和一些相關功能的高階選項。
參考系
ReferenceFrame 被顯示為具有 .name 屬性和 .x, .y, 和 .z 屬性用於訪問基向量，並且有一個相當嚴格定義的列印輸出。如果你希望有一個不同的索引集定義，這也是可以的。這也將需要一個不同的介面來訪問基向量。
>>> from sympy.physics.vector import ReferenceFrame, vprint, vpprint, vlatex
>>> N = ReferenceFrame('N', indices=['i', 'j', 'k'])
>>> N['i']
N['i']
>>> N.x
N['i']
>>> vlatex(N.x)
'\\mathbf{\\hat{n}_{i}}'
此外，latex 輸出可以有自定義字串；而不僅僅是指標，每個基向量的整體都可以指定。自定義 latex 字串可以不帶自定義指標而發生，也覆蓋瞭如果有自定義指標則將使用的 latex 字串。
>>> from sympy.physics.vector import ReferenceFrame, vlatex
>>> N = ReferenceFrame('N', latexs=['n1','\\mathbf{n}_2','cat'])
>>> vlatex(N.x)
'n1'
>>> vlatex(N.y)
'\\mathbf{n}_2'
>>> vlatex(N.z)
'cat'
動態符號
dynamicsymbols函式還具有‘隱藏’功能；與時間相關聯的變數可以更改，以及用於列印導數的符號。
>>> from sympy import symbols
>>> from sympy.physics.vector import dynamicsymbols, vprint
>>> q1 = dynamicsymbols('q1')
>>> q1
q1(t)
>>> dynamicsymbols._t = symbols('T')
>>> q2 = dynamicsymbols('q2')
>>> q2
q2(T)
>>> q1
q1(t)
>>> q1d = dynamicsymbols('q1', 1)
>>> vprint(q1d)
q1'
>>> dynamicsymbols._str = 'd'
>>> vprint(q1d)
q1d
>>> dynamicsymbols._str = '\''
>>> dynamicsymbols._t = symbols('t')
注意，僅在更改後建立的動態符號不同。這對於(._str)屬性並非如此；這僅影響列印輸出，因此在更改前後建立的動態符號將以相同的方式列印。
還要注意，Vector的.dt方法使用dynamicsymbols的._t屬性，以及其他一些重要的函式和方法。不要混合表示時間的符號。
解向量方程
要解決涉及向量的方程，不能直接使用向量上的解函式。相反，必須將向量轉換為一組標量方程。
假設我們有兩個框架N和A，其中A相對於N繞 z 軸旋轉 30 度。
>>> from sympy import pi, symbols, solve
>>> from sympy.physics.vector import ReferenceFrame
>>> N = ReferenceFrame("N")
>>> A = ReferenceFrame("A")
>>> A.orient_axis(N, pi / 6, N.z)
假設我們有兩個向量v1和v2，它們用不同的符號表示相同的向量。
>>> v1x, v1y, v1z = symbols("v1x v1y v1z")
>>> v2x, v2y, v2z = symbols("v2x v2y v2z")
>>> v1 = v1x * N.x + v1y * N.y + v1z * N.z
>>> v2 = v2x * A.x + v2y * A.y + v2z * A.z
我們的目標是找到v2中使用的符號與v1中使用的符號之間的關係。我們可以透過將向量轉換為矩陣，然後使用sympy.solvers.solvers.solve()來實現這一點。
>>> solve((v1 - v2).to_matrix(N), [v2x, v2y, v2z])
{v2x: sqrt(3)*v1x/2 + v1y/2, v2y: -v1x/2 + sqrt(3)*v1y/2, v2z: v1z}
標量和向量場功能
原文：
docs.sympy.org/latest/modules/physics/vector/fields.html
介紹
向量和標量
在物理學中，我們處理兩種量 - 標量和向量。
標量是僅具有大小而沒有方向的實體。標量量例如質量、電荷、溫度、距離等。
另一方面，向量是由大小和方向特徵的實體。向量量的例子包括位移、速度、磁場等。
標量可以僅用一個數字表示，例如 300K 的溫度。另一方面，向量量如加速度通常用向量表示。給定一個向量(\mathbf{V})，相應量的大小可以透過向量本身的大小(\Vert \mathbf{V} \Vert)計算，而方向則由原始向量方向上的單位向量指定，(\mathbf{\hat{V}} = \frac{\mathbf{V}}{\Vert \mathbf{V} \Vert})。
例如，考慮位移為((3\mathbf{\hat{i}} + 4\mathbf{\hat{j}} + 5\mathbf{\hat{k}}))米，其中，按照標準慣例，(\mathbf{\hat{i}})、(\mathbf{\hat{j}})和(\mathbf{\hat{k}})分別代表(\mathbf{X})、(\mathbf{Y})和(\mathbf{Z})方向的單位向量。因此，可以得出行程距離為(\Vert 3\mathbf{\hat{i}} + 4\mathbf{\hat{j}} + 5\mathbf{\hat{k}} \Vert)米 = (5\sqrt{2})米。行進方向由單位向量(\frac{3}{5\sqrt{2}}\mathbf{\hat{i}} + \frac{4}{5\sqrt{2}}\mathbf{\hat{j}} + \frac{5}{5\sqrt{2}}\mathbf{\hat{k}})給出。
場
一般來說，一個(場)是可以作為位置函式在空間中的每個位置指定的向量或標量量（注意，通常情況下場也可能依賴於時間和其他自定義變數）。在本模組中，我們只處理三維空間。因此，場被定義為(x)、(y)和(z)座標的函式，對應於 3D 空間中的位置。
例如，三維空間中的溫度（溫度場）可以寫為(T(x, y, z)) - 位置的標量函式。在電磁學中標量場的例子是電勢。
類似地，向量場可以定義為空間中任意點((x, y, z))位置的向量函式。
例如，地球上的每一點都可以看作處於地球的重力場中。我們可以透過每個空間點處的加速度（即單位質量的力）(g(x, y, z))的大小和方向來指定場。
舉例來說，考慮一個電動勢形式為(2{x}^{2}y)的電勢標量場在三維空間中。相應的保守電場可以計算為電勢函式的梯度，並表示為(4xy\mathbf{\hat{i}} + 2{x}{2}\mathbf{\hat{j}})。這個電場的大小可以進一步表示為形如(\sqrt{4{x} + 16{x}{2}{y}{2}})的標量場。
在sympy.physics.vector中的場的實現
在sympy.physics.vector模組中，每個ReferenceFrame例項都被分配了對應於(X)、(Y)和(Z)方向的基向量。這些可以透過分別命名為x、y和z的屬性來訪問。因此，要在給定的參考框架(\mathbf{R})中定義形式為(3\mathbf{\hat{i}} + 4\mathbf{\hat{j}} + 5\mathbf{\hat{k}})的向量(\mathbf{v})，你可以這樣做：
>>> from sympy.physics.vector import ReferenceFrame
>>> R = ReferenceFrame('R')
>>> v = 3*R.x + 4*R.y + 5*R.z
有關向量及其對應的基本微積分操作，本模組文件的其他部分已經有詳細闡述。
另一方面，基標量（或座標變數）被實現為分配給每個參考框架的特殊 SymPy Symbol，每個方向從(X)、(Y)和(Z)各有一個。對於框架R，(X)、(Y)和(Z)基標量Symbol可以分別透過R[0]、R[1]和R[2]表示式訪問。
因此，要生成上述電勢場(2{x}^{2}y)的表示式，你需要這樣做：
>>> from sympy.physics.vector import ReferenceFrame
>>> R = ReferenceFrame('R')
>>> electric_potential = 2*R[0]**2*R[1]
>>> electric_potential
2*R_x**2*R_y
在字串表示中，R_x表示分配給ReferenceFrame R的(X)基標量。實質上，R_x是R[0]的字串表示。
標量場可以像任何其他 SymPy 表示式一樣用於任何數學/微積分功能。因此，要相對於(x)（即R[0]）對上述電勢進行微分，你需要使用diff函式。
>>> from sympy.physics.vector import ReferenceFrame
>>> R = ReferenceFrame('R')
>>> electric_potential = 2*R[0]**2*R[1]
>>> from sympy import diff
>>> diff(electric_potential, R[0])
4*R_x*R_y
與向量（和向量場）類似，標量場也可以在除定義它們的框架之外的其他參考框架中重新表達，假設所涉及的框架之間存在方向關係。這可以使用sympy.physics.vector.vector.Vector.express方法完成，方法類似於向量，但variables引數設定為True。
>>> from sympy.physics.vector import ReferenceFrame
>>> R = ReferenceFrame('R')
>>> electric_potential = 2*R[0]**2*R[1]
>>> from sympy.physics.vector import dynamicsymbols, express
>>> q = dynamicsymbols('q')
>>> R1 = R.orientnew('R1', rot_type = 'Axis', amounts = [q, R.z])
>>> express(electric_potential, R1, variables=True)
2*(R1_x*sin(q(t)) + R1_y*cos(q(t)))*(R1_x*cos(q(t)) - R1_y*sin(q(t)))**2
此外，考慮到標量也可以是時間的函式，就像向量一樣，可以進行時間微分。根據表示式中的Symbol和進行時間微分的參考框架，輸出會改變/保持不變。
>>> from sympy.physics.vector import ReferenceFrame
>>> R = ReferenceFrame('R')
>>> electric_potential = 2*R[0]**2*R[1]
>>> q = dynamicsymbols('q')
>>> R1 = R.orientnew('R1', rot_type = 'Axis', amounts = [q, R.z])
>>> from sympy.physics.vector import time_derivative
>>> time_derivative(electric_potential, R)
0
>>> time_derivative(electric_potential, R1).simplify()
2*(R1_x*cos(q(t)) - R1_y*sin(q(t)))*(3*R1_x**2*cos(2*q(t))/2 -
R1_x**2/2 - 3*R1_x*R1_y*sin(2*q(t)) - 3*R1_y**2*cos(2*q(t))/2 -
R1_y**2/2)*Derivative(q(t), t)
場算符和其他相關函式
這裡我們描述了在 sympy.physics.vector 中實現的一些基本與場相關的功能。
旋度
旋度是描述三維空間中向量微小旋轉的數學運算元。方向由右手法則（沿著旋轉軸）確定，幅度由旋轉的大小給出。
在 3D 笛卡爾系統中，三維向量( \mathbf{F} )的旋度，記作( \nabla \times \mathbf{F} )，由以下公式給出 -
( \nabla \times \mathbf{F} = \left(\frac{\partial F_z}{\partial y} - \frac{\partial F_y}{\partial z}\right) \mathbf{\hat{i}} + \left(\frac{\partial F_x}{\partial z} - \frac{\partial F_z}{\partial x}\right) \mathbf{\hat{j}} + \left(\frac{\partial F_y}{\partial x} - \frac{\partial F_x}{\partial y}\right) \mathbf{\hat{k}} )
其中( F_x )表示向量( \mathbf{F} )的( X )分量。
在sympy.physics.vector中計算向量場的旋度，您可以執行以下操作：
>>> from sympy.physics.vector import ReferenceFrame
>>> R = ReferenceFrame('R')
>>> from sympy.physics.vector import curl
>>> field = R[0]*R[1]*R[2]*R.x
>>> curl(field, R)
R_x*R_y*R.y - R_x*R_z*R.z
散度
散度是一個向量運算元，用於衡量向量場在給定點的源或匯的大小，以有符號標量形式表示。
散度運算元在作用於向量後始終返回一個標量。
在 3D 笛卡爾系統中，三維向量( \mathbf{F} )的散度，記作( \nabla\cdot\mathbf{F} )，由以下公式給出 -
( \nabla\cdot\mathbf{F} = \frac{\partial U}{\partial x} + \frac{\partial V}{\partial y} + \frac{\partial W}{\partial z } )
其中( U )，( V )和( W )分別表示( \mathbf{F} )的( X )，( Y )和( Z )分量。
在sympy.physics.vector中計算向量場的散度，您可以執行以下操作：
>>> from sympy.physics.vector import ReferenceFrame
>>> R = ReferenceFrame('R')
>>> from sympy.physics.vector import divergence
>>> field = R[0]*R[1]*R[2] * (R.x+R.y+R.z)
>>> divergence(field, R)
R_x*R_y + R_x*R_z + R_y*R_z
梯度
考慮在三維空間中的標量場( f(x, y, z) )。該場的梯度定義為關於( X )，( Y )和( Z )方向上( f )的三個偏導數的向量。
在 3D 笛卡爾系統中，標量場( f )的梯度，記作( \nabla f )，由以下公式給出 -
( \nabla f = \frac{\partial f}{\partial x} \mathbf{\hat{i}} + \frac{\partial f}{\partial y} \mathbf{\hat{j}} + \frac{\partial f}{\partial z} \mathbf{\hat{k}} )
在sympy.physics.vector中計算標量場的梯度，您可以執行以下操作：
>>> from sympy.physics.vector import ReferenceFrame
>>> R = ReferenceFrame('R')
>>> from sympy.physics.vector import gradient
>>> scalar_field = R[0]*R[1]*R[2]
>>> gradient(scalar_field, R)
R_y*R_z*R.x + R_x*R_z*R.y + R_x*R_y*R.z
保守與旋度場
在向量微積分中，保守場是某個標量場的梯度。保守場具有這樣的性質，即其沿任意路徑的線積分僅依賴於端點，並且與路徑本身無關。保守向量場也被稱為‘無旋場’，因為保守場的旋度始終為零。
在物理學中，保守場代表能量守恆的物理系統中的力。
若要檢查向量場在 sympy.physics.vector 中是否為保守場，請使用 sympy.physics.vector.fieldfunctions.is_conservative 函式。
>>> from sympy.physics.vector import ReferenceFrame, is_conservative
>>> R = ReferenceFrame('R')
>>> field = R[1]*R[2]*R.x + R[0]*R[2]*R.y + R[0]*R[1]*R.z
>>> is_conservative(field)
True
>>> curl(field, R)
0
另一方面，旋量場是指其在空間中所有點的散度均為零的向量場。
若要檢查向量場在 sympy.physics.vector 中是否為旋量場，請使用 sympy.physics.vector.fieldfunctions.is_solenoidal 函式。
>>> from sympy.physics.vector import ReferenceFrame, is_solenoidal
>>> R = ReferenceFrame('R')
>>> field = R[1]*R[2]*R.x + R[0]*R[2]*R.y + R[0]*R[1]*R.z
>>> is_solenoidal(field)
True
>>> divergence(field, R)
0
標量勢函式
我們之前提到，每個保守場都可以被定義為某個標量場的梯度。這個標量場也被稱為與前述保守場對應的‘標量勢場’。
sympy.physics.vector.fieldfunctions.scalar_potential 函式在 sympy.physics.vector 中計算給定三維空間中保守向量場對應的標量勢場 - 當然要減去積分的額外常數。
使用示例 -
>>> from sympy.physics.vector import ReferenceFrame, scalar_potential
>>> R = ReferenceFrame('R')
>>> conservative_field = 4*R[0]*R[1]*R[2]*R.x + 2*R[0]**2*R[2]*R.y + 2*R[0]**2*R[1]*R.z
>>> scalar_potential(conservative_field, R)
2*R_x**2*R_y*R_z
將非保守向量場作為引數提供給 sympy.physics.vector.fieldfunctions.scalar_potential 會引發 ValueError。
對應於保守向量場的標量勢差，或簡稱‘勢差’，可以定義為空間中兩點處其標量勢函式值的差。這在計算關於保守函式的線積分中非常有用，因為它僅依賴於路徑的端點。
在 sympy.physics.vector 中，該計算執行如下。
>>> from sympy.physics.vector import ReferenceFrame, Point
>>> from sympy.physics.vector import scalar_potential_difference
>>> R = ReferenceFrame('R')
>>> O = Point('O')
>>> P = O.locatenew('P', 1*R.x + 2*R.y + 3*R.z)
>>> vectfield = 4*R[0]*R[1]*R.x + 2*R[0]**2*R.y
>>> scalar_potential_difference(vectfield, R, O, P, O)
4
如果提供的是標量表示式而不是向量場，sympy.physics.vector.fieldfunctions.scalar_potential_difference 返回空間中兩個給定點處該標量場值的差異。
物理向量 API
原文：
docs.sympy.org/latest/modules/physics/vector/api/index.html
-
基本類
-
運動學（文件字串）
-
列印（文件字串）
-
基本函式（文件字串）
-
基本場函式的文件字串
關鍵類
原文：
docs.sympy.org/latest/modules/physics/vector/api/classes.html
class sympy.physics.vector.frame.CoordinateSym(name, frame, index)
與參考框架相關的座標符號/基量標量。
理想情況下，使用者不應該例項化這個類。這個類的例項必須僅透過相應的框架作為‘frame[index]’來訪問。
具有相同框架和索引引數的 CoordinateSyms 是相等的（即使它們可能是分別例項化的）。
引數：
name：字串
CoordinateSym 的顯示名稱
frame：ReferenceFrame
此基量標量所屬的參考框架
index：0、1 或 2
由此座標變數表示的維度的索引
示例
>>> from sympy.physics.vector import ReferenceFrame, CoordinateSym
>>> A = ReferenceFrame('A')
>>> A[1]
A_y
>>> type(A[0])
<class 'sympy.physics.vector.frame.CoordinateSym'>
>>> a_y = CoordinateSym('a_y', A, 1)
>>> a_y == A[1]
True
class sympy.physics.vector.frame.ReferenceFrame(name, indices=None, latexs=None, variables=None)
經典力學中的參考框架。
ReferenceFrame 是用於表示經典力學中參考框架的類。它在框架的 x、y 和 z 方向具有標準基向量。
它也可以相對於父框架進行旋轉；這種旋轉由一個方向餘弦矩陣定義，將該框架的基向量與父框架的基向量相關聯。它還可以具有在另一個框架中定義的角速度向量。
ang_acc_in(otherframe)
返回參考框架的角加速度向量。
有效地返回向量：
N_alpha_B
其中 N 表示 B 在 N 中的角加速度，其中 B 是自身，N 是 otherframe。
引數：
otherframe：ReferenceFrame
返回角加速度的 ReferenceFrame。
示例
>>> from sympy.physics.vector import ReferenceFrame
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_acc(N, V)
>>> A.ang_acc_in(N)
10*N.x
ang_vel_in(otherframe)
返回參考框架的角速度向量。
有效地返回向量：
^N omega ^B
其中 N 表示 B 在 N 中的角速度，其中 B 是自身，N 是 otherframe。
引數：
otherframe：ReferenceFrame
返回角速度的 ReferenceFrame。
示例
>>> from sympy.physics.vector import ReferenceFrame
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_vel(N, V)
>>> A.ang_vel_in(N)
10*N.x
dcm(otherframe)
返回相對於提供的參考框架的此參考框架的方向餘弦矩陣。
返回的矩陣可用於用otherframe的正交單位向量表示該框架的正交單位向量。
引數：
otherframe：ReferenceFrame
形成此框架的方向餘弦矩陣相對於的參考框架。
示例
以下示例透過簡單旋轉將參考框架 A 相對於 N 旋轉，然後計算 N 相對於 A 的方向餘弦矩陣。
>>> from sympy import symbols, sin, cos
>>> from sympy.physics.vector import ReferenceFrame
>>> q1 = symbols('q1')
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> A.orient_axis(N, q1, N.x)
>>> N.dcm(A)
Matrix([
[1, 0, 0],
[0, cos(q1), -sin(q1)],
[0, sin(q1), cos(q1)]])
上述方向餘弦矩陣的第二行表示在 A 中表示的 N.y 單位向量N.y。如下所示：
>>> Ny = 0*A.x + cos(q1)*A.y - sin(q1)*A.z
因此，在 A 中表達N.y應該返回相同的結果：
>>> N.y.express(A)
cos(q1)*A.y - sin(q1)*A.z
註釋
知道返回的方向餘弦矩陣的形式很重要。如果呼叫B.dcm(A)，表示“B 相對於 A 旋轉的方向餘弦矩陣”。這是下面關係中顯示的矩陣 ({}B\mathbf{C}A)：
[\begin{split}\begin{bmatrix} \hat{\mathbf{b}}_1 \ \hat{\mathbf{b}}_2 \ \hat{\mathbf{b}}_3 \end{bmatrix} = {}B\mathbf{C}A \begin{bmatrix} \hat{\mathbf{a}}_1 \ \hat{\mathbf{a}}_2 \ \hat{\mathbf{a}}_3 \end{bmatrix}.\end{split}]
({}B\mathbf{C}A)是表達 B 單位向量與 A 單位向量關係的矩陣。
orient(parent, rot_type, amounts, rot_order='')
設定此參考框架相對於另一個（父）參考框架的方向。
注意
現在建議使用.orient_axis, .orient_body_fixed, .orient_space_fixed, .orient_quaternion方法來處理不同的旋轉型別。
引數：
parent：參考框架。
將此參考框架旋轉到的參考框架。
rot_type：字串。
生成方向餘弦矩陣的方法。支援的方法有：
'Axis'：圍繞單個共同軸的簡單旋轉。'DCM'：用於直接設定方向餘弦矩陣。'Body'：圍繞新中間軸的三次連續旋轉，也稱為“尤拉和泰特-布賴恩角”。'Space'：圍繞父框架單位向量的三次連續旋轉。'Quaternion'：由四個引數定義的旋轉，其結果是一個無奇點的方向餘弦矩陣。
amounts：
定義旋轉角度或方向餘弦矩陣的表示式。這些必須與
rot_type匹配。有關詳細資訊，請參見下面的示例。輸入型別為：
'Axis'：2 元組（表示式/符號/函式，向量）。'DCM'：矩陣，形狀(3,3)。'Body'：三元組表示式、符號或函式。'Space'：三元組表示式、符號或函式。'Quaternion'：四元組表示式、符號或函式。
rot_order：字串或整數，可選。
如果適用，表示連續旋轉的順序。例如，字串
'123'和整數123是等效的。對'Body'和'Space'型別是必需的。
警告：
使用者警告
如果方向建立了一個運動學閉環。
orient_axis(parent, axis, angle)
透過繞父參考框架中固定軸旋轉角度，設定此參考框架的方向。
引數：
parent：參考框架。
將此參考框架旋轉到的參考框架。
axis：向量。
固定在父框架中的向量，圍繞其旋轉的框架。它不需要是單位向量，旋轉遵循右手規則。
angle：可合併。
以弧度表示的旋轉角度。
警告：
使用者警告
如果方向建立了一個運動學閉環。
示例
為示例設定變數：
>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame
>>> q1 = symbols('q1')
>>> N = ReferenceFrame('N')
>>> B = ReferenceFrame('B')
>>> B.orient_axis(N, N.x, q1)
orient_axis()方法生成一個方向餘弦矩陣及其轉置，定義了 B 相對於 N 的方向和反向。一旦呼叫orient，dcm()輸出適當的方向餘弦矩陣：
>>> B.dcm(N)
Matrix([
[1, 0, 0],
[0, cos(q1), sin(q1)],
[0, -sin(q1), cos(q1)]])
>>> N.dcm(B)
Matrix([
[1, 0, 0],
[0, cos(q1), -sin(q1)],
[0, sin(q1), cos(q1)]])
下面兩行表明旋轉的方向可以透過對向量方向或角度取反來定義。這兩行都會產生相同的結果。
>>> B.orient_axis(N, -N.x, q1)
>>> B.orient_axis(N, N.x, -q1)
orient_body_fixed(parent, angles, rotation_order)
將此參考框架相對於父參考框架透過連續的身體固定簡單軸旋轉右手旋轉。每個後續旋轉軸圍繞新的中間參考框架的“身體固定”單位向量。這種旋轉型別也稱為繞尤拉和 Tait-Bryan 角度旋轉。
該方法中計算的角速度預設以子框架的形式表示，因此最好使用 u1 * child.x + u2 * child.y + u3 * child.z 作為廣義速度。
引數：
parent ：參考框架
將相對於父參考框架設定此參考框架的方向。
angles ：3-tuple of sympifiable
三個用於連續旋轉的弧度角。
rotation_order ：3 個字元字串或 3 位整數
關於每個中間參考框架單位向量的旋轉順序。關於 X、Z'、X'' 軸的尤拉旋轉可以用字串
'XZX'、'131'或整數131來指定。有 12 個唯一的有效旋轉順序（6 個尤拉和 6 個 Tait-Bryan）：zxz、xyx、yzy、zyz、xzx、yxy、xyz、yzx、zxy、xzy、zyx 和 yxz。
警告：
使用者警告
如果方向建立一個運動學環路。
示例
為示例設定變數：
>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame
>>> q1, q2, q3 = symbols('q1, q2, q3')
>>> N = ReferenceFrame('N')
>>> B = ReferenceFrame('B')
>>> B1 = ReferenceFrame('B1')
>>> B2 = ReferenceFrame('B2')
>>> B3 = ReferenceFrame('B3')
例如，經典的尤拉角旋轉可以透過以下方式完成：
>>> B.orient_body_fixed(N, (q1, q2, q3), 'XYX')
>>> B.dcm(N)
Matrix([
[ cos(q2), sin(q1)*sin(q2), -sin(q2)*cos(q1)],
[sin(q2)*sin(q3), -sin(q1)*sin(q3)*cos(q2) + cos(q1)*cos(q3), sin(q1)*cos(q3) + sin(q3)*cos(q1)*cos(q2)],
[sin(q2)*cos(q3), -sin(q1)*cos(q2)*cos(q3) - sin(q3)*cos(q1), -sin(q1)*sin(q3) + cos(q1)*cos(q2)*cos(q3)]])
這將參考框架 B 相對於參考框架 N 透過 q1 關於 N.x 的旋轉，然後再次透過 q2 關於 B.y 的旋轉，並最終透過 q3 關於 B.x 的旋轉。這相當於三個連續的 orient_axis() 呼叫：
>>> B1.orient_axis(N, N.x, q1)
>>> B2.orient_axis(B1, B1.y, q2)
>>> B3.orient_axis(B2, B2.x, q3)
>>> B3.dcm(N)
Matrix([
[ cos(q2), sin(q1)*sin(q2), -sin(q2)*cos(q1)],
[sin(q2)*sin(q3), -sin(q1)*sin(q3)*cos(q2) + cos(q1)*cos(q3), sin(q1)*cos(q3) + sin(q3)*cos(q1)*cos(q2)],
[sin(q2)*cos(q3), -sin(q1)*cos(q2)*cos(q3) - sin(q3)*cos(q1), -sin(q1)*sin(q3) + cos(q1)*cos(q2)*cos(q3)]])
可接受的旋轉順序長度為 3，表示為字串 'XYZ' 或 '123' 或整數 123。禁止連續兩次繞一個軸旋轉。
>>> B.orient_body_fixed(N, (q1, q2, 0), 'ZXZ')
>>> B.orient_body_fixed(N, (q1, q2, 0), '121')
>>> B.orient_body_fixed(N, (q1, q2, q3), 123)
orient_dcm(parent, dcm)
使用描述從子參考框架到父參考框架的旋轉的方向餘弦矩陣設定此參考框架的方向。
引數：
parent ：參考框架
將相對於另一個（父級）參考框架設定此參考框架的方向。
dcm ：矩陣，形狀(3, 3)
指定兩個參考框架之間相對旋轉的方向餘弦矩陣。
警告：
使用者警告
如果方向建立一個運動學環路。
示例
為示例設定變數：
>>> from sympy import symbols, Matrix, sin, cos
>>> from sympy.physics.vector import ReferenceFrame
>>> q1 = symbols('q1')
>>> A = ReferenceFrame('A')
>>> B = ReferenceFrame('B')
>>> N = ReferenceFrame('N')
簡單的相對於 N 關於 N.x 的旋轉由以下方向餘弦矩陣定義：
>>> dcm = Matrix([[1, 0, 0],
... [0, cos(q1), sin(q1)],
... [0, -sin(q1), cos(q1)]])
>>> A.orient_dcm(N, dcm)
>>> A.dcm(N)
Matrix([
[1, 0, 0],
[0, cos(q1), sin(q1)],
[0, -sin(q1), cos(q1)]])
這相當於使用 orient_axis()：
>>> B.orient_axis(N, N.x, q1)
>>> B.dcm(N)
Matrix([
[1, 0, 0],
[0, cos(q1), sin(q1)],
[0, -sin(q1), cos(q1)]])
orient_quaternion(parent, numbers)
透過方向餘弦矩陣設定此參考框架相對於父參考框架的方向。方向餘弦矩陣被定義為由角度 theta 的單位向量 (lambda_x, lambda_y, lambda_z) 繞一個軸進行的有限旋轉。方向餘弦矩陣由四個引數描述：
-
q0 = cos(theta/2) -
q1 = lambda_x*sin(theta/2) -
q2 = lambda_y*sin(theta/2) -
q3 = lambda_z*sin(theta/2)
更多資訊請參見四元數和空間旋轉在維基百科上。
引數：
parent : ReferenceFrame
將旋轉相對於此參考系的參考系。
numbers : sympy 化的 4 元組
四個四元數標量數如上定義：
q0，q1，q2，q3。
警告：
UserWarning
如果方向性建立了一個運動學回路。
示例
設定示例變數：
>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame
>>> q0, q1, q2, q3 = symbols('q0 q1 q2 q3')
>>> N = ReferenceFrame('N')
>>> B = ReferenceFrame('B')
設定方向：
>>> B.orient_quaternion(N, (q0, q1, q2, q3))
>>> B.dcm(N)
Matrix([
[q0**2 + q1**2 - q2**2 - q3**2, 2*q0*q3 + 2*q1*q2, -2*q0*q2 + 2*q1*q3],
[ -2*q0*q3 + 2*q1*q2, q0**2 - q1**2 + q2**2 - q3**2, 2*q0*q1 + 2*q2*q3],
[ 2*q0*q2 + 2*q1*q3, -2*q0*q1 + 2*q2*q3, q0**2 - q1**2 - q2**2 + q3**2]])
orient_space_fixed(parent, angles, rotation_order)
相對於父參考系透過右手側旋轉的三個連續空間固定簡單軸旋轉旋轉此參考系。每個後續旋轉軸都是關於父參考系的“空間固定”單位向量。
本方法中計算的角速度預設為在子參考系中表示，因此最好使用u1 * child.x + u2 * child.y + u3 * child.z作為廣義速度。
引數：
parent : ReferenceFrame
將旋轉相對於此參考系的參考系。
angles : sympy 化的 3 元組
用於連續旋轉的三個弧度角。
rotation_order : 3 個字元字串或 3 位整數
父參考系單位向量的旋轉順序。順序可以由字串
'XZX'，'131'或整數131指定。有 12 個唯一的有效旋轉順序。
警告：
UserWarning
如果方向性建立了一個運動學回路。
示例
設定示例變數：
>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame
>>> q1, q2, q3 = symbols('q1, q2, q3')
>>> N = ReferenceFrame('N')
>>> B = ReferenceFrame('B')
>>> B1 = ReferenceFrame('B1')
>>> B2 = ReferenceFrame('B2')
>>> B3 = ReferenceFrame('B3')
>>> B.orient_space_fixed(N, (q1, q2, q3), '312')
>>> B.dcm(N)
Matrix([
[ sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1)],
[-sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3)],
[ sin(q3)*cos(q2), -sin(q2), cos(q2)*cos(q3)]])
等價於：
>>> B1.orient_axis(N, N.z, q1)
>>> B2.orient_axis(B1, N.x, q2)
>>> B3.orient_axis(B2, N.y, q3)
>>> B3.dcm(N).simplify()
Matrix([
[ sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1)],
[-sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3)],
[ sin(q3)*cos(q2), -sin(q2), cos(q2)*cos(q3)]])
值得注意的是，空間固定和體固定旋轉透過旋轉順序相關聯，即體固定的逆順序將給出空間固定，反之亦然。
>>> B.orient_space_fixed(N, (q1, q2, q3), '231')
>>> B.dcm(N)
Matrix([
[cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), -sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)],
[ -sin(q2), cos(q2)*cos(q3), sin(q3)*cos(q2)],
[sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1), sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3)]])
>>> B.orient_body_fixed(N, (q3, q2, q1), '132')
>>> B.dcm(N)
Matrix([
[cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), -sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)],
[ -sin(q2), cos(q2)*cos(q3), sin(q3)*cos(q2)],
[sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1), sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3)]])
orientnew(newname, rot_type, amounts, rot_order='', variables=None, indices=None, latexs=None)
返回相對於此參考系定向的新參考系。
參見ReferenceFrame.orient()，瞭解如何定向參考系的詳細示例。
引數：
newname : 字串
新參考系的名稱。
rot_type : 字串
生成方向餘弦矩陣的方法。支援的方法有：
'Axis': 簡單繞單一公共軸旋轉'DCM': 用於直接設定方向餘弦矩陣'Body': 關於新中間軸的三個連續旋轉，也稱為“尤拉和泰特-布賴恩角”'Space': 關於父參考系單位向量的三個連續旋轉'Quaternion': 由四個引數定義的旋轉，其結果是無奇點的方向餘弦矩陣
amounts :
定義旋轉角度或方向餘弦矩陣的表示式。這些必須與
rot_type匹配。有關詳細資訊，請參閱下面的示例。
'Axis': 2 元組（表示式/符號/函式，向量）'DCM': 矩陣，形狀(3,3)'Body': 表示式、符號或函式的 3 元組'Space': 表示式、符號或函式的 3 元組'Quaternion': 表示式、符號或函式的 4 元組
rot_order : 字串或整數，可選
如果適用，旋轉順序的順序。例如字串
'123'和整數123是等效的。對'Body'和'Space'是必需的。
indices : 字串元組
使得可以透過 Python 的方括號索引符號訪問參考框架的基單位向量，使用提供的三個索引字串，並修改單元向量的列印以反映此選擇。
latexs : 字串元組
修改參考框架的基單位向量的 LaTeX 列印為提供的三個有效的 LaTeX 字串。
例子
>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame, vlatex
>>> q0, q1, q2, q3 = symbols('q0 q1 q2 q3')
>>> N = ReferenceFrame('N')
建立一個透過簡單旋轉相對於 N 旋轉的新參考框架 A。
>>> A = N.orientnew('A', 'Axis', (q0, N.x))
建立一個透過體固定旋轉相對於 N 旋轉的新參考框架 B。
>>> B = N.orientnew('B', 'Body', (q1, q2, q3), '123')
建立一個透過簡單旋轉相對於 N 旋轉的新參考框架 C，具有獨特的索引和 LaTeX 列印。
>>> C = N.orientnew('C', 'Axis', (q0, N.x), indices=('1', '2', '3'),
... latexs=(r'\hat{\mathbf{c}}_1',r'\hat{\mathbf{c}}_2',
... r'\hat{\mathbf{c}}_3'))
>>> C['1']
C['1']
>>> print(vlatex(C['1']))
\hat{\mathbf{c}}_1
partial_velocity(frame, *gen_speeds)
返回該框架在給定框架中關於一個或多個提供的廣義速度的部分角速度。
引數：
frame : 參考框架
定義角速度相對於的框架。
gen_speeds : 時間的函式
廣義速度。
返回：
partial_velocities : 向量元組
對應於所提供廣義速度的部分角速度向量。
例子
>>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> u1, u2 = dynamicsymbols('u1, u2')
>>> A.set_ang_vel(N, u1 * A.x + u2 * N.y)
>>> A.partial_velocity(N, u1)
A.x
>>> A.partial_velocity(N, u1, u2)
(A.x, N.y)
set_ang_acc(otherframe, value)
在參考框架中定義角加速度向量。
定義該參考框架的角加速度，另一種。 角加速度可以相對於多個不同的參考框架定義。 必須小心，以免建立不一致的迴圈。
引數：
otherframe : 參考框架
定義角加速度的參考框架
value : 向量
表示角加速度的向量
例子
>>> from sympy.physics.vector import ReferenceFrame
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_acc(N, V)
>>> A.ang_acc_in(N)
10*N.x
set_ang_vel(otherframe, value)
在參考框架中定義角速度向量。
定義該參考框架的角速度，另一種。 角速度可以相對於多個不同的參考框架定義。 必須小心，以免建立不一致的迴圈。
引數：
otherframe : 參考框架
定義角速度的參考框架
value : 向量
表示角速度的向量
例子
>>> from sympy.physics.vector import ReferenceFrame
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_vel(N, V)
>>> A.ang_vel_in(N)
10*N.x
property u
參考框架的單位二重項。
variable_map(otherframe)
返回一個表達該框架的座標變數與其他框架變數的字典。
如果 Vector.simp 為 True，則返回對映值的簡化版本。 否則，返回未簡化的值。
簡化表達可能需要時間。
引數：
otherframe : 參考框架
對映變數到另一個框架
例子
>>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
>>> A = ReferenceFrame('A')
>>> q = dynamicsymbols('q')
>>> B = A.orientnew('B', 'Axis', [q, A.z])
>>> A.variable_map(B)
{A_x: B_x*cos(q(t)) - B_y*sin(q(t)), A_y: B_x*sin(q(t)) + B_y*cos(q(t)), A_z: B_z}
property x
參考框架中 x 方向的基向量。
property xx
參考框架中基向量 x 和 x 的單位二重項。
property xy
參考框架中基向量 x 和 y 的單位二重項。
property xz
參考框架中基向量 x 和 z 的單位二重項。
property y
參考框架中 y 方向的基向量。
property yx
參考框架中基向量 y 和 x 的單位二重項。
property yy
參考框架中基向量 y 和 y 的單位二重項。
property yz
參考框架中基向量 y 和 z 的單位二重項。
property z
參考框架中 z 方向的基向量。
property zx
參考框架中基向量 z 和 x 的單位二重項。
property zy
與參考框架中基向量 z 和 y 的單位二重
property zz
用於參考框架中基向量 z 和 z 的單位二重
class sympy.physics.vector.vector.Vector(inlist)
用於定義向量的類。
它以及 ReferenceFrame 是在 PyDy 和 sympy.physics.vector 中描述經典力學系統的基本構件。
屬性
| simp | (布林值) 允許某些方法在其輸出上使用 trigsimp |
|---|
angle_between(vec)
返回向量 'vec' 和自身之間的最小角度。
警告
Python 忽略前導負號，可能導致錯誤結果。-A.x.angle_between() 將被處理為 -(A.x.angle_between())，而不是 (-A.x).angle_between()。
引數
vecVector
需要角度的兩個向量之間的向量。
示例
>>> from sympy.physics.vector import ReferenceFrame
>>> A = ReferenceFrame("A")
>>> v1 = A.x
>>> v2 = A.y
>>> v1.angle_between(v2)
pi/2
>>> v3 = A.x + A.y + A.z
>>> v1.angle_between(v3)
acos(sqrt(3)/3)
applyfunc(f)
對向量的每個分量應用一個函式。
cross(other)
兩個向量的叉乘運算元。
返回一個與自身相同參考框架表達的向量。
引數：
other：Vector
我們正在與之交叉的向量
示例
>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame, cross
>>> q1 = symbols('q1')
>>> N = ReferenceFrame('N')
>>> cross(N.x, N.y)
N.z
>>> A = ReferenceFrame('A')
>>> A.orient_axis(N, q1, N.x)
>>> cross(A.x, N.y)
N.z
>>> cross(N.y, A.x)
- sin(q1)*A.y - cos(q1)*A.z
diff(var, frame, var_in_dcm=True)
返回相對於所提供參考框架中變數的向量的偏導數。
引數：
var：Symbol
所取偏導數的物件。
frame：ReferenceFrame
在其中進行時間導數計算的參考框架。
var_in_dcm：布林值
如果為 true，則差異化演算法假定該變數可能存在於將框架與向量任何分量的框架相關聯的方向餘弦矩陣中。但如果已知該變數不存在於方向餘弦矩陣中，則可以設定 false 以跳過完全重新表達為所需框架。
示例
>>> from sympy import Symbol
>>> from sympy.physics.vector import dynamicsymbols, ReferenceFrame
>>> from sympy.physics.vector import init_vprinting
>>> init_vprinting(pretty_print=False)
>>> t = Symbol('t')
>>> q1 = dynamicsymbols('q1')
>>> N = ReferenceFrame('N')
>>> A = N.orientnew('A', 'Axis', [q1, N.y])
>>> A.x.diff(t, N)
- sin(q1)*q1'*N.x - cos(q1)*q1'*N.z
>>> A.x.diff(t, N).express(A).simplify()
- q1'*A.z
>>> B = ReferenceFrame('B')
>>> u1, u2 = dynamicsymbols('u1, u2')
>>> v = u1 * A.x + u2 * B.y
>>> v.diff(u2, N, var_in_dcm=False)
B.y
doit(**hints)
在向量的每個項上呼叫 .doit()
dot(other)
兩個向量的點積。
返回一個標量，兩個向量的點積
引數：
other：Vector
我們正在與之做點乘的向量
示例
>>> from sympy.physics.vector import ReferenceFrame, dot
>>> from sympy import symbols
>>> q1 = symbols('q1')
>>> N = ReferenceFrame('N')
>>> dot(N.x, N.x)
1
>>> dot(N.x, N.y)
0
>>> A = N.orientnew('A', 'Axis', [q1, N.x])
>>> dot(N.y, A.y)
cos(q1)
dt(otherframe)
返回一個在其他幀中時間導數的向量。
呼叫全域性 time_derivative 方法
引數：
otherframe：ReferenceFrame
計算時間導數的框架
express(otherframe, variables=False)
返回等效於此向量的向量，表達為 otherframe。使用全域性 express 方法。
引數：
otherframe：ReferenceFrame
描述此向量的幀
variables：布林值
如果為 True，則此向量中的座標符號（如果存在）將重新表達為其他幀的術語
示例
>>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
>>> from sympy.physics.vector import init_vprinting
>>> init_vprinting(pretty_print=False)
>>> q1 = dynamicsymbols('q1')
>>> N = ReferenceFrame('N')
>>> A = N.orientnew('A', 'Axis', [q1, N.y])
>>> A.x.express(N)
cos(q1)*N.x - sin(q1)*N.z
free_dynamicsymbols(reference_frame)
返回在給定參考框架中表達的向量中的自由動態符號（時間函式 t）。
引數：
reference_frame：ReferenceFrame
要確定給定向量的自由動態符號的框架。
返回：
set
時間函式
t的集合，例如Function('f')(me.dynamicsymbols._t)。
free_symbols(reference_frame)
返回在給定參考框架中表達的向量的測量數字中的自由符號。
引數：
reference_frame：ReferenceFrame
要確定給定向量自由符號的框架。
返回：
一組 Symbol
表達參考框架的測量數中存在的符號集。
property func
返回類向量。
magnitude()
返回自身的大小（歐幾里得範數）。
警告
Python 忽略了前導負號，這可能導致錯誤的結果。-A.x.magnitude() 會被視為 -(A.x.magnitude())，而不是 (-A.x).magnitude()。
normalize()
返回大小為 1、與自身共向的向量。
outer(other)
兩個向量之間的外積。
一個增加秩的操作，從兩個向量返回一個二元組
引數:
其他 : 向量
與向量進行外積。
例子
>>> from sympy.physics.vector import ReferenceFrame, outer
>>> N = ReferenceFrame('N')
>>> outer(N.x, N.x)
(N.x|N.x)
separate()
根據其定義，這個向量在不同參考框架中的組成部分。
返回將每個參考框架對映到相應組成向量的字典。
例子
>>> from sympy.physics.vector import ReferenceFrame
>>> R1 = ReferenceFrame('R1')
>>> R2 = ReferenceFrame('R2')
>>> v = R1.x + R2.x
>>> v.separate() == {R1: R1.x, R2: R2.x}
True
simplify()
返回一個簡化的向量。
subs(*args, **kwargs)
對向量進行替換。
例子
>>> from sympy.physics.vector import ReferenceFrame
>>> from sympy import Symbol
>>> N = ReferenceFrame('N')
>>> s = Symbol('s')
>>> a = N.x * s
>>> a.subs({s: 2})
2*N.x
to_matrix(reference_frame)
返回給定框架下向量的矩陣形式。
引數:
參考框架 : 參考框架
矩陣的行對應的參考框架。
返回:
矩陣 : 不可變矩陣，形狀(3,1)
提供給 1D 向量的矩陣。
例子
>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame
>>> a, b, c = symbols('a, b, c')
>>> N = ReferenceFrame('N')
>>> vector = a * N.x + b * N.y + c * N.z
>>> vector.to_matrix(N)
Matrix([
[a],
[b],
[c]])
>>> beta = symbols('beta')
>>> A = N.orientnew('A', 'Axis', (beta, N.x))
>>> vector.to_matrix(A)
Matrix([
[ a],
[ b*cos(beta) + c*sin(beta)],
[-b*sin(beta) + c*cos(beta)]])
xreplace(rule)
替換向量的測量數內的物件出現。
引數:
規則 : 類似字典
表達替換規則。
返回:
向量
替換結果。
例子
>>> from sympy import symbols, pi
>>> from sympy.physics.vector import ReferenceFrame
>>> A = ReferenceFrame('A')
>>> x, y, z = symbols('x y z')
>>> ((1 + x*y) * A.x).xreplace({x: pi})
(pi*y + 1)*A.x
>>> ((1 + x*y) * A.x).xreplace({x: pi, y: 2})
(1 + 2*pi)*A.x
僅當匹配表達樹中的整個節點時才進行替換：
>>> ((x*y + z) * A.x).xreplace({x*y: pi})
(z + pi)*A.x
>>> ((x*y*z) * A.x).xreplace({x*y: pi})
x*y*z*A.x
class sympy.physics.vector.dyadic.Dyadic(inlist)
一個二元組物件。
見：en.wikipedia.org/wiki/Dyadic_tensor Kane, T., Levinson, D. Dynamics Theory and Applications. 1985 McGraw-Hill
更強大地表示剛體的慣性的一種方法。雖然更復雜，但透過選擇二元組的分量為體固定基向量，得到的矩陣等效於慣性張量。
applyfunc(f)
對二元組的每個分量應用函式。
cross(other)
返回二元組與向量的叉積結果：二元組 x 向量。
引數:
其他 : 向量
與之交叉的向量。
例子
>>> from sympy.physics.vector import ReferenceFrame, outer, cross
>>> N = ReferenceFrame('N')
>>> d = outer(N.x, N.x)
>>> cross(d, N.y)
(N.x|N.z)
doit(**hints)
對二元組中的每個項呼叫 .doit()
dot(other)
二元組和二元組或向量的內積運算子。
引數:
其他 : 二元組或向量
與二元組或向量進行內積的其他二元組或向量
例子
>>> from sympy.physics.vector import ReferenceFrame, outer
>>> N = ReferenceFrame('N')
>>> D1 = outer(N.x, N.y)
>>> D2 = outer(N.y, N.y)
>>> D1.dot(D2)
(N.x|N.y)
>>> D1.dot(N.y)
N.x
dt(frame)
對此二元組在一個框架中進行時間導數。
此函式呼叫全域性 time_derivative 方法
引數:
框架 : 參考框架
用於進行時間導數的框架
例子
>>> from sympy.physics.vector import ReferenceFrame, outer, dynamicsymbols
>>> from sympy.physics.vector import init_vprinting
>>> init_vprinting(pretty_print=False)
>>> N = ReferenceFrame('N')
>>> q = dynamicsymbols('q')
>>> B = N.orientnew('B', 'Axis', [q, N.z])
>>> d = outer(N.x, N.x)
>>> d.dt(B)
- q'*(N.y|N.x) - q'*(N.x|N.y)
express(frame1, frame2=None)
表達該二元組在備用框架中
第一個框架是列表達表示式，第二個框架是右邊；如果二元組以 A.x|B.y 形式存在，則可以在兩個不同的框架中表達它。如果沒有給出第二個框架，則二元組只在一個框架中表達。
呼叫全域性表達函式
引數:
框架 1 : 參考框架
表達二元組左側的框架
框架 2 : 參考框架
如果提供，則表達二元組右側的框架
例子
>>> from sympy.physics.vector import ReferenceFrame, outer, dynamicsymbols
>>> from sympy.physics.vector import init_vprinting
>>> init_vprinting(pretty_print=False)
>>> N = ReferenceFrame('N')
>>> q = dynamicsymbols('q')
>>> B = N.orientnew('B', 'Axis', [q, N.z])
>>> d = outer(N.x, N.x)
>>> d.express(B, N)
cos(q)*(B.x|N.x) - sin(q)*(B.y|N.x)
property func
返回類二元組。
simplify()
返回一個簡化的二元組。
subs(*args, **kwargs)
對二元組進行替換。
例子
>>> from sympy.physics.vector import ReferenceFrame
>>> from sympy import Symbol
>>> N = ReferenceFrame('N')
>>> s = Symbol('s')
>>> a = s*(N.x|N.x)
>>> a.subs({s: 2})
2*(N.x|N.x)
to_matrix(reference_frame, second_reference_frame=None)
返回與一個或兩個參考框架相關的二階張量形式的矩陣。
引數：
reference_frame：參考框架
矩陣的行和列所對應的參考框架。如果提供了第二個參考框架，這僅對矩陣的行起作用。
second_reference_frame：參考框架，可選，預設為 None
矩陣的列所對應的參考框架。
返回：
matrix：ImmutableMatrix，形狀為(3,3)
給出二維張量形式的矩陣。
示例
>>> from sympy import symbols, trigsimp
>>> from sympy.physics.vector import ReferenceFrame
>>> from sympy.physics.mechanics import inertia
>>> Ixx, Iyy, Izz, Ixy, Iyz, Ixz = symbols('Ixx, Iyy, Izz, Ixy, Iyz, Ixz')
>>> N = ReferenceFrame('N')
>>> inertia_dyadic = inertia(N, Ixx, Iyy, Izz, Ixy, Iyz, Ixz)
>>> inertia_dyadic.to_matrix(N)
Matrix([
[Ixx, Ixy, Ixz],
[Ixy, Iyy, Iyz],
[Ixz, Iyz, Izz]])
>>> beta = symbols('beta')
>>> A = N.orientnew('A', 'Axis', (beta, N.x))
>>> trigsimp(inertia_dyadic.to_matrix(A))
Matrix([
[ Ixx, Ixy*cos(beta) + Ixz*sin(beta), -Ixy*sin(beta) + Ixz*cos(beta)],
[ Ixy*cos(beta) + Ixz*sin(beta), Iyy*cos(2*beta)/2 + Iyy/2 + Iyz*sin(2*beta) - Izz*cos(2*beta)/2 + Izz/2, -Iyy*sin(2*beta)/2 + Iyz*cos(2*beta) + Izz*sin(2*beta)/2],
[-Ixy*sin(beta) + Ixz*cos(beta), -Iyy*sin(2*beta)/2 + Iyz*cos(2*beta) + Izz*sin(2*beta)/2, -Iyy*cos(2*beta)/2 + Iyy/2 - Iyz*sin(2*beta) + Izz*cos(2*beta)/2 + Izz/2]])
xreplace(rule)
替換二階張量測量數中物件的出現。
引數：
rule：類似字典
表達一個替換規則。
返回：
二階張量
替換的結果。
示例
>>> from sympy import symbols, pi
>>> from sympy.physics.vector import ReferenceFrame, outer
>>> N = ReferenceFrame('N')
>>> D = outer(N.x, N.x)
>>> x, y, z = symbols('x y z')
>>> ((1 + x*y) * D).xreplace({x: pi})
(pi*y + 1)*(N.x|N.x)
>>> ((1 + x*y) * D).xreplace({x: pi, y: 2})
(1 + 2*pi)*(N.x|N.x)
只有在匹配表示式樹中的整個節點時才會發生替換：
>>> ((x*y + z) * D).xreplace({x*y: pi})
(z + pi)*(N.x|N.x)
>>> ((x*y*z) * D).xreplace({x*y: pi})
x*y*z*(N.x|N.x)