控制API¶

lti¶

class sympy.physics.control.lti.TransferFunction(num, den, var)[源代码][源代码]¶

一个用于表示 LTI（线性时不变）系统的类，该系统可以通过拉普拉斯变换复变量中的多项式比率严格描述。参数为 num、den 和 var，其中 num 和 den 分别是 TransferFunction 的分子和分母多项式，第三个参数是传递函数多项式使用的拉普拉斯变换的复变量。num 和 den 可以是多项式或数字，而 var 必须是 Symbol。

参数:

numExpr, Number: 传递函数的分子多项式。
denExpr, Number: 传递函数的分母多项式。
变量符号: 传递函数多项式所使用的拉普拉斯变换的复变量。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
den: 返回传递函数的分母多项式。
expr_free_symbols
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
is_SISO: 如果传入的LTI系统是SISO，则返回`True`，否则返回`False`。
is_algebraic
is_antihermitian
is_biproper: 如果分子多项式的次数等于分母多项式的次数，则返回 True，否则返回 False。
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_polar
is_positive
is_prime
is_proper: 如果分子多项式的次数小于或等于分母多项式的次数，则返回 True，否则返回 False。
is_rational
is_real
is_strictly_proper: 如果分子多项式的次数严格小于分母多项式的次数，则返回 True，否则返回 False。
is_transcendental
is_zero
num: 返回传递函数的分子多项式。
num_inputs: 返回 SISOLinearTimeInvariant 的输入数量。
num_outputs: 返回 SISOLinearTimeInvariant 的输出数量。
var: 返回传递函数多项式所使用的拉普拉斯变换的复变量。

方法

`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`dc_gain`()	计算频率接近零时的响应增益。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`eval_frequency`(other)	返回在实数或复数平面中任意点的系统响应。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`expand`()	返回分子和分母展开形式的传递函数。
`find`(query[, group])	查找所有匹配查询的子表达式。
`from_coeff_lists`(num_list, den_list, var)	从系数列表高效创建一个新的 `TransferFunction`。
`from_rational_expression`(expr[, var])	从有理表达式高效创建一个新的 `TransferFunction`。
`from_zpk`(zeros, poles, gain, var)	从给定的零点、极点和增益创建一个新的 `TransferFunction`。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_stable`()	如果传递函数是渐近稳定的，则返回 True；否则返回 False。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`poles`()	返回传递函数的极点。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`to_expr`()	将 `TransferFunction` 对象转换为 SymPy Expr。
`xreplace`(rule)	替换表达式中对象的出现。
`zeros`()	返回传递函数的零点。

复制
could_extract_minus_sign
is_hypergeometric

Raises:

类型错误: 当 var 不是符号，或者 num 或 den 不是数字或多项式时。
ValueError: 当 den 为零时。

参见

Feedback, Series, Parallel

参考文献

[1]

https://en.wikipedia.org/wiki/Transfer_function

[2]

https://en.wikipedia.org/wiki/拉普拉斯变换

示例

>>> 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)

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序列: 包含分母系数的序列。
变量符号: 传递函数多项式所使用的拉普拉斯变换的复变量。

Raises:

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], [2*p, 0, 4], s) >>> tf1 TransferFunction(p*s + 1, 2*p*s**2 + 4, s)

classmethod from_rational_expression( expr, var=None, )[源代码][源代码]¶

从有理表达式高效创建一个新的 TransferFunction。

参数:

表达式Expr, Number: 表示 TransferFunction 的有理表达式。
变量符号, 可选: 传递函数多项式所使用的拉普拉斯变换的复变量。

Raises:

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)

如果在表达式中两个或多个变量之间存在冲突，如果用户没有传递 var，SymPy 将引发 ValueError。

>>> 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。

参数:

零序列: 包含传递函数零点的序列。
极点序列: 包含传递函数极点的序列。
增益数字, 符号, 表达式: 指定模型增益的标量值。
变量符号: 传递函数多项式所使用的拉普拉斯变换的复变量。

示例

>>> 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(-2*s, (s - 2)*(s - 1.0 - 1.0*I)*(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 Expr。

示例

>>> 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系统系列配置的类。

参数:

参数SISOLinearTimeInvariant: 串联配置中的SISO系统。
评估布尔值, 关键字: 当传递 True 时，返回等效的 Series(*args).doit()。默认设置为 False。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
is_SISO: 如果传入的LTI系统是SISO，则返回`True`，否则返回`False`。
is_StateSpace_object
is_algebraic
is_antihermitian
is_biproper: 如果结果传递函数分子多项式的次数等于同一分母多项式的次数，则返回 True，否则返回 False。
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_polar
is_positive
is_prime
is_proper: 如果结果传递函数分子多项式的次数小于或等于同一分母多项式的次数，则返回 True，否则返回 False。
is_rational
is_real
is_strictly_proper: 如果结果传递函数分子多项式的次数严格小于同一分母多项式的次数，则返回 True，否则返回 False。
is_transcendental
is_zero
num_inputs: 返回 SISOLinearTimeInvariant 的输入数量。
num_outputs: 返回 SISOLinearTimeInvariant 的输出数量。
var: 返回所有传递函数使用的复变量。

方法

`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`doit`(**hints)	返回在评估串联连接后得到的结果传递函数或状态空间模型。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`to_expr`()	返回等效的 `Expr` 对象。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

Raises:

ValueError

当没有传递参数时。

var 属性在每个系统中并不相同。

类型错误

传递的 *args 中任意一个具有不支持的类型

传递了 SISO 和 MIMO 系统的组合。传递的系统类型应保持一致，在此情况下应为 SISO。

参见

MIMOSeries, Parallel, TransferFunction, Feedback

注释

所有传递函数应使用相同的拉普拉斯变换的复变量 var。

示例

>>> from sympy.abc import s, p, a, b
>>> from sympy import Matrix
>>> from sympy.physics.control.lti import TransferFunction, Series, Parallel, StateSpace
>>> 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)

你也可以连接 StateSpace，这将导致 SISO

>>> A1 = Matrix([[-1]])
>>> B1 = Matrix([[1]])
>>> C1 = Matrix([[-1]])
>>> D1 = Matrix([1])
>>> A2 = Matrix([[0]])
>>> B2 = Matrix([[1]])
>>> C2 = Matrix([[1]])
>>> D2 = Matrix([[0]])
>>> ss1 = StateSpace(A1, B1, C1, D1)
>>> ss2 = StateSpace(A2, B2, C2, D2)
>>> S5 = Series(ss1, ss2)
>>> S5
Series(StateSpace(Matrix([[-1]]), Matrix([[1]]), Matrix([[-1]]), Matrix([[1]])), StateSpace(Matrix([[0]]), Matrix([[1]]), Matrix([[1]]), Matrix([[0]])))
>>> S5.doit()
StateSpace(Matrix([
[-1,  0],
[-1, 0]]), Matrix([
[1],
[1]]), Matrix([[0, 1]]), Matrix([[0]]))

doit(**hints)[源代码][源代码]¶

返回在评估串联连接后得到的结果传递函数或状态空间模型。

注释

如果一个串联连接只包含 TransferFunction 组件，返回的等效系统将是一个 TransferFunction。然而，如果在任何参数中使用了 StateSpace 对象，输出将是一个 StateSpace 对象。

示例

>>> 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系统并行配置的类。

参数:

参数SISOLinearTimeInvariant: 并联布置中的SISO系统。
评估布尔值, 关键字: 当传递 True 时，返回等效的 Parallel(*args).doit()。默认设置为 False。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
is_SISO: 如果传入的LTI系统是SISO，则返回`True`，否则返回`False`。
is_StateSpace_object
is_algebraic
is_antihermitian
is_biproper: 如果结果传递函数分子多项式的次数等于同一分母多项式的次数，则返回 True，否则返回 False。
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_polar
is_positive
is_prime
is_proper: 如果结果传递函数分子多项式的次数小于或等于同一分母多项式的次数，则返回 True，否则返回 False。
is_rational
is_real
is_strictly_proper: 如果结果传递函数分子多项式的次数严格小于同一分母多项式的次数，则返回 True，否则返回 False。
is_transcendental
is_zero
num_inputs: 返回 SISOLinearTimeInvariant 的输入数量。
num_outputs: 返回 SISOLinearTimeInvariant 的输出数量。
var: 返回所有传递函数使用的复变量。

方法

`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`doit`(**hints)	返回通过并联连接传递函数或状态空间对象得到的结果传递函数或状态空间。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`to_expr`()	返回等效的 `Expr` 对象。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

Raises:

ValueError

当没有传递参数时。

var 属性在每个系统中并不相同。

类型错误

传递的 *args 中任意一个具有不支持的类型

传递了SISO和MIMO系统的组合。传递的系统类型应具有同质性。

参见

Series, TransferFunction, Feedback

注释

所有传递函数应使用相同的拉普拉斯变换的复变量 var。

示例

>>> from sympy import Matrix
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Parallel, Series, StateSpace
>>> 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)

Parallel 可以用来将 SISO StateSpace 系统连接在一起。

>>> A1 = Matrix([[-1]])
>>> B1 = Matrix([[1]])
>>> C1 = Matrix([[-1]])
>>> D1 = Matrix([1])
>>> A2 = Matrix([[0]])
>>> B2 = Matrix([[1]])
>>> C2 = Matrix([[1]])
>>> D2 = Matrix([[0]])
>>> ss1 = StateSpace(A1, B1, C1, D1)
>>> ss2 = StateSpace(A2, B2, C2, D2)
>>> P4 = Parallel(ss1, ss2)
>>> P4
Parallel(StateSpace(Matrix([[-1]]), Matrix([[1]]), Matrix([[-1]]), Matrix([[1]])), StateSpace(Matrix([[0]]), Matrix([[1]]), Matrix([[1]]), Matrix([[0]])))

doit() 可以用于找到包含 StateSpace 对象的系统的 StateSpace 等效形式。

>>> P4.doit()
StateSpace(Matrix([
[-1, 0],
[ 0, 0]]), Matrix([
[1],
[1]]), Matrix([[-1, 1]]), Matrix([[1]]))
>>> P4.rewrite(TransferFunction)
TransferFunction(s*(s + 1) + 1, s*(s + 1), s)

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、StateSpace 或 TransferFunction 对象。

参数:

sys1Series, StateSpace, TransferFunction

前馈路径系统。

sys2Series, StateSpace, TransferFunction, 可选

反馈路径系统（通常是一个反馈控制器）。它是位于反馈路径上的模型。

如果没有明确指定，sys2 被假定为单位（1.0）传递函数。

签名int, 可选

反馈的符号。可以是 ``1``（表示正面反馈）或 ``-1``（表示负面反馈）。默认值是 \(-1\)。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
den: 返回闭环反馈模型的分母。
expr_free_symbols
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
is_SISO: 如果传入的LTI系统是SISO，则返回`True`，否则返回`False`。
is_algebraic
is_antihermitian
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_polar
is_positive
is_prime
is_rational
is_real
is_transcendental
is_zero
num: 返回闭环反馈系统的分子。
num_inputs: 返回 SISOLinearTimeInvariant 的输入数量。
num_outputs: 返回 SISOLinearTimeInvariant 的输出数量。
sensitivity: 返回反馈回路的灵敏度函数。
sign: 返回MIMO反馈模型的类型。
sys1: 返回反馈互联的前馈系统。
sys2: 返回反馈互联的反馈控制器。
var: 返回反馈互联中涉及的所有传递函数所使用的拉普拉斯变换的复变量。

方法

`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`doit`([cancel, expand])	返回通过反馈连接传递函数或状态空间对象得到的结果传递函数或状态空间。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`to_expr`()	将 `Feedback` 对象转换为 SymPy Expr。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

Raises:

ValueError

当 sys1 和 sys2 没有使用相同的拉普拉斯变换的复变量时。

当 sys1 和 sys2 的组合导致分母为零时。

类型错误

当 sys1 或 sys2 不是 Series、StateSpace 或 TransferFunction 对象时。

参见

MIMOFeedback, Series, Parallel

示例

>>> from sympy import Matrix
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import StateSpace, 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)

Feedback 也可以用来连接 SISO StateSpace 系统。

>>> A1 = Matrix([[-1]])
>>> B1 = Matrix([[1]])
>>> C1 = Matrix([[-1]])
>>> D1 = Matrix([1])
>>> A2 = Matrix([[0]])
>>> B2 = Matrix([[1]])
>>> C2 = Matrix([[1]])
>>> D2 = Matrix([[0]])
>>> ss1 = StateSpace(A1, B1, C1, D1)
>>> ss2 = StateSpace(A2, B2, C2, D2)
>>> F3 = Feedback(ss1, ss2)
>>> F3
Feedback(StateSpace(Matrix([[-1]]), Matrix([[1]]), Matrix([[-1]]), Matrix([[1]])), StateSpace(Matrix([[0]]), Matrix([[1]]), Matrix([[1]]), Matrix([[0]])), -1)

doit() 可以用于找到包含 StateSpace 对象的系统的 StateSpace 等效形式。

>>> F3.doit()
StateSpace(Matrix([
[-1, -1],
[-1, -1]]), Matrix([
[1],
[1]]), Matrix([[-1, -1]]), Matrix([[1]]))

我们也可以通过使用 rewrite(TransferFunction) 方法找到等效的 TransferFunction。

>>> F3.rewrite(TransferFunction)
TransferFunction(s, s + 2, s)

property den¶: 返回闭环反馈模型的分母。

doit(cancel=False, expand=False, **hints)[源代码][源代码]¶

返回通过反馈连接传递函数或状态空间对象得到的结果传递函数或状态空间。

示例

>>> from sympy.abc import s
>>> from sympy import Matrix
>>> from sympy.physics.control.lti import TransferFunction, Feedback, StateSpace
>>> 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)

如果连接包含任何 StateSpace 对象，那么 doit() 将返回等效的 StateSpace 对象。

>>> A1 = Matrix([[-1.5, -2], [1, 0]])
>>> B1 = Matrix([0.5, 0])
>>> C1 = Matrix([[0, 1]])
>>> A2 = Matrix([[0, 1], [-5, -2]])
>>> B2 = Matrix([0, 3])
>>> C2 = Matrix([[0, 1]])
>>> ss1 = StateSpace(A1, B1, C1)
>>> ss2 = StateSpace(A2, B2, C2)
>>> F3 = Feedback(ss1, ss2)
>>> F3.doit()
StateSpace(Matrix([
[-1.5, -2,  0, -0.5],
[   1,  0,  0,    0],
[   0,  0,  0,    1],
[   0,  3, -5,   -2]]), Matrix([
[0.5],
[  0],
[  0],
[  0]]), Matrix([[0, 1, 0, 0]]), Matrix([[0]]))

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 Expr。

示例

>>> 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)[源代码][源代码]¶

一个用于表示 MIMO（多输入多输出）的类，它是 SISO（单输入单输出）传递函数的推广。

它是一个传递函数矩阵（TransferFunction，SISO-Series 或 SISO-Parallel）。只有一个参数 arg，这也是一个必需的参数。arg 应严格为包含传递函数或可简化为传递函数的列表的列表类型。

参数:

arg : 嵌套的 List （严格）。嵌套: 用户需要输入一个嵌套的 TransferFunction、Series 和/或 Parallel 对象列表。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
is_SISO: 如果传入的LTI系统是SISO，则返回`True`，否则返回`False`。
is_algebraic
is_antihermitian
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_polar
is_positive
is_prime
is_rational
is_real
is_transcendental
is_zero
num_inputs: 返回系统的输入数量。
num_outputs: 返回系统的输出数量。
shape: 返回传递函数矩阵的形状，即 (输出数量, 输入数量)。
var: 返回由传递函数矩阵中的所有传递函数或 Series/Parallel 对象使用的复变量。

方法

`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`elem_poles`()	返回 `TransferFunctionMatrix` 中每个元素的极点。
`elem_zeros`()	返回 `TransferFunctionMatrix` 中每个元素的零点。
`eval_frequency`(other)	在 `TransferFunctionMatrix` 中的每个传递函数在实数或复数平面的任意点处评估系统响应。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`expand`(**hints)	扩展传递函数矩阵
`find`(query[, group])	查找所有匹配查询的子表达式。
`from_Matrix`(matrix, var)	从 `Expr` 对象的 SymPy 矩阵高效地创建一个新的 `TransferFunctionMatrix`。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`transpose`()	返回 `TransferFunctionMatrix` 的转置（交换输入和输出层）。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

参见

TransferFunction, MIMOSeries, MIMOParallel, Feedback

示例

备注

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),)))

elem_poles()[源代码][源代码]¶

返回 TransferFunctionMatrix 中每个元素的极点。

备注

MIMO 系统的实际极点并不是各个元素的极点。

参见

elem_zeros

示例

>>> 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()[源代码][源代码]¶

返回 TransferFunctionMatrix 中每个元素的零点。

备注

MIMO 系统的实际零点并不是各个元素的零点。

参见

elem_poles

示例

>>> 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]]]

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)[源代码][源代码]¶

从 Expr 对象的 SymPy 矩阵高效地创建一个新的 TransferFunctionMatrix。

参数:

矩阵 : 不可变矩阵 包含 表达式/数字 元素。ImmutableMatrix 包含 Expr/Number 元素。
变量符号: 拉普拉斯变换的复变量，将由 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¶

返回系统的输入数量。

参见

num_outputs

示例

>>> 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

property num_outputs¶

返回系统的输出数量。

参见

num_inputs

示例

>>> 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

property shape¶

返回传递函数矩阵的形状，即 (输出数量, 输入数量)。

示例

>>> 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.PIDController(kp=kp, ki=ki, kd=kd, tf=0, var=s)[源代码][源代码]¶

用于表示控制系统中的PID（比例-积分-微分）控制器的类。PIDController类是TransferFunction的子类，表示控制器在拉普拉斯域中的传递函数。参数包括``kp``、ki、kd、tf``和``var，其中``kp``、``ki``和``kd``分别是比例、积分和微分增益。``tf``是微分滤波器的时间常数，用于滤除噪声，``var``是传递函数中使用的复变量。

参数:

kpExpr, Number: 比例增益。如果未指定，默认为 Symbol('kp')。
kiExpr, Number: 积分增益。如果未指定，默认为 Symbol('ki')。
kdExpr, Number: 导数增益。如果未指定，默认为 Symbol('kd')。
tfExpr, Number: 导数滤波器时间常数。如果未指定，默认为 0。
变量符号: 复杂的频率变量。如果未指定，默认为 s。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
den: 返回传递函数的分母多项式。
expr_free_symbols
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
is_SISO: 如果传入的LTI系统是SISO，则返回`True`，否则返回`False`。
is_algebraic
is_antihermitian
is_biproper: 如果分子多项式的次数等于分母多项式的次数，则返回 True，否则返回 False。
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_polar
is_positive
is_prime
is_proper: 如果分子多项式的次数小于或等于分母多项式的次数，则返回 True，否则返回 False。
is_rational
is_real
is_strictly_proper: 如果分子多项式的次数严格小于分母多项式的次数，则返回 True，否则返回 False。
is_transcendental
is_zero
kd: 返回PID控制器的微分增益（kd）。
ki: 返回PID控制器的积分增益（ki）。
kp: 返回PID控制器的比例增益（kp）。
num: 返回传递函数的分子多项式。
num_inputs: 返回 SISOLinearTimeInvariant 的输入数量。
num_outputs: 返回 SISOLinearTimeInvariant 的输出数量。
tf: 返回PID控制器的导数滤波器时间常数（tf）。
var: 返回传递函数多项式所使用的拉普拉斯变换的复变量。

方法

`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`dc_gain`()	计算频率接近零时的响应增益。
`doit`()	将 PIDController 转换为 TransferFunction。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`eval_frequency`(other)	返回在实数或复数平面中任意点的系统响应。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`expand`()	返回分子和分母展开形式的传递函数。
`find`(query[, group])	查找所有匹配查询的子表达式。
`from_coeff_lists`(num_list, den_list, var)	从系数列表高效创建一个新的 `TransferFunction`。
`from_rational_expression`(expr[, var])	从有理表达式高效创建一个新的 `TransferFunction`。
`from_zpk`(zeros, poles, gain, var)	从给定的零点、极点和增益创建一个新的 `TransferFunction`。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_stable`()	如果传递函数是渐近稳定的，则返回 True；否则返回 False。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`poles`()	返回传递函数的极点。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`to_expr`()	将 `TransferFunction` 对象转换为 SymPy Expr。
`xreplace`(rule)	替换表达式中对象的出现。
`zeros`()	返回传递函数的零点。

复制
could_extract_minus_sign
is_hypergeometric

参见

TransferFunction

参考文献

[1]

https://zh.wikipedia.org/wiki/PID%E6%8E%A7%E5%88%B6%E5%99%A8

[2]

https://in.mathworks.com/help/control/ug/proportional-integral-derivative-pid-controllers.html

示例

>>> from sympy import symbols
>>> from sympy.physics.control.lti import PIDController
>>> kp, ki, kd = symbols('kp ki kd')
>>> p1 = PIDController(kp, ki, kd)
>>> print(p1)
PIDController(kp, ki, kd, 0, s)
>>> p1.doit()
TransferFunction(kd*s**2 + ki + kp*s, s, s)
>>> p1.kp
kp
>>> p1.ki
ki
>>> p1.kd
kd
>>> p1.tf
0
>>> p1.var
s
>>> p1.to_expr()
(kd*s**2 + ki + kp*s)/s

doit()[源代码][源代码]¶: 将 PIDController 转换为 TransferFunction。

property kd¶: 返回PID控制器的微分增益（kd）。

property ki¶: 返回PID控制器的积分增益（ki）。

property kp¶: 返回PID控制器的比例增益（kp）。

property tf¶: 返回PID控制器的导数滤波器时间常数（tf）。

class sympy.physics.control.lti.MIMOSeries(*args, evaluate=False)[源代码][源代码]¶

一个用于表示MIMO系统系列配置的类。

参数:

参数MIMOLinearTimeInvariant: 串联配置中的MIMO系统。
评估布尔值, 关键字: 当传递 True 时，返回等效的 MIMOSeries(*args).doit()。默认设置为 False。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
is_SISO: 如果传入的LTI系统是SISO，则返回`True`，否则返回`False`。
is_StateSpace_object
is_algebraic
is_antihermitian
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_polar
is_positive
is_prime
is_rational
is_real
is_transcendental
is_zero
num_inputs: 返回串联系统的输入信号数量。
num_outputs: 返回串联系统的输出信号数量。
shape: 返回等效MIMO系统的形状。
var: 返回所有传递函数使用的复变量。

方法

`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`doit`([cancel])	返回在串联配置中排列的MIMO系统评估后的结果。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

Raises:

ValueError

当没有传递参数时。

var 属性在每个系统中并不相同。

MIMO 系统的 num_outputs 与其相邻 MIMO 系统的 num_inputs 不相等。（基本上是矩阵乘法约束）

类型错误

传递的 *args 中任意一个具有不支持的类型

传递了 SISO 和 MIMO 系统的组合。传递的系统类型应具有同质性，在这种情况下为 MIMO。

参见

Series, MIMOParallel

注释

所有传递函数矩阵应使用相同的拉普拉斯变换的复变量 var。

MIMOSeries(A, B) 不等同于 A*B。它总是以相反的顺序，即 B*A。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import MIMOSeries, TransferFunctionMatrix, StateSpace
>>> 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}
>>> a1 = Matrix([[4, 1], [2, -3]])
>>> b1 = Matrix([[5, 2], [-3, -3]])
>>> c1 = Matrix([[2, -4], [0, 1]])
>>> d1 = Matrix([[3, 2], [1, -1]])
>>> a2 = Matrix([[-3, 4, 2], [-1, -3, 0], [2, 5, 3]])
>>> b2 = Matrix([[1, 4], [-3, -3], [-2, 1]])
>>> c2 = Matrix([[4, 2, -3], [1, 4, 3]])
>>> d2 = Matrix([[-2, 4], [0, 1]])
>>> ss1 = StateSpace(a1, b1, c1, d1) #2 inputs, 2 outputs
>>> ss2 = StateSpace(a2, b2, c2, d2) #2 inputs, 2 outputs
>>> S1 = MIMOSeries(ss1, ss2) #(2 inputs, 2 outputs) -> (2 inputs, 2 outputs)
>>> S1
MIMOSeries(StateSpace(Matrix([
        [4,  1],
        [2, -3]]), Matrix([
        [ 5,  2],
        [-3, -3]]), Matrix([
        [2, -4],
        [0,  1]]), Matrix([
        [3,  2],
        [1, -1]])), StateSpace(Matrix([
        [-3,  4, 2],
        [-1, -3, 0],
        [ 2,  5, 3]]), Matrix([
        [ 1,  4],
        [-3, -3],
        [-2,  1]]), Matrix([
        [4, 2, -3],
        [1, 4,  3]]), Matrix([
        [-2, 4],
        [ 0, 1]])))
>>> S1.doit()
StateSpace(Matrix([
[ 4,  1,  0,  0, 0],
[ 2, -3,  0,  0, 0],
[ 2,  0, -3,  4, 2],
[-6,  9, -1, -3, 0],
[-4,  9,  2,  5, 3]]), Matrix([
[  5,  2],
[ -3, -3],
[  7, -2],
[-12, -3],
[ -5, -5]]), Matrix([
[-4, 12, 4, 2, -3],
[ 0,  1, 1, 4,  3]]), Matrix([
[-2, -8],
[ 1, -1]]))

doit(cancel=False, **kwargs)[源代码][源代码]¶

返回在串联配置中排列的MIMO系统评估后的结果。对于TransferFunction系统，它返回一个TransferFunctionMatrix，对于StateSpace系统，它返回结果StateSpace系统。

示例

>>> 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 系统并行配置的类。

参数:

参数MIMOLinearTimeInvariant: 并行排列的MIMO系统。
评估布尔值, 关键字: 当传递 True 时，返回等效的 MIMOParallel(*args).doit()。默认设置为 False。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
is_SISO: 如果传入的LTI系统是SISO，则返回`True`，否则返回`False`。
is_StateSpace_object
is_algebraic
is_antihermitian
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_polar
is_positive
is_prime
is_rational
is_real
is_transcendental
is_zero
num_inputs: 返回并行系统的输入信号数量。
num_outputs: 返回并行系统的输出信号数量。
shape: 返回等效MIMO系统的形状。
var: 返回所有系统使用的复变量。

方法

`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`doit`(**hints)	返回在并行配置中排列的MIMO系统评估后得到的结果传递函数矩阵或状态空间。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

Raises:

ValueError

当没有传递参数时。

var 属性在每个系统中并不相同。

所有通过的MIMO系统并不具有相同的形状。

类型错误

传递的 *args 中任意一个具有不支持的类型

传递了 SISO 和 MIMO 系统的组合。传递的系统类型应具有同质性，在这种情况下为 MIMO。

参见

Parallel, MIMOSeries

注释

所有传递函数矩阵应使用相同的拉普拉斯变换的复变量 var。

示例

>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunctionMatrix, MIMOParallel, StateSpace
>>> 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}

MIMOParallel 也可以用于连接 MIMO StateSpace 系统。

>>> A1 = Matrix([[4, 1], [2, -3]])
>>> B1 = Matrix([[5, 2], [-3, -3]])
>>> C1 = Matrix([[2, -4], [0, 1]])
>>> D1 = Matrix([[3, 2], [1, -1]])
>>> A2 = Matrix([[-3, 4, 2], [-1, -3, 0], [2, 5, 3]])
>>> B2 = Matrix([[1, 4], [-3, -3], [-2, 1]])
>>> C2 = Matrix([[4, 2, -3], [1, 4, 3]])
>>> D2 = Matrix([[-2, 4], [0, 1]])
>>> ss1 = StateSpace(A1, B1, C1, D1)
>>> ss2 = StateSpace(A2, B2, C2, D2)
>>> p1 = MIMOParallel(ss1, ss2)
>>> p1
MIMOParallel(StateSpace(Matrix([
[4,  1],
[2, -3]]), Matrix([
[ 5,  2],
[-3, -3]]), Matrix([
[2, -4],
[0,  1]]), Matrix([
[3,  2],
[1, -1]])), StateSpace(Matrix([
[-3,  4, 2],
[-1, -3, 0],
[ 2,  5, 3]]), Matrix([
[ 1,  4],
[-3, -3],
[-2,  1]]), Matrix([
[4, 2, -3],
[1, 4,  3]]), Matrix([
[-2, 4],
[ 0, 1]])))

doit() 可以用于找到包含 StateSpace 对象的系统的 StateSpace 等效形式。

>>> p1.doit()
StateSpace(Matrix([
[4,  1,  0,  0, 0],
[2, -3,  0,  0, 0],
[0,  0, -3,  4, 2],
[0,  0, -1, -3, 0],
[0,  0,  2,  5, 3]]), Matrix([
[ 5,  2],
[-3, -3],
[ 1,  4],
[-3, -3],
[-2,  1]]), Matrix([
[2, -4, 4, 2, -3],
[0,  1, 1, 4,  3]]), Matrix([
[1, 6],
[1, 0]]))

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 输入/输出系统之间闭环反馈互连的类。

参数:

sys1MIMOSeries, TransferFunctionMatrix, StateSpace: 放置在正向路径上的MIMO系统。
sys2MIMOSeries, TransferFunctionMatrix, StateSpace: 放置在反馈路径上的系统（通常是一个反馈控制器）。
签名int, 可选: 反馈的符号。可以是 ``1``（表示正面反馈）或 ``-1``（表示负面反馈）。默认值是 \(-1\)。

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
is_SISO: 如果传入的LTI系统是SISO，则返回`True`，否则返回`False`。
is_algebraic
is_antihermitian
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_polar
is_positive
is_prime
is_rational
is_real
is_transcendental
is_zero
num_inputs: 返回系统的输入数量。
num_outputs: 返回系统的输出数量。
sensitivity: 返回反馈回路的灵敏度函数矩阵。
sign: 返回两个模型的反馈互联类型。
sys1: 返回放置在 MIMO 反馈互连前馈路径上的系统。
sys2: 返回 MIMO 反馈互联的反馈控制器。
var: 返回由MIMO反馈回路中所有传递函数使用的拉普拉斯变换的复变量。

方法

`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`doit`([cancel, expand])	返回通过反馈互连获得的结果传递函数矩阵。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

Raises:

ValueError

当 sys1 和 sys2 没有使用相同的拉普拉斯变换的复变量时。

前向路径模型应具有与反馈路径输出/输入数量相等的输入/输出数量。

当 sys1 和 sys2 的乘积不是方阵时。

当等效的MIMO系统不可逆时。

类型错误

当 sys1 或 sys2 不是 MIMOSeries、TransferFunctionMatrix 或 StateSpace 对象时。

参见

Feedback, MIMOSeries, MIMOParallel

示例

>>> from sympy import Matrix, pprint
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import StateSpace, 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}

MIMOFeedback 也可以用于连接 MIMO StateSpace 系统。

>>> A1 = Matrix([[4, 1], [2, -3]])
>>> B1 = Matrix([[5, 2], [-3, -3]])
>>> C1 = Matrix([[2, -4], [0, 1]])
>>> D1 = Matrix([[3, 2], [1, -1]])
>>> A2 = Matrix([[-3, 4, 2], [-1, -3, 0], [2, 5, 3]])
>>> B2 = Matrix([[1, 4], [-3, -3], [-2, 1]])
>>> C2 = Matrix([[4, 2, -3], [1, 4, 3]])
>>> D2 = Matrix([[-2, 4], [0, 1]])
>>> ss1 = StateSpace(A1, B1, C1, D1)
>>> ss2 = StateSpace(A2, B2, C2, D2)
>>> F1 = MIMOFeedback(ss1, ss2)
>>> F1
MIMOFeedback(StateSpace(Matrix([
[4,  1],
[2, -3]]), Matrix([
[ 5,  2],
[-3, -3]]), Matrix([
[2, -4],
[0,  1]]), Matrix([
[3,  2],
[1, -1]])), StateSpace(Matrix([
[-3,  4, 2],
[-1, -3, 0],
[ 2,  5, 3]]), Matrix([
[ 1,  4],
[-3, -3],
[-2,  1]]), Matrix([
[4, 2, -3],
[1, 4,  3]]), Matrix([
[-2, 4],
[ 0, 1]])), -1)

doit() 可以用于找到包含 StateSpace 对象的系统的 StateSpace 等效形式。

>>> F1.doit()
StateSpace(Matrix([
[   3,  -3/4, -15/4, -37/2, -15],
[ 7/2, -39/8,   9/8,  39/4,   9],
[   3, -41/4, -45/4, -51/2, -19],
[-9/2, 129/8,  73/8, 171/4,  36],
[-3/2,  47/8,  31/8,  85/4,  18]]), Matrix([
[-1/4,  19/4],
[ 3/8, -21/8],
[ 1/4,  29/4],
[ 3/8, -93/8],
[ 5/8, -35/8]]), Matrix([
[  1, -15/4,  -7/4, -21/2, -9],
[1/2, -13/8, -13/8, -19/4, -3]]), Matrix([
[-1/4, 11/4],
[ 1/8,  9/8]]))

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 kwarg 传递为 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 num_inputs¶: 返回系统的输入数量。

property num_outputs¶: 返回系统的输出数量。

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

class sympy.physics.control.lti.StateSpace(A=None, B=None, C=None, D=None)[源代码][源代码]¶

线性时不变控制系统的状态空间模型 (ssm)。

表示具有 A、B、C、D 作为状态空间矩阵的标准状态空间模型。这构成了线性控制系统：

x’(t) = A * x(t) + B * u(t); x 在 R^n 中, u 在 R^k 中

y(t) = C * x(t) + D * u(t); y 在 R^m 中

其中 u(t) 是任意输入信号，y(t) 是相应的输出，x(t) 是系统的状态。

参数:

A矩阵: 状态空间模型的状态矩阵。
B矩阵: 状态空间模型的输入到状态矩阵。
C矩阵: 状态空间模型的状态到输出矩阵。
D矩阵: 状态空间模型的传递矩阵。

属性:

A: 返回模型的状态矩阵。
B: 返回模型的输入矩阵。
C: 返回模型的输出矩阵。
D: 返回模型的前馈矩阵。
args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
expr_free_symbols
feedforward_matrix: 返回模型的前馈矩阵。
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
input_matrix: 返回模型的输入矩阵。
is_SISO: 如果传入的LTI系统是SISO，则返回`True`，否则返回`False`。
is_algebraic
is_antihermitian
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_polar
is_positive
is_prime
is_rational
is_real
is_transcendental
is_zero
num_inputs: 返回模型的输入数量。
num_outputs: 返回模型的输出数量。
num_states: 返回模型的状态数量。
output_matrix: 返回模型的输出矩阵。
shape: 返回等效 StateSpace 系统的形状。
state_matrix: 返回模型的状态矩阵。

方法

`append`(other)	返回第一个模型与第二个模型连接后的结果。
`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`controllability_matrix`()	返回系统的可控性矩阵：
`controllable_subspace`()	返回状态空间模型的可控子空间。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dsolve`([initial_conditions, input_vector, var])	返回 \(y(t)\) 或由方程解给出的 StateSpace 的输出：
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`is_controllable`()	返回状态空间模型是否可控。
`is_observable`()	返回状态空间模型是否可观测。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`observability_matrix`()	返回状态空间模型的可观测性矩阵：
`observable_subspace`()	返回状态空间模型的可观测子空间。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

参见

TransferFunction, TransferFunctionMatrix

参考文献

[1]

https://en.wikipedia.org/wiki/状态空间表示法

[2]

https://in.mathworks.com/help/control/ref/ss.html

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace

创建 StateSpaceModel 最简单的方法是通过四个矩阵：

>>> A = Matrix([[1, 2], [1, 0]])
>>> B = Matrix([1, 1])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([0])
>>> StateSpace(A, B, C, D)
StateSpace(Matrix([
[1, 2],
[1, 0]]), Matrix([
[1],
[1]]), Matrix([[0, 1]]), Matrix([[0]]))

可以使用较少的矩阵。其余部分将用最少的零填充：

>>> StateSpace(A, B)
StateSpace(Matrix([
[1, 2],
[1, 0]]), Matrix([
[1],
[1]]), Matrix([[0, 0]]), Matrix([[0]]))

property A¶

返回模型的状态矩阵。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[1, 2], [1, 0]])
>>> B = Matrix([1, 1])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([0])
>>> ss = StateSpace(A, B, C, D)
>>> ss.state_matrix
Matrix([
[1, 2],
[1, 0]])

property B¶

返回模型的输入矩阵。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[1, 2], [1, 0]])
>>> B = Matrix([1, 1])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([0])
>>> ss = StateSpace(A, B, C, D)
>>> ss.input_matrix
Matrix([
[1],
[1]])

property C¶

返回模型的输出矩阵。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[1, 2], [1, 0]])
>>> B = Matrix([1, 1])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([0])
>>> ss = StateSpace(A, B, C, D)
>>> ss.output_matrix
Matrix([[0, 1]])

property D¶

返回模型的前馈矩阵。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[1, 2], [1, 0]])
>>> B = Matrix([1, 1])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([0])
>>> ss = StateSpace(A, B, C, D)
>>> ss.feedforward_matrix
Matrix([[0]])

append(other)[源代码][源代码]¶

返回第一个模型与第二个模型连接后的结果。顺序保持不变。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A1 = Matrix([[1]])
>>> B1 = Matrix([[2]])
>>> C1 = Matrix([[-1]])
>>> D1 = Matrix([[-2]])
>>> A2 = Matrix([[-1]])
>>> B2 = Matrix([[-2]])
>>> C2 = Matrix([[1]])
>>> D2 = Matrix([[2]])
>>> ss1 = StateSpace(A1, B1, C1, D1)
>>> ss2 = StateSpace(A2, B2, C2, D2)
>>> ss1.append(ss2)
StateSpace(Matrix([
[1,  0],
[0, -1]]), Matrix([
[2,  0],
[0, -2]]), Matrix([
[-1, 0],
[ 0, 1]]), Matrix([
[-2, 0],
[ 0, 2]]))

controllability_matrix()[源代码][源代码]¶

返回系统的可控性矩阵：: [B, A * B, A^2 * B, .. , A^(n-1) * B]; A 在 R^(n x n) 中，B 在 R^(n x m) 中

参考文献

[1]

https://in.mathworks.com/help/control/ref/statespacemodel.ctrb.html

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[-1.5, -2], [1, 0]])
>>> B = Matrix([0.5, 0])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([1])
>>> ss = StateSpace(A, B, C, D)
>>> ss.controllability_matrix()
Matrix([
[0.5, -0.75],
[  0,   0.5]])

controllable_subspace()[源代码][源代码]¶

返回状态空间模型的可控子空间。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[-1.5, -2], [1, 0]])
>>> B = Matrix([0.5, 0])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([1])
>>> ss = StateSpace(A, B, C, D)
>>> co_subspace = ss.controllable_subspace()
>>> co_subspace
[Matrix([
[0.5],
[  0]]), Matrix([
[-0.75],
[  0.5]])]

dsolve( initial_conditions=None, input_vector=None, var=t, )[源代码][源代码]¶

返回 \(y(t)\) 或由方程解给出的 StateSpace 的输出：: x’(t) = A * x(t) + B * u(t) y(t) = C * x(t) + D * u(t)

参数:

初始条件矩阵: \(x\) 状态向量的初始条件。如果未提供，则默认为零向量。
输入向量矩阵: 状态空间输入向量。如果未提供，则默认为零向量。
变量符号: 表示时间的符号。如果未提供，它默认为 \(t\)。

参考文献

[1]

https://web.mit.edu/2.14/www/Handouts/StateSpaceResponse.pdf

[2]

https://docs.sympy.org/latest/modules/solvers/ode.html#sympy.solvers.ode.systems.linodesolve

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[-2, 0], [1, -1]])
>>> B = Matrix([[1], [0]])
>>> C = Matrix([[2, 1]])
>>> ip = Matrix([5])
>>> i = Matrix([0, 0])
>>> ss = StateSpace(A, B, C)
>>> ss.dsolve(input_vector=ip, initial_conditions=i).simplify()
Matrix([[15/2 - 5*exp(-t) - 5*exp(-2*t)/2]])

如果没有提供输入，它默认以零初始条件和零输入来求解系统。

>>> ss.dsolve()
Matrix([[0]])

property feedforward_matrix¶

返回模型的前馈矩阵。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[1, 2], [1, 0]])
>>> B = Matrix([1, 1])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([0])
>>> ss = StateSpace(A, B, C, D)
>>> ss.feedforward_matrix
Matrix([[0]])

property input_matrix¶

返回模型的输入矩阵。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[1, 2], [1, 0]])
>>> B = Matrix([1, 1])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([0])
>>> ss = StateSpace(A, B, C, D)
>>> ss.input_matrix
Matrix([
[1],
[1]])

is_controllable()[源代码][源代码]¶

返回状态空间模型是否可控。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[-1.5, -2], [1, 0]])
>>> B = Matrix([0.5, 0])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([1])
>>> ss = StateSpace(A, B, C, D)
>>> ss.is_controllable()
True

is_observable()[源代码][源代码]¶

返回状态空间模型是否可观测。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[-1.5, -2], [1, 0]])
>>> B = Matrix([0.5, 0])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([1])
>>> ss = StateSpace(A, B, C, D)
>>> ss.is_observable()
True

property num_inputs¶

返回模型的输入数量。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[1, 2], [1, 0]])
>>> B = Matrix([1, 1])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([0])
>>> ss = StateSpace(A, B, C, D)
>>> ss.num_inputs
1

property num_outputs¶

返回模型的输出数量。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[1, 2], [1, 0]])
>>> B = Matrix([1, 1])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([0])
>>> ss = StateSpace(A, B, C, D)
>>> ss.num_outputs
1

property num_states¶

返回模型的状态数量。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[1, 2], [1, 0]])
>>> B = Matrix([1, 1])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([0])
>>> ss = StateSpace(A, B, C, D)
>>> ss.num_states
2

observability_matrix()[源代码][源代码]¶

返回状态空间模型的可观测性矩阵：: [C, C * A^1, C * A^2, .. , C * A^(n-1)]; A 在 R^(n x n) 中, C 在 R^(m x k) 中

参考文献

[1]

https://in.mathworks.com/help/control/ref/statespacemodel.obsv.html

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[-1.5, -2], [1, 0]])
>>> B = Matrix([0.5, 0])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([1])
>>> ss = StateSpace(A, B, C, D)
>>> ob = ss.observability_matrix()
>>> ob
Matrix([
[0, 1],
[1, 0]])

observable_subspace()[源代码][源代码]¶

返回状态空间模型的可观测子空间。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[-1.5, -2], [1, 0]])
>>> B = Matrix([0.5, 0])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([1])
>>> ss = StateSpace(A, B, C, D)
>>> ob_subspace = ss.observable_subspace()
>>> ob_subspace
[Matrix([
[0],
[1]]), Matrix([
[1],
[0]])]

property output_matrix¶

返回模型的输出矩阵。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[1, 2], [1, 0]])
>>> B = Matrix([1, 1])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([0])
>>> ss = StateSpace(A, B, C, D)
>>> ss.output_matrix
Matrix([[0, 1]])

property shape¶: 返回等效 StateSpace 系统的形状。

property state_matrix¶

返回模型的状态矩阵。

示例

>>> from sympy import Matrix
>>> from sympy.physics.control import StateSpace
>>> A = Matrix([[1, 2], [1, 0]])
>>> B = Matrix([1, 1])
>>> C = Matrix([[0, 1]])
>>> D = Matrix([0])
>>> ss = StateSpace(A, B, C, D)
>>> ss.state_matrix
Matrix([
[1, 2],
[1, 0]])

sympy.physics.control.lti.gbt(tf, sample_per, alpha)[源代码][源代码]¶

返回从分子和分母得到的 H(z) 的下降系数。

参考文献

[1]

https://www.polyu.edu.hk/ama/profile/gfzhang/Research/ZCC09_IJC.pdf

示例

>>> 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)]

sympy.physics.control.lti.bilinear(tf, sample_per)[源代码][源代码]¶

返回从分子和分母得到的 H(z) 的下降系数。

示例

>>> 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) 的下降系数。

示例

>>> 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) 的下降系数。

示例

>>> 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)]