SymPy-1-13-中文文件-十九-

绝不原创的飞龙發表於2024-06-27

SymPy 1.13 中文文件（十九）

原文：docs.sympy.org/latest/index.html

State

原文：docs.sympy.org/latest/modules/physics/quantum/state.html

狀態的 Dirac 符號表示法。

class sympy.physics.quantum.state.Bra(*args, **kwargs)

量子力學中的一般時間無關的 Bra。

繼承自 State 和 BraBase。Bra 是 Ket 的對偶[R769]。這個類及其子類將是使用者表達 Dirac 符號表示法中 Bras 的主要類。

引數：

args：元組

一組唯一指定 Ket 的數字或引數列表。這通常是其符號或量子數。對於時間相關狀態，這將包括時間。

例子

建立一個簡單的 Bra 並檢視其屬性：

>>> from sympy.physics.quantum import Bra
>>> from sympy import symbols, I
>>> b = Bra('psi')
>>> b
<psi|
>>> b.hilbert_space
H
>>> b.is_commutative
False

Bra 的知道它們對偶 Ket 的：

>>> b.dual
|psi>
>>> b.dual_class()
<class 'sympy.physics.quantum.state.Ket'>

和 Kets 一樣，Bras 可以有複合標籤，並且可以以類似的方式進行操作：

>>> n, m = symbols('n,m')
>>> b = Bra(n,m) - I*Bra(m,n)
>>> b
-I*<mn| + <nm|

可以使用.subs替換 Bra 中的符號。

>>> b.subs(n,m)
<mm| - I*<mm|

參考資料

[R769] (1,2)

en.wikipedia.org/wiki/Bra-ket_notation

class sympy.physics.quantum.state.BraBase(*args, **kwargs)

Bras 的基類。

該類定義了對偶屬性和列印時的括號。這是一個抽象基類，不應直接例項化，而是使用 Bra。

class sympy.physics.quantum.state.Ket(*args, **kwargs)

量子力學中的一般時間無關的 Ket。

繼承自 State 和 KetBase。這個類應該作為系統中所有物理、時間無關的 Ket 的基類使用。這個類及其子類將是使用者表達 Dirac 符號表示法中 Kets 的主要類。

引數：

args：元組

一組唯一指定 Ket 的數字或引數列表。這通常是其符號或量子數。對於時間相關狀態，這將包括時間。

例子

建立一個簡單的 Ket 並檢視其屬性：

>>> from sympy.physics.quantum import Ket
>>> from sympy import symbols, I
>>> k = Ket('psi')
>>> k
|psi>
>>> k.hilbert_space
H
>>> k.is_commutative
False
>>> k.label
(psi,)

Ket 知道其關聯的 Bra：

>>> k.dual
<psi|
>>> k.dual_class()
<class 'sympy.physics.quantum.state.Bra'>

取兩個 Ket 的線性組合：

>>> k0 = Ket(0)
>>> k1 = Ket(1)
>>> 2*I*k0 - 4*k1
2*I*|0> - 4*|1>

複合標籤作為元組傳遞：

>>> n, m = symbols('n,m')
>>> k = Ket(n,m)
>>> k
|nm>

參考資料

[R770] (1,2)

en.wikipedia.org/wiki/Bra-ket_notation

class sympy.physics.quantum.state.KetBase(*args, **kwargs)

Kets 的基類。

該類定義了對偶屬性和列印時的括號。這是一個抽象基類，不應直接例項化，而是使用 Ket。

class sympy.physics.quantum.state.OrthogonalBra(*args, **kwargs)

量子力學中的正交 Bra。

class sympy.physics.quantum.state.OrthogonalKet(*args, **kwargs)

量子力學中的正交 Ket。

兩個具有不同標籤的態的內積為零，具有相同標籤的態的內積為一。

>>> from sympy.physics.quantum import OrthogonalBra, OrthogonalKet
>>> from sympy.abc import m, n
>>> (OrthogonalBra(n)*OrthogonalKet(n)).doit()
1
>>> (OrthogonalBra(n)*OrthogonalKet(n+1)).doit()
0
>>> (OrthogonalBra(n)*OrthogonalKet(m)).doit()
<n|m>

class sympy.physics.quantum.state.OrthogonalState(*args, **kwargs)

用作 Ket 和 Bra 的基類的一般抽象量子態。

class sympy.physics.quantum.state.State(*args, **kwargs)

用作 Ket 和 Bra 的基類的一般抽象量子態。

class sympy.physics.quantum.state.StateBase(*args, **kwargs)

量子力學中一般抽象態的抽象基類。

所有其他定義的狀態類都需要從此類繼承。它承載了所有其他狀態的基本結構，如對偶、_eval_adjoint 和標籤。

這是一個抽象基類，不應直接例項化，而是使用 State。

property dual

返回此態的對偶態。

classmethod dual_class()

返回用於構造對偶的類。

property operators

返回這個態是本徵態的算符（們）。

class sympy.physics.quantum.state.TimeDepBra(*args, **kwargs)

量子力學中的通用時間依賴Bra。

這繼承自TimeDepState和BraBase，是應該用於隨時間變化的Bra的主要類。其對偶體是一個TimeDepBra。

引數：

args：元組

列出唯一指定ket的數字或引數的列表。通常將是其符號或量子數。對於時間依賴狀態，這將包括時間作為最後一個引數。

例子

>>> from sympy.physics.quantum import TimeDepBra
>>> b = TimeDepBra('psi', 't')
>>> b
<psi;t|
>>> b.time
t
>>> b.label
(psi,)
>>> b.hilbert_space
H
>>> b.dual
|psi;t>

class sympy.physics.quantum.state.TimeDepKet(*args, **kwargs)

量子力學中的通用時間依賴Ket。

這繼承自TimeDepState和KetBase，是應該用於隨時間變化的Ket的主要類。其對偶體是一個TimeDepBra。

引數：

args：元組

列出唯一指定ket的數字或引數的列表。通常將是其符號或量子數。對於時間依賴狀態，這將包括時間作為最後一個引數。

例子

建立一個TimeDepKet並檢視其屬性：

>>> from sympy.physics.quantum import TimeDepKet
>>> k = TimeDepKet('psi', 't')
>>> k
|psi;t>
>>> k.time
t
>>> k.label
(psi,)
>>> k.hilbert_space
H

TimeDepKets 知道它們的對偶bra：

>>> k.dual
<psi;t|
>>> k.dual_class()
<class 'sympy.physics.quantum.state.TimeDepBra'>

class sympy.physics.quantum.state.TimeDepState(*args, **kwargs)

通用時間依賴量子態的基類。

此類用作任何時間依賴狀態的基類。此類與時間獨立狀態的主要區別在於，此類除了通常的標籤引數外，還接受第二個引數作為時間。

引數：

args：元組

列出唯一指定ket的數字或引數的列表。通常將是其符號或量子數。對於時間依賴狀態，這將包括時間作為最後一個引數。

property label

狀態的標籤。

property time

狀態的時間。

class sympy.physics.quantum.state.Wavefunction(*args)

連續基底表示的類

此類在其建構函式中接受表示式和座標。可用於輕鬆計算標準化和機率。

引數：

expr：表示式

表示波函式功能形式的表示式。

coords：符號或元組

要進行積分的座標及其邊界

例子

在盒子中的粒子，以更原始的方式使用Piecewise來指定邊界：

>>> from sympy import Symbol, Piecewise, pi, N
>>> from sympy.functions import sqrt, sin
>>> from sympy.physics.quantum.state import Wavefunction
>>> x = Symbol('x', real=True)
>>> n = 1
>>> L = 1
>>> g = Piecewise((0, x < 0), (0, x > L), (sqrt(2//L)*sin(n*pi*x/L), True))
>>> f = Wavefunction(g, x)
>>> f.norm
1
>>> f.is_normalized
True
>>> p = f.prob()
>>> p(0)
0
>>> p(L)
0
>>> p(0.5)
2
>>> p(0.85*L)
2*sin(0.85*pi)**2
>>> N(p(0.85*L))
0.412214747707527

此外，您可以以更緊湊的方式指定函式的邊界和指數：

>>> from sympy import symbols, pi, diff
>>> from sympy.functions import sqrt, sin
>>> from sympy.physics.quantum.state import Wavefunction
>>> x, L = symbols('x,L', positive=True)
>>> n = symbols('n', integer=True, positive=True)
>>> g = sqrt(2/L)*sin(n*pi*x/L)
>>> f = Wavefunction(g, (x, 0, L))
>>> f.norm
1
>>> f(L+1)
0
>>> f(L-1)
sqrt(2)*sin(pi*n*(L - 1)/L)/sqrt(L)
>>> f(-1)
0
>>> f(0.85)
sqrt(2)*sin(0.85*pi*n/L)/sqrt(L)
>>> f(0.85, n=1, L=1)
sqrt(2)*sin(0.85*pi)
>>> f.is_commutative
False

所有引數都會自動轉換為sympy物件，因此您可以將變數定義為字串，而不是符號：

>>> expr = x**2
>>> f = Wavefunction(expr, 'x')
>>> type(f.variables[0])
<class 'sympy.core.symbol.Symbol'>

波函式的導數將返回波函式：

>>> diff(f, x)
Wavefunction(2*x, x)

property expr

返回表示波函式功能形式的表示式

例子

>>> from sympy.physics.quantum.state import Wavefunction
>>> from sympy import symbols
>>> x, y = symbols('x, y')
>>> f = Wavefunction(x**2, x)
>>> f.expr
x**2

property is_commutative

覆蓋函式的is_commutative，以保持表示式中的順序

property is_normalized

如果波函式正確歸一化則返回真

例子

>>> from sympy import symbols, pi
>>> from sympy.functions import sqrt, sin
>>> from sympy.physics.quantum.state import Wavefunction
>>> x, L = symbols('x,L', positive=True)
>>> n = symbols('n', integer=True, positive=True)
>>> g = sqrt(2/L)*sin(n*pi*x/L)
>>> f = Wavefunction(g, (x, 0, L))
>>> f.is_normalized
True

property limits

返回波函式依賴的座標的限制。如果未指定限制，則預設為(-oo, oo)。

例子

>>> from sympy.physics.quantum.state import Wavefunction
>>> from sympy import symbols
>>> x, y = symbols('x, y')
>>> f = Wavefunction(x**2, (x, 0, 1))
>>> f.limits
{x: (0, 1)}
>>> f = Wavefunction(x**2, x)
>>> f.limits
{x: (-oo, oo)}
>>> f = Wavefunction(x**2 + y**2, x, (y, -1, 2))
>>> f.limits
{x: (-oo, oo), y: (-1, 2)}

property norm

返回指定函式形式的歸一化。

此函式對Wavefunction的座標進行積分，指定了邊界。

例子

>>> from sympy import symbols, pi
>>> from sympy.functions import sqrt, sin
>>> from sympy.physics.quantum.state import Wavefunction
>>> x, L = symbols('x,L', positive=True)
>>> n = symbols('n', integer=True, positive=True)
>>> g = sqrt(2/L)*sin(n*pi*x/L)
>>> f = Wavefunction(g, (x, 0, L))
>>> f.norm
1
>>> g = sin(n*pi*x/L)
>>> f = Wavefunction(g, (x, 0, L))
>>> f.norm
sqrt(2)*sqrt(L)/2

normalize()

返回波函式的歸一化版本

例子

>>> from sympy import symbols, pi
>>> from sympy.functions import sin
>>> from sympy.physics.quantum.state import Wavefunction
>>> x = symbols('x', real=True)
>>> L = symbols('L', positive=True)
>>> n = symbols('n', integer=True, positive=True)
>>> g = sin(n*pi*x/L)
>>> f = Wavefunction(g, (x, 0, L))
>>> f.normalize()
Wavefunction(sqrt(2)*sin(pi*n*x/L)/sqrt(L), (x, 0, L))

prob()

返回波函式的絕對幅度，(|\psi(x)|²)

例子

>>> from sympy import symbols, pi
>>> from sympy.functions import sin
>>> from sympy.physics.quantum.state import Wavefunction
>>> x, L = symbols('x,L', real=True)
>>> n = symbols('n', integer=True)
>>> g = sin(n*pi*x/L)
>>> f = Wavefunction(g, (x, 0, L))
>>> f.prob()
Wavefunction(sin(pi*n*x/L)**2, x)

property variables

返回波函式依賴的座標

例子

>>> from sympy.physics.quantum.state import Wavefunction
>>> from sympy import symbols
>>> x,y = symbols('x,y')
>>> f = Wavefunction(x*y, x, y)
>>> f.variables
(x, y)
>>> g = Wavefunction(x*y, x)
>>> g.variables
(x,)

電路繪圖

原文：docs.sympy.org/latest/modules/physics/quantum/circuitplot.html

基於 Matplotlib 的量子電路繪圖。

待辦事項：

最佳化大電路的列印。
使其與單門一起工作。
更好地檢查電路形式，以確保它是 Gates 的乘積。
獲取多目標門繪圖。
獲取初始狀態和最終狀態以繪製。
獲取用於繪製的測量值。可能需要重新考慮測量作為一個門的問題。
更好地處理比例和 figsize。
編寫一些測試/示例！

class sympy.physics.quantum.circuitplot.CircuitPlot(c, nqubits, **kwargs)

一個管理電路圖的類。

control_line(gate_idx, min_wire, max_wire)

繪製垂直控制線。

control_point(gate_idx, wire_idx)

繪製一個控制點。

not_point(gate_idx, wire_idx)

繪製 NOT 門，作為中間帶加號的圓圈。

one_qubit_box(t, gate_idx, wire_idx)

為單量子位元門繪製一個框。

swap_point(gate_idx, wire_idx)

將交換點繪製為十字架。

two_qubit_box(t, gate_idx, wire_idx)

為兩量子位元門繪製一個框。目前還不能正常工作。

update(kwargs)

將 kwargs 載入到例項字典中。

sympy.physics.quantum.circuitplot.CreateCGate(name, latexname=None)

使用詞法閉包製作一個受控門。

class sympy.physics.quantum.circuitplot.Mx(*args, **kwargs)

一個 x 測量門的草圖。

這是在 circuitplot 中而不是 gate.py 中，因為它不是一個真正的門，它只是畫了一個門。

class sympy.physics.quantum.circuitplot.Mz(*args, **kwargs)

一個 z 測量門的草圖。

這是在 circuitplot 中而不是 gate.py 中，因為它不是一個真正的門，它只是畫了一個門。

sympy.physics.quantum.circuitplot.circuit_plot(c, nqubits, **kwargs)

繪製具有 n 量子位元電路的電路圖。

引數：

c：電路

要繪製的電路。應該是 Gate 例項的乘積。

nqubits：整數

要包括在電路中的量子位元數。必須至少與門的最大min_qubits一樣大。

sympy.physics.quantum.circuitplot.labeller(n, symbol='q')

為量子電路的線自動生成標籤。

引數：

n：整數

電路中的量子位元數。

符號：字串

一個字元字串，用於所有門標籤之前。例如‘q_0’，‘q_1’等。

>>> from sympy.physics.quantum.circuitplot import labeller

>>> labeller(2)

['q_1', 'q_0']

>>> labeller(3,'j')

['j_2', 'j_1', 'j_0']

門

原文：docs.sympy.org/latest/modules/physics/quantum/gate.html

作用於量子位元的門的實現。

門是作用於量子位元空間的么正算符。

中期待辦事項：

最佳化 Gate._apply_operators_Qubit 以消除許多中間 Qubit 物件的建立。
為所有運算子新增交換關係，並在 gate_sort 中使用。
修復 gate_sort 和 gate_simp。
正確地繪製多目標 UGates。
使用 sympy/numpy 矩陣中的 UGate，並輸出任意格式。這也應該使用矩陣槽。

class sympy.physics.quantum.gate.CGate(*args, **kwargs)

帶有控制量子位元的通用么正門。

通用控制門在所有控制量子位元具有特定值時（由CGate.control_value設定）對一組目標執行目標門。

引數：

標籤：tuple

在此情況下，標籤的形式為(control, gate)，其中 control 是控制量子位元的元組/列表（作為整數），gate 是目標運算子的Gate例項。

property controls

一個控制量子位元的元組。

decompose(**options)

將受控門分解為 CNOT 門和單量子位元門。

eval_controls(qubit)

返回 True/False 以指示是否滿足控制條件。

property gate

將應用於目標的非受控門。

property min_qubits

該門需要作用的最小量子位元數。

property nqubits

該門作用的總量子位元數。

對於受控門子類，包括目標和控制量子位元，例如 CNOT 門作用於 2 個量子位元。

plot_gate(circ_plot, gate_idx)

繪製受控門。如果simplify_cgate為 true，則將 C-X 和 C-Z 門簡化為它們更熟悉的形式。

property targets

一個目標量子位元的元組。

class sympy.physics.quantum.gate.CGateS(*args, **kwargs)

允許門簡化的 CGate 版本。例如，cnot 看起來像 oplus，cphase 有點等等。

sympy.physics.quantum.gate.CNOT

CNotGate的別名

class sympy.physics.quantum.gate.CNotGate(*args, **kwargs)

兩量子位元控制 NOT 門。

如果所有控制量子位元的值都為 1，則該門在目標量子位元上執行 NOT 或 X 門。

引數：

標籤：tuple

一個形如(control, target)的元組。

示例

>>> from sympy.physics.quantum.gate import CNOT
>>> from sympy.physics.quantum.qapply import qapply
>>> from sympy.physics.quantum.qubit import Qubit
>>> c = CNOT(1,0)
>>> qapply(c*Qubit('10')) # note that qubits are indexed from right to left
|11>

property controls

一個控制量子位元的元組。

property gate

將應用於目標的非受控門。

property min_qubits

該門需要作用的最小量子位元數。

property targets

一個目標量子位元的元組。

class sympy.physics.quantum.gate.Gate(*args, **kwargs)

非控制么正門運算子，作用於量子位元。

這是一個一般的抽象門，需要子類化才能有用。

引數：

標籤：tuple, int

將門應用於的目標量子位元的列表（作為整數）。

get_target_matrix(format='sympy')

門的目標部分的矩陣表示。

引數：

格式：str

格式字串（'sympy'，'numpy'等）。

property min_qubits

該門需要作用的最小量子位元數。

property nqubits

該門作用的總量子位元數。

對於受控門子類，包括目標和控制量子位元，例如 CNOT 門作用於 2 個量子位元。

property targets

一個目標量子位元的元組。

sympy.physics.quantum.gate.H

HadamardGate的別名

class sympy.physics.quantum.gate.HadamardGate(*args, **kwargs)

單量子位元 Hadamard 門。

引數：

目標：int

此門將應用於的目標量子位元。

示例

>>> from sympy import sqrt
>>> from sympy.physics.quantum.qubit import Qubit
>>> from sympy.physics.quantum.gate import HadamardGate
>>> from sympy.physics.quantum.qapply import qapply
>>> qapply(HadamardGate(0)*Qubit('1'))
sqrt(2)*|0>/2 - sqrt(2)*|1>/2
>>> # Hadamard on bell state, applied on 2 qubits.
>>> psi = 1/sqrt(2)*(Qubit('00')+Qubit('11'))
>>> qapply(HadamardGate(0)*HadamardGate(1)*psi)
sqrt(2)*|00>/2 + sqrt(2)*|11>/2

class sympy.physics.quantum.gate.IdentityGate(*args, **kwargs)

單量子位元恆等門。

引數：

目標 : 整數

此門將應用於的目標量子位元。

class sympy.physics.quantum.gate.OneQubitGate(*args, **kwargs)

單量子位元酉門基類。

sympy.physics.quantum.gate.Phase

PhaseGate 的別名。

class sympy.physics.quantum.gate.PhaseGate(*args, **kwargs)

單量子位元相位或 S 門。

此門在狀態為 |1> 時將狀態相位旋轉 π/2，如果狀態為 |0> 則不做任何操作。

引數：

目標 : 整數

此門將應用於的目標量子位元。

sympy.physics.quantum.gate.S

PhaseGate 的別名。

sympy.physics.quantum.gate.SWAP

SwapGate 的別名。

class sympy.physics.quantum.gate.SwapGate(*args, **kwargs)

兩量子位元 SWAP 門。

此門交換兩個量子位元的值。

引數：

標籤 : 元組

一個形如 (目標 1, 目標 2) 的元組。

decompose(**options)

將 SWAP 門分解為 CNOT 門。

sympy.physics.quantum.gate.T

TGate 的別名。

class sympy.physics.quantum.gate.TGate(*args, **kwargs)

單量子位元 π/8 門。

此門在狀態為 |1> 時將狀態相位旋轉 π/4，如果狀態為 |0> 則不做任何操作。

引數：

目標 : 整數

此門將應用於的目標量子位元。

class sympy.physics.quantum.gate.TwoQubitGate(*args, **kwargs)

兩量子位元酉門基類。

class sympy.physics.quantum.gate.UGate(*args, **kwargs)

由一組目標和目標矩陣指定的通用門。

引數：

標籤 : 元組

一個形如 (目標, U) 的元組，其中目標是目標量子位元的一個元組，U 是一個維度為 len(targets) 的酉矩陣。

get_target_matrix(format='sympy')

目標部分門的矩陣表示。

引數：

格式 : 字串

格式化字串（‘sympy’，‘numpy’等）。

property targets

目標量子位元的一個元組。

sympy.physics.quantum.gate.X

XGate 的別名。

class sympy.physics.quantum.gate.XGate(*args, **kwargs)

單量子位元 X 或 NOT 門。

引數：

目標 : 整數

此門將應用於的目標量子位元。

sympy.physics.quantum.gate.Y

YGate 的別名。

class sympy.physics.quantum.gate.YGate(*args, **kwargs)

單量子位元 Y 門。

引數：

目標 : 整數

此門將應用於的目標量子位元。

sympy.physics.quantum.gate.Z

ZGate 的別名。

class sympy.physics.quantum.gate.ZGate(*args, **kwargs)

單量子位元 Z 門。

引數：

目標 : 整數

此門將應用於的目標量子位元。

sympy.physics.quantum.gate.gate_simp(circuit)

符號化簡門。

首先使用 gate_sort 對門進行排序。然後應用基本簡化規則到電路，例如 XGate**2 = Identity。

sympy.physics.quantum.gate.gate_sort(circuit)

在保持對易關係的同時對門進行排序。

此函式使用氣泡排序重新排列門的應用順序。跟蹤量子計算的特殊對易關係（例如，應用於同一量子位元的事物不會相互對易）。

電路是要排序的門的乘積。

sympy.physics.quantum.gate.normalized(normalize)

設定標誌，控制 Hadamard 門透過 (1/\sqrt{2}) 進行歸一化。

這是一個全域性設定，可以透過省略 Hadamard 門的前導 (1/\sqrt{2}) 來簡化各種表示式的外觀。

引數：

歸一化 : 布林值

哈達瑪門是否應包括 (1/\sqrt{2}) 的歸一化因子？當為 True 時，哈達瑪門將包括 (1/\sqrt{2})。當為 False 時，則不包括此因子。

sympy.physics.quantum.gate.random_circuit(ngates, nqubits, gate_space=(<class 'sympy.physics.quantum.gate.XGate'>, <class 'sympy.physics.quantum.gate.YGate'>, <class 'sympy.physics.quantum.gate.ZGate'>, <class 'sympy.physics.quantum.gate.PhaseGate'>, <class 'sympy.physics.quantum.gate.TGate'>, <class 'sympy.physics.quantum.gate.HadamardGate'>, <class 'sympy.physics.quantum.gate.CNotGate'>, <class 'sympy.physics.quantum.gate.SwapGate'>))

返回一個 ngates 和 nqubits 的隨機電路。

這使用了等權重的樣本（X, Y, Z, S, T, H, CNOT, SWAP）門。

引數：

ngates : 整數

電路中的門數量。

nqubits : 整數

電路中的量子位元數量。

gate_space : 元組

一個元組，包含將在電路中使用的門類。在此元組中多次重複門類將增加它們在隨機電路中出現的頻率。

Grover 演算法

原文連結：docs.sympy.org/latest/modules/physics/quantum/grover.html

Grover 演算法和輔助函式。

待辦事項：

W 門的構造（或者根據 Mermin 的書可能是 -W 門）
為返回多量子位元狀態為 1 的未知函式泛化演算法。
在 OracleGate 中實現 _represent_ZGate

class sympy.physics.quantum.grover.OracleGate(*args, **kwargs)

一個黑盒門。

該門透過翻轉量子位的符號來標記未知函式的所需量子位元。當未知函式找到所需量子位元時返回 true，否則返回 false。

引數：

qubits : 整數

量子位元的數量。

oracle : 可呼叫物件

返回一個在計算基上返回布林值的可呼叫函式。

示例

在不同量子位元上應用翻轉 |2> 的 Oracle 門：

>>> from sympy.physics.quantum.qubit import IntQubit
>>> from sympy.physics.quantum.qapply import qapply
>>> from sympy.physics.quantum.grover import OracleGate
>>> f = lambda qubits: qubits == IntQubit(2)
>>> v = OracleGate(2, f)
>>> qapply(v*IntQubit(2))
-|2>
>>> qapply(v*IntQubit(3))
|3>

property search_function

幫助找到所需量子位元的未知函式。

property targets

目標量子位元的元組。

class sympy.physics.quantum.grover.WGate(*args, **kwargs)

Grover 演算法中的一般 n 量子位 W 門。

該門在某些量子位元上執行操作 2|phi><phi| - 1。|phi> = (n 個 Hadamard 的張量積)*(n 量子位元的 |0>)

引數：

nqubits : 整數

操作的量子位元數

sympy.physics.quantum.grover.apply_grover(oracle, nqubits, iterations=None)

應用 Grover 演算法。

引數：

oracle : 可呼叫物件

未知的可呼叫函式，在應用於所需的量子位元時返回 true，否則返回 false。

state : 表示式

Grover 演算法迭代後的結果狀態。

示例

將 Grover 演算法應用於兩個量子位元的均勻疊加：

>>> from sympy.physics.quantum.qapply import qapply
>>> from sympy.physics.quantum.qubit import IntQubit
>>> from sympy.physics.quantum.grover import apply_grover
>>> f = lambda qubits: qubits == IntQubit(2)
>>> qapply(apply_grover(f, 2))
|2>

sympy.physics.quantum.grover.grover_iteration(qstate, oracle)

應用一次 Oracle 和 W 門，WV。

引數：

qstate : 量子位

量子位元的疊加態。

oracle : OracleGate

黑盒運算子，翻轉所需基礎量子位的符號。

Qubit : 在應用 Oracle 和 W 門後的量子位元。

示例

執行一次 Grover 演算法迭代以檢視相位變化：

>>> from sympy.physics.quantum.qapply import qapply
>>> from sympy.physics.quantum.qubit import IntQubit
>>> from sympy.physics.quantum.grover import OracleGate
>>> from sympy.physics.quantum.grover import superposition_basis
>>> from sympy.physics.quantum.grover import grover_iteration
>>> numqubits = 2
>>> basis_states = superposition_basis(numqubits)
>>> f = lambda qubits: qubits == IntQubit(2)
>>> v = OracleGate(numqubits, f)
>>> qapply(grover_iteration(basis_states, v))
|2>

sympy.physics.quantum.grover.superposition_basis(nqubits)

建立計算基的等么角疊加。

引數：

nqubits : 整數

量子位元的數量。

state : 量子位

用 nqubits 建立計算基的等么角疊加。

示例

建立兩個量子位元的等么角疊加：

>>> from sympy.physics.quantum.grover import superposition_basis
>>> superposition_basis(2)
|0>/2 + |1>/2 + |2>/2 + |3>/2

QFT

原文連結：docs.sympy.org/latest/modules/physics/quantum/qft.html

一個作用於量子位元及其門的實現。

待辦事項：

更新文件字串。
更新測試。
使用分解實現應用。
使用分解或更智慧的方法來實現 represent。為此，我們首先必須為 SWAP 實現 represent。
決定是否要在建構函式中包含上限索引。
修復繪圖中 Rk 門的列印。

class sympy.physics.quantum.qft.IQFT(*args, **kwargs)

量子傅立葉逆變換。

decompose()

將 IQFT 分解為基本門。

class sympy.physics.quantum.qft.QFT(*args, **kwargs)

正向量子傅立葉變換。

decompose()

將 QFT 分解為基本門。

sympy.physics.quantum.qft.Rk

RkGate 的別名。

class sympy.physics.quantum.qft.RkGate(*args)

這是 QTF 的 R_k 門。

Qubit

原始文件：docs.sympy.org/latest/modules/physics/quantum/qubit.html

量子計算的 Qubit。

Todo: * 完成實現測量邏輯。這應包括 POVM。 * 更新文件字串。 * 更新測試。

class sympy.physics.quantum.qubit.IntQubit(*args, **kwargs)

儲存整數作為 qubit 值的 qubit ket。

此類與 Qubit 之間的區別是：

建構函式的形式。
qubit 值以其相應的整數形式列印，而不是原始 qubit 值。qubit 值的內部儲存格式與 Qubit 相同。

引數：

values : 整數，元組

如果是單個引數，是我們想要表示在 qubit 值中的整數。這個整數將使用盡可能少的 qubit 數來表示。如果是一對整數，第二個值超過一個，那麼第一個整數以二進位制形式表示我們要表示的整數，第二個整數給出要使用的 qubit 數量。也接受零和一的列表以按位模式生成 qubit。

nqubits : 整數

表示 qubit 數量的整數。應使用關鍵字 nqubits=N 傳遞此數字。您可以使用此功能來避免 Qubit 樣式的位元組的歧義。有關更多詳細資訊，請參見下面的示例。

示例

建立整數 5 的 qubit：

>>> from sympy.physics.quantum.qubit import IntQubit
>>> from sympy.physics.quantum.qubit import Qubit
>>> q = IntQubit(5)
>>> q
|5>

我們還可以透過傳遞 Qubit 例項來建立 IntQubit。

>>> q = IntQubit(Qubit('101'))
>>> q
|5>
>>> q.as_int()
5
>>> q.nqubits
3
>>> q.qubit_values
(1, 0, 1)

我們可以回到常規的 qubit 形式。

>>> Qubit(q)
|101>

請注意，IntQubit 還接受 Qubit 風格的位列表。因此，下面的程式碼產生的是 3 個 qubits，而不是單個位 1。

>>> IntQubit(1, 1)
|3>

為避免歧義，請使用 nqubits 引數。特別是在透過變數提供值時，建議使用此關鍵字。

>>> IntQubit(1, nqubits=1)
|1>
>>> a = 1
>>> IntQubit(a, nqubits=1)
|1>

class sympy.physics.quantum.qubit.IntQubitBra(*args, **kwargs)

儲存整數作為 qubit 值的 qubit bra。

class sympy.physics.quantum.qubit.Qubit(*args, **kwargs)

在計算（z）基礎上的多 qubit ket。

我們使用正常約定，即最低有效 qubit 在右側，因此 |00001> 在最低有效 qubit 中有 1。

引數：

values : 列表，字串

qubit 值作為整數列表（[0,0,0,1,1,]）或字串（‘011’）。

示例

以幾種不同的方式建立 qubit 並檢視它們的屬性：

>>> from sympy.physics.quantum.qubit import Qubit
>>> Qubit(0,0,0)
|000>
>>> q = Qubit('0101')
>>> q
|0101>

>>> q.nqubits
4
>>> len(q)
4
>>> q.dimension
4
>>> q.qubit_values
(0, 1, 0, 1)

我們可以翻轉單個 qubit 的值：

>>> q.flip(1)
|0111>

我們可以取 Qubit 的 dagger 來得到一個 bra：

>>> from sympy.physics.quantum.dagger import Dagger
>>> Dagger(q)
<0101|
>>> type(Dagger(q))
<class 'sympy.physics.quantum.qubit.QubitBra'>

內積按預期工作：

>>> ip = Dagger(q)*q
>>> ip
<0101|0101>
>>> ip.doit()
1

class sympy.physics.quantum.qubit.QubitBra(*args, **kwargs)

在計算（z）基礎上的多 qubit bra。

我們使用正常約定，即最低有效 qubit 在右側，因此 |00001> 在最低有效 qubit 中有 1。

引數：

values : 列表，字串

qubit 值作為整數列表（[0,0,0,1,1,]）或字串（‘011’）。

參見

Qubit

使用 qubits 的示例

sympy.physics.quantum.qubit.matrix_to_density(mat)

透過找到矩陣的特徵向量和特徵值來工作。我們知道可以透過以下方式分解 rho：sum(EigenVal*|Eigenvect><Eigenvect|)

sympy.physics.quantum.qubit.matrix_to_qubit(matrix)

從矩陣表示轉換為一組 Qubit 物件的總和。

引數：

matrix : 矩陣，numpy.matrix，scipy.sparse

構建 Qubit 表示的矩陣。適用於 SymPy 矩陣、numpy 矩陣和 scipy.sparse 稀疏矩陣。

示例

表示一個狀態，然後返回其 Qubit 形式：

>>> from sympy.physics.quantum.qubit import matrix_to_qubit, Qubit
>>> from sympy.physics.quantum.represent import represent
>>> q = Qubit('01')
>>> matrix_to_qubit(represent(q))
|01>

sympy.physics.quantum.qubit.measure_all(qubit, format='sympy', normalize=True)

對所有量子位執行集合測量。

引數：

qubit : Qubit, Add

要測量的量子位（qubit）。可以是任何量子位或它們的線性組合。

format : 字串

要使用的中間矩陣的格式。可能的值為（‘sympy’，‘numpy’，‘scipy.sparse’）。目前只實現了‘sympy’。

result : 列表

由原始狀態及其機率組成的列表。

示例

>>> from sympy.physics.quantum.qubit import Qubit, measure_all
>>> from sympy.physics.quantum.gate import H
>>> from sympy.physics.quantum.qapply import qapply

>>> c = H(0)*H(1)*Qubit('00')
>>> c
H(0)*H(1)*|00>
>>> q = qapply(c)
>>> measure_all(q)
[(|00>, 1/4), (|01>, 1/4), (|10>, 1/4), (|11>, 1/4)]

sympy.physics.quantum.qubit.measure_all_oneshot(qubit, format='sympy')

對所有量子位執行一次性集合測量。

一次性測量等同於對量子系統進行測量。這種型別的測量不像集合測量那樣返回機率，而是返回可能結果中的一個。返回的確切狀態是根據集合機率隨機選擇的。

引數：

qubits : Qubit

要測量的量子位。可以是任何量子位或它們的線性組合。

format : 字串

要使用的中間矩陣的格式。可能的值為（‘sympy’，‘numpy’，‘scipy.sparse’）。目前只實現了‘sympy’。

result : Qubit

系統在測量時崩潰到的量子位。

sympy.physics.quantum.qubit.measure_partial(qubit, bits, format='sympy', normalize=True)

對指定量子位執行部分集合測量。

引數：

qubits : Qubit

要測量的量子位。可以是任何量子位或它們的線性組合。

bits : 元組

要測量的量子位。

format : 字串

要使用的中間矩陣的格式。可能的值為（‘sympy’，‘numpy’，‘scipy.sparse’）。目前只實現了‘sympy’。

result : 列表

由原始狀態及其機率組成的列表。

示例

>>> from sympy.physics.quantum.qubit import Qubit, measure_partial
>>> from sympy.physics.quantum.gate import H
>>> from sympy.physics.quantum.qapply import qapply

>>> c = H(0)*H(1)*Qubit('00')
>>> c
H(0)*H(1)*|00>
>>> q = qapply(c)
>>> measure_partial(q, (0,))
[(sqrt(2)*|00>/2 + sqrt(2)*|10>/2, 1/2), (sqrt(2)*|01>/2 + sqrt(2)*|11>/2, 1/2)]

sympy.physics.quantum.qubit.measure_partial_oneshot(qubit, bits, format='sympy')

對指定量子位執行部分一次性測量。

引數：

qubits : Qubit

要測量的量子位。可以是任何量子位或它們的線性組合。

bits : 元組

要測量的量子位。

format : 字串

要使用的中間矩陣的格式。可能的值為（‘sympy’，‘numpy’，‘scipy.sparse’）。目前只實現了‘sympy’。

result : Qubit

系統在測量時崩潰到的量子位。

sympy.physics.quantum.qubit.qubit_to_matrix(qubit, format='sympy')

將 Qubit 物件的 Add/Mul 轉換為其矩陣表示

此函式是matrix_to_qubit的反函式，是represent(qubit)的簡寫。

Shor 演算法

原文連結：docs.sympy.org/latest/modules/physics/quantum/shor.html

Shor 演算法及其輔助函式。

待辦事項：

使用新的 Gate API 重新使 CMod 門工作。
修復一切。
更新文件字串並重新格式化。

class sympy.physics.quantum.shor.CMod(*args, **kwargs)

一個控制的模門。

這是用於 Shor 演算法的黑盒子控制模函式。TODO：實現一個 decompose 屬性，以元素門的術語返回如何執行此操作。

property N

N 是我們進行的模算術的型別。

property a

控制模函式的基礎。

property t

1/2 輸入暫存器的大小。前半部分儲存輸出。

sympy.physics.quantum.shor.period_find(a, N)

在模 N 算術中找到 a 的週期

這是 Shor 演算法的量子部分。它接受兩個暫存器，將第一個置於哈達瑪德變換的狀態疊加中：|k>|0>，其中 k 是所有可能的選擇。然後進行一個控制模門和一個量子傅立葉變換以確定 a 的階。

sympy.physics.quantum.shor.shor(N)

這個函式在整數 N 上實現了 Shor 的因數分解演算法。

演算法首先隨機選擇一個數（a），並檢查它是否與 N 互質。如果不是，則兩個數的最大公約數是一個因子，我們完成了。否則，它開始執行 period_finding 子例程，用於找到在模 N 算術中 a 的週期。如果這個週期是偶數，可以透過取 a(r/2)-1 和 a(r/2)+1 來計算因子。這些值被返回。

盒中的粒子

原文：docs.sympy.org/latest/modules/physics/quantum/piab.html

1D 量子盒子中的粒子。

class sympy.physics.quantum.piab.PIABBra(*args, **kwargs)

粒子在盒子中的本徵矢。

class sympy.physics.quantum.piab.PIABHamiltonian(*args, **kwargs)

粒子在盒子中的哈密頓算符。

class sympy.physics.quantum.piab.PIABKet(*args, **kwargs)

粒子在盒子中的本徵態。

光學模組

原文：docs.sympy.org/latest/modules/physics/optics/index.html

高斯光學
介質
極化
實用工具
波

高斯光學

原文連結：docs.sympy.org/latest/modules/physics/optics/gaussopt.html

高斯光學。

模組實現：

幾何光學和高斯光學的射線傳輸矩陣。

參見 RayTransferMatrix，GeometricRay 和 BeamParameter
幾何光學和高斯光學的共軛關係。

檢視 geometric_conj*, gauss_conj 和 conjugate_gauss_beams

距離的慣例如下：

焦距

對於會聚透鏡為正

物體距離

對於真實物體為正

影像距離

對於真實影像為正

class sympy.physics.optics.gaussopt.BeamParameter(wavelen, z, z_r=None, w=None, n=1)

高斯光線在射線傳輸矩陣形式主義中的表示。

引數：

wavelen : 波長，

z : 腰部距離，以及

w : 腰部，或

z_r : 雷利範圍。

n : 介質的折射率。

示例

>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.q
1 + 1.88679245283019*I*pi

>>> p.q.n()
1.0 + 5.92753330865999*I
>>> p.w_0.n()
0.00100000000000000
>>> p.z_r.n()
5.92753330865999

>>> from sympy.physics.optics import FreeSpace
>>> fs = FreeSpace(10)
>>> p1 = fs*p
>>> p.w.n()
0.00101413072159615
>>> p1.w.n()
0.00210803120913829

另見

RayTransferMatrix

參考文獻

[R740]

en.wikipedia.org/wiki/Complex_beam_parameter

[R741]

en.wikipedia.org/wiki/Gaussian_beam

property divergence

總角度擴充套件的一半。

示例

>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.divergence
0.00053/pi

property gouy

Gouy 相位。

示例

>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.gouy
atan(0.53/pi)

property q

表示光束的復引數。

示例

>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.q
1 + 1.88679245283019*I*pi

property radius

相位前沿的曲率半徑。

示例

>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.radius
1 + 3.55998576005696*pi**2

property w

在光束沿著光束的任何位置 z 處的光束半徑 w(z)。光束半徑在(1/e²)強度（軸向值）處。

示例

>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.w
0.001*sqrt(0.2809/pi**2 + 1)

另見

w_0

光束的最小半徑。

property w_0

光束在(1/e²)強度（峰值）處的最小半徑。

示例

>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.w_0
0.00100000000000000

另見

w

光束在(1/e²)強度（軸向值）處的光束半徑。

property waist_approximation_limit

適用於高斯光束近似有效的最小腰部。

解釋

高斯光束是拋物近軸方程的解。對於曲率太大的情況，這不是一個有效的近似。

示例

>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.waist_approximation_limit
1.06e-6/pi

class sympy.physics.optics.gaussopt.CurvedMirror(R)

曲面反射的射線傳輸矩陣。

引數：

R : 曲率半徑（凹面為正）

示例

>>> from sympy.physics.optics import CurvedMirror
>>> from sympy import symbols
>>> R = symbols('R')
>>> CurvedMirror(R)
Matrix([
[   1, 0],
[-2/R, 1]])

另見

RayTransferMatrix

class sympy.physics.optics.gaussopt.CurvedRefraction(R, n1, n2)

曲面間折射的射線傳輸矩陣。

引數：

R :

曲率半徑（凹面為正）。

n1 :

單個介質的折射率。

n2 :

其他介質的折射率。

示例

>>> from sympy.physics.optics import CurvedRefraction
>>> from sympy import symbols
>>> R, n1, n2 = symbols('R n1 n2')
>>> CurvedRefraction(R, n1, n2)
Matrix([
[               1,     0],
[(n1 - n2)/(R*n2), n1/n2]])

另見

RayTransferMatrix

class sympy.physics.optics.gaussopt.FlatMirror

反射的射線傳輸矩陣。

示例

>>> from sympy.physics.optics import FlatMirror
>>> FlatMirror()
Matrix([
[1, 0],
[0, 1]])

另見

RayTransferMatrix

class sympy.physics.optics.gaussopt.FlatRefraction(n1, n2)

折射的射線傳輸矩陣。

引數：

n1 :

單個介質的折射率。

n2 :

其他介質的折射率。

示例

>>> from sympy.physics.optics import FlatRefraction
>>> from sympy import symbols
>>> n1, n2 = symbols('n1 n2')
>>> FlatRefraction(n1, n2)
Matrix([
[1,     0],
[0, n1/n2]])

另見

RayTransferMatrix

class sympy.physics.optics.gaussopt.FreeSpace(d)

自由空間的光線傳輸矩陣。

引數：

distance

示例

>>> from sympy.physics.optics import FreeSpace
>>> from sympy import symbols
>>> d = symbols('d')
>>> FreeSpace(d)
Matrix([
[1, d],
[0, 1]])

另見

RayTransferMatrix

class sympy.physics.optics.gaussopt.GeometricRay(*args)

幾何光線在射線傳輸矩陣形式化中的表示。

引數：

h : 高度，和

angle : 角度，或

matrix : a 2x1 matrix (Matrix(2, 1, [height, angle]))

示例

>>> from sympy.physics.optics import GeometricRay, FreeSpace
>>> from sympy import symbols, Matrix
>>> d, h, angle = symbols('d, h, angle')

>>> GeometricRay(h, angle)
Matrix([
[    h],
[angle]])

>>> FreeSpace(d)*GeometricRay(h, angle)
Matrix([
[angle*d + h],
[      angle]])

>>> GeometricRay( Matrix( ((h,), (angle,)) ) )
Matrix([
[    h],
[angle]])

另見

RayTransferMatrix

property angle

光軸角度。

示例

>>> from sympy.physics.optics import GeometricRay
>>> from sympy import symbols
>>> h, angle = symbols('h, angle')
>>> gRay = GeometricRay(h, angle)
>>> gRay.angle
angle

property height

光軸距離。

示例

>>> from sympy.physics.optics import GeometricRay
>>> from sympy import symbols
>>> h, angle = symbols('h, angle')
>>> gRay = GeometricRay(h, angle)
>>> gRay.height
h

class sympy.physics.optics.gaussopt.RayTransferMatrix(*args)

射線傳輸矩陣的基類。

如果“參見”中沒有更具體的子類，則應使用此選項。

引數：

parameters :

A, B, C and D or 2x2 matrix (Matrix(2, 2, [A, B, C, D]))

示例

>>> from sympy.physics.optics import RayTransferMatrix, ThinLens
>>> from sympy import Symbol, Matrix

>>> mat = RayTransferMatrix(1, 2, 3, 4)
>>> mat
Matrix([
[1, 2],
[3, 4]])

>>> RayTransferMatrix(Matrix([[1, 2], [3, 4]]))
Matrix([
[1, 2],
[3, 4]])

>>> mat.A
1

>>> f = Symbol('f')
>>> lens = ThinLens(f)
>>> lens
Matrix([
[   1, 0],
[-1/f, 1]])

>>> lens.C
-1/f

另見

GeometricRay, BeamParameter, FreeSpace, FlatRefraction, CurvedRefraction, FlatMirror, CurvedMirror, ThinLens

參考文獻

[R742]

en.wikipedia.org/wiki/Ray_transfer_matrix_analysis

property A

矩陣的引數 A。

示例

>>> from sympy.physics.optics import RayTransferMatrix
>>> mat = RayTransferMatrix(1, 2, 3, 4)
>>> mat.A
1

property B

矩陣的引數 B。

示例

>>> from sympy.physics.optics import RayTransferMatrix
>>> mat = RayTransferMatrix(1, 2, 3, 4)
>>> mat.B
2

property C

矩陣的引數 C。

示例

>>> from sympy.physics.optics import RayTransferMatrix
>>> mat = RayTransferMatrix(1, 2, 3, 4)
>>> mat.C
3

property D

矩陣的引數 D。

示例

>>> from sympy.physics.optics import RayTransferMatrix
>>> mat = RayTransferMatrix(1, 2, 3, 4)
>>> mat.D
4

class sympy.physics.optics.gaussopt.ThinLens(f)

薄透鏡的光線傳輸矩陣。

引數：

f :

焦距。

示例

>>> from sympy.physics.optics import ThinLens
>>> from sympy import symbols
>>> f = symbols('f')
>>> ThinLens(f)
Matrix([
[   1, 0],
[-1/f, 1]])

另見

RayTransferMatrix

sympy.physics.optics.gaussopt.conjugate_gauss_beams(wavelen, waist_in, waist_out, **kwargs)

找到將物體/像腰部共軛的光學設定。

引數：

wavelen :

光束的波長。

waist_in and waist_out :

要共軛的腰部。

f :

用於共軛中使用的元件的焦距。

一個包含（s_in, s_out, f）的元組。

s_in :

光學元件前的距離。

s_out :

光學元件後的距離。

f :

光學元件的焦距。

示例

>>> from sympy.physics.optics import conjugate_gauss_beams
>>> from sympy import symbols, factor
>>> l, w_i, w_o, f = symbols('l w_i w_o f')

>>> conjugate_gauss_beams(l, w_i, w_o, f=f)[0]
f*(1 - sqrt(w_i**2/w_o**2 - pi**2*w_i**4/(f**2*l**2)))

>>> factor(conjugate_gauss_beams(l, w_i, w_o, f=f)[1])
f*w_o**2*(w_i**2/w_o**2 - sqrt(w_i**2/w_o**2 -
 pi**2*w_i**4/(f**2*l**2)))/w_i**2

>>> conjugate_gauss_beams(l, w_i, w_o, f=f)[2]
f

sympy.physics.optics.gaussopt.gaussian_conj(s_in, z_r_in, f)

高斯光束的共軛關係。

引數：

s_in :

光學元件距離腰部的距離。

z_r_in :

入射光束的瑞利範圍。

f :

光學元件的焦距。

包含 (s_out, z_r_out, m) 的元組

s_out :

新腰部與光學元件之間的距離。

z_r_out :

出射光束的瑞利範圍。

m :

新舊腰部之間的比率。

示例

>>> from sympy.physics.optics import gaussian_conj
>>> from sympy import symbols
>>> s_in, z_r_in, f = symbols('s_in z_r_in f')

>>> gaussian_conj(s_in, z_r_in, f)[0]
1/(-1/(s_in + z_r_in**2/(-f + s_in)) + 1/f)

>>> gaussian_conj(s_in, z_r_in, f)[1]
z_r_in/(1 - s_in**2/f**2 + z_r_in**2/f**2)

>>> gaussian_conj(s_in, z_r_in, f)[2]
1/sqrt(1 - s_in**2/f**2 + z_r_in**2/f**2)

sympy.physics.optics.gaussopt.geometric_conj_ab(a, b)

偏軸條件下幾何光束的共軛關係。

解釋

獲取到光學元件的距離，並返回所需的焦距。

示例

>>> from sympy.physics.optics import geometric_conj_ab
>>> from sympy import symbols
>>> a, b = symbols('a b')
>>> geometric_conj_ab(a, b)
a*b/(a + b)

參見

geometric_conj_af, geometric_conj_bf

sympy.physics.optics.gaussopt.geometric_conj_af(a, f)

偏軸條件下幾何光束的共軛關係。

解釋

獲取光學元件的物距（用於 geometric_conj_af）或像距（用於 geometric_conj_bf）和焦距。然後返回共軛所需的另一個距離。

示例

>>> from sympy.physics.optics.gaussopt import geometric_conj_af, geometric_conj_bf
>>> from sympy import symbols
>>> a, b, f = symbols('a b f')
>>> geometric_conj_af(a, f)
a*f/(a - f)
>>> geometric_conj_bf(b, f)
b*f/(b - f)

參見

geometric_conj_ab

sympy.physics.optics.gaussopt.geometric_conj_bf(a, f)

偏軸條件下幾何光束的共軛關係。

解釋

獲取光學元件的物距（用於 geometric_conj_af）或像距（用於 geometric_conj_bf）和焦距。然後返回共軛所需的另一個距離。

示例

>>> from sympy.physics.optics.gaussopt import geometric_conj_af, geometric_conj_bf
>>> from sympy import symbols
>>> a, b, f = symbols('a b f')
>>> geometric_conj_af(a, f)
a*f/(a - f)
>>> geometric_conj_bf(b, f)
b*f/(b - f)

參見

geometric_conj_ab

sympy.physics.optics.gaussopt.rayleigh2waist(z_r, wavelen)

計算高斯光束的腰部從瑞利範圍。

示例

>>> from sympy.physics.optics import rayleigh2waist
>>> from sympy import symbols
>>> z_r, wavelen = symbols('z_r wavelen')
>>> rayleigh2waist(z_r, wavelen)
sqrt(wavelen*z_r)/sqrt(pi)

參見

waist2rayleigh, BeamParameter

sympy.physics.optics.gaussopt.waist2rayleigh(w, wavelen, n=1)

計算高斯光束從腰部到瑞利範圍的光線範圍。

示例

>>> from sympy.physics.optics import waist2rayleigh
>>> from sympy import symbols
>>> w, wavelen = symbols('w wavelen')
>>> waist2rayleigh(w, wavelen)
pi*w**2/wavelen

參見

rayleigh2waist, BeamParameter

介質

原文：docs.sympy.org/latest/modules/physics/optics/medium.html

包含

介質

class sympy.physics.optics.medium.Medium(name, permittivity=None, permeability=None, n=None)

這個類表示一個光學介質。實施這一點的主要原因是為了促進折射、費馬原理等。

引數：

名稱：字串

介質的顯示名稱。

電容率：可以符號化

空間的電介質常數。

磁導率：可以符號化

空間的磁導率。

n：可以符號化

介質的折射率。

解釋

光學介質是電磁波傳播的材料。介質的電容率和磁導率決定了電磁波在其中的傳播方式。

例子

>>> from sympy.abc import epsilon, mu
>>> from sympy.physics.optics import Medium
>>> m1 = Medium('m1')
>>> m2 = Medium('m2', epsilon, mu)
>>> m1.intrinsic_impedance
149896229*pi*kilogram*meter**2/(1250000*ampere**2*second**3)
>>> m2.refractive_index
299792458*meter*sqrt(epsilon*mu)/second

參考文獻

[R743]

en.wikipedia.org/wiki/Optical_medium

property refractive_index

返回介質的折射率。

例子

>>> from sympy.physics.optics import Medium
>>> m = Medium('m')
>>> m.refractive_index
1

property speed

返回介質中電磁波的傳播速度。

例子

>>> from sympy.physics.optics import Medium
>>> m = Medium('m')
>>> m.speed
299792458*meter/second
>>> m2 = Medium('m2', n=1)
>>> m.speed == m2.speed
True

極化

原文：docs.sympy.org/latest/modules/physics/optics/polarization.html

該模組實現了光場極化建模的例程，並可用於計算極化光元件對場的影響。

Jones 向量。
Stokes 向量。
Jones 矩陣。
Mueller 矩陣。

示例

我們計算一個通用的 Jones 向量：

>>> from sympy import symbols, pprint, zeros, simplify
>>> from sympy.physics.optics.polarization import (jones_vector, stokes_vector,
...     half_wave_retarder, polarizing_beam_splitter, jones_2_stokes)

>>> psi, chi, p, I0 = symbols("psi, chi, p, I0", real=True)
>>> x0 = jones_vector(psi, chi)
>>> pprint(x0, use_unicode=True)
⎡-ⅈ⋅sin(χ)⋅sin(ψ) + cos(χ)⋅cos(ψ)⎤
⎢                                ⎥
⎣ⅈ⋅sin(χ)⋅cos(ψ) + sin(ψ)⋅cos(χ) ⎦

以及更一般的 Stokes 向量：

>>> s0 = stokes_vector(psi, chi, p, I0)
>>> pprint(s0, use_unicode=True)
⎡          I₀          ⎤
⎢                      ⎥
⎢I₀⋅p⋅cos(2⋅χ)⋅cos(2⋅ψ)⎥
⎢                      ⎥
⎢I₀⋅p⋅sin(2⋅ψ)⋅cos(2⋅χ)⎥
⎢                      ⎥
⎣    I₀⋅p⋅sin(2⋅χ)     ⎦

我們計算 Jones 向量如何被半波片修改：

>>> alpha = symbols("alpha", real=True)
>>> HWP = half_wave_retarder(alpha)
>>> x1 = simplify(HWP*x0)

我們計算將光束透過半波片，然後透過偏振分束器的常見操作。我們透過將這個 Jones 向量作為第一個條目放入一個模擬偏振分束器的 4x4 Jones 矩陣的兩個 Jones 向量狀態來實現這一點，以獲得傳輸和反射的 Jones 向量：

>>> PBS = polarizing_beam_splitter()
>>> X1 = zeros(4, 1)
>>> X1[:2, :] = x1
>>> X2 = PBS*X1
>>> transmitted_port = X2[:2, :]
>>> reflected_port = X2[2:, :]

這使我們能夠計算兩個埠中的功率如何依賴於初始極化：

>>> transmitted_power = jones_2_stokes(transmitted_port)[0]
>>> reflected_power = jones_2_stokes(reflected_port)[0]
>>> print(transmitted_power)
cos(-2*alpha + chi + psi)**2/2 + cos(2*alpha + chi - psi)**2/2

>>> print(reflected_power)
sin(-2*alpha + chi + psi)**2/2 + sin(2*alpha + chi - psi)**2/2

請檢視單個函式的描述以獲取更多詳細資訊和示例。

References

[R744]

en.wikipedia.org/wiki/Jones_calculus

[R745]

en.wikipedia.org/wiki/Mueller_calculus

[R746]

en.wikipedia.org/wiki/Stokes_parameters

sympy.physics.optics.polarization.half_wave_retarder(theta)

角度為theta的半波片 Jones 矩陣。

Parameters:

theta : 數值型別或 SymPy 符號

快軸相對於水平面的角度。

Returns:

SymPy 矩陣

表示減速器的 Jones 矩陣。

示例

一個通用的半波片。

>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import half_wave_retarder
>>> theta= symbols("theta", real=True)
>>> HWP = half_wave_retarder(theta)
>>> pprint(HWP, use_unicode=True)
⎡   ⎛     2         2   ⎞                        ⎤
⎢-ⅈ⋅⎝- sin (θ) + cos (θ)⎠    -2⋅ⅈ⋅sin(θ)⋅cos(θ)  ⎥
⎢                                                ⎥
⎢                             ⎛   2         2   ⎞⎥
⎣   -2⋅ⅈ⋅sin(θ)⋅cos(θ)     -ⅈ⋅⎝sin (θ) - cos (θ)⎠⎦

sympy.physics.optics.polarization.jones_2_stokes(e)

返回 Jones 向量e的 Stokes 向量。

Parameters:

e : SymPy 矩陣

一個 Jones 向量。

Returns:

SymPy 矩陣

一個 Jones 向量。

示例

Poincaré球上的軸。

>>> from sympy import pprint, pi
>>> from sympy.physics.optics.polarization import jones_vector
>>> from sympy.physics.optics.polarization import jones_2_stokes
>>> H = jones_vector(0, 0)
>>> V = jones_vector(pi/2, 0)
>>> D = jones_vector(pi/4, 0)
>>> A = jones_vector(-pi/4, 0)
>>> R = jones_vector(0, pi/4)
>>> L = jones_vector(0, -pi/4)
>>> pprint([jones_2_stokes(e) for e in [H, V, D, A, R, L]],
...         use_unicode=True)
⎡⎡1⎤  ⎡1 ⎤  ⎡1⎤  ⎡1 ⎤  ⎡1⎤  ⎡1 ⎤⎤
⎢⎢ ⎥  ⎢  ⎥  ⎢ ⎥  ⎢  ⎥  ⎢ ⎥  ⎢  ⎥⎥
⎢⎢1⎥  ⎢-1⎥  ⎢0⎥  ⎢0 ⎥  ⎢0⎥  ⎢0 ⎥⎥
⎢⎢ ⎥, ⎢  ⎥, ⎢ ⎥, ⎢  ⎥, ⎢ ⎥, ⎢  ⎥⎥
⎢⎢0⎥  ⎢0 ⎥  ⎢1⎥  ⎢-1⎥  ⎢0⎥  ⎢0 ⎥⎥
⎢⎢ ⎥  ⎢  ⎥  ⎢ ⎥  ⎢  ⎥  ⎢ ⎥  ⎢  ⎥⎥
⎣⎣0⎦  ⎣0 ⎦  ⎣0⎦  ⎣0 ⎦  ⎣1⎦  ⎣-1⎦⎦

sympy.physics.optics.polarization.jones_vector(psi, chi)

一個與極化橢圓（具有(psi)傾斜和(chi)圓度）對應的 Jones 向量。

Parameters:

psi : 數值型別或 SymPy 符號

相對於(x)軸的極化傾斜。

chi : 數值型別或 SymPy 符號

極化橢圓主軸相鄰的角度。

Returns:

矩陣 :

一個 Jones 向量。

示例

Poincaré球上的軸。

>>> from sympy import pprint, symbols, pi
>>> from sympy.physics.optics.polarization import jones_vector
>>> psi, chi = symbols("psi, chi", real=True)

一個通用的 Jones 向量。

>>> pprint(jones_vector(psi, chi), use_unicode=True)
⎡-ⅈ⋅sin(χ)⋅sin(ψ) + cos(χ)⋅cos(ψ)⎤
⎢                                ⎥
⎣ⅈ⋅sin(χ)⋅cos(ψ) + sin(ψ)⋅cos(χ) ⎦

水平極化。

>>> pprint(jones_vector(0, 0), use_unicode=True)
⎡1⎤
⎢ ⎥
⎣0⎦

垂直極化。

>>> pprint(jones_vector(pi/2, 0), use_unicode=True)
⎡0⎤
⎢ ⎥
⎣1⎦

對角極化。

>>> pprint(jones_vector(pi/4, 0), use_unicode=True)
⎡√2⎤
⎢──⎥
⎢2 ⎥
⎢  ⎥
⎢√2⎥
⎢──⎥
⎣2 ⎦

反對角極化。

>>> pprint(jones_vector(-pi/4, 0), use_unicode=True)
⎡ √2 ⎤
⎢ ── ⎥
⎢ 2  ⎥
⎢    ⎥
⎢-√2 ⎥
⎢────⎥
⎣ 2  ⎦

右旋圓極化。

>>> pprint(jones_vector(0, pi/4), use_unicode=True)
⎡ √2 ⎤
⎢ ── ⎥
⎢ 2  ⎥
⎢    ⎥
⎢√2⋅ⅈ⎥
⎢────⎥
⎣ 2  ⎦

左旋圓極化。

>>> pprint(jones_vector(0, -pi/4), use_unicode=True)
⎡  √2  ⎤
⎢  ──  ⎥
⎢  2   ⎥
⎢      ⎥
⎢-√2⋅ⅈ ⎥
⎢──────⎥
⎣  2   ⎦

sympy.physics.optics.polarization.linear_polarizer(theta=0)

一個帶有傳輸軸角度為theta的線性偏振器 Jones 矩陣。

Parameters:

theta : 數值型別或 SymPy 符號

傳輸軸相對於水平面的角度。

Returns:

SymPy 矩陣

表示偏振器的 Jones 矩陣。

示例

一個通用的偏振器。

>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import linear_polarizer
>>> theta = symbols("theta", real=True)
>>> J = linear_polarizer(theta)
>>> pprint(J, use_unicode=True)
⎡      2                     ⎤
⎢   cos (θ)     sin(θ)⋅cos(θ)⎥
⎢                            ⎥
⎢                     2      ⎥
⎣sin(θ)⋅cos(θ)     sin (θ)   ⎦

sympy.physics.optics.polarization.mueller_matrix(J)

與 Jones 矩陣(J)對應的 Mueller 矩陣。

Parameters:

J : SymPy 矩陣

一個 Jones 矩陣。

Returns:

SymPy 矩陣

相應的 Mueller 矩陣。

示例

通用光學元件。

>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import (mueller_matrix,
...     linear_polarizer, half_wave_retarder, quarter_wave_retarder)
>>> theta = symbols("theta", real=True)

一個線性偏振器

>>> pprint(mueller_matrix(linear_polarizer(theta)), use_unicode=True)
⎡            cos(2⋅θ)      sin(2⋅θ)     ⎤
⎢  1/2       ────────      ────────    0⎥
⎢               2             2         ⎥
⎢                                       ⎥
⎢cos(2⋅θ)  cos(4⋅θ)   1    sin(4⋅θ)     ⎥
⎢────────  ──────── + ─    ────────    0⎥
⎢   2         4       4       4         ⎥
⎢                                       ⎥
⎢sin(2⋅θ)    sin(4⋅θ)    1   cos(4⋅θ)   ⎥
⎢────────    ────────    ─ - ────────  0⎥
⎢   2           4        4      4       ⎥
⎢                                       ⎥
⎣   0           0             0        0⎦

一個半波片

>>> pprint(mueller_matrix(half_wave_retarder(theta)), use_unicode=True)
⎡1              0                           0               0 ⎤
⎢                                                             ⎥
⎢        4           2                                        ⎥
⎢0  8⋅sin (θ) - 8⋅sin (θ) + 1           sin(4⋅θ)            0 ⎥
⎢                                                             ⎥
⎢                                     4           2           ⎥
⎢0          sin(4⋅θ)           - 8⋅sin (θ) + 8⋅sin (θ) - 1  0 ⎥
⎢                                                             ⎥
⎣0              0                           0               -1⎦

一個四分之一波片

>>> pprint(mueller_matrix(quarter_wave_retarder(theta)), use_unicode=True)
⎡1       0             0            0    ⎤
⎢                                        ⎥
⎢   cos(4⋅θ)   1    sin(4⋅θ)             ⎥
⎢0  ──────── + ─    ────────    -sin(2⋅θ)⎥
⎢      2       2       2                 ⎥
⎢                                        ⎥
⎢     sin(4⋅θ)    1   cos(4⋅θ)           ⎥
⎢0    ────────    ─ - ────────  cos(2⋅θ) ⎥
⎢        2        2      2               ⎥
⎢                                        ⎥
⎣0    sin(2⋅θ)     -cos(2⋅θ)        0    ⎦

sympy.physics.optics.polarization.phase_retarder(theta=0, delta=0)

在角度 theta 處具有 delta 減速度的相位減速器 Jones 矩陣。

引數：

theta：數值型別或 SymPy 符號

快軸相對於水平面的角度。

delta：數值型別或 SymPy 符號

傳輸光的快軸和慢軸之間的相位差。

SymPy 矩陣：

代表減速器的 Jones 矩陣。

示例

通用減速器。

>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import phase_retarder
>>> theta, delta = symbols("theta, delta", real=True)
>>> R = phase_retarder(theta, delta)
>>> pprint(R, use_unicode=True)
⎡                          -ⅈ⋅δ               -ⅈ⋅δ               ⎤
⎢                          ─────              ─────              ⎥
⎢⎛ ⅈ⋅δ    2         2   ⎞    2    ⎛     ⅈ⋅δ⎞    2                ⎥
⎢⎝ℯ   ⋅sin (θ) + cos (θ)⎠⋅ℯ       ⎝1 - ℯ   ⎠⋅ℯ     ⋅sin(θ)⋅cos(θ)⎥
⎢                                                                ⎥
⎢            -ⅈ⋅δ                                           -ⅈ⋅δ ⎥
⎢            ─────                                          ─────⎥
⎢⎛     ⅈ⋅δ⎞    2                  ⎛ ⅈ⋅δ    2         2   ⎞    2  ⎥
⎣⎝1 - ℯ   ⎠⋅ℯ     ⋅sin(θ)⋅cos(θ)  ⎝ℯ   ⋅cos (θ) + sin (θ)⎠⋅ℯ     ⎦

sympy.physics.optics.polarization.polarizing_beam_splitter(Tp=1, Rs=1, Ts=0, Rp=0, phia=0, phib=0)

在角度 (theta) 處的偏振分光鏡 Jones 矩陣。

引數：

J：SymPy 矩陣

一個 Jones 矩陣。

Tp：數值型別或 SymPy 符號

P 極化組分的透射率。

Rs：數值型別或 SymPy 符號

S 極化組分的反射率。

Ts：數值型別或 SymPy 符號

S 極化組分的透射率。

Rp：數值型別或 SymPy 符號

P 極化組分的反射率。

phia：數值型別或 SymPy 符號

輸出模式 a 的傳輸和反射組分之間的相位差。

phib：數值型別或 SymPy 符號

輸出模式 b 的傳輸和反射組分之間的相位差。

SymPy 矩陣

代表 PBS 的 4x4 矩陣。此矩陣作用於 4x1 向量，其前兩個條目是 PBS 一個埠上的 Jones 向量，後兩個條目是另一個埠上的 Jones 向量。

示例

通用偏振分光鏡。

>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import polarizing_beam_splitter
>>> Ts, Rs, Tp, Rp = symbols(r"Ts, Rs, Tp, Rp", positive=True)
>>> phia, phib = symbols("phi_a, phi_b", real=True)
>>> PBS = polarizing_beam_splitter(Tp, Rs, Ts, Rp, phia, phib)
>>> pprint(PBS, use_unicode=False)
[   ____                           ____                    ]
[ \/ Tp            0           I*\/ Rp           0         ]
[                                                          ]
[                  ____                       ____  I*phi_a]
[   0            \/ Ts            0      -I*\/ Rs *e       ]
[                                                          ]
[    ____                         ____                     ]
[I*\/ Rp           0            \/ Tp            0         ]
[                                                          ]
[               ____  I*phi_b                    ____      ]
[   0      -I*\/ Rs *e            0            \/ Ts       ]

sympy.physics.optics.polarization.quarter_wave_retarder(theta)

在角度 theta 處的四分之一波減速器 Jones 矩陣。

引數：

theta：數值型別或 SymPy 符號

快軸相對於水平面的角度。

SymPy 矩陣

代表減速器的 Jones 矩陣。

示例

通用四分之一波片。

>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import quarter_wave_retarder
>>> theta= symbols("theta", real=True)
>>> QWP = quarter_wave_retarder(theta)
>>> pprint(QWP, use_unicode=True)
⎡                       -ⅈ⋅π            -ⅈ⋅π               ⎤
⎢                       ─────           ─────              ⎥
⎢⎛     2         2   ⎞    4               4                ⎥
⎢⎝ⅈ⋅sin (θ) + cos (θ)⎠⋅ℯ       (1 - ⅈ)⋅ℯ     ⋅sin(θ)⋅cos(θ)⎥
⎢                                                          ⎥
⎢         -ⅈ⋅π                                        -ⅈ⋅π ⎥
⎢         ─────                                       ─────⎥
⎢           4                  ⎛   2           2   ⎞    4  ⎥
⎣(1 - ⅈ)⋅ℯ     ⋅sin(θ)⋅cos(θ)  ⎝sin (θ) + ⅈ⋅cos (θ)⎠⋅ℯ     ⎦

sympy.physics.optics.polarization.reflective_filter(R)

具有反射率 R 的反射型濾波器 Jones 矩陣。

引數：

R：數值型別或 SymPy 符號

濾波器的反射率。

SymPy 矩陣

代表濾波器的 Jones 矩陣。

示例

通用濾波器。

>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import reflective_filter
>>> R = symbols("R", real=True)
>>> pprint(reflective_filter(R), use_unicode=True)
⎡√R   0 ⎤
⎢       ⎥
⎣0   -√R⎦

sympy.physics.optics.polarization.stokes_vector(psi, chi, p=1, I=1)

與極化橢圓的 Stokes 向量相對應，其傾斜為 psi，圓性為 chi。

引數：

psi：數值型別或 SymPy 符號

相對於 x 軸的極化傾斜。

chi：數值型別或 SymPy 符號

極化橢圓主軸相鄰的角度。

p：數值型別或 SymPy 符號

偏振度。

I：數值型別或 SymPy 符號

場的強度。

矩陣：

一個 Stokes 向量。

示例

波爾卡雷球上的軸。

>>> from sympy import pprint, symbols, pi
>>> from sympy.physics.optics.polarization import stokes_vector
>>> psi, chi, p, I = symbols("psi, chi, p, I", real=True)
>>> pprint(stokes_vector(psi, chi, p, I), use_unicode=True)
⎡          I          ⎤
⎢                     ⎥
⎢I⋅p⋅cos(2⋅χ)⋅cos(2⋅ψ)⎥
⎢                     ⎥
⎢I⋅p⋅sin(2⋅ψ)⋅cos(2⋅χ)⎥
⎢                     ⎥
⎣    I⋅p⋅sin(2⋅χ)     ⎦

水平極化

>>> pprint(stokes_vector(0, 0), use_unicode=True)
⎡1⎤
⎢ ⎥
⎢1⎥
⎢ ⎥
⎢0⎥
⎢ ⎥
⎣0⎦

垂直極化

>>> pprint(stokes_vector(pi/2, 0), use_unicode=True)
⎡1 ⎤
⎢  ⎥
⎢-1⎥
⎢  ⎥
⎢0 ⎥
⎢  ⎥
⎣0 ⎦

對角極化

>>> pprint(stokes_vector(pi/4, 0), use_unicode=True)
⎡1⎤
⎢ ⎥
⎢0⎥
⎢ ⎥
⎢1⎥
⎢ ⎥
⎣0⎦

反對角極化

>>> pprint(stokes_vector(-pi/4, 0), use_unicode=True)
⎡1 ⎤
⎢  ⎥
⎢0 ⎥
⎢  ⎥
⎢-1⎥
⎢  ⎥
⎣0 ⎦

右旋圓偏振

>>> pprint(stokes_vector(0, pi/4), use_unicode=True)
⎡1⎤
⎢ ⎥
⎢0⎥
⎢ ⎥
⎢0⎥
⎢ ⎥
⎣1⎦

左旋圓偏振

>>> pprint(stokes_vector(0, -pi/4), use_unicode=True)
⎡1 ⎤
⎢  ⎥
⎢0 ⎥
⎢  ⎥
⎢0 ⎥
⎢  ⎥
⎣-1⎦

非偏振光

>>> pprint(stokes_vector(0, 0, 0), use_unicode=True)
⎡1⎤
⎢ ⎥
⎢0⎥
⎢ ⎥
⎢0⎥
⎢ ⎥
⎣0⎦

sympy.physics.optics.polarization.transmissive_filter(T)

具有透射率 T 的衰減器 Jones 矩陣。

引數：

T：數值型別或 SymPy 符號

衰減器的透射率。

SymPy 矩陣

代表濾波器的 Jones 矩陣。

示例

通用濾波器。

>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import transmissive_filter
>>> T = symbols("T", real=True)
>>> NDF = transmissive_filter(T)
>>> pprint(NDF, use_unicode=True)
⎡√T  0 ⎤
⎢      ⎥
⎣0   √T⎦

實用工具

原文：docs.sympy.org/latest/modules/physics/optics/utils.html

包含

折射角
菲涅爾係數
偏差
布魯斯特角
臨界角
鏡片製造公式
鏡公式
鏡頭公式
超焦距
橫向放大率

sympy.physics.optics.utils.brewster_angle(medium1, medium2)

此函式計算入射到 Medium 1 到 Medium 2 的布魯斯特角（弧度）。

引數：

medium 1：Medium 或可合成物件

Medium 1 的折射率

medium 2：Medium 或可合成物件

Medium 1 的折射率

示例

>>> from sympy.physics.optics import brewster_angle
>>> brewster_angle(1, 1.33)
0.926093295503462

sympy.physics.optics.utils.critical_angle(medium1, medium2)

此函式計算入射到 Medium 1 到 Medium 2 的臨界入射角（標記總內反射開始）的角度（弧度）。

引數：

medium 1：Medium 或可合成物件

Medium 1 的折射率。

medium 2：Medium 或可合成物件

Medium 1 的折射率。

示例

>>> from sympy.physics.optics import critical_angle
>>> critical_angle(1.33, 1)
0.850908514477849

sympy.physics.optics.utils.deviation(incident, medium1, medium2, normal=None, plane=None)

此函式計算光線由於在平面表面的折射而產生的偏離角度。

引數：

incident：Matrix、Ray3D、序列或浮點數

入射向量或入射角

medium1：sympy.physics.optics.medium.Medium 或可合成物件

Medium 1 或其折射率

medium2：sympy.physics.optics.medium.Medium 或可合成物件

Medium 2 或其折射率

normal：Matrix、Ray3D 或序列

法線向量

平面：平面

兩個介質的分離面。

返回入射和折射光線之間的角度偏差

示例

>>> from sympy.physics.optics import deviation
>>> from sympy.geometry import Point3D, Ray3D, Plane
>>> from sympy.matrices import Matrix
>>> from sympy import symbols
>>> n1, n2 = symbols('n1, n2')
>>> n = Matrix([0, 0, 1])
>>> P = Plane(Point3D(0, 0, 0), normal_vector=[0, 0, 1])
>>> r1 = Ray3D(Point3D(-1, -1, 1), Point3D(0, 0, 0))
>>> deviation(r1, 1, 1, n)
0
>>> deviation(r1, n1, n2, plane=P)
-acos(-sqrt(-2*n1**2/(3*n2**2) + 1)) + acos(-sqrt(3)/3)
>>> round(deviation(0.1, 1.2, 1.5), 5)
-0.02005

sympy.physics.optics.utils.fresnel_coefficients(angle_of_incidence, medium1, medium2)

此函式使用菲涅爾方程計算反射和透射係數。當電場向量在入射平面內（標記為‘p’）時和當電場向量垂直於入射平面（標記為‘s’）時，分別獲得兩種極化的係數。除非入射光線完全內反射，否則有四個實係數和兩個復係數。入射角是入射光線與表面法線之間的角度。medium1 和 medium2 可以是 Medium 或任何可合成的物件。

引數：

入射角：sympifiable

medium1：Medium 或可合成物件

Medium 1 或其折射率

medium2：Medium 或可合成物件

Medium 2 或其折射率

返回一個包含四個實菲涅爾係數的列表：

[反射 p（TM），反射 s（TE），

透射 p（TM），透射 s（TE）]

如果光線經歷全內反射，則返回

兩個復菲涅爾係數的列表：

[反射 p（TM），反射 s（TE）]

示例

>>> from sympy.physics.optics import fresnel_coefficients
>>> fresnel_coefficients(0.3, 1, 2)
[0.317843553417859, -0.348645229818821,
 0.658921776708929, 0.651354770181179]
>>> fresnel_coefficients(0.6, 2, 1)
[-0.235625382192159 - 0.971843958291041*I,
 0.816477005968898 - 0.577377951366403*I]

參考文獻

[R747]

en.wikipedia.org/wiki/Fresnel_equations

sympy.physics.optics.utils.hyperfocal_distance(f, N, c)

引數：

f: sympifiable

給定鏡頭的焦距。

N: sympifiable

給定鏡頭的 F 數。

c: sympifiable

給定影像格式的焦點混淆圈（CoC）。

示例

>>> from sympy.physics.optics import hyperfocal_distance
>>> round(hyperfocal_distance(f = 0.5, N = 8, c = 0.0033), 2)
9.47

sympy.physics.optics.utils.lens_formula(focal_length=None, u=None, v=None)

此函式在提供兩個引數時，提供其中三個引數之一。僅適用於副軸光線。

引數：

focal_length：sympifiable

鏡的焦距。

u：可簡化

物體到主軸上光學中心的距離。

v：可簡化

影像到主軸上光學中心的距離。

示例

>>> from sympy.physics.optics import lens_formula
>>> from sympy.abc import f, u, v
>>> lens_formula(focal_length=f, u=u)
f*u/(f + u)
>>> lens_formula(focal_length=f, v=v)
f*v/(f - v)
>>> lens_formula(u=u, v=v)
u*v/(u - v)

sympy.physics.optics.utils.lens_makers_formula(n_lens, n_surr, r1, r2, d=0)

此函式計算透鏡的焦距。遵循笛卡爾符號約定。

引數：

n_lens：介質或可簡化

透鏡的折射率。

n_surr：介質或可簡化

周圍的反射率指數。

r1：可簡化

第一表面的曲率半徑。

r2：可簡化

第二表面的曲率半徑。

d：可簡化，可選

透鏡厚度，預設值為 0。

示例

>>> from sympy.physics.optics import lens_makers_formula
>>> from sympy import S
>>> lens_makers_formula(1.33, 1, 10, -10)
15.1515151515151
>>> lens_makers_formula(1.2, 1, 10, S.Infinity)
50.0000000000000
>>> lens_makers_formula(1.33, 1, 10, -10, d=1)
15.3418463277618

sympy.physics.optics.utils.mirror_formula(focal_length=None, u=None, v=None)

此函式在提供兩個引數時提供其中一個的引數。這僅對於平行光線有效。

引數：

focal_length：可簡化

鏡的焦距。

u：可簡化

物體到主軸極點的距離。

v：可簡化

影像到主軸極點的距離。

示例

>>> from sympy.physics.optics import mirror_formula
>>> from sympy.abc import f, u, v
>>> mirror_formula(focal_length=f, u=u)
f*u/(-f + u)
>>> mirror_formula(focal_length=f, v=v)
f*v/(-f + v)
>>> mirror_formula(u=u, v=v)
u*v/(u + v)

sympy.physics.optics.utils.refraction_angle(incident, medium1, medium2, normal=None, plane=None)

此函式計算平面表面折射後的傳輸向量。medium1和medium2可以是Medium或任何可簡化的物件。如果incident是一個數字，則視為入射角（弧度），在這種情況下返回折射角。

如果incident是(Ray3D)的物件，則為了得到(Ray3D)作為輸出，normal也必須是(Ray3D)的例項。請注意，如果未提供分離面而normal是(Ray3D)的例項，則假定normal與分離面處的入射光線相交。當normal是(Matrix)或其他序列時，情況並非如此。如果incident是(Ray3D)的例項且未提供plane且normal不是(Ray3D)，則輸出將為(Matrix)。

引數：

incident：矩陣、Ray3D、序列或數字

入射向量或入射角

medium1：sympy.physics.optics.medium.Medium 或可簡化

第一介質或其折射率

medium2：sympy.physics.optics.medium.Medium 或可簡化

第二介質或其折射率

normal：矩陣、Ray3D 或序列

法向量

plane：平面

兩種介質的分介面。

返回折射角或依據輸入返回折射光線。

示例

>>> from sympy.physics.optics import refraction_angle
>>> from sympy.geometry import Point3D, Ray3D, Plane
>>> from sympy.matrices import Matrix
>>> from sympy import symbols, pi
>>> n = Matrix([0, 0, 1])
>>> P = Plane(Point3D(0, 0, 0), normal_vector=[0, 0, 1])
>>> r1 = Ray3D(Point3D(-1, -1, 1), Point3D(0, 0, 0))
>>> refraction_angle(r1, 1, 1, n)
Matrix([
[ 1],
[ 1],
[-1]])
>>> refraction_angle(r1, 1, 1, plane=P)
Ray3D(Point3D(0, 0, 0), Point3D(1, 1, -1))

具有不同折射率的兩種介質

>>> n1, n2 = symbols('n1, n2')
>>> refraction_angle(r1, n1, n2, n)
Matrix([
[                                n1/n2],
[                                n1/n2],
[-sqrt(3)*sqrt(-2*n1**2/(3*n2**2) + 1)]])
>>> refraction_angle(r1, n1, n2, plane=P)
Ray3D(Point3D(0, 0, 0), Point3D(n1/n2, n1/n2, -sqrt(3)*sqrt(-2*n1**2/(3*n2**2) + 1)))
>>> round(refraction_angle(pi/6, 1.2, 1.5), 5)
0.41152

sympy.physics.optics.utils.transverse_magnification(si, so)

計算鏡面反射時的橫向放大倍數，即影像大小與物體大小的比率。

引數：

so: sympifiable

透鏡物距。

si: sympifiable

透鏡影像距離。

示例

>>> from sympy.physics.optics import transverse_magnification
>>> transverse_magnification(30, 15)
-2

波

原文：docs.sympy.org/latest/modules/physics/optics/waves.html

該模組包含所有與光學波相關的類和函式.

Contains

TWave

class sympy.physics.optics.waves.TWave(amplitude, frequency=None, phase=0, time_period=None, n=n)

這是一個簡單的橫向正弦波，在一維空間中傳播. 在物件建立時需要基本屬性，但可以使用提供的相應方法隨後更改.

引發:

ValueError : 當未提供頻率或時間週期時

或者它們不一致.

TypeError : 當新增的物件不是 TWave 物件時.

解釋

它表示為 (A \times cos(k*x - \omega \times t + \phi )), 其中 (A) 是振幅, (\omega) 是角頻率, (k) 是波數（空間頻率）, (x) 是表示波傳播的維度上的位置的空間變數, (\phi) 是波的相位角.

引數

amplitudeSympifyable

波的振幅.

frequencySympifyable

波的頻率.

phaseSympifyable

波的相位角.

time_periodSympifyable

波的時間週期.

nSympifyable

介質的折射率.

示例

>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A1, phi1, A2, phi2, f = symbols('A1, phi1, A2, phi2, f')
>>> w1 = TWave(A1, f, phi1)
>>> w2 = TWave(A2, f, phi2)
>>> w3 = w1 + w2  # Superposition of two waves
>>> w3
TWave(sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2) + A2**2), f,
 atan2(A1*sin(phi1) + A2*sin(phi2), A1*cos(phi1) + A2*cos(phi2)), 1/f, n)
>>> w3.amplitude
sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2) + A2**2)
>>> w3.phase
atan2(A1*sin(phi1) + A2*sin(phi2), A1*cos(phi1) + A2*cos(phi2))
>>> w3.speed
299792458*meter/(second*n)
>>> w3.angular_velocity
2*pi*f

property amplitude

返回波的振幅.

示例

>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.amplitude
A

property angular_velocity

返回波的角速度，單位為每秒弧度.

示例

>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.angular_velocity
2*pi*f

property frequency

返回波的頻率，單位為每秒週期數.

示例

>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.frequency
f

property n

返回介質的折射率

property phase

返回波的相位角，單位為弧度.

示例

>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.phase
phi

property speed

返回波的傳播速度，單位為每秒米. 它依賴於傳播介質.

示例

>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.speed
299792458*meter/(second*n)

property time_period

返回波的時間週期，單位為每週期秒.

示例

>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.time_period
1/f

property wavelength

返回波的波長（空間週期），單位為每週期米. 它取決於波的介質.

示例

>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.wavelength
299792458*meter/(second*f*n)

property wavenumber

返回波的波數，單位為每米的弧度.

示例

>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.wavenumber
pi*second*f*n/(149896229*meter)

控制模組

原文：docs.sympy.org/latest/modules/physics/control/index.html

控制

控制 API
控制系統圖表

控制

原文：docs.sympy.org/latest/modules/physics/control/control.html

目前，sympy.physics.control 能夠處理 LTI（線性、時不變）系統。TransferFunction 類用於表示拉普拉斯域中的連續時間傳遞函式；其中傳遞函式是動態系統的輸入到輸出表示。Parallel 類中用於傳遞函式的加法屬性，Series 類中用於傳遞函式的乘法屬性。此外，還有一個 Feedback 類，用於表示兩個輸入/輸出系統之間的負反饋互連。MIMO 系統也支援，使用 TransferFunctionMatrix 作為表示的基類。MIMOSeries、MIMOParallel 和 MIMOFeedback 是 Series、Parallel 和 Feedback 類的 MIMO 版本。

這個符號控制系統包的優勢在於，從中獲得的解決方案非常準確，並且不依賴於數值方法來近似解決方案。獲得的符號解決方案還以緊湊的形式存在，可用於進一步的分析。

控制 API

原文：docs.sympy.org/latest/modules/physics/control/lti.html

lti

class sympy.physics.control.lti.TransferFunction(num, den, var)

用於表示可以由拉普拉斯變換複數變數中的多項式比嚴格描述的 LTI（線性、時不變）系統的類。引數包括 num、den 和 var，其中 num 和 den 分別是傳遞函式的分子和分母多項式，第三個引數是這些傳遞函式中使用的拉普拉斯變換的複數變數。num 和 den 可以是多項式或數字，而 var 必須是一個Symbol。

引數：

num：表示式，數值

傳遞函式的分子多項式。

den：表示式，數值

傳遞函式的分母多項式。

var：符號

傳遞函式的拉普拉斯變換中使用的複數變數。

引發：

TypeError

當 var 不是符號或 num 或 den 不是數字或多項式時。

ValueError

當 den 為零時。

解釋

一般來說，表示物理模型的動態系統可以用線性常微分方程描述，如 -

(\small{b_{m}y^{{\left(m\right)}+b_{m-1}y}+\dots+b_{1}y^{\left(1\right)}+b_{0}y= a_{n}x^{{\left(n\right)}+a_{n-1}x}+\dots+a_{1}x^{\left(1\right)}+a_{0}x})

這裡，(x) 是輸入訊號，(y) 是輸出訊號，兩者上的上標表示導數的階數（不是指數）。導數是相對於自變數 (t) 求取的。一般情況下，(m) 大於 (n)。

在其原生形式下分析這類系統的屬性是不可行的，因此我們使用拉普拉斯變換等數學工具來獲得更好的視角。在方程兩邊（在零初值條件下）進行拉普拉斯變換，我們得到 -

(\small{\mathcal{L}[b_{m}y^{{\left(m\right)}+b_{m-1}y}+\dots+b_{1}y^{\left(1\right)}+b_{0}y]= \mathcal{L}[a_{n}x^{{\left(n\right)}+a_{n-1}x}+\dots+a_{1}x^{\left(1\right)}+a_{0}x]})

利用拉普拉斯變換的線性性質，並考慮零初值條件（即 (\small{y(0^{-}) = 0})，(\small{y'(0^{-}) = 0}) 等），上述方程可以轉化為 -

(\small{b_{m}\mathcal{L}[y^{{\left(m\right)}]+\dots+b_{1}\mathcal{L}[y}]+b_{0}\mathcal{L}[y]= a_{n}\mathcal{L}[x^{{\left(n\right)}]+\dots+a_{1}\mathcal{L}[x}]+a_{0}\mathcal{L}[x]})

現在，應用拉普拉斯變換的導數性質，

(\small{b_{m}s^{m}\mathcal{L}[y]+\dots+b_{1}s\mathcal{L}[y]+b_{0}\mathcal{L}[y]= a_{n}s^{n}\mathcal{L}[x]+\dots+a_{1}s\mathcal{L}[x]+a_{0}\mathcal{L}[x]})

在這裡，(s)上的上標是指數。請注意，上面提到的零初始條件假設非常重要，不能忽略，否則動態系統不能被視為時間獨立，並且無法達到上述簡化的方程。

從兩邊收集(\mathcal{L}[y])和(\mathcal{L}[x])項，並取比率(\frac{ \mathcal{L}\left{y\right} }{ \mathcal{L}\left{x\right} })，我們得到傳遞函式的典型有理形式。

傳遞函式的分子因此是輸出訊號（訊號表示為時間函式）的拉普拉斯變換，類似地，傳遞函式的分母是輸入訊號的拉普拉斯變換。如下所示，將輸入和輸出訊號的拉普拉斯變換用大寫字母表示也是一種約定。

(H(s) = \frac{Y(s)}{X(s)} = \frac{ \mathcal{L}\left{y(t)\right} }{ \mathcal{L}\left{x(t)\right} })

(s)，也稱為複頻率，在拉普拉斯域中是一個復變數。它對應於時間域中的等效變數(t)。傳遞函式有時也稱為系統衝激響應的拉普拉斯變換。傳遞函式(H)在(s)中表示為一個有理函式，如下所示，

(H(s) =\ \frac{a_{n}s^{n}+a_{n-1}s+\dots+a_{1}s+a_{0}}{b_{m}s^{m}+b_{m-1}s+\dots+b_{1}s+b_{0}})

示例

>>> from sympy.abc import s, p, a
>>> from sympy.physics.control.lti import TransferFunction
>>> tf1 = TransferFunction(s + a, s**2 + s + 1, s)
>>> tf1
TransferFunction(a + s, s**2 + s + 1, s)
>>> tf1.num
a + s
>>> tf1.den
s**2 + s + 1
>>> tf1.var
s
>>> tf1.args
(a + s, s**2 + s + 1, s)

任何復變數都可以用於var。

>>> tf2 = TransferFunction(a*p**3 - a*p**2 + s*p, p + a**2, p)
>>> tf2
TransferFunction(a*p**3 - a*p**2 + p*s, a**2 + p, p)
>>> tf3 = TransferFunction((p + 3)*(p - 1), (p - 1)*(p + 5), p)
>>> tf3
TransferFunction((p - 1)*(p + 3), (p - 1)*(p + 5), p)

要對傳遞函式取反，可以在其前面加上-運算子：

>>> tf4 = TransferFunction(-a + s, p**2 + s, p)
>>> -tf4
TransferFunction(a - s, p**2 + s, p)
>>> tf5 = TransferFunction(s**4 - 2*s**3 + 5*s + 4, s + 4, s)
>>> -tf5
TransferFunction(-s**4 + 2*s**3 - 5*s - 4, s + 4, s)

您可以使用浮點數或整數（或其他常數）作為分子和分母：

>>> tf6 = TransferFunction(1/2, 4, s)
>>> tf6.num
0.500000000000000
>>> tf6.den
4
>>> tf6.var
s
>>> tf6.args
(0.5, 4, s)

您可以使用**運算子對傳遞函式進行整數冪運算：

>>> tf7 = TransferFunction(s + a, s - a, s)
>>> tf7**3
TransferFunction((a + s)**3, (-a + s)**3, s)
>>> tf7**0
TransferFunction(1, 1, s)
>>> tf8 = TransferFunction(p + 4, p - 3, p)
>>> tf8**-1
TransferFunction(p - 3, p + 4, p)

傳遞函式的加法、減法和乘法可以形成未計算的Series或Parallel物件。

>>> tf9 = TransferFunction(s + 1, s**2 + s + 1, s)
>>> tf10 = TransferFunction(s - p, s + 3, s)
>>> tf11 = TransferFunction(4*s**2 + 2*s - 4, s - 1, s)
>>> tf12 = TransferFunction(1 - s, s**2 + 4, s)
>>> tf9 + tf10
Parallel(TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(-p + s, s + 3, s))
>>> tf10 - tf11
Parallel(TransferFunction(-p + s, s + 3, s), TransferFunction(-4*s**2 - 2*s + 4, s - 1, s))
>>> tf9 * tf10
Series(TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(-p + s, s + 3, s))
>>> tf10 - (tf9 + tf12)
Parallel(TransferFunction(-p + s, s + 3, s), TransferFunction(-s - 1, s**2 + s + 1, s), TransferFunction(s - 1, s**2 + 4, s))
>>> tf10 - (tf9 * tf12)
Parallel(TransferFunction(-p + s, s + 3, s), Series(TransferFunction(-1, 1, s), TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(1 - s, s**2 + 4, s)))
>>> tf11 * tf10 * tf9
Series(TransferFunction(4*s**2 + 2*s - 4, s - 1, s), TransferFunction(-p + s, s + 3, s), TransferFunction(s + 1, s**2 + s + 1, s))
>>> tf9 * tf11 + tf10 * tf12
Parallel(Series(TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(4*s**2 + 2*s - 4, s - 1, s)), Series(TransferFunction(-p + s, s + 3, s), TransferFunction(1 - s, s**2 + 4, s)))
>>> (tf9 + tf12) * (tf10 + tf11)
Series(Parallel(TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(1 - s, s**2 + 4, s)), Parallel(TransferFunction(-p + s, s + 3, s), TransferFunction(4*s**2 + 2*s - 4, s - 1, s)))

這些未計算的Series或Parallel物件可以透過.doit()方法或.rewrite(TransferFunction)轉換為最終的傳遞函式。

>>> ((tf9 + tf10) * tf12).doit()
TransferFunction((1 - s)*((-p + s)*(s**2 + s + 1) + (s + 1)*(s + 3)), (s + 3)*(s**2 + 4)*(s**2 + s + 1), s)
>>> (tf9 * tf10 - tf11 * tf12).rewrite(TransferFunction)
TransferFunction(-(1 - s)*(s + 3)*(s**2 + s + 1)*(4*s**2 + 2*s - 4) + (-p + s)*(s - 1)*(s + 1)*(s**2 + 4), (s - 1)*(s + 3)*(s**2 + 4)*(s**2 + s + 1), s)

另請參見

反饋, 串聯, 並聯

參考文獻

[R734]

zh.wikipedia.org/wiki/傳遞函式

[R735]

zh.wikipedia.org/wiki/拉普拉斯變換

dc_gain()

計算頻率接近零時響應的增益。

對於純積分器系統，直流增益是無窮大。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction
>>> tf1 = TransferFunction(s + 3, s**2 - 9, s)
>>> tf1.dc_gain()
-1/3
>>> tf2 = TransferFunction(p**2, p - 3 + p**3, p)
>>> tf2.dc_gain()
0
>>> tf3 = TransferFunction(a*p**2 - b, s + b, s)
>>> tf3.dc_gain()
(a*p**2 - b)/b
>>> tf4 = TransferFunction(1, s, s)
>>> tf4.dc_gain()
oo

property den

返回傳遞函式的分母多項式。

示例

>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction
>>> G1 = TransferFunction(s + 4, p**3 - 2*p + 4, s)
>>> G1.den
p**3 - 2*p + 4
>>> G2 = TransferFunction(3, 4, s)
>>> G2.den
4

eval_frequency(other)

返回在實數或複數平面上任意點的系統響應。

示例

>>> from sympy.abc import s, p, a
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy import I
>>> tf1 = TransferFunction(1, s**2 + 2*s + 1, s)
>>> omega = 0.1
>>> tf1.eval_frequency(I*omega)
1/(0.99 + 0.2*I)
>>> tf2 = TransferFunction(s**2, a*s + p, s)
>>> tf2.eval_frequency(2)
4/(2*a + p)
>>> tf2.eval_frequency(I*2)
-4/(2*I*a + p)

expand()

返回展開形式中分子和分母的傳遞函式。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction
>>> G1 = TransferFunction((a - s)**2, (s**2 + a)**2, s)
>>> G1.expand()
TransferFunction(a**2 - 2*a*s + s**2, a**2 + 2*a*s**2 + s**4, s)
>>> G2 = TransferFunction((p + 3*b)*(p - b), (p - b)*(p + 2*b), p)
>>> G2.expand()
TransferFunction(-3*b**2 + 2*b*p + p**2, -2*b**2 + b*p + p**2, p)

classmethod from_coeff_lists(num_list, den_list, var)

從係數列表高效地建立新的TransferFunction。

引數：

num_list : 序列

組成分子係數的序列。

den_list : 序列

組成分母系數的序列。

var : 符號

傳遞函式多項式使用的復變數拉普拉斯變換。

丟擲：

ZeroDivisionError

當構造的分母為零時。

示例

>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction
>>> num = [1, 0, 2]
>>> den = [3, 2, 2, 1]
>>> tf = TransferFunction.from_coeff_lists(num, den, s)
>>> tf
TransferFunction(s**2 + 2, 3*s**3 + 2*s**2 + 2*s + 1, s)

使用多個變數建立傳遞函式 >>> tf1 = TransferFunction.from_coeff_lists([p, 1], [2p, 0, 4], s) >>> tf1 TransferFunction(ps + 1, 2ps**2 + 4, s)

classmethod from_rational_expression(expr, var=None)

從有理表示式有效地建立新的 TransferFunction。

引數：

expr : 表示式，數值

表示 TransferFunction 的有理表示式。

var : 符號，可選

傳遞函式多項式使用的復變數拉普拉斯變換。

丟擲：

ValueError

當 expr 是 Number 型別且可選引數 var 未傳遞時。

當 expr 包含多個變數且可選引數 var 未傳遞時。

ZeroDivisionError

當 expr 的分母為零或其分子中包含 ComplexInfinity 時。

示例

>>> from sympy.abc import s, p, a
>>> from sympy.physics.control.lti import TransferFunction
>>> expr1 = (s + 5)/(3*s**2 + 2*s + 1)
>>> tf1 = TransferFunction.from_rational_expression(expr1)
>>> tf1
TransferFunction(s + 5, 3*s**2 + 2*s + 1, s)
>>> expr2 = (a*p**3 - a*p**2 + s*p)/(p + a**2)  # Expr with more than one variables
>>> tf2 = TransferFunction.from_rational_expression(expr2, p)
>>> tf2
TransferFunction(a*p**3 - a*p**2 + p*s, a**2 + p, p)

如果在表示式中存在兩個或多個變數的衝突，SymPy 將會丟擲 ValueError，如果使用者未傳遞 var。

>>> tf = TransferFunction.from_rational_expression((a + a*s)/(s**2 + s + 1))
Traceback (most recent call last):
...
ValueError: Conflicting values found for positional argument `var` ({a, s}). Specify it manually.

這可以透過手動指定 var 引數來糾正。

>>> tf = TransferFunction.from_rational_expression((a + a*s)/(s**2 + s + 1), s)
>>> tf
TransferFunction(a*s + a, s**2 + s + 1, s)

當 expr 是 Number 時，也需要指定 var。

>>> tf3 = TransferFunction.from_rational_expression(10, s)
>>> tf3
TransferFunction(10, 1, s)

classmethod from_zpk(zeros, poles, gain, var)

從給定的零點、極點和增益建立新的 TransferFunction。

引數：

zeros : 序列

組成傳遞函式的零點序列。

poles : 序列

傳遞函式的極點序列。

gain : 數值，符號，表示式

指定模型增益的標量值。

var : 符號

傳遞函式多項式使用的復變數拉普拉斯變換。

示例

>>> from sympy.abc import s, p, k
>>> from sympy.physics.control.lti import TransferFunction
>>> zeros = [1, 2, 3]
>>> poles = [6, 5, 4]
>>> gain = 7
>>> tf = TransferFunction.from_zpk(zeros, poles, gain, s)
>>> tf
TransferFunction(7*(s - 3)*(s - 2)*(s - 1), (s - 6)*(s - 5)*(s - 4), s)

使用變數極點和零點建立傳遞函式 >>> tf1 = TransferFunction.from_zpk([p, k], [p + k, p - k], 2, s) >>> tf1 TransferFunction(2(-k + s)(-p + s), (-k - p + s)*(k - p + s), s)

復極點或零點都是可以接受的 >>> tf2 = TransferFunction.from_zpk([0], [1-1j, 1+1j, 2], -2, s) >>> tf2 TransferFunction(-2s, (s - 2)(s - 1.0 - 1.0I)(s - 1.0 + 1.0*I), s)

property is_biproper

返回如果分子多項式的次數等於分母多項式的次數則為 True，否則為 False。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf1.is_biproper
True
>>> tf2 = TransferFunction(p**2, p + a, p)
>>> tf2.is_biproper
False

property is_proper

返回如果分子多項式的次數小於或等於分母多項式的次數則為 True，否則為 False。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction
>>> tf1 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s)
>>> tf1.is_proper
False
>>> tf2 = TransferFunction(p**2 - 4*p, p**3 + 3*p + 2, p)
>>> tf2.is_proper
True

is_stable()

返回如果傳遞函式是漸近穩定的則為 True，否則為 False。

這不會檢查系統的邊際或條件穩定性。

示例

>>> from sympy.abc import s, p, a
>>> from sympy import symbols
>>> from sympy.physics.control.lti import TransferFunction
>>> q, r = symbols('q, r', negative=True)
>>> tf1 = TransferFunction((1 - s)**2, (s + 1)**2, s)
>>> tf1.is_stable()
True
>>> tf2 = TransferFunction((1 - p)**2, (s**2 + 1)**2, s)
>>> tf2.is_stable()
False
>>> tf3 = TransferFunction(4, q*s - r, s)
>>> tf3.is_stable()
False
>>> tf4 = TransferFunction(p + 1, a*p - s**2, p)
>>> tf4.is_stable() is None   # Not enough info about the symbols to determine stability
True

property is_strictly_proper

返回如果分子多項式的次數嚴格小於分母多項式的次數則為 True，否則為 False。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf1.is_strictly_proper
False
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> tf2.is_strictly_proper
True

property num

返回傳遞函式的分子多項式。

示例

>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction
>>> G1 = TransferFunction(s**2 + p*s + 3, s - 4, s)
>>> G1.num
p*s + s**2 + 3
>>> G2 = TransferFunction((p + 5)*(p - 3), (p - 3)*(p + 1), p)
>>> G2.num
(p - 3)*(p + 5)

poles()

返回傳遞函式的極點。

示例

>>> from sympy.abc import s, p, a
>>> from sympy.physics.control.lti import TransferFunction
>>> tf1 = TransferFunction((p + 3)*(p - 1), (p - 1)*(p + 5), p)
>>> tf1.poles()
[-5, 1]
>>> tf2 = TransferFunction((1 - s)**2, (s**2 + 1)**2, s)
>>> tf2.poles()
[I, I, -I, -I]
>>> tf3 = TransferFunction(s**2, a*s + p, s)
>>> tf3.poles()
[-p/a]

to_expr()

將 TransferFunction 物件轉換為 SymPy 表示式。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy import Expr
>>> tf1 = TransferFunction(s, a*s**2 + 1, s)
>>> tf1.to_expr()
s/(a*s**2 + 1)
>>> isinstance(_, Expr)
True
>>> tf2 = TransferFunction(1, (p + 3*b)*(b - p), p)
>>> tf2.to_expr()
1/((b - p)*(3*b + p))
>>> tf3 = TransferFunction((s - 2)*(s - 3), (s - 1)*(s - 2)*(s - 3), s)
>>> tf3.to_expr()
((s - 3)*(s - 2))/(((s - 3)*(s - 2)*(s - 1)))

property var

返回傳遞函式多項式使用的復變數拉普拉斯變換。

示例

>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction
>>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p)
>>> G1.var
p
>>> G2 = TransferFunction(0, s - 5, s)
>>> G2.var
s

zeros()

返回傳遞函式的零點。

示例

>>> from sympy.abc import s, p, a
>>> from sympy.physics.control.lti import TransferFunction
>>> tf1 = TransferFunction((p + 3)*(p - 1), (p - 1)*(p + 5), p)
>>> tf1.zeros()
[-3, 1]
>>> tf2 = TransferFunction((1 - s)**2, (s**2 + 1)**2, s)
>>> tf2.zeros()
[1, 1]
>>> tf3 = TransferFunction(s**2, a*s + p, s)
>>> tf3.zeros()
[0, 0]

class sympy.physics.control.lti.Series(*args, evaluate=False)

用於表示串聯配置的 SISO 系統的類。

引數：

args : SISO 線性時不變

串聯配置的 SISO 系統。

評估 : 布林值，關鍵字

當傳遞 True 時，返回等效於 Series(*args).doit()。預設設定為 False。

引發：

數值錯誤

當沒有傳遞引數時。

var 屬性對每個系統不相同。

型別錯誤

任何傳遞的 *args 具有不支援的型別

傳遞了 SISO 和 MIMO 系統的組合。傳遞的系統型別應保持同質性，此處為 SISO。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Series, Parallel
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> tf3 = TransferFunction(p**2, p + s, s)
>>> S1 = Series(tf1, tf2)
>>> S1
Series(TransferFunction(a*p**2 + b*s, -p + s, s), TransferFunction(s**3 - 2, s**4 + 5*s + 6, s))
>>> S1.var
s
>>> S2 = Series(tf2, Parallel(tf3, -tf1))
>>> S2
Series(TransferFunction(s**3 - 2, s**4 + 5*s + 6, s), Parallel(TransferFunction(p**2, p + s, s), TransferFunction(-a*p**2 - b*s, -p + s, s)))
>>> S2.var
s
>>> S3 = Series(Parallel(tf1, tf2), Parallel(tf2, tf3))
>>> S3
Series(Parallel(TransferFunction(a*p**2 + b*s, -p + s, s), TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)), Parallel(TransferFunction(s**3 - 2, s**4 + 5*s + 6, s), TransferFunction(p**2, p + s, s)))
>>> S3.var
s

您可以透過使用 .doit() 方法獲得結果傳遞函式：

>>> S3 = Series(tf1, tf2, -tf3)
>>> S3.doit()
TransferFunction(-p**2*(s**3 - 2)*(a*p**2 + b*s), (-p + s)*(p + s)*(s**4 + 5*s + 6), s)
>>> S4 = Series(tf2, Parallel(tf1, -tf3))
>>> S4.doit()
TransferFunction((s**3 - 2)*(-p**2*(-p + s) + (p + s)*(a*p**2 + b*s)), (-p + s)*(p + s)*(s**4 + 5*s + 6), s)

注意

所有傳遞函式應使用拉普拉斯變換的同一復變數 var。

參見

MIMO 串聯, 並聯, 傳遞函式, 反饋

doit(**hints)

返回在串聯配置中評估傳遞函式後獲得的結果傳遞函式。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Series
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> Series(tf2, tf1).doit()
TransferFunction((s**3 - 2)*(a*p**2 + b*s), (-p + s)*(s**4 + 5*s + 6), s)
>>> Series(-tf1, -tf2).doit()
TransferFunction((2 - s**3)*(-a*p**2 - b*s), (-p + s)*(s**4 + 5*s + 6), s)

property is_biproper

如果結果傳遞函式的分子多項式的度數等於相同分母多項式的度數，則返回 True，否則返回 False。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Series
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(p, s**2, s)
>>> tf3 = TransferFunction(s**2, 1, s)
>>> S1 = Series(tf1, -tf2)
>>> S1.is_biproper
False
>>> S2 = Series(tf2, tf3)
>>> S2.is_biproper
True

property is_proper

如果結果傳遞函式的分子多項式的度數小於或等於相同分母多項式的度數，則返回 True，否則返回 False。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Series
>>> tf1 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s)
>>> tf2 = TransferFunction(p**2 - 4*p, p**3 + 3*s + 2, s)
>>> tf3 = TransferFunction(s, s**2 + s + 1, s)
>>> S1 = Series(-tf2, tf1)
>>> S1.is_proper
False
>>> S2 = Series(tf1, tf2, tf3)
>>> S2.is_proper
True

property is_strictly_proper

如果結果傳遞函式的分子多項式的度數嚴格小於相同分母多項式的度數，則返回 True，否則返回 False。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Series
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**2 + 5*s + 6, s)
>>> tf3 = TransferFunction(1, s**2 + s + 1, s)
>>> S1 = Series(tf1, tf2)
>>> S1.is_strictly_proper
False
>>> S2 = Series(tf1, tf2, tf3)
>>> S2.is_strictly_proper
True

to_expr()

返回等效於 Expr 物件。

property var

返回所有傳遞函式使用的復變數。

示例

>>> from sympy.abc import p
>>> from sympy.physics.control.lti import TransferFunction, Series, Parallel
>>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p)
>>> G2 = TransferFunction(p, 4 - p, p)
>>> G3 = TransferFunction(0, p**4 - 1, p)
>>> Series(G1, G2).var
p
>>> Series(-G3, Parallel(G1, G2)).var
p

class sympy.physics.control.lti.Parallel(*args, evaluate=False)

用於表示串聯配置的 SISO 系統的類。

引數：

args : SISO 線性時不變

並聯排列的 SISO 系統。

評估 : 布林值，關鍵字

當傳遞 True 時，返回等效於 Parallel(*args).doit()。預設設定為 False。

引發：

數值錯誤

當沒有傳遞引數時。

var 屬性對每個系統不相同。

型別錯誤

任何傳遞的 *args 具有不支援的型別

傳遞了 SISO 和 MIMO 系統的組合。傳遞的系統型別應保持同質性。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Parallel, Series
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> tf3 = TransferFunction(p**2, p + s, s)
>>> P1 = Parallel(tf1, tf2)
>>> P1
Parallel(TransferFunction(a*p**2 + b*s, -p + s, s), TransferFunction(s**3 - 2, s**4 + 5*s + 6, s))
>>> P1.var
s
>>> P2 = Parallel(tf2, Series(tf3, -tf1))
>>> P2
Parallel(TransferFunction(s**3 - 2, s**4 + 5*s + 6, s), Series(TransferFunction(p**2, p + s, s), TransferFunction(-a*p**2 - b*s, -p + s, s)))
>>> P2.var
s
>>> P3 = Parallel(Series(tf1, tf2), Series(tf2, tf3))
>>> P3
Parallel(Series(TransferFunction(a*p**2 + b*s, -p + s, s), TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)), Series(TransferFunction(s**3 - 2, s**4 + 5*s + 6, s), TransferFunction(p**2, p + s, s)))
>>> P3.var
s

您可以透過使用 .doit() 方法獲得結果傳遞函式：

>>> Parallel(tf1, tf2, -tf3).doit()
TransferFunction(-p**2*(-p + s)*(s**4 + 5*s + 6) + (-p + s)*(p + s)*(s**3 - 2) + (p + s)*(a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(p + s)*(s**4 + 5*s + 6), s)
>>> Parallel(tf2, Series(tf1, -tf3)).doit()
TransferFunction(-p**2*(a*p**2 + b*s)*(s**4 + 5*s + 6) + (-p + s)*(p + s)*(s**3 - 2), (-p + s)*(p + s)*(s**4 + 5*s + 6), s)

注意

所有傳遞函式應使用拉普拉斯變換的同一復變數 var。

參見

串聯, 傳遞函式, 反饋

doit(**hints)

返回在並聯配置中評估傳遞函式後獲得的結果傳遞函式。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Parallel
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> Parallel(tf2, tf1).doit()
TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s)
>>> Parallel(-tf1, -tf2).doit()
TransferFunction((2 - s**3)*(-p + s) + (-a*p**2 - b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s)

property is_biproper

如果結果傳遞函式的分子多項式的次數等於相同的分母多項式的次數，則返回 True，否則返回 False。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Parallel
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(p**2, p + s, s)
>>> tf3 = TransferFunction(s, s**2 + s + 1, s)
>>> P1 = Parallel(tf1, -tf2)
>>> P1.is_biproper
True
>>> P2 = Parallel(tf2, tf3)
>>> P2.is_biproper
False

property is_proper

如果結果傳遞函式的分子多項式的次數小於或等於相同的分母多項式的次數，則返回 True，否則返回 False。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Parallel
>>> tf1 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s)
>>> tf2 = TransferFunction(p**2 - 4*p, p**3 + 3*s + 2, s)
>>> tf3 = TransferFunction(s, s**2 + s + 1, s)
>>> P1 = Parallel(-tf2, tf1)
>>> P1.is_proper
False
>>> P2 = Parallel(tf2, tf3)
>>> P2.is_proper
True

property is_strictly_proper

如果結果傳遞函式的分子多項式的次數嚴格小於分母多項式的次數，則返回 True，否則返回 False。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Parallel
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> tf3 = TransferFunction(s, s**2 + s + 1, s)
>>> P1 = Parallel(tf1, tf2)
>>> P1.is_strictly_proper
False
>>> P2 = Parallel(tf2, tf3)
>>> P2.is_strictly_proper
True

to_expr()

返回等效的Expr物件。

property var

返回所有傳遞函式使用的複數變數。

示例

>>> from sympy.abc import p
>>> from sympy.physics.control.lti import TransferFunction, Parallel, Series
>>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p)
>>> G2 = TransferFunction(p, 4 - p, p)
>>> G3 = TransferFunction(0, p**4 - 1, p)
>>> Parallel(G1, G2).var
p
>>> Parallel(-G3, Series(G1, G2)).var
p

class sympy.physics.control.lti.Feedback(sys1, sys2=None, sign=-1)

一個用於表示兩個 SISO 輸入/輸出系統之間閉環反饋互連的類。

第一個引數sys1是閉環系統的前饋部分，或者簡單來說，是代表要控制的過程的動態模型。第二個引數sys2是反饋系統，並控制反饋訊號到sys1。sys1和sys2都可以是Series或TransferFunction物件。

引數：

sys1 : Series, TransferFunction

前饋路徑系統。

sys2 : Series, TransferFunction, optional

反饋路徑系統（通常是反饋控制器）。它是位於反饋路徑上的模型。

如果未明確指定，假設sys2為單位（1.0）傳遞函式。

sign : int, optional

反饋的符號。可以是1（正反饋）或-1（負反饋）。預設值為(-1)。

丟擲：

ValueError

當sys1和sys2沒有使用相同的拉普拉斯變換複數變數時。

當sys1和sys2的組合產生零分母時。

TypeError

當sys1或sys2不是Series或TransferFunction物件時。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, Feedback
>>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s)
>>> controller = TransferFunction(5*s - 10, s + 7, s)
>>> F1 = Feedback(plant, controller)
>>> F1
Feedback(TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s), TransferFunction(5*s - 10, s + 7, s), -1)
>>> F1.var
s
>>> F1.args
(TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s), TransferFunction(5*s - 10, s + 7, s), -1)

你可以分別使用.sys1和.sys2獲取前饋和反饋路徑系統。

>>> F1.sys1
TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s)
>>> F1.sys2
TransferFunction(5*s - 10, s + 7, s)

透過使用.doit()方法，你可以獲得透過負反饋互連得到的結果閉環傳遞函式。

>>> F1.doit()
TransferFunction((s + 7)*(s**2 - 4*s + 2)*(3*s**2 + 7*s - 3), ((s + 7)*(s**2 - 4*s + 2) + (5*s - 10)*(3*s**2 + 7*s - 3))*(s**2 - 4*s + 2), s)
>>> G = TransferFunction(2*s**2 + 5*s + 1, s**2 + 2*s + 3, s)
>>> C = TransferFunction(5*s + 10, s + 10, s)
>>> F2 = Feedback(G*C, TransferFunction(1, 1, s))
>>> F2.doit()
TransferFunction((s + 10)*(5*s + 10)*(s**2 + 2*s + 3)*(2*s**2 + 5*s + 1), (s + 10)*((s + 10)*(s**2 + 2*s + 3) + (5*s + 10)*(2*s**2 + 5*s + 1))*(s**2 + 2*s + 3), s)

要否定Feedback物件，可以新增-運算子：

>>> -F1
Feedback(TransferFunction(-3*s**2 - 7*s + 3, s**2 - 4*s + 2, s), TransferFunction(10 - 5*s, s + 7, s), -1)
>>> -F2
Feedback(Series(TransferFunction(-1, 1, s), TransferFunction(2*s**2 + 5*s + 1, s**2 + 2*s + 3, s), TransferFunction(5*s + 10, s + 10, s)), TransferFunction(-1, 1, s), -1)

另見

MIMOFeedback, Series, Parallel

property den

返回閉環反饋模型的分母。

doit(cancel=False, expand=False, **hints)

返回透過反饋互連得到的結果傳遞函式。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, Feedback
>>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s)
>>> controller = TransferFunction(5*s - 10, s + 7, s)
>>> F1 = Feedback(plant, controller)
>>> F1.doit()
TransferFunction((s + 7)*(s**2 - 4*s + 2)*(3*s**2 + 7*s - 3), ((s + 7)*(s**2 - 4*s + 2) + (5*s - 10)*(3*s**2 + 7*s - 3))*(s**2 - 4*s + 2), s)
>>> G = TransferFunction(2*s**2 + 5*s + 1, s**2 + 2*s + 3, s)
>>> F2 = Feedback(G, TransferFunction(1, 1, s))
>>> F2.doit()
TransferFunction((s**2 + 2*s + 3)*(2*s**2 + 5*s + 1), (s**2 + 2*s + 3)*(3*s**2 + 7*s + 4), s)

使用關鍵字引數expand=True來展開結果傳遞函式。使用cancel=True來取消分子和分母中的公共項。

>>> F2.doit(cancel=True, expand=True)
TransferFunction(2*s**2 + 5*s + 1, 3*s**2 + 7*s + 4, s)
>>> F2.doit(expand=True)
TransferFunction(2*s**4 + 9*s**3 + 17*s**2 + 17*s + 3, 3*s**4 + 13*s**3 + 27*s**2 + 29*s + 12, s)

property num

返回閉環反饋系統的分子。

property sensitivity

返回反饋環路的靈敏度函式。

反饋系統的敏感性是開環增益變化與閉環增益變化的比率。

注意

此方法不會返回互補的敏感性函式。

例子

>>> from sympy.abc import p
>>> from sympy.physics.control.lti import TransferFunction, Feedback
>>> C = TransferFunction(5*p + 10, p + 10, p)
>>> P = TransferFunction(1 - p, p + 2, p)
>>> F_1 = Feedback(P, C)
>>> F_1.sensitivity
1/((1 - p)*(5*p + 10)/((p + 2)*(p + 10)) + 1)

property sign

返回 MIMO 反饋模型的型別。 1表示正反饋，-1表示負反饋。

property sys1

返回反饋互聯的前饋系統。

例子

>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction, Feedback
>>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s)
>>> controller = TransferFunction(5*s - 10, s + 7, s)
>>> F1 = Feedback(plant, controller)
>>> F1.sys1
TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s)
>>> G = TransferFunction(2*s**2 + 5*s + 1, p**2 + 2*p + 3, p)
>>> C = TransferFunction(5*p + 10, p + 10, p)
>>> P = TransferFunction(1 - s, p + 2, p)
>>> F2 = Feedback(TransferFunction(1, 1, p), G*C*P)
>>> F2.sys1
TransferFunction(1, 1, p)

property sys2

返回反饋互聯的反饋控制器。

例子

>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction, Feedback
>>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s)
>>> controller = TransferFunction(5*s - 10, s + 7, s)
>>> F1 = Feedback(plant, controller)
>>> F1.sys2
TransferFunction(5*s - 10, s + 7, s)
>>> G = TransferFunction(2*s**2 + 5*s + 1, p**2 + 2*p + 3, p)
>>> C = TransferFunction(5*p + 10, p + 10, p)
>>> P = TransferFunction(1 - s, p + 2, p)
>>> F2 = Feedback(TransferFunction(1, 1, p), G*C*P)
>>> F2.sys2
Series(TransferFunction(2*s**2 + 5*s + 1, p**2 + 2*p + 3, p), TransferFunction(5*p + 10, p + 10, p), TransferFunction(1 - s, p + 2, p))

to_expr()

將Feedback物件轉換為 SymPy 表示式。

例子

>>> from sympy.abc import s, a, b
>>> from sympy.physics.control.lti import TransferFunction, Feedback
>>> from sympy import Expr
>>> tf1 = TransferFunction(a+s, 1, s)
>>> tf2 = TransferFunction(b+s, 1, s)
>>> fd1 = Feedback(tf1, tf2)
>>> fd1.to_expr()
(a + s)/((a + s)*(b + s) + 1)
>>> isinstance(_, Expr)
True

property var

返回在反饋互聯中涉及的所有傳遞函式使用的拉普拉斯變換的復變數。

例子

>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction, Feedback
>>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s)
>>> controller = TransferFunction(5*s - 10, s + 7, s)
>>> F1 = Feedback(plant, controller)
>>> F1.var
s
>>> G = TransferFunction(2*s**2 + 5*s + 1, p**2 + 2*p + 3, p)
>>> C = TransferFunction(5*p + 10, p + 10, p)
>>> P = TransferFunction(1 - s, p + 2, p)
>>> F2 = Feedback(TransferFunction(1, 1, p), G*C*P)
>>> F2.var
p

class sympy.physics.control.lti.TransferFunctionMatrix(arg)

用於表示 SISO（單輸入單輸出）傳遞函式的 MIMO（多輸入多輸出）概括的類。

它是傳遞函式矩陣（TransferFunction，SISO-Series或 SISO-Parallel）的矩陣。只有一個引數，arg也是強制性引數。期望arg嚴格為列表列表型別，其中包含傳遞函式或可化簡為傳遞函式。

引數：

arg：巢狀的List（嚴格）。

使用者預期輸入TransferFunction，Series和/或Parallel物件的巢狀列表。

例子

注意

pprint()可用於更好地視覺化TransferFunctionMatrix物件。

>>> from sympy.abc import s, p, a
>>> from sympy import pprint
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, Series, Parallel
>>> tf_1 = TransferFunction(s + a, s**2 + s + 1, s)
>>> tf_2 = TransferFunction(p**4 - 3*p + 2, s + p, s)
>>> tf_3 = TransferFunction(3, s + 2, s)
>>> tf_4 = TransferFunction(-a + p, 9*s - 9, s)
>>> tfm_1 = TransferFunctionMatrix([[tf_1], [tf_2], [tf_3]])
>>> tfm_1
TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(3, s + 2, s),)))
>>> tfm_1.var
s
>>> tfm_1.num_inputs
1
>>> tfm_1.num_outputs
3
>>> tfm_1.shape
(3, 1)
>>> tfm_1.args
(((TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(3, s + 2, s),)),)
>>> tfm_2 = TransferFunctionMatrix([[tf_1, -tf_3], [tf_2, -tf_1], [tf_3, -tf_2]])
>>> tfm_2
TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s), TransferFunction(-3, s + 2, s)), (TransferFunction(p**4 - 3*p + 2, p + s, s), TransferFunction(-a - s, s**2 + s + 1, s)), (TransferFunction(3, s + 2, s), TransferFunction(-p**4 + 3*p - 2, p + s, s))))
>>> pprint(tfm_2, use_unicode=False)  # pretty-printing for better visualization
[   a + s           -3       ]
[ ----------       -----     ]
[  2               s + 2     ]
[ s  + s + 1                 ]
[                            ]
[ 4                          ]
[p  - 3*p + 2      -a - s    ]
[------------    ----------  ]
[   p + s         2          ]
[                s  + s + 1  ]
[                            ]
[                 4          ]
[     3        - p  + 3*p - 2]
[   -----      --------------]
[   s + 2          p + s     ]{t}

如果使用者希望切換輸入和輸出傳遞函式，可以對TransferFunctionMatrix進行轉置。

>>> tfm_2.transpose()
TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s), TransferFunction(p**4 - 3*p + 2, p + s, s), TransferFunction(3, s + 2, s)), (TransferFunction(-3, s + 2, s), TransferFunction(-a - s, s**2 + s + 1, s), TransferFunction(-p**4 + 3*p - 2, p + s, s))))
>>> pprint(_, use_unicode=False)
[             4                          ]
[  a + s     p  - 3*p + 2        3       ]
[----------  ------------      -----     ]
[ 2             p + s          s + 2     ]
[s  + s + 1                              ]
[                                        ]
[                             4          ]
[   -3          -a - s     - p  + 3*p - 2]
[  -----      ----------   --------------]
[  s + 2       2               p + s     ]
[             s  + s + 1                 ]{t}

>>> tf_5 = TransferFunction(5, s, s)
>>> tf_6 = TransferFunction(5*s, (2 + s**2), s)
>>> tf_7 = TransferFunction(5, (s*(2 + s**2)), s)
>>> tf_8 = TransferFunction(5, 1, s)
>>> tfm_3 = TransferFunctionMatrix([[tf_5, tf_6], [tf_7, tf_8]])
>>> tfm_3
TransferFunctionMatrix(((TransferFunction(5, s, s), TransferFunction(5*s, s**2 + 2, s)), (TransferFunction(5, s*(s**2 + 2), s), TransferFunction(5, 1, s))))
>>> pprint(tfm_3, use_unicode=False)
[    5        5*s  ]
[    -       ------]
[    s        2    ]
[            s  + 2]
[                  ]
[    5         5   ]
[----------    -   ]
[  / 2    \    1   ]
[s*\s  + 2/        ]{t}
>>> tfm_3.var
s
>>> tfm_3.shape
(2, 2)
>>> tfm_3.num_outputs
2
>>> tfm_3.num_inputs
2
>>> tfm_3.args
(((TransferFunction(5, s, s), TransferFunction(5*s, s**2 + 2, s)), (TransferFunction(5, s*(s**2 + 2), s), TransferFunction(5, 1, s))),)

要訪問TransferFunctionMatrix中任何索引處的TransferFunction，請使用索引表示法。

>>> tfm_3[1, 0]  # gives the TransferFunction present at 2nd Row and 1st Col. Similar to that in Matrix classes
TransferFunction(5, s*(s**2 + 2), s)
>>> tfm_3[0, 0]  # gives the TransferFunction present at 1st Row and 1st Col.
TransferFunction(5, s, s)
>>> tfm_3[:, 0]  # gives the first column
TransferFunctionMatrix(((TransferFunction(5, s, s),), (TransferFunction(5, s*(s**2 + 2), s),)))
>>> pprint(_, use_unicode=False)
[    5     ]
[    -     ]
[    s     ]
[          ]
[    5     ]
[----------]
[  / 2    \]
[s*\s  + 2/]{t}
>>> tfm_3[0, :]  # gives the first row
TransferFunctionMatrix(((TransferFunction(5, s, s), TransferFunction(5*s, s**2 + 2, s)),))
>>> pprint(_, use_unicode=False)
[5   5*s  ]
[-  ------]
[s   2    ]
[   s  + 2]{t}

要對傳遞函式矩陣取反，可以在其前面加上-運算子：

>>> tfm_4 = TransferFunctionMatrix([[tf_2], [-tf_1], [tf_3]])
>>> -tfm_4
TransferFunctionMatrix(((TransferFunction(-p**4 + 3*p - 2, p + s, s),), (TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(-3, s + 2, s),)))
>>> tfm_5 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, -tf_1]])
>>> -tfm_5
TransferFunctionMatrix(((TransferFunction(-a - s, s**2 + s + 1, s), TransferFunction(-p**4 + 3*p - 2, p + s, s)), (TransferFunction(-3, s + 2, s), TransferFunction(a + s, s**2 + s + 1, s))))

subs()返回替換為表示式中的值的TransferFunctionMatrix物件。這不會改變您的原始TransferFunctionMatrix。

>>> tfm_2.subs(p, 2)  #  substituting p everywhere in tfm_2 with 2.
TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s), TransferFunction(-3, s + 2, s)), (TransferFunction(12, s + 2, s), TransferFunction(-a - s, s**2 + s + 1, s)), (TransferFunction(3, s + 2, s), TransferFunction(-12, s + 2, s))))
>>> pprint(_, use_unicode=False)
[  a + s        -3     ]
[----------    -----   ]
[ 2            s + 2   ]
[s  + s + 1            ]
[                      ]
[    12        -a - s  ]
[  -----     ----------]
[  s + 2      2        ]
[            s  + s + 1]
[                      ]
[    3          -12    ]
[  -----       -----   ]
[  s + 2       s + 2   ]{t}
>>> pprint(tfm_2, use_unicode=False) # State of tfm_2 is unchanged after substitution
[   a + s           -3       ]
[ ----------       -----     ]
[  2               s + 2     ]
[ s  + s + 1                 ]
[                            ]
[ 4                          ]
[p  - 3*p + 2      -a - s    ]
[------------    ----------  ]
[   p + s         2          ]
[                s  + s + 1  ]
[                            ]
[                 4          ]
[     3        - p  + 3*p - 2]
[   -----      --------------]
[   s + 2          p + s     ]{t}

subs()還支援多個替換。

>>> tfm_2.subs({p: 2, a: 1})  # substituting p with 2 and a with 1
TransferFunctionMatrix(((TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(-3, s + 2, s)), (TransferFunction(12, s + 2, s), TransferFunction(-s - 1, s**2 + s + 1, s)), (TransferFunction(3, s + 2, s), TransferFunction(-12, s + 2, s))))
>>> pprint(_, use_unicode=False)
[  s + 1        -3     ]
[----------    -----   ]
[ 2            s + 2   ]
[s  + s + 1            ]
[                      ]
[    12        -s - 1  ]
[  -----     ----------]
[  s + 2      2        ]
[            s  + s + 1]
[                      ]
[    3          -12    ]
[  -----       -----   ]
[  s + 2       s + 2   ]{t}

使用者可以透過使用doit()將矩陣的Series和Parallel元素減少為TransferFunction。

>>> tfm_6 = TransferFunctionMatrix([[Series(tf_3, tf_4), Parallel(tf_3, tf_4)]])
>>> tfm_6
TransferFunctionMatrix(((Series(TransferFunction(3, s + 2, s), TransferFunction(-a + p, 9*s - 9, s)), Parallel(TransferFunction(3, s + 2, s), TransferFunction(-a + p, 9*s - 9, s))),))
>>> pprint(tfm_6, use_unicode=False)
[-a + p    3    -a + p      3  ]
[-------*-----  ------- + -----]
[9*s - 9 s + 2  9*s - 9   s + 2]{t}
>>> tfm_6.doit()
TransferFunctionMatrix(((TransferFunction(-3*a + 3*p, (s + 2)*(9*s - 9), s), TransferFunction(27*s + (-a + p)*(s + 2) - 27, (s + 2)*(9*s - 9), s)),))
>>> pprint(_, use_unicode=False)
[    -3*a + 3*p     27*s + (-a + p)*(s + 2) - 27]
[-----------------  ----------------------------]
[(s + 2)*(9*s - 9)       (s + 2)*(9*s - 9)      ]{t}
>>> tf_9 = TransferFunction(1, s, s)
>>> tf_10 = TransferFunction(1, s**2, s)
>>> tfm_7 = TransferFunctionMatrix([[Series(tf_9, tf_10), tf_9], [tf_10, Parallel(tf_9, tf_10)]])
>>> tfm_7
TransferFunctionMatrix(((Series(TransferFunction(1, s, s), TransferFunction(1, s**2, s)), TransferFunction(1, s, s)), (TransferFunction(1, s**2, s), Parallel(TransferFunction(1, s, s), TransferFunction(1, s**2, s)))))
>>> pprint(tfm_7, use_unicode=False)
[ 1      1   ]
[----    -   ]
[   2    s   ]
[s*s         ]
[            ]
[ 1    1    1]
[ --   -- + -]
[  2    2   s]
[ s    s     ]{t}
>>> tfm_7.doit()
TransferFunctionMatrix(((TransferFunction(1, s**3, s), TransferFunction(1, s, s)), (TransferFunction(1, s**2, s), TransferFunction(s**2 + s, s**3, s))))
>>> pprint(_, use_unicode=False)
[1     1   ]
[--    -   ]
[ 3    s   ]
[s         ]
[          ]
[     2    ]
[1   s  + s]
[--  ------]
[ 2     3  ]
[s     s   ]{t}

傳遞函式矩陣的加法、減法和乘法可以形成未評估的Series或Parallel物件。

對於加法和減法：所有傳遞函式矩陣必須具有相同的形狀。
對於乘法（C = A * B）：第一個傳遞函式矩陣（A）的輸入數量必須等於第二個傳遞函式矩陣（B）的輸出數量。

還有，使用漂亮列印（pprint）來進行更好的分析。

>>> tfm_8 = TransferFunctionMatrix([[tf_3], [tf_2], [-tf_1]])
>>> tfm_9 = TransferFunctionMatrix([[-tf_3]])
>>> tfm_10 = TransferFunctionMatrix([[tf_1], [tf_2], [tf_4]])
>>> tfm_11 = TransferFunctionMatrix([[tf_4], [-tf_1]])
>>> tfm_12 = TransferFunctionMatrix([[tf_4, -tf_1, tf_3], [-tf_2, -tf_4, -tf_3]])
>>> tfm_8 + tfm_10
MIMOParallel(TransferFunctionMatrix(((TransferFunction(3, s + 2, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a - s, s**2 + s + 1, s),))), TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a + p, 9*s - 9, s),))))
>>> pprint(_, use_unicode=False)
[     3      ]      [   a + s    ]
[   -----    ]      [ ---------- ]
[   s + 2    ]      [  2         ]
[            ]      [ s  + s + 1 ]
[ 4          ]      [            ]
[p  - 3*p + 2]      [ 4          ]
[------------]    + [p  - 3*p + 2]
[   p + s    ]      [------------]
[            ]      [   p + s    ]
[   -a - s   ]      [            ]
[ ---------- ]      [   -a + p   ]
[  2         ]      [  -------   ]
[ s  + s + 1 ]{t}   [  9*s - 9   ]{t}
>>> -tfm_10 - tfm_8
MIMOParallel(TransferFunctionMatrix(((TransferFunction(-a - s, s**2 + s + 1, s),), (TransferFunction(-p**4 + 3*p - 2, p + s, s),), (TransferFunction(a - p, 9*s - 9, s),))), TransferFunctionMatrix(((TransferFunction(-3, s + 2, s),), (TransferFunction(-p**4 + 3*p - 2, p + s, s),), (TransferFunction(a + s, s**2 + s + 1, s),))))
>>> pprint(_, use_unicode=False)
[    -a - s    ]      [     -3       ]
[  ----------  ]      [    -----     ]
[   2          ]      [    s + 2     ]
[  s  + s + 1  ]      [              ]
[              ]      [   4          ]
[   4          ]      [- p  + 3*p - 2]
[- p  + 3*p - 2]    + [--------------]
[--------------]      [    p + s     ]
[    p + s     ]      [              ]
[              ]      [    a + s     ]
[    a - p     ]      [  ----------  ]
[   -------    ]      [   2          ]
[   9*s - 9    ]{t}   [  s  + s + 1  ]{t}
>>> tfm_12 * tfm_8
MIMOSeries(TransferFunctionMatrix(((TransferFunction(3, s + 2, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a - s, s**2 + s + 1, s),))), TransferFunctionMatrix(((TransferFunction(-a + p, 9*s - 9, s), TransferFunction(-a - s, s**2 + s + 1, s), TransferFunction(3, s + 2, s)), (TransferFunction(-p**4 + 3*p - 2, p + s, s), TransferFunction(a - p, 9*s - 9, s), TransferFunction(-3, s + 2, s)))))
>>> pprint(_, use_unicode=False)
 [     3      ]
 [   -----    ]
[    -a + p        -a - s      3  ]    [   s + 2    ]
[   -------      ----------  -----]    [            ]
[   9*s - 9       2          s + 2]    [ 4          ]
[                s  + s + 1       ]    [p  - 3*p + 2]
[                                 ]   *[------------]
[   4                             ]    [   p + s    ]
[- p  + 3*p - 2    a - p      -3  ]    [            ]
[--------------   -------    -----]    [   -a - s   ]
[    p + s        9*s - 9    s + 2]{t} [ ---------- ]
 [  2         ]
 [ s  + s + 1 ]{t}
>>> tfm_12 * tfm_8 * tfm_9
MIMOSeries(TransferFunctionMatrix(((TransferFunction(-3, s + 2, s),),)), TransferFunctionMatrix(((TransferFunction(3, s + 2, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a - s, s**2 + s + 1, s),))), TransferFunctionMatrix(((TransferFunction(-a + p, 9*s - 9, s), TransferFunction(-a - s, s**2 + s + 1, s), TransferFunction(3, s + 2, s)), (TransferFunction(-p**4 + 3*p - 2, p + s, s), TransferFunction(a - p, 9*s - 9, s), TransferFunction(-3, s + 2, s)))))
>>> pprint(_, use_unicode=False)
 [     3      ]
 [   -----    ]
[    -a + p        -a - s      3  ]    [   s + 2    ]
[   -------      ----------  -----]    [            ]
[   9*s - 9       2          s + 2]    [ 4          ]
[                s  + s + 1       ]    [p  - 3*p + 2]    [ -3  ]
[                                 ]   *[------------]   *[-----]
[   4                             ]    [   p + s    ]    [s + 2]{t}
[- p  + 3*p - 2    a - p      -3  ]    [            ]
[--------------   -------    -----]    [   -a - s   ]
[    p + s        9*s - 9    s + 2]{t} [ ---------- ]
 [  2         ]
 [ s  + s + 1 ]{t}
>>> tfm_10 + tfm_8*tfm_9
MIMOParallel(TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a + p, 9*s - 9, s),))), MIMOSeries(TransferFunctionMatrix(((TransferFunction(-3, s + 2, s),),)), TransferFunctionMatrix(((TransferFunction(3, s + 2, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a - s, s**2 + s + 1, s),)))))
>>> pprint(_, use_unicode=False)
[   a + s    ]      [     3      ]
[ ---------- ]      [   -----    ]
[  2         ]      [   s + 2    ]
[ s  + s + 1 ]      [            ]
[            ]      [ 4          ]
[ 4          ]      [p  - 3*p + 2]    [ -3  ]
[p  - 3*p + 2]    + [------------]   *[-----]
[------------]      [   p + s    ]    [s + 2]{t}
[   p + s    ]      [            ]
[            ]      [   -a - s   ]
[   -a + p   ]      [ ---------- ]
[  -------   ]      [  2         ]
[  9*s - 9   ]{t}   [ s  + s + 1 ]{t}

這些未評估的Series或Parallel物件可以透過.doit()方法或.rewrite(TransferFunctionMatrix)轉換為結果傳遞函式矩陣。

>>> (-tfm_8 + tfm_10 + tfm_8*tfm_9).doit()
TransferFunctionMatrix(((TransferFunction((a + s)*(s + 2)**3 - 3*(s + 2)**2*(s**2 + s + 1) - 9*(s + 2)*(s**2 + s + 1), (s + 2)**3*(s**2 + s + 1), s),), (TransferFunction((p + s)*(-3*p**4 + 9*p - 6), (p + s)**2*(s + 2), s),), (TransferFunction((-a + p)*(s + 2)*(s**2 + s + 1)**2 + (a + s)*(s + 2)*(9*s - 9)*(s**2 + s + 1) + (3*a + 3*s)*(9*s - 9)*(s**2 + s + 1), (s + 2)*(9*s - 9)*(s**2 + s + 1)**2, s),)))
>>> (-tfm_12 * -tfm_8 * -tfm_9).rewrite(TransferFunctionMatrix)
TransferFunctionMatrix(((TransferFunction(3*(-3*a + 3*p)*(p + s)*(s + 2)*(s**2 + s + 1)**2 + 3*(-3*a - 3*s)*(p + s)*(s + 2)*(9*s - 9)*(s**2 + s + 1) + 3*(a + s)*(s + 2)**2*(9*s - 9)*(-p**4 + 3*p - 2)*(s**2 + s + 1), (p + s)*(s + 2)**3*(9*s - 9)*(s**2 + s + 1)**2, s),), (TransferFunction(3*(-a + p)*(p + s)*(s + 2)**2*(-p**4 + 3*p - 2)*(s**2 + s + 1) + 3*(3*a + 3*s)*(p + s)**2*(s + 2)*(9*s - 9) + 3*(p + s)*(s + 2)*(9*s - 9)*(-3*p**4 + 9*p - 6)*(s**2 + s + 1), (p + s)**2*(s + 2)**3*(9*s - 9)*(s**2 + s + 1), s),)))

另請參見

TransferFunction，MIMOSeries，MIMOParallel，Feedback

elem_poles()

返回每個TransferFunctionMatrix元素的極點。

注意

MIMO 系統的實際極點不是各個元素的極點。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix
>>> tf_1 = TransferFunction(3, (s + 1), s)
>>> tf_2 = TransferFunction(s + 6, (s + 1)*(s + 2), s)
>>> tf_3 = TransferFunction(s + 3, s**2 + 3*s + 2, s)
>>> tf_4 = TransferFunction(s + 2, s**2 + 5*s - 10, s)
>>> tfm_1 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, tf_4]])
>>> tfm_1
TransferFunctionMatrix(((TransferFunction(3, s + 1, s), TransferFunction(s + 6, (s + 1)*(s + 2), s)), (TransferFunction(s + 3, s**2 + 3*s + 2, s), TransferFunction(s + 2, s**2 + 5*s - 10, s))))
>>> tfm_1.elem_poles()
[[[-1], [-2, -1]], [[-2, -1], [-5/2 + sqrt(65)/2, -sqrt(65)/2 - 5/2]]]

參見

elem_zeros

elem_zeros()

返回TransferFunctionMatrix的每個元素的零點。

注意

MIMO 系統的實際零點不是各個元素的零點。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix
>>> tf_1 = TransferFunction(3, (s + 1), s)
>>> tf_2 = TransferFunction(s + 6, (s + 1)*(s + 2), s)
>>> tf_3 = TransferFunction(s + 3, s**2 + 3*s + 2, s)
>>> tf_4 = TransferFunction(s**2 - 9*s + 20, s**2 + 5*s - 10, s)
>>> tfm_1 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, tf_4]])
>>> tfm_1
TransferFunctionMatrix(((TransferFunction(3, s + 1, s), TransferFunction(s + 6, (s + 1)*(s + 2), s)), (TransferFunction(s + 3, s**2 + 3*s + 2, s), TransferFunction(s**2 - 9*s + 20, s**2 + 5*s - 10, s))))
>>> tfm_1.elem_zeros()
[[[], [-6]], [[-3], [4, 5]]]

參見

elem_poles

eval_frequency(other)

在實數或複數平面的任意點評估TransferFunctionMatrix中每個傳輸函式的系統響應。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix
>>> from sympy import I
>>> tf_1 = TransferFunction(3, (s + 1), s)
>>> tf_2 = TransferFunction(s + 6, (s + 1)*(s + 2), s)
>>> tf_3 = TransferFunction(s + 3, s**2 + 3*s + 2, s)
>>> tf_4 = TransferFunction(s**2 - 9*s + 20, s**2 + 5*s - 10, s)
>>> tfm_1 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, tf_4]])
>>> tfm_1
TransferFunctionMatrix(((TransferFunction(3, s + 1, s), TransferFunction(s + 6, (s + 1)*(s + 2), s)), (TransferFunction(s + 3, s**2 + 3*s + 2, s), TransferFunction(s**2 - 9*s + 20, s**2 + 5*s - 10, s))))
>>> tfm_1.eval_frequency(2)
Matrix([
[   1, 2/3],
[5/12, 3/2]])
>>> tfm_1.eval_frequency(I*2)
Matrix([
[   3/5 - 6*I/5,                -I],
[3/20 - 11*I/20, -101/74 + 23*I/74]])

expand(**hints)

擴充套件傳輸函式矩陣

classmethod from_Matrix(matrix, var)

有效地從 SymPy 矩陣的Expr物件建立新的TransferFunctionMatrix。

引數：

matrix：具有Expr/Number元素的ImmutableMatrix。

var：符號

拉普拉斯變換的復變數，將被TransferFunctionMatrix中所有TransferFunction物件使用。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunctionMatrix
>>> from sympy import Matrix, pprint
>>> M = Matrix([[s, 1/s], [1/(s+1), s]])
>>> M_tf = TransferFunctionMatrix.from_Matrix(M, s)
>>> pprint(M_tf, use_unicode=False)
[  s    1]
[  -    -]
[  1    s]
[        ]
[  1    s]
[-----  -]
[s + 1  1]{t}
>>> M_tf.elem_poles()
[[[], [0]], [[-1], []]]
>>> M_tf.elem_zeros()
[[[0], []], [[], [0]]]

property num_inputs

返回系統的輸入數量。

示例

>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix
>>> G1 = TransferFunction(s + 3, s**2 - 3, s)
>>> G2 = TransferFunction(4, s**2, s)
>>> G3 = TransferFunction(p**2 + s**2, p - 3, s)
>>> tfm_1 = TransferFunctionMatrix([[G2, -G1, G3], [-G2, -G1, -G3]])
>>> tfm_1.num_inputs
3

參見

num_outputs

property num_outputs

返回系統輸出的數量。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunctionMatrix
>>> from sympy import Matrix
>>> M_1 = Matrix([[s], [1/s]])
>>> TFM = TransferFunctionMatrix.from_Matrix(M_1, s)
>>> print(TFM)
TransferFunctionMatrix(((TransferFunction(s, 1, s),), (TransferFunction(1, s, s),)))
>>> TFM.num_outputs
2

參見

num_inputs

property shape

返回傳輸函式矩陣的形狀，即(# of outputs, # of inputs)。

示例

>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix
>>> tf1 = TransferFunction(p**2 - 1, s**4 + s**3 - p, p)
>>> tf2 = TransferFunction(1 - p, p**2 - 3*p + 7, p)
>>> tf3 = TransferFunction(3, 4, p)
>>> tfm1 = TransferFunctionMatrix([[tf1, -tf2]])
>>> tfm1.shape
(1, 2)
>>> tfm2 = TransferFunctionMatrix([[-tf2, tf3], [tf1, -tf1]])
>>> tfm2.shape
(2, 2)

transpose()

返回TransferFunctionMatrix的轉置（交換輸入和輸出層）。

property var

返回所有傳輸函式或Series/Parallel物件中使用的復變數。

示例

>>> from sympy.abc import p, s
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, Series, Parallel
>>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p)
>>> G2 = TransferFunction(p, 4 - p, p)
>>> G3 = TransferFunction(0, p**4 - 1, p)
>>> G4 = TransferFunction(s + 1, s**2 + s + 1, s)
>>> S1 = Series(G1, G2)
>>> S2 = Series(-G3, Parallel(G2, -G1))
>>> tfm1 = TransferFunctionMatrix([[G1], [G2], [G3]])
>>> tfm1.var
p
>>> tfm2 = TransferFunctionMatrix([[-S1, -S2], [S1, S2]])
>>> tfm2.var
p
>>> tfm3 = TransferFunctionMatrix([[G4]])
>>> tfm3.var
s

class sympy.physics.control.lti.MIMOSeries(*args, evaluate=False)

用於表示 MIMO 系統串聯配置的類。

引數：

args：MIMOLinearTimeInvariant

MIMO 系統處於串聯配置。

evaluate：布林值，關鍵字

當傳遞True時，返回等效的MIMOSeries(*args).doit()。預設設定為False。

引發：

ValueError

當不傳遞任何引數時。

對於每個系統，var屬性並不相同。

MIMO 系統的num_outputs不等於其相鄰 MIMO 系統的num_inputs。（基本上是矩陣乘法約束）

TypeError

任何傳遞的*args具有不支援的型別

將 SISO 和 MIMO 系統的組合傳遞。在傳遞的系統型別中應保持同質性，本例中是 MIMO 系統。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import MIMOSeries, TransferFunctionMatrix
>>> from sympy import Matrix, pprint
>>> mat_a = Matrix([[5*s], [5]])  # 2 Outputs 1 Input
>>> mat_b = Matrix([[5, 1/(6*s**2)]])  # 1 Output 2 Inputs
>>> mat_c = Matrix([[1, s], [5/s, 1]])  # 2 Outputs 2 Inputs
>>> tfm_a = TransferFunctionMatrix.from_Matrix(mat_a, s)
>>> tfm_b = TransferFunctionMatrix.from_Matrix(mat_b, s)
>>> tfm_c = TransferFunctionMatrix.from_Matrix(mat_c, s)
>>> MIMOSeries(tfm_c, tfm_b, tfm_a)
MIMOSeries(TransferFunctionMatrix(((TransferFunction(1, 1, s), TransferFunction(s, 1, s)), (TransferFunction(5, s, s), TransferFunction(1, 1, s)))), TransferFunctionMatrix(((TransferFunction(5, 1, s), TransferFunction(1, 6*s**2, s)),)), TransferFunctionMatrix(((TransferFunction(5*s, 1, s),), (TransferFunction(5, 1, s),))))
>>> pprint(_, use_unicode=False)  #  For Better Visualization
[5*s]                 [1  s]
[---]    [5   1  ]    [-  -]
[ 1 ]    [-  ----]    [1  1]
[   ]   *[1     2]   *[    ]
[ 5 ]    [   6*s ]{t} [5  1]
[ - ]                 [-  -]
[ 1 ]{t}              [s  1]{t}
>>> MIMOSeries(tfm_c, tfm_b, tfm_a).doit()
TransferFunctionMatrix(((TransferFunction(150*s**4 + 25*s, 6*s**3, s), TransferFunction(150*s**4 + 5*s, 6*s**2, s)), (TransferFunction(150*s**3 + 25, 6*s**3, s), TransferFunction(150*s**3 + 5, 6*s**2, s))))
>>> pprint(_, use_unicode=False)  # (2 Inputs -A-> 2 Outputs) -> (2 Inputs -B-> 1 Output) -> (1 Input -C-> 2 Outputs) is equivalent to (2 Inputs -Series Equivalent-> 2 Outputs).
[     4              4      ]
[150*s  + 25*s  150*s  + 5*s]
[-------------  ------------]
[        3             2    ]
[     6*s           6*s     ]
[                           ]
[      3              3     ]
[ 150*s  + 25    150*s  + 5 ]
[ -----------    ---------- ]
[        3             2    ]
[     6*s           6*s     ]{t}

注意

所有傳輸函式矩陣應使用拉普拉斯變換的相同復變數var。

MIMOSeries(A, B)與A*B不等同。它總是以相反的順序，即B*A。

參見

Series, MIMOParallel

doit(cancel=False, **kwargs)

返回在串聯配置的 MIMO 系統評估後獲得的結果傳遞函式矩陣。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, MIMOSeries, TransferFunctionMatrix
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> tfm1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf2]])
>>> tfm2 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf1]])
>>> MIMOSeries(tfm2, tfm1).doit()
TransferFunctionMatrix(((TransferFunction(2*(-p + s)*(s**3 - 2)*(a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)**2*(s**4 + 5*s + 6)**2, s), TransferFunction((-p + s)**2*(s**3 - 2)*(a*p**2 + b*s) + (-p + s)*(a*p**2 + b*s)**2*(s**4 + 5*s + 6), (-p + s)**3*(s**4 + 5*s + 6), s)), (TransferFunction((-p + s)*(s**3 - 2)**2*(s**4 + 5*s + 6) + (s**3 - 2)*(a*p**2 + b*s)*(s**4 + 5*s + 6)**2, (-p + s)*(s**4 + 5*s + 6)**3, s), TransferFunction(2*(s**3 - 2)*(a*p**2 + b*s), (-p + s)*(s**4 + 5*s + 6), s))))

property num_inputs

返回串聯絡統的輸入訊號數量。

property num_outputs

返回串聯絡統的輸出訊號數量。

property shape

返回等效 MIMO 系統的形狀。

property var

返回所有傳遞函式使用的復變數。

示例

>>> from sympy.abc import p
>>> from sympy.physics.control.lti import TransferFunction, MIMOSeries, TransferFunctionMatrix
>>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p)
>>> G2 = TransferFunction(p, 4 - p, p)
>>> G3 = TransferFunction(0, p**4 - 1, p)
>>> tfm_1 = TransferFunctionMatrix([[G1, G2, G3]])
>>> tfm_2 = TransferFunctionMatrix([[G1], [G2], [G3]])
>>> MIMOSeries(tfm_2, tfm_1).var
p

class sympy.physics.control.lti.MIMOParallel(*args, evaluate=False)

表示並聯配置的 MIMO 系統的類。

引數:

args：MIMOLinearTimeInvariant

並聯配置的 MIMO 系統。

evaluate：布林值，關鍵字

當傳遞True時，返回等效的MIMOParallel(*args).doit()。預設為False。

Raises:

數值錯誤

當未傳遞引數時。

var屬性在每個系統中不相同。

所有傳遞的 MIMO 系統形狀不同。

型別錯誤

傳遞的任何*args型別都不受支援。

傳遞了一組 SISO 和 MIMO 系統。在這種情況下，傳遞的系統型別應該是同質的，即 MIMO。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunctionMatrix, MIMOParallel
>>> from sympy import Matrix, pprint
>>> expr_1 = 1/s
>>> expr_2 = s/(s**2-1)
>>> expr_3 = (2 + s)/(s**2 - 1)
>>> expr_4 = 5
>>> tfm_a = TransferFunctionMatrix.from_Matrix(Matrix([[expr_1, expr_2], [expr_3, expr_4]]), s)
>>> tfm_b = TransferFunctionMatrix.from_Matrix(Matrix([[expr_2, expr_1], [expr_4, expr_3]]), s)
>>> tfm_c = TransferFunctionMatrix.from_Matrix(Matrix([[expr_3, expr_4], [expr_1, expr_2]]), s)
>>> MIMOParallel(tfm_a, tfm_b, tfm_c)
MIMOParallel(TransferFunctionMatrix(((TransferFunction(1, s, s), TransferFunction(s, s**2 - 1, s)), (TransferFunction(s + 2, s**2 - 1, s), TransferFunction(5, 1, s)))), TransferFunctionMatrix(((TransferFunction(s, s**2 - 1, s), TransferFunction(1, s, s)), (TransferFunction(5, 1, s), TransferFunction(s + 2, s**2 - 1, s)))), TransferFunctionMatrix(((TransferFunction(s + 2, s**2 - 1, s), TransferFunction(5, 1, s)), (TransferFunction(1, s, s), TransferFunction(s, s**2 - 1, s)))))
>>> pprint(_, use_unicode=False)  #  For Better Visualization
[  1       s   ]      [  s       1   ]      [s + 2     5   ]
[  -     ------]      [------    -   ]      [------    -   ]
[  s      2    ]      [ 2        s   ]      [ 2        1   ]
[        s  - 1]      [s  - 1        ]      [s  - 1        ]
[              ]    + [              ]    + [              ]
[s + 2     5   ]      [  5     s + 2 ]      [  1       s   ]
[------    -   ]      [  -     ------]      [  -     ------]
[ 2        1   ]      [  1      2    ]      [  s      2    ]
[s  - 1        ]{t}   [        s  - 1]{t}   [        s  - 1]{t}
>>> MIMOParallel(tfm_a, tfm_b, tfm_c).doit()
TransferFunctionMatrix(((TransferFunction(s**2 + s*(2*s + 2) - 1, s*(s**2 - 1), s), TransferFunction(2*s**2 + 5*s*(s**2 - 1) - 1, s*(s**2 - 1), s)), (TransferFunction(s**2 + s*(s + 2) + 5*s*(s**2 - 1) - 1, s*(s**2 - 1), s), TransferFunction(5*s**2 + 2*s - 3, s**2 - 1, s))))
>>> pprint(_, use_unicode=False)
[       2                              2       / 2    \    ]
[      s  + s*(2*s + 2) - 1         2*s  + 5*s*\s  - 1/ - 1]
[      --------------------         -----------------------]
[             / 2    \                       / 2    \      ]
[           s*\s  - 1/                     s*\s  - 1/      ]
[                                                          ]
[ 2                   / 2    \             2               ]
[s  + s*(s + 2) + 5*s*\s  - 1/ - 1      5*s  + 2*s - 3     ]
[---------------------------------      --------------     ]
[              / 2    \                      2             ]
[            s*\s  - 1/                     s  - 1         ]{t}

註釋

所有傳遞函式矩陣應使用拉普拉斯變換的相同復變數var。

另請參閱

Parallel, MIMOSeries

doit(**hints)

返回在並聯配置的 MIMO 系統評估後獲得的結果傳遞函式矩陣。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, MIMOParallel, TransferFunctionMatrix
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> tfm_1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
>>> tfm_2 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf2]])
>>> MIMOParallel(tfm_1, tfm_2).doit()
TransferFunctionMatrix(((TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s), TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s)), (TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s), TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s))))

property num_inputs

返回並聯系統的輸入訊號數量。

property num_outputs

返回並行系統的輸出訊號數量。

property shape

返回等效 MIMO 系統的形狀。

property var

返回所有系統使用的復變數。

示例

>>> from sympy.abc import p
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOParallel
>>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p)
>>> G2 = TransferFunction(p, 4 - p, p)
>>> G3 = TransferFunction(0, p**4 - 1, p)
>>> G4 = TransferFunction(p**2, p**2 - 1, p)
>>> tfm_a = TransferFunctionMatrix([[G1, G2], [G3, G4]])
>>> tfm_b = TransferFunctionMatrix([[G2, G1], [G4, G3]])
>>> MIMOParallel(tfm_a, tfm_b).var
p

class sympy.physics.control.lti.MIMOFeedback(sys1, sys2, sign=-1)

表示兩個 MIMO 輸入/輸出系統之間閉環反饋連線的類。

引數:

sys1：MIMOSeries，TransferFunctionMatrix

將 MIMO 系統放置在前饋路徑上。

sys2：MIMOSeries，TransferFunctionMatrix

放置在反饋路徑上的系統（通常是反饋控制器）。

符號：整數，可選

反饋的符號。可以是1（正反饋）或-1（負反饋）。預設值為(-1)。

Raises:

數值錯誤

當sys1和sys2沒有使用拉普拉斯變換的相同復變數時。

前向路徑模型應具有與反饋路徑輸出/輸入相等數量的輸入/輸出。

當sys1和sys2的乘積不是方陣時。

當等效 MIMO 系統不可逆時。

型別錯誤

當sys1或sys2不是MIMOSeries或TransferFunctionMatrix物件時。

示例

>>> from sympy import Matrix, pprint
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunctionMatrix, MIMOFeedback
>>> plant_mat = Matrix([[1, 1/s], [0, 1]])
>>> controller_mat = Matrix([[10, 0], [0, 10]])  # Constant Gain
>>> plant = TransferFunctionMatrix.from_Matrix(plant_mat, s)
>>> controller = TransferFunctionMatrix.from_Matrix(controller_mat, s)
>>> feedback = MIMOFeedback(plant, controller)  # Negative Feedback (default)
>>> pprint(feedback, use_unicode=False)
/    [1  1]    [10  0 ]   \-1   [1  1]
|    [-  -]    [--  - ]   |     [-  -]
|    [1  s]    [1   1 ]   |     [1  s]
|I + [    ]   *[      ]   |   * [    ]
|    [0  1]    [0   10]   |     [0  1]
|    [-  -]    [-   --]   |     [-  -]
\    [1  1]{t} [1   1 ]{t}/     [1  1]{t}

要獲取等效系統矩陣，請使用doit或rewrite方法。

>>> pprint(feedback.doit(), use_unicode=False)
[1     1  ]
[--  -----]
[11  121*s]
[         ]
[0    1   ]
[-    --  ]
[1    11  ]{t}

要否定MIMOFeedback物件，請使用-運算子。

>>> neg_feedback = -feedback
>>> pprint(neg_feedback.doit(), use_unicode=False)
[-1    -1  ]
[---  -----]
[11   121*s]
[          ]
[ 0    -1  ]
[ -    --- ]
[ 1    11  ]{t}

另請參閱

Feedback, MIMOSeries, MIMOParallel

doit(cancel=True, expand=False, **hints)

返回透過反饋互連獲得的結果傳遞函式矩陣。

示例

>>> from sympy import pprint
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback
>>> tf1 = TransferFunction(s, 1 - s, s)
>>> tf2 = TransferFunction(1, s, s)
>>> tf3 = TransferFunction(5, 1, s)
>>> tf4 = TransferFunction(s - 1, s, s)
>>> tf5 = TransferFunction(0, 1, s)
>>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf3, tf4]])
>>> sys2 = TransferFunctionMatrix([[tf3, tf5], [tf5, tf5]])
>>> F_1 = MIMOFeedback(sys1, sys2, 1)
>>> pprint(F_1, use_unicode=False)
/    [  s      1  ]    [5  0]   \-1   [  s      1  ]
|    [-----    -  ]    [-  -]   |     [-----    -  ]
|    [1 - s    s  ]    [1  1]   |     [1 - s    s  ]
|I - [            ]   *[    ]   |   * [            ]
|    [  5    s - 1]    [0  0]   |     [  5    s - 1]
|    [  -    -----]    [-  -]   |     [  -    -----]
\    [  1      s  ]{t} [1  1]{t}/     [  1      s  ]{t}
>>> pprint(F_1.doit(), use_unicode=False)
[  -s           s - 1       ]
[-------     -----------    ]
[6*s - 1     s*(6*s - 1)    ]
[                           ]
[5*s - 5  (s - 1)*(6*s + 24)]
[-------  ------------------]
[6*s - 1     s*(6*s - 1)    ]{t}

如果使用者希望獲得結果的TransferFunctionMatrix物件而不取消公共因子，則應將cancel引數傳遞為False。

>>> pprint(F_1.doit(cancel=False), use_unicode=False)
[             s*(s - 1)                              s - 1               ]
[         -----------------                       -----------            ]
[         (1 - s)*(6*s - 1)                       s*(6*s - 1)            ]
[                                                                        ]
[s*(25*s - 25) + 5*(1 - s)*(6*s - 1)  s*(s - 1)*(6*s - 1) + s*(25*s - 25)]
[-----------------------------------  -----------------------------------]
[         (1 - s)*(6*s - 1)                        2                     ]
[                                                 s *(6*s - 1)           ]{t}

如果使用者希望獲得結果傳遞函式矩陣的展開形式，則應將expand引數傳遞為True。

>>> pprint(F_1.doit(expand=True), use_unicode=False)
[  -s          s - 1      ]
[-------      --------    ]
[6*s - 1         2        ]
[             6*s  - s    ]
[                         ]
[            2            ]
[5*s - 5  6*s  + 18*s - 24]
[-------  ----------------]
[6*s - 1         2        ]
[             6*s  - s    ]{t}

property sensitivity

返回反饋環路的靈敏度函式矩陣。

閉環系統的靈敏度是指開環增益變化與閉環增益變化的比率。

注意

此方法不會返回互補靈敏度函式。

示例

>>> from sympy import pprint
>>> from sympy.abc import p
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback
>>> tf1 = TransferFunction(p, 1 - p, p)
>>> tf2 = TransferFunction(1, p, p)
>>> tf3 = TransferFunction(1, 1, p)
>>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
>>> sys2 = TransferFunctionMatrix([[tf1, tf3], [tf3, tf2]])
>>> F_1 = MIMOFeedback(sys1, sys2, 1)  # Positive feedback
>>> F_2 = MIMOFeedback(sys1, sys2)  # Negative feedback
>>> pprint(F_1.sensitivity, use_unicode=False)
[   4      3      2               5      4      2           ]
[- p  + 3*p  - 4*p  + 3*p - 1    p  - 2*p  + 3*p  - 3*p + 1 ]
[----------------------------  -----------------------------]
[  4      3      2              5      4      3      2      ]
[ p  + 3*p  - 8*p  + 8*p - 3   p  + 3*p  - 8*p  + 8*p  - 3*p]
[                                                           ]
[       4    3    2                  3      2               ]
[      p  - p  - p  + p           3*p  - 6*p  + 4*p - 1     ]
[ --------------------------    --------------------------  ]
[  4      3      2               4      3      2            ]
[ p  + 3*p  - 8*p  + 8*p - 3    p  + 3*p  - 8*p  + 8*p - 3  ]
>>> pprint(F_2.sensitivity, use_unicode=False)
[ 4      3      2           5      4      2          ]
[p  - 3*p  + 2*p  + p - 1  p  - 2*p  + 3*p  - 3*p + 1]
[------------------------  --------------------------]
[   4      3                   5      4      2       ]
[  p  - 3*p  + 2*p - 1        p  - 3*p  + 2*p  - p   ]
[                                                    ]
[     4    3    2               4      3             ]
[    p  - p  - p  + p        2*p  - 3*p  + 2*p - 1   ]
[  -------------------       ---------------------   ]
[   4      3                   4      3              ]
[  p  - 3*p  + 2*p - 1        p  - 3*p  + 2*p - 1    ]

property sign

返回兩個模型的反饋互連型別。正反饋返回1，負反饋返回-1。

property sys1

返回放置在 MIMO 反饋互連的前饋路徑上的系統。

示例

>>> from sympy import pprint
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback
>>> tf1 = TransferFunction(s**2 + s + 1, s**2 - s + 1, s)
>>> tf2 = TransferFunction(1, s, s)
>>> tf3 = TransferFunction(1, 1, s)
>>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
>>> sys2 = TransferFunctionMatrix([[tf3, tf3], [tf3, tf2]])
>>> F_1 = MIMOFeedback(sys1, sys2, 1)
>>> F_1.sys1
TransferFunctionMatrix(((TransferFunction(s**2 + s + 1, s**2 - s + 1, s), TransferFunction(1, s, s)), (TransferFunction(1, s, s), TransferFunction(s**2 + s + 1, s**2 - s + 1, s))))
>>> pprint(_, use_unicode=False)
[ 2                    ]
[s  + s + 1      1     ]
[----------      -     ]
[ 2              s     ]
[s  - s + 1            ]
[                      ]
[             2        ]
[    1       s  + s + 1]
[    -       ----------]
[    s        2        ]
[            s  - s + 1]{t}

property sys2

返回 MIMO 反饋互連的反饋控制器。

示例

>>> from sympy import pprint
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback
>>> tf1 = TransferFunction(s**2, s**3 - s + 1, s)
>>> tf2 = TransferFunction(1, s, s)
>>> tf3 = TransferFunction(1, 1, s)
>>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
>>> sys2 = TransferFunctionMatrix([[tf1, tf3], [tf3, tf2]])
>>> F_1 = MIMOFeedback(sys1, sys2)
>>> F_1.sys2
TransferFunctionMatrix(((TransferFunction(s**2, s**3 - s + 1, s), TransferFunction(1, 1, s)), (TransferFunction(1, 1, s), TransferFunction(1, s, s))))
>>> pprint(_, use_unicode=False)
[     2       ]
[    s       1]
[----------  -]
[ 3          1]
[s  - s + 1   ]
[             ]
[    1       1]
[    -       -]
[    1       s]{t}

property var

返回所有 MIMO 反饋環路中涉及的傳遞函式使用的拉普拉斯變換的復變數。

示例

>>> from sympy.abc import p
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback
>>> tf1 = TransferFunction(p, 1 - p, p)
>>> tf2 = TransferFunction(1, p, p)
>>> tf3 = TransferFunction(1, 1, p)
>>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
>>> sys2 = TransferFunctionMatrix([[tf1, tf3], [tf3, tf2]])
>>> F_1 = MIMOFeedback(sys1, sys2, 1)  # Positive feedback
>>> F_1.var
p

sympy.physics.control.lti.gbt(tf, sample_per, alpha)

返回 H(z) 的分子和分母的降序係數。

解釋

其中 H(z) 是相應的離散化傳遞函式，使用廣義雙線性變換方法進行離散化。H(z) 是透過將 (s(z) = \frac{z-1}{T(\alpha z + (1-\alpha))}) 替換到 H(s) 中獲得的，其中 T 是取樣週期。係數是降序排列的，即 (H(z) = \frac{az+b}{cz+d}) 返回為 [a, b], [c, d]。

示例

>>> from sympy.physics.control.lti import TransferFunction, gbt
>>> from sympy.abc import s, L, R, T

>>> tf = TransferFunction(1, s*L + R, s)
>>> numZ, denZ = gbt(tf, T, 0.5)
>>> numZ
[T/(2*(L + R*T/2)), T/(2*(L + R*T/2))]
>>> denZ
[1, (-L + R*T/2)/(L + R*T/2)]

>>> numZ, denZ = gbt(tf, T, 0)
>>> numZ
[T/L]
>>> denZ
[1, (-L + R*T)/L]

>>> numZ, denZ = gbt(tf, T, 1)
>>> numZ
[T/(L + R*T), 0]
>>> denZ
[1, -L/(L + R*T)]

>>> numZ, denZ = gbt(tf, T, 0.3)
>>> numZ
[3*T/(10*(L + 3*R*T/10)), 7*T/(10*(L + 3*R*T/10))]
>>> denZ
[1, (-L + 7*R*T/10)/(L + 3*R*T/10)]

參考文獻

[R736]

www.polyu.edu.hk/ama/profile/gfzhang/Research/ZCC09_IJC.pdf

sympy.physics.control.lti.bilinear(tf, sample_per)

返回 H(z) 的分子和分母的降序係數。

解釋

其中 H(z) 是相應的離散化傳遞函式，使用雙線性變換方法進行離散化。H(z) 是透過將 (s(z) = \frac{2}{T}\frac{z-1}{z+1}) 替換到 H(s) 中獲得的，其中 T 是取樣週期。係數是降序排列的，即 (H(z) = \frac{az+b}{cz+d}) 返回為 [a, b], [c, d]。

示例

>>> from sympy.physics.control.lti import TransferFunction, bilinear
>>> from sympy.abc import s, L, R, T

>>> tf = TransferFunction(1, s*L + R, s)
>>> numZ, denZ = bilinear(tf, T)
>>> numZ
[T/(2*(L + R*T/2)), T/(2*(L + R*T/2))]
>>> denZ
[1, (-L + R*T/2)/(L + R*T/2)]

sympy.physics.control.lti.forward_diff(tf, sample_per)

返回 H(z) 的分子和分母的降序係數。

解釋

其中 H(z) 是相應的離散化傳遞函式，使用前向差分變換方法進行離散化。H(z) 是透過將 (s(z) = \frac{z-1}{T}) 替換到 H(s) 中獲得的，其中 T 是取樣週期。係數是降序排列的，即 (H(z) = \frac{az+b}{cz+d}) 返回為 [a, b], [c, d]。

示例

>>> from sympy.physics.control.lti import TransferFunction, forward_diff
>>> from sympy.abc import s, L, R, T

>>> tf = TransferFunction(1, s*L + R, s)
>>> numZ, denZ = forward_diff(tf, T)
>>> numZ
[T/L]
>>> denZ
[1, (-L + R*T)/L]

sympy.physics.control.lti.backward_diff(tf, sample_per)

返回 H(z) 的分子和分母的降序係數。

解釋

其中，H(z) 是相應的離散化傳遞函式，使用後向差分變換方法離散化。H(z) 是從連續傳遞函式 H(s) 透過將 (s(z) = \frac{z-1}{Tz}) 代入 H(s) 而獲得的，其中 T 是取樣週期。係數在變小，即 (H(z) = \frac{az+b}{cz+d}) 被返回為 [a, b], [c, d]。

舉例

>>> from sympy.physics.control.lti import TransferFunction, backward_diff
>>> from sympy.abc import s, L, R, T

>>> tf = TransferFunction(1, s*L + R, s)
>>> numZ, denZ = backward_diff(tf, T)
>>> numZ
[T/(L + R*T), 0]
>>> denZ
[1, -L/(L + R*T)]

SymPy-1-13-中文文件-十八-
2024-06-27
SymPy-1-13-中文文件-十四-
2024-06-27
SymPy-1-13-中文文件-十三-
2024-06-27
SymPy-1-13-中文文件-十一-
2024-06-27
SymPy-1-13-中文文件-十五-
2024-06-27
BackTrader 中文文件（二十九）
2024-04-15
mongoose中文文件
2018-12-18
Go
aiohttp中文文件
2018-03-03
AIHTTP
GORM 中文文件
2017-01-12
GoORM
JointJS中文文件
2019-02-16
JS
Laravel Package 中文文件
2021-04-18
LaravelPackage
Ace editor中文文件
2020-10-27
蘋果文件中文版
2017-12-20
蘋果
NUnit中文說明文件
2013-08-01
Activiti中文文件地址
2014-09-10
PostgreSQL 8.2.3 中文文件
2008-05-25
SQL
iptables中文man文件(轉)
2007-08-10
Elasticsearch6.5中文文件-刪除文件
2020-10-22
Elasticsearch
SnapKit 中文文件翻譯
2019-03-04
APK
PHP-redis中文文件
2021-09-09
PHPRedis
JSON Editor 中文文件
2018-11-07
JSON
Ocelot中文文件-快取
2018-05-08
快取
React Starter Kit 中文文件
2017-04-22
React
Oracle官方中文支援文件
2015-02-04
Oracle
蘋果ios 技術文件中文
2013-04-08
蘋果iOS
LaTeX 編寫中文文件
2024-05-10
【Python】官方文件中文版
2019-03-22
Python
[開發文件]bootstrap中文手冊
2019-05-11
boot
HTTPie 官方文件中文翻譯版
2019-02-16
HTTP
Airflow 中文文件：快速開始
2018-11-28
AI
sharp.js中文文件
2018-11-24
JS
Nextjs中文文件
2018-09-11
NextJS
Gin 框架中文文件（翻譯）
2018-07-13
框架
POI匯入Excel中文API文件
2018-03-02
ExcelAPI
[譯] Laravel-mix 中文文件
2018-05-27
Laravel
Ocelot中文文件-微服務ServiceFabric
2018-05-08
微服務
Ocelot中文文件-轉換Claims
2018-05-08
AI
SQL SERVER 函式中文文件
2012-05-04
SQLServer函式

SymPy-1-13-中文文件-十九-

SymPy 1.13 中文文件（十九）

State

電路繪圖

門

Grover 演算法

QFT

Qubit

Shor 演算法

盒中的粒子

光學模組

高斯光學

介質

極化

示例

References

實用工具

波

控制模組

控制

控制 API

lti

使用多個變數建立傳遞函式 >>> tf1 = TransferFunction.from_coeff_lists([p, 1], [2p, 0, 4], s) >>> tf1 TransferFunction(ps + 1, 2ps**2 + 4, s)

使用變數極點和零點建立傳遞函式 >>> tf1 = TransferFunction.from_zpk([p, k], [p + k, p - k], 2, s) >>> tf1 TransferFunction(2(-k + s)(-p + s), (-k - p + s)*(k - p + s), s)

復極點或零點都是可以接受的 >>> tf2 = TransferFunction.from_zpk([0], [1-1j, 1+1j, 2], -2, s) >>> tf2 TransferFunction(-2s, (s - 2)(s - 1.0 - 1.0I)(s - 1.0 + 1.0*I), s)

相關文章