高斯光学

高斯光学。

该模块实现了：

• 几何光学和高斯光学的射线传输矩阵。

  参见 RayTransferMatrix、GeometricRay 和 BeamParameter

• 几何光学和高斯光学的共轭关系。

  参见 geometric_conj*, gauss_conj 和 conjugate_gauss_beams

距离的约定如下：

焦距

对于会聚透镜呈阳性

物体距离

对真实物体的积极态度

图像距离

真实图像为阳性

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

在光线传输矩阵形式主义中表示的高斯光线。

参数:

wavelen波长

z到腰部的距离，以及

w腰部，或

z_r瑞利范围。

n介质的折射率。

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

返回对象 \(type\) 假设。

canonical_variables

返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。

divergence

总角展度的二分之一。

expr_free_symbols

类似于 free_symbols，但仅在自由符号包含在表达式节点中时返回它们。

free_symbols

从自身的原子中返回那些自由符号。

func

表达式中的顶级函数。

gouy

Gouy 相位。

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_number

如果 self 没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。

is_odd

is_polar

is_positive

is_prime

is_rational

is_real

is_transcendental

is_zero

n

将给定的公式计算到 n 位精度。

q

表示光束的复杂参数。

radius

相位前缘的曲率半径。

w

光束的半径 w(z)，在光束沿 z 轴的任意位置。

w_0

光束在 \(1/e^2\) 强度（峰值）处的最小半径。

waist_approximation_limit

高斯光束近似有效的最小腰斑。

wavelen

z

z_r

方法

apart([x])	请参阅 sympy.polys 中的 apart 函数。
args_cnc([cset, warn, split_1])	返回 [交换因子, 非交换因子] 的自身。
as_coeff_Add([rational])	高效地提取求和的系数。
as_coeff_Mul([rational])	高效地提取乘积的系数。
as_coeff_add(*deps)	返回元组 (c, args)，其中 self 被写成一个 Add，a。
as_coeff_exponent(x)	c*x**e -> c,e 其中 x 可以是任何符号表达式。
as_coeff_mul(*deps, **kwargs)	返回元组 (c, args)，其中 self 被写成一个 Mul，m。
as_coefficient(expr)	提取给定表达式中的符号系数。
as_coefficients_dict(*syms)	返回一个字典，将术语映射到它们的 Rational 系数。
as_content_primitive([radical, clear])	此方法应递归地从所有参数中移除一个 Rational，并返回该内容和新的 self（原始类型）。
as_dummy()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
as_expr(*gens)	将多项式转换为 SymPy 表达式。
as_independent(*deps, **hint)	将 Mul 或 Add 的大部分天真分离为不依赖于 deps 的参数。
as_leading_term(*symbols[, logx, cdir])	返回自身级数展开的主导（非零）项。
as_numer_denom()	返回一个表达式的分子和分母。
as_ordered_factors([order])	返回有序因子列表（如果是 Mul），否则返回 [self]。
as_ordered_terms([order, data])	将表达式转换为有序的项列表。
as_poly(*gens, **args)	将 self 转换为多项式，或返回 None。
as_powers_dict()	将自身作为一个因子的字典返回，每个因子都被视为一个幂。
as_real_imag([deep])	对 'self' 执行复杂的扩展，并返回一个包含收集到的实部和虚部的元组。
as_terms()	将一个表达式转换为项的列表。
aseries([x, n, bound, hir])	自变量的渐近级数展开
atoms(*types)	返回构成当前对象的原子。
cancel(*gens, **args)	参见 sympy.polys 中的取消函数
class_key()	类的好顺序。
coeff(x[, n, right, _first])	返回包含 x**n 的项中的系数。
collect(syms[, func, evaluate, exact, ...])	请参阅 sympy.simplify 中的 collect 函数。
combsimp()	请参阅 sympy.simplify 中的 combsimp 函数。
compare(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
compute_leading_term(x[, logx])	已弃用的函数，用于计算级数的首项。
conjugate()	返回 'self' 的复数共轭。
could_extract_minus_sign()	如果 self 以 -1 作为前导因子，或在求和中有比正号更多的负号，则返回 True，否则返回 False。
count(query)	计算匹配的子表达式的数量。
count_ops([visual])
doit(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
equals(other[, failing_expression])	如果 self == other 则返回 True，如果不相等则返回 False，或者返回 None。
evalf([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
expand([deep, modulus, power_base, ...])	使用提示扩展表达式。
extract_additively(c)	如果可以从自身减去 c 并且使所有匹配的系数趋向于零，则返回 self - c，否则返回 None。
extract_branch_factor([allow_half])	尝试以 exp_polar(2*pi*I*n)*z 的方式优雅地表达自身。
extract_multiplicatively(c)	如果无法以一种良好的方式将 self 表示为 c * something，即保留 self 参数的属性，则返回 None。
factor(*gens, **args)	参见 sympy.polys.polytools 中的 factor() 函数
find(query[, group])	查找所有匹配查询的子表达式。
fourier_series([limits])	计算自身的傅里叶正弦/余弦级数。
fps([x, x0, dir, hyper, order, rational, full])	计算自身的形式幂级数。
fromiter(args, **assumptions)	从可迭代对象创建一个新对象。
gammasimp()	参见 sympy.simplify 中的 gammasimp 函数
getO()	如果有加法 O(..) 符号，则返回该符号，否则返回 None。
getn()	返回表达式的顺序。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
has_free(*patterns)	如果 self 包含对象 x 作为自由表达式，则返回 True，否则返回 False。
has_xfree(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
integrate(*args, **kwargs)	请参阅 sympy.integrals 中的 integrate 函数。
invert(g, *gens, **args)	返回 self 对 g 的乘法逆元，其中 self``（和 ``g）可以是符号表达式。
is_algebraic_expr(*syms)	此测试给定的表达式是否在给定的符号 syms 中是代数的。
is_constant(*wrt, **flags)	如果 self 是常量则返回 True，如果不是则返回 False，如果无法明确确定常量性则返回 None。
is_meromorphic(x, a)	此测试表达式是否作为给定符号 x 的函数在点 a 处是亚纯的。
is_polynomial(*syms)	如果 self 是 syms 中的多项式，则返回 True，否则返回 False。
is_rational_function(*syms)	测试函数是否是给定符号 syms 中的两个多项式的比率。
is_same(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
leadterm(x[, logx, cdir])	返回前导项 a*x**b 作为元组 (a, b)。
limit(x, xlim[, dir])	计算极限 x->xlim。
lseries([x, x0, dir, logx, cdir])	用于生成序列项的迭代器的包装器。
match(pattern[, old])	模式匹配。
matches(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
normal()	返回表达式为分数形式。
nseries([x, x0, n, dir, logx, cdir])	如果假设允许，则包装到 _eval_nseries，否则包装到 series。
nsimplify([constants, tolerance, full])	参见 sympy.simplify 中的 nsimplify 函数
powsimp(*args, **kwargs)	请参阅 sympy.simplify 中的 powsimp 函数
primitive()	返回可以从自身每个项中非递归提取的正有理数（即，将自身视为一个加法）。
radsimp(**kwargs)	参见 sympy.simplify 中的 radsimp 函数
ratsimp()	参见 sympy.simplify 中的 ratsimp 函数。
rcall(*args)	通过表达式树递归应用于参数。
refine([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
removeO()	如果存在，移除加性的 O(..) 符号
replace(query, value[, map, simultaneous, exact])	将 self 中匹配的子表达式替换为 value。
rewrite(*args[, deep])	使用定义的规则重写 self。
round([n])	返回 x 四舍五入到给定的十进制位数。
separate([deep, force])	参见 sympy.simplify 中的单独函数
series([x, x0, n, dir, logx, cdir])	在 x = x0 附近对 "self" 进行级数展开，当 n=None 时逐项给出级数项（即惰性级数），否则当 n != None 时一次性给出所有项。
simplify(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
taylor_term(n, x, *previous_terms)	泰勒项的一般方法。
together(*args, **kwargs)	请参阅 sympy.polys 中的 together 函数。
trigsimp(**args)	参见 sympy.simplify 中的 trigsimp 函数
xreplace(rule)	替换表达式中对象的出现。

伴随
as_base_exp
复制
差异
目录
is_hypergeometric
转置

参见

RayTransferMatrix

参考文献

[1]

https://en.wikipedia.org/wiki/复数束参数

[2]

https://en.wikipedia.org/wiki/高斯光束

示例

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

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

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

property divergence

总角展度的二分之一。

示例

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

property gouy

Gouy 相位。

示例

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

property q

表示光束的复杂参数。

示例

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

property radius

相位前缘的曲率半径。

示例

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

property w

光束在沿光束任意位置 z 处的半径 w(z)。光束半径在 \(1/e^2\) 强度（轴向值）处。

参见

w_0

梁的最小半径。

示例

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

property w_0

光束在 \(1/e^2\) 强度（峰值）处的最小半径。

参见

w

在 \(1/e^2\) 强度处的束半径（轴向值）。

示例

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

property waist_approximation_limit

高斯光束近似有效的最小腰斑。

示例

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

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

曲面反射的射线传输矩阵。

参数:

R曲率半径（凹面为正）

属性:

A

矩阵的A参数。

B

Matrix 的 B 参数。

C

Matrix 的 C 参数。

D

Matrix 的 D 参数。

H

返回厄米共轭。

T

矩阵转置

cols

free_symbols

返回矩阵中的自由符号。

is_Identity

is_echelon

如果矩阵是阶梯形式，则返回 \(True\)。

is_hermitian

检查矩阵是否为厄米矩阵。

is_indefinite

找出矩阵的确定性。

is_lower

检查矩阵是否为下三角矩阵。

is_lower_hessenberg

检查矩阵是否为下Hessenberg形式。

is_negative_definite

找出矩阵的确定性。

is_negative_semidefinite

找出矩阵的确定性。

is_positive_definite

找出矩阵的确定性。

is_positive_semidefinite

找出矩阵的确定性。

is_square

检查矩阵是否为方阵。

is_strongly_diagonally_dominant

测试矩阵是否为行强对角占优。

is_upper

检查矩阵是否为上三角矩阵。

is_upper_hessenberg

检查矩阵是否为上Hessenberg形式。

is_weakly_diagonally_dominant

测试矩阵是否为行弱对角占优。

is_zero_matrix

检查一个矩阵是否为零矩阵。

种类

行

shape

矩阵的形状（维度）作为 2 元组 (行数, 列数)。

方法

LDLdecomposition([hermitian])	返回矩阵 A 的 LDL 分解 (L, D)，使得如果 hermitian 标志为 True，则 L * D * L.H == A，或者如果 hermitian 为 False，则 L * D * L.T == A。
LDLsolve(rhs)	使用LDL分解求解 Ax = B，适用于一般的方阵和非奇异矩阵。
LUdecomposition([iszerofunc, simpfunc, ...])	返回 (L, U, perm)，其中 L 是一个对角线为单位矩阵的下三角矩阵，U 是一个上三角矩阵，perm 是一个行交换索引对的列表。
LUdecompositionFF()	计算一个无分数的LU分解。
LUdecomposition_Simple([iszerofunc, ...])	计算矩阵的 PLU 分解。
LUsolve(rhs[, iszerofunc])	求解线性系统 Ax = rhs 中的 x，其中 A = M。
QRdecomposition()	返回一个QR分解。
QRsolve(b)	求解线性系统 Ax = b。
add(b)	返回 self + b。
adjoint()	共轭转置或厄米共轭。
adjugate([method])	返回矩阵的伴随矩阵，或经典伴随矩阵。
analytic_func(f, x)	计算 f(A)，其中 A 是一个方阵，f 是一个解析函数。
applyfunc(f)	对矩阵的每个元素应用一个函数。
as_immutable()	返回此矩阵的不可变版本
as_mutable()	返回此矩阵的可变版本
as_real_imag([deep])	返回一个包含矩阵的（实部，虚部）部分的元组。
atoms(*types)	返回构成当前对象的原子。
berkowitz_det()	使用Berkowitz方法计算行列式。
berkowitz_eigenvals(**flags)	使用Berkowitz方法计算矩阵的特征值。
berkowitz_minors()	使用Berkowitz方法计算主子式。
bidiagonal_decomposition([upper])	返回 $(U,B,V.H)$ 用于
bidiagonalize([upper])	返回 $B$，即输入矩阵的双对角化形式。
charpoly([x, simplify])	计算特征多项式 det(x*I - M)，其中 I 是单位矩阵。
cholesky([hermitian])	返回矩阵 A 的 Cholesky 类型分解 L，使得如果 hermitian 标志为 True，则 L * L.H == A，或者如果 hermitian 为 False，则 L * L.T == A。
cholesky_solve(rhs)	使用 Cholesky 分解求解 Ax = B，适用于一般的非奇异方阵。
cofactor(i, j[, method])	计算元素的余子式。
cofactor_matrix([method])	返回一个包含每个元素的余子式的矩阵。
col(j)	基本列选择器。
col_del(col)	删除指定的列。
col_insert(pos, other)	在给定的列位置插入一列或多列。
col_join(other)	将两个矩阵沿着自身的最后一行和另一个矩阵的第一行进行连接。
col_op(j, f)	在列 j 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], i)。
col_swap(i, j)	就地交换矩阵中的两个给定列。
columnspace([simplify])	返回一个向量列表（矩阵对象），这些向量跨越 M 的列空间
companion(poly)	返回多项式的伴随矩阵。
condition_number()	返回矩阵的条件数。
conjugate()	返回按元素的共轭。
connected_components()	当一个方阵被视为加权图时，返回图中连接顶点的列表。
connected_components_decomposition()	仅使用排列将一个方阵分解为块对角形式。
copy()
copyin_list(key, value)	从列表中复制元素。
copyin_matrix(key, value)	将矩阵中的值复制到给定的边界内。
cramer_solve(rhs[, det_method])	使用克莱姆法则求解线性方程组。
cross(b)	返回 self 和 b 的叉积，放松兼容维度的条件：如果每个都有3个元素，将返回与 self 相同类型和形状的矩阵。
det([method, iszerofunc])	如果 M 是一个具体的矩阵对象，则计算其行列式；否则，如果 M 是一个 MatrixSymbol 或其他表达式，则返回表达式 Determinant(M)。
det_LU_decomposition()	使用LU分解计算矩阵行列式。
diag(*args[, strict, unpack, rows, cols])	返回具有指定对角线的矩阵。
diagonal([k])	返回自身的第 k 个对角线。
diagonal_solve(rhs)	高效求解 Ax = B，其中 A 是一个对角矩阵，且对角元素非零。
diagonalize([reals_only, sort, normalize])	返回 (P, D)，其中 D 是对角矩阵。
diff(*args[, evaluate])	计算矩阵中每个元素的导数。
dot(b[, hermitian, conjugate_convention])	返回两个长度相等的向量的点积或内积。
dual()	返回矩阵的对偶。
echelon_form([iszerofunc, simplify, with_pivots])	返回一个与 M 行等价的矩阵，该矩阵为阶梯形式。
eigenvals([error_when_incomplete])	计算矩阵的特征值。
eigenvects([error_when_incomplete, iszerofunc])	计算矩阵的特征向量。
elementary_col_op([op, col, k, col1, col2])	执行基本列操作 \(op\)。
elementary_row_op([op, row, k, row1, row2])	执行基本行操作 \(op\)。
equals(other[, failing_expression])	对矩阵的对应元素应用 equals ，试图证明这些元素是等价的，如果它们是等价的则返回 True ，如果有任何一对不等价则返回 False ，如果无法确定表达式是否等价，则返回 None （或者如果 failing_expression 为 True ，则返回第一个失败的表达式）。
evalf([n, subs, maxn, chop, strict, quad, ...])	对 self 的每个元素应用 evalf()。
exp()	返回一个方阵的指数。
expand([deep, modulus, power_base, ...])	对矩阵的每个条目应用 core.function.expand。
extract(rowsList, colsList)	通过指定行和列的列表返回一个子矩阵。
eye(rows[, cols])	返回一个单位矩阵。
fill(value)	用给定的值填充自身。
flat()
from_dok(rows, cols, dok)	从键的字典创建一个矩阵。
gauss_jordan_solve(B[, freevar])	使用高斯-约旦消元法求解 Ax = B。
get_diag_blocks()	获取方阵主对角线上的子方阵。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
hat()	返回表示叉积的反对称矩阵，使得 self.hat() * b 等价于 self.cross(b)。
hstack(*args)	返回一个矩阵，该矩阵通过水平连接参数（即通过重复应用 row_join）形成。
integrate(*args, **kwargs)	积分矩阵的每个元素。
inv([method, iszerofunc, try_block_diag])	使用指定方法返回矩阵的逆。
inv_mod(m)	返回整数矩阵 M 模 m 的逆。
inverse_ADJ([iszerofunc])	使用伴随矩阵和行列式计算逆矩阵。
inverse_BLOCK([iszerofunc])	使用块状逆运算计算逆矩阵。
inverse_CH([iszerofunc])	使用 Cholesky 分解计算逆矩阵。
inverse_GE([iszerofunc])	使用高斯消去法计算逆矩阵。
inverse_LDL([iszerofunc])	使用 LDL 分解计算逆矩阵。
inverse_LU([iszerofunc])	使用LU分解计算逆矩阵。
inverse_QR([iszerofunc])	使用QR分解计算逆矩阵。
irregular(ntop, *matrices, **kwargs)	返回一个矩阵，该矩阵由给定的矩阵填充，这些矩阵按从左到右、从上到下的顺序依次出现，与它们在矩阵中首次出现的位置一致。
is_anti_symmetric([simplify])	检查矩阵 M 是否为反对称矩阵，即，M 是一个方阵，且所有 M[i, j] == -M[j, i]。
is_diagonal()	检查矩阵是否为对角矩阵，即主对角线以外的所有元素均为零的矩阵。
is_diagonalizable([reals_only])	如果矩阵可对角化，则返回 True。
is_nilpotent()	检查矩阵是否为幂零矩阵。
is_symbolic()	检查是否有元素包含符号。
is_symmetric([simplify])	检查矩阵是否为对称矩阵，即方阵且等于其转置矩阵。
iter_items()	遍历非零项的索引和值。
iter_values()	遍历 self 的非零值
jacobian(X)	计算雅可比矩阵（向量值函数的导数）。
jordan_block([size, eigenvalue, band])	返回一个 Jordan 块
jordan_form([calc_transform])	返回 $(P, J)$，其中 $J$ 是一个约旦块矩阵，$P$ 是一个矩阵，使得 $M = P J P^{-1}$
key2bounds(keys)	将一个可能包含混合类型键（整数和切片）的键转换为范围元组，如果任何索引超出 self 的范围，则引发错误。
key2ij(key)	将键转换为规范形式，将整数或可索引项转换为 self 范围内的有效整数，或者返回切片不变。
left_eigenvects(**flags)	返回左特征向量和特征值。
limit(*args)	计算矩阵中每个元素的极限。
lll([delta])	LLL-约化基用于整数矩阵行空间的基。
lll_transform([delta])	LLL-约化基和变换矩阵。
log([simplify])	返回一个方阵的对数。
lower_triangular([k])	返回矩阵中第k条对角线及其以下的元素。
lower_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个下三角矩阵。
minor(i, j[, method])	返回 M 的 (i,j) 子式。
minor_submatrix(i, j)	返回通过从 M 中移除第 \(i\) 行和第 \(j\) 列得到的子矩阵（适用于Python风格的负索引）。
multiply(other[, dotprodsimp])	与 __mul__() 相同，但带有可选的简化。
multiply_elementwise(other)	返回 A 和 B 的 Hadamard 积（逐元素乘积）
n(*args, **kwargs)	对 self 的每个元素应用 evalf()。
norm([ord])	返回矩阵或向量的范数。
normalized([iszerofunc])	返回 self 的规范化版本。
nullspace([simplify, iszerofunc])	返回一个向量列表（Matrix 对象），这些向量跨越 M 的零空间
ones(rows[, cols])	返回一个全为1的矩阵。
orthogonalize(*vecs, **kwargs)	对 vecs 中的向量应用格拉姆-施密特正交化过程。
per()	返回矩阵的永久值。
permute(perm[, orientation, direction])	通过给定的交换列表置换矩阵的行或列。
permuteBkwd(perm)	使用给定的排列逆序排列矩阵的行。
permuteFwd(perm)	使用给定的排列来置换矩阵的行。
permute_cols(swaps[, direction])	self.permute(swaps, orientation='cols', direction=direction) 的别名
permute_rows(swaps[, direction])	self.permute(swaps, orientation='rows', direction=direction) 的别名
pinv([method])	计算矩阵的 Moore-Penrose 伪逆。
pinv_solve(B[, arbitrary_matrix])	使用 Moore-Penrose 伪逆求解 Ax = B。
pow(exp[, method])	返回 self**exp，其中 exp 是一个标量或符号。
print_nonzero([symb])	显示非零条目的位置，以便快速查找形状。
project(v)	返回 self 在包含 v 的直线上的投影。
rank([iszerofunc, simplify])	返回矩阵的秩。
rank_decomposition([iszerofunc, simplify])	返回一对矩阵 (\(C\), \(F\))，它们具有匹配的秩，使得 \(A = C F\)。
refine([assumptions])	对矩阵的每个元素应用细化。
replace(F, G[, map, simultaneous, exact])	将矩阵条目中的函数 F 替换为函数 G。
reshape(rows, cols)	重塑矩阵。
rmultiply(other[, dotprodsimp])	与 __rmul__() 相同，但带有可选的简化功能。
rot90([k])	将矩阵旋转90度
row(i)	基本行选择器。
row_add(s, t, k)	将行 s（源）的 k 倍加到行 t（目标）上，原地操作。
row_del(row)	删除指定的行。
row_insert(pos, other)	在给定的行位置插入一行或多行。
row_join(other)	将两个矩阵沿着自身的最后一列和rhs的第一列进行连接
row_mult(i, factor)	将给定的行按给定的因子就地乘以。
row_op(i, f)	在行 i 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], j)。
row_swap(i, j)	在原地交换矩阵的两行。
rowspace([simplify])	返回一个向量列表，这些向量跨越矩阵 M 的行空间。
rref([iszerofunc, simplify, pivots, ...])	返回矩阵的简化行阶梯形式和主元变量的索引。
rref_rhs(rhs)	返回矩阵的简化行阶梯形式，显示简化步骤后的右侧矩阵。
simplify(**kwargs)	对矩阵的元素就地应用简化。
singular_value_decomposition()	返回一个压缩的奇异值分解。
singular_values()	计算矩阵的奇异值
solve(rhs[, method])	求解存在唯一解的线性方程。
solve_least_squares(rhs[, method])	返回对数据的最小二乘拟合。
strongly_connected_components()	当将方阵视为加权图时，返回图中强连通顶点的列表。
strongly_connected_components_decomposition([lower])	仅使用排列将一个方阵分解为块三角形式。
subs(*args, **kwargs)	返回一个新的矩阵，其中每个条目都应用了subs。
table(printer[, rowstart, rowend, rowsep, ...])	以表格形式表示的矩阵字符串。
to_DM([domain])	转换为 DomainMatrix。
todod()	返回矩阵为包含矩阵非零元素的字典的字典
todok()	返回矩阵作为键的字典。
tolist()	返回矩阵作为嵌套的 Python 列表。
trace()	返回一个方阵的迹，即对角元素之和。
transpose()	返回矩阵的转置。
upper_hessenberg_decomposition()	将矩阵转换为Hessenberg矩阵H。
upper_triangular([k])	返回矩阵中第k条对角线及其以上的元素。
upper_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个上三角矩阵。
values()	返回 self 的非零值。
vec()	通过堆叠列将矩阵转换为一列矩阵
vech([diagonal, check_symmetry])	通过堆叠下三角中的元素，将矩阵重塑为列向量。
vee()	从表示叉积的反对称矩阵返回一个3x1向量，使得 self * b 等价于 self.vee().cross(b)。
vstack(*args)	返回一个矩阵，该矩阵是通过垂直连接参数（即通过重复应用 col_join）形成的。
wilkinson(n, **kwargs)	返回两个大小为 2*n + 1 的平方 Wilkinson 矩阵 $W_{2n + 1}^-, W_{2n + 1}^+ =$ Wilkinson(n)
xreplace(rule)	返回一个新的矩阵，其中每个条目都应用了 xreplace。
zeros(rows[, cols])	返回一个全零矩阵。
zip_row_op(i, k, f)	使用双参数仿函数对行 i 进行就地操作，其参数被解释为 (self[i, j], self[k, j])。

berkowitz
berkowitz_charpoly
cofactorMatrix
det_bareis
执行
jordan_cell
jordan_cells
minorEntry
minorMatrix

参见

RayTransferMatrix

示例

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

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

曲面界面折射的射线传输矩阵。

参数:

R

曲率半径（凹面为正）。

n1

一种介质的折射率。

n2

其他介质的折射率。

属性:

A

矩阵的A参数。

B

Matrix 的 B 参数。

C

Matrix 的 C 参数。

D

Matrix 的 D 参数。

H

返回厄米共轭。

T

矩阵转置

cols

free_symbols

返回矩阵中的自由符号。

is_Identity

is_echelon

如果矩阵是阶梯形式，则返回 \(True\)。

is_hermitian

检查矩阵是否为厄米矩阵。

is_indefinite

找出矩阵的确定性。

is_lower

检查矩阵是否为下三角矩阵。

is_lower_hessenberg

检查矩阵是否为下Hessenberg形式。

is_negative_definite

找出矩阵的确定性。

is_negative_semidefinite

找出矩阵的确定性。

is_positive_definite

找出矩阵的确定性。

is_positive_semidefinite

找出矩阵的确定性。

is_square

检查矩阵是否为方阵。

is_strongly_diagonally_dominant

测试矩阵是否为行强对角占优。

is_upper

检查矩阵是否为上三角矩阵。

is_upper_hessenberg

检查矩阵是否为上Hessenberg形式。

is_weakly_diagonally_dominant

测试矩阵是否为行弱对角占优。

is_zero_matrix

检查一个矩阵是否为零矩阵。

种类

行

shape

矩阵的形状（维度）作为 2 元组 (行数, 列数)。

方法

LDLdecomposition([hermitian])	返回矩阵 A 的 LDL 分解 (L, D)，使得如果 hermitian 标志为 True，则 L * D * L.H == A，或者如果 hermitian 为 False，则 L * D * L.T == A。
LDLsolve(rhs)	使用LDL分解求解 Ax = B，适用于一般的方阵和非奇异矩阵。
LUdecomposition([iszerofunc, simpfunc, ...])	返回 (L, U, perm)，其中 L 是一个对角线为单位矩阵的下三角矩阵，U 是一个上三角矩阵，perm 是一个行交换索引对的列表。
LUdecompositionFF()	计算一个无分数的LU分解。
LUdecomposition_Simple([iszerofunc, ...])	计算矩阵的 PLU 分解。
LUsolve(rhs[, iszerofunc])	求解线性系统 Ax = rhs 中的 x，其中 A = M。
QRdecomposition()	返回一个QR分解。
QRsolve(b)	求解线性系统 Ax = b。
add(b)	返回 self + b。
adjoint()	共轭转置或厄米共轭。
adjugate([method])	返回矩阵的伴随矩阵，或经典伴随矩阵。
analytic_func(f, x)	计算 f(A)，其中 A 是一个方阵，f 是一个解析函数。
applyfunc(f)	对矩阵的每个元素应用一个函数。
as_immutable()	返回此矩阵的不可变版本
as_mutable()	返回此矩阵的可变版本
as_real_imag([deep])	返回一个包含矩阵的（实部，虚部）部分的元组。
atoms(*types)	返回构成当前对象的原子。
berkowitz_det()	使用Berkowitz方法计算行列式。
berkowitz_eigenvals(**flags)	使用Berkowitz方法计算矩阵的特征值。
berkowitz_minors()	使用Berkowitz方法计算主子式。
bidiagonal_decomposition([upper])	返回 $(U,B,V.H)$ 用于
bidiagonalize([upper])	返回 $B$，即输入矩阵的双对角化形式。
charpoly([x, simplify])	计算特征多项式 det(x*I - M)，其中 I 是单位矩阵。
cholesky([hermitian])	返回矩阵 A 的 Cholesky 类型分解 L，使得如果 hermitian 标志为 True，则 L * L.H == A，或者如果 hermitian 为 False，则 L * L.T == A。
cholesky_solve(rhs)	使用 Cholesky 分解求解 Ax = B，适用于一般的非奇异方阵。
cofactor(i, j[, method])	计算元素的余子式。
cofactor_matrix([method])	返回一个包含每个元素的余子式的矩阵。
col(j)	基本列选择器。
col_del(col)	删除指定的列。
col_insert(pos, other)	在给定的列位置插入一列或多列。
col_join(other)	将两个矩阵沿着自身的最后一行和另一个矩阵的第一行进行连接。
col_op(j, f)	在列 j 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], i)。
col_swap(i, j)	就地交换矩阵中的两个给定列。
columnspace([simplify])	返回一个向量列表（矩阵对象），这些向量跨越 M 的列空间
companion(poly)	返回多项式的伴随矩阵。
condition_number()	返回矩阵的条件数。
conjugate()	返回按元素的共轭。
connected_components()	当一个方阵被视为加权图时，返回图中连接顶点的列表。
connected_components_decomposition()	仅使用排列将一个方阵分解为块对角形式。
copy()
copyin_list(key, value)	从列表中复制元素。
copyin_matrix(key, value)	将矩阵中的值复制到给定的边界内。
cramer_solve(rhs[, det_method])	使用克莱姆法则求解线性方程组。
cross(b)	返回 self 和 b 的叉积，放松兼容维度的条件：如果每个都有3个元素，将返回与 self 相同类型和形状的矩阵。
det([method, iszerofunc])	如果 M 是一个具体的矩阵对象，则计算其行列式；否则，如果 M 是一个 MatrixSymbol 或其他表达式，则返回表达式 Determinant(M)。
det_LU_decomposition()	使用LU分解计算矩阵行列式。
diag(*args[, strict, unpack, rows, cols])	返回具有指定对角线的矩阵。
diagonal([k])	返回自身的第 k 个对角线。
diagonal_solve(rhs)	高效求解 Ax = B，其中 A 是一个对角矩阵，且对角元素非零。
diagonalize([reals_only, sort, normalize])	返回 (P, D)，其中 D 是对角矩阵。
diff(*args[, evaluate])	计算矩阵中每个元素的导数。
dot(b[, hermitian, conjugate_convention])	返回两个长度相等的向量的点积或内积。
dual()	返回矩阵的对偶。
echelon_form([iszerofunc, simplify, with_pivots])	返回一个与 M 行等价的矩阵，该矩阵为阶梯形式。
eigenvals([error_when_incomplete])	计算矩阵的特征值。
eigenvects([error_when_incomplete, iszerofunc])	计算矩阵的特征向量。
elementary_col_op([op, col, k, col1, col2])	执行基本列操作 \(op\)。
elementary_row_op([op, row, k, row1, row2])	执行基本行操作 \(op\)。
equals(other[, failing_expression])	对矩阵的对应元素应用 equals ，试图证明这些元素是等价的，如果它们是等价的则返回 True ，如果有任何一对不等价则返回 False ，如果无法确定表达式是否等价，则返回 None （或者如果 failing_expression 为 True ，则返回第一个失败的表达式）。
evalf([n, subs, maxn, chop, strict, quad, ...])	对 self 的每个元素应用 evalf()。
exp()	返回一个方阵的指数。
expand([deep, modulus, power_base, ...])	对矩阵的每个条目应用 core.function.expand。
extract(rowsList, colsList)	通过指定行和列的列表返回一个子矩阵。
eye(rows[, cols])	返回一个单位矩阵。
fill(value)	用给定的值填充自身。
flat()
from_dok(rows, cols, dok)	从键的字典创建一个矩阵。
gauss_jordan_solve(B[, freevar])	使用高斯-约旦消元法求解 Ax = B。
get_diag_blocks()	获取方阵主对角线上的子方阵。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
hat()	返回表示叉积的反对称矩阵，使得 self.hat() * b 等价于 self.cross(b)。
hstack(*args)	返回一个矩阵，该矩阵通过水平连接参数（即通过重复应用 row_join）形成。
integrate(*args, **kwargs)	积分矩阵的每个元素。
inv([method, iszerofunc, try_block_diag])	使用指定方法返回矩阵的逆。
inv_mod(m)	返回整数矩阵 M 模 m 的逆。
inverse_ADJ([iszerofunc])	使用伴随矩阵和行列式计算逆矩阵。
inverse_BLOCK([iszerofunc])	使用块状逆运算计算逆矩阵。
inverse_CH([iszerofunc])	使用 Cholesky 分解计算逆矩阵。
inverse_GE([iszerofunc])	使用高斯消去法计算逆矩阵。
inverse_LDL([iszerofunc])	使用 LDL 分解计算逆矩阵。
inverse_LU([iszerofunc])	使用LU分解计算逆矩阵。
inverse_QR([iszerofunc])	使用QR分解计算逆矩阵。
irregular(ntop, *matrices, **kwargs)	返回一个矩阵，该矩阵由给定的矩阵填充，这些矩阵按从左到右、从上到下的顺序依次出现，与它们在矩阵中首次出现的位置一致。
is_anti_symmetric([simplify])	检查矩阵 M 是否为反对称矩阵，即，M 是一个方阵，且所有 M[i, j] == -M[j, i]。
is_diagonal()	检查矩阵是否为对角矩阵，即主对角线以外的所有元素均为零的矩阵。
is_diagonalizable([reals_only])	如果矩阵可对角化，则返回 True。
is_nilpotent()	检查矩阵是否为幂零矩阵。
is_symbolic()	检查是否有元素包含符号。
is_symmetric([simplify])	检查矩阵是否为对称矩阵，即方阵且等于其转置矩阵。
iter_items()	遍历非零项的索引和值。
iter_values()	遍历 self 的非零值
jacobian(X)	计算雅可比矩阵（向量值函数的导数）。
jordan_block([size, eigenvalue, band])	返回一个 Jordan 块
jordan_form([calc_transform])	返回 $(P, J)$，其中 $J$ 是一个约旦块矩阵，$P$ 是一个矩阵，使得 $M = P J P^{-1}$
key2bounds(keys)	将一个可能包含混合类型键（整数和切片）的键转换为范围元组，如果任何索引超出 self 的范围，则引发错误。
key2ij(key)	将键转换为规范形式，将整数或可索引项转换为 self 范围内的有效整数，或者返回切片不变。
left_eigenvects(**flags)	返回左特征向量和特征值。
limit(*args)	计算矩阵中每个元素的极限。
lll([delta])	LLL-约化基用于整数矩阵行空间的基。
lll_transform([delta])	LLL-约化基和变换矩阵。
log([simplify])	返回一个方阵的对数。
lower_triangular([k])	返回矩阵中第k条对角线及其以下的元素。
lower_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个下三角矩阵。
minor(i, j[, method])	返回 M 的 (i,j) 子式。
minor_submatrix(i, j)	返回通过从 M 中移除第 \(i\) 行和第 \(j\) 列得到的子矩阵（适用于Python风格的负索引）。
multiply(other[, dotprodsimp])	与 __mul__() 相同，但带有可选的简化。
multiply_elementwise(other)	返回 A 和 B 的 Hadamard 积（逐元素乘积）
n(*args, **kwargs)	对 self 的每个元素应用 evalf()。
norm([ord])	返回矩阵或向量的范数。
normalized([iszerofunc])	返回 self 的规范化版本。
nullspace([simplify, iszerofunc])	返回一个向量列表（Matrix 对象），这些向量跨越 M 的零空间
ones(rows[, cols])	返回一个全为1的矩阵。
orthogonalize(*vecs, **kwargs)	对 vecs 中的向量应用格拉姆-施密特正交化过程。
per()	返回矩阵的永久值。
permute(perm[, orientation, direction])	通过给定的交换列表置换矩阵的行或列。
permuteBkwd(perm)	使用给定的排列逆序排列矩阵的行。
permuteFwd(perm)	使用给定的排列来置换矩阵的行。
permute_cols(swaps[, direction])	self.permute(swaps, orientation='cols', direction=direction) 的别名
permute_rows(swaps[, direction])	self.permute(swaps, orientation='rows', direction=direction) 的别名
pinv([method])	计算矩阵的 Moore-Penrose 伪逆。
pinv_solve(B[, arbitrary_matrix])	使用 Moore-Penrose 伪逆求解 Ax = B。
pow(exp[, method])	返回 self**exp，其中 exp 是一个标量或符号。
print_nonzero([symb])	显示非零条目的位置，以便快速查找形状。
project(v)	返回 self 在包含 v 的直线上的投影。
rank([iszerofunc, simplify])	返回矩阵的秩。
rank_decomposition([iszerofunc, simplify])	返回一对矩阵 (\(C\), \(F\))，它们具有匹配的秩，使得 \(A = C F\)。
refine([assumptions])	对矩阵的每个元素应用细化。
replace(F, G[, map, simultaneous, exact])	将矩阵条目中的函数 F 替换为函数 G。
reshape(rows, cols)	重塑矩阵。
rmultiply(other[, dotprodsimp])	与 __rmul__() 相同，但带有可选的简化功能。
rot90([k])	将矩阵旋转90度
row(i)	基本行选择器。
row_add(s, t, k)	将行 s（源）的 k 倍加到行 t（目标）上，原地操作。
row_del(row)	删除指定的行。
row_insert(pos, other)	在给定的行位置插入一行或多行。
row_join(other)	将两个矩阵沿着自身的最后一列和rhs的第一列进行连接
row_mult(i, factor)	将给定的行按给定的因子就地乘以。
row_op(i, f)	在行 i 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], j)。
row_swap(i, j)	在原地交换矩阵的两行。
rowspace([simplify])	返回一个向量列表，这些向量跨越矩阵 M 的行空间。
rref([iszerofunc, simplify, pivots, ...])	返回矩阵的简化行阶梯形式和主元变量的索引。
rref_rhs(rhs)	返回矩阵的简化行阶梯形式，显示简化步骤后的右侧矩阵。
simplify(**kwargs)	对矩阵的元素就地应用简化。
singular_value_decomposition()	返回一个压缩的奇异值分解。
singular_values()	计算矩阵的奇异值
solve(rhs[, method])	求解存在唯一解的线性方程。
solve_least_squares(rhs[, method])	返回对数据的最小二乘拟合。
strongly_connected_components()	当将方阵视为加权图时，返回图中强连通顶点的列表。
strongly_connected_components_decomposition([lower])	仅使用排列将一个方阵分解为块三角形式。
subs(*args, **kwargs)	返回一个新的矩阵，其中每个条目都应用了subs。
table(printer[, rowstart, rowend, rowsep, ...])	以表格形式表示的矩阵字符串。
to_DM([domain])	转换为 DomainMatrix。
todod()	返回矩阵为包含矩阵非零元素的字典的字典
todok()	返回矩阵作为键的字典。
tolist()	返回矩阵作为嵌套的 Python 列表。
trace()	返回一个方阵的迹，即对角元素之和。
transpose()	返回矩阵的转置。
upper_hessenberg_decomposition()	将矩阵转换为Hessenberg矩阵H。
upper_triangular([k])	返回矩阵中第k条对角线及其以上的元素。
upper_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个上三角矩阵。
values()	返回 self 的非零值。
vec()	通过堆叠列将矩阵转换为一列矩阵
vech([diagonal, check_symmetry])	通过堆叠下三角中的元素，将矩阵重塑为列向量。
vee()	从表示叉积的反对称矩阵返回一个3x1向量，使得 self * b 等价于 self.vee().cross(b)。
vstack(*args)	返回一个矩阵，该矩阵是通过垂直连接参数（即通过重复应用 col_join）形成的。
wilkinson(n, **kwargs)	返回两个大小为 2*n + 1 的平方 Wilkinson 矩阵 $W_{2n + 1}^-, W_{2n + 1}^+ =$ Wilkinson(n)
xreplace(rule)	返回一个新的矩阵，其中每个条目都应用了 xreplace。
zeros(rows[, cols])	返回一个全零矩阵。
zip_row_op(i, k, f)	使用双参数仿函数对行 i 进行就地操作，其参数被解释为 (self[i, j], self[k, j])。

berkowitz
berkowitz_charpoly
cofactorMatrix
det_bareis
执行
jordan_cell
jordan_cells
minorEntry
minorMatrix

参见

RayTransferMatrix

示例

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

class sympy.physics.optics.gaussopt.FlatMirror

反射的射线传输矩阵。

属性:

A

矩阵的A参数。

B

Matrix 的 B 参数。

C

Matrix 的 C 参数。

D

Matrix 的 D 参数。

H

返回厄米共轭。

T

矩阵转置

cols

free_symbols

返回矩阵中的自由符号。

is_Identity

is_echelon

如果矩阵是阶梯形式，则返回 \(True\)。

is_hermitian

检查矩阵是否为厄米矩阵。

is_indefinite

找出矩阵的确定性。

is_lower

检查矩阵是否为下三角矩阵。

is_lower_hessenberg

检查矩阵是否为下Hessenberg形式。

is_negative_definite

找出矩阵的确定性。

is_negative_semidefinite

找出矩阵的确定性。

is_positive_definite

找出矩阵的确定性。

is_positive_semidefinite

找出矩阵的确定性。

is_square

检查矩阵是否为方阵。

is_strongly_diagonally_dominant

测试矩阵是否为行强对角占优。

is_upper

检查矩阵是否为上三角矩阵。

is_upper_hessenberg

检查矩阵是否为上Hessenberg形式。

is_weakly_diagonally_dominant

测试矩阵是否为行弱对角占优。

is_zero_matrix

检查一个矩阵是否为零矩阵。

种类

行

shape

矩阵的形状（维度）作为 2 元组 (行数, 列数)。

方法

LDLdecomposition([hermitian])	返回矩阵 A 的 LDL 分解 (L, D)，使得如果 hermitian 标志为 True，则 L * D * L.H == A，或者如果 hermitian 为 False，则 L * D * L.T == A。
LDLsolve(rhs)	使用LDL分解求解 Ax = B，适用于一般的方阵和非奇异矩阵。
LUdecomposition([iszerofunc, simpfunc, ...])	返回 (L, U, perm)，其中 L 是一个对角线为单位矩阵的下三角矩阵，U 是一个上三角矩阵，perm 是一个行交换索引对的列表。
LUdecompositionFF()	计算一个无分数的LU分解。
LUdecomposition_Simple([iszerofunc, ...])	计算矩阵的 PLU 分解。
LUsolve(rhs[, iszerofunc])	求解线性系统 Ax = rhs 中的 x，其中 A = M。
QRdecomposition()	返回一个QR分解。
QRsolve(b)	求解线性系统 Ax = b。
add(b)	返回 self + b。
adjoint()	共轭转置或厄米共轭。
adjugate([method])	返回矩阵的伴随矩阵，或经典伴随矩阵。
analytic_func(f, x)	计算 f(A)，其中 A 是一个方阵，f 是一个解析函数。
applyfunc(f)	对矩阵的每个元素应用一个函数。
as_immutable()	返回此矩阵的不可变版本
as_mutable()	返回此矩阵的可变版本
as_real_imag([deep])	返回一个包含矩阵的（实部，虚部）部分的元组。
atoms(*types)	返回构成当前对象的原子。
berkowitz_det()	使用Berkowitz方法计算行列式。
berkowitz_eigenvals(**flags)	使用Berkowitz方法计算矩阵的特征值。
berkowitz_minors()	使用Berkowitz方法计算主子式。
bidiagonal_decomposition([upper])	返回 $(U,B,V.H)$ 用于
bidiagonalize([upper])	返回 $B$，即输入矩阵的双对角化形式。
charpoly([x, simplify])	计算特征多项式 det(x*I - M)，其中 I 是单位矩阵。
cholesky([hermitian])	返回矩阵 A 的 Cholesky 类型分解 L，使得如果 hermitian 标志为 True，则 L * L.H == A，或者如果 hermitian 为 False，则 L * L.T == A。
cholesky_solve(rhs)	使用 Cholesky 分解求解 Ax = B，适用于一般的非奇异方阵。
cofactor(i, j[, method])	计算元素的余子式。
cofactor_matrix([method])	返回一个包含每个元素的余子式的矩阵。
col(j)	基本列选择器。
col_del(col)	删除指定的列。
col_insert(pos, other)	在给定的列位置插入一列或多列。
col_join(other)	将两个矩阵沿着自身的最后一行和另一个矩阵的第一行进行连接。
col_op(j, f)	在列 j 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], i)。
col_swap(i, j)	就地交换矩阵中的两个给定列。
columnspace([simplify])	返回一个向量列表（矩阵对象），这些向量跨越 M 的列空间
companion(poly)	返回多项式的伴随矩阵。
condition_number()	返回矩阵的条件数。
conjugate()	返回按元素的共轭。
connected_components()	当一个方阵被视为加权图时，返回图中连接顶点的列表。
connected_components_decomposition()	仅使用排列将一个方阵分解为块对角形式。
copy()
copyin_list(key, value)	从列表中复制元素。
copyin_matrix(key, value)	将矩阵中的值复制到给定的边界内。
cramer_solve(rhs[, det_method])	使用克莱姆法则求解线性方程组。
cross(b)	返回 self 和 b 的叉积，放松兼容维度的条件：如果每个都有3个元素，将返回与 self 相同类型和形状的矩阵。
det([method, iszerofunc])	如果 M 是一个具体的矩阵对象，则计算其行列式；否则，如果 M 是一个 MatrixSymbol 或其他表达式，则返回表达式 Determinant(M)。
det_LU_decomposition()	使用LU分解计算矩阵行列式。
diag(*args[, strict, unpack, rows, cols])	返回具有指定对角线的矩阵。
diagonal([k])	返回自身的第 k 个对角线。
diagonal_solve(rhs)	高效求解 Ax = B，其中 A 是一个对角矩阵，且对角元素非零。
diagonalize([reals_only, sort, normalize])	返回 (P, D)，其中 D 是对角矩阵。
diff(*args[, evaluate])	计算矩阵中每个元素的导数。
dot(b[, hermitian, conjugate_convention])	返回两个长度相等的向量的点积或内积。
dual()	返回矩阵的对偶。
echelon_form([iszerofunc, simplify, with_pivots])	返回一个与 M 行等价的矩阵，该矩阵为阶梯形式。
eigenvals([error_when_incomplete])	计算矩阵的特征值。
eigenvects([error_when_incomplete, iszerofunc])	计算矩阵的特征向量。
elementary_col_op([op, col, k, col1, col2])	执行基本列操作 \(op\)。
elementary_row_op([op, row, k, row1, row2])	执行基本行操作 \(op\)。
equals(other[, failing_expression])	对矩阵的对应元素应用 equals ，试图证明这些元素是等价的，如果它们是等价的则返回 True ，如果有任何一对不等价则返回 False ，如果无法确定表达式是否等价，则返回 None （或者如果 failing_expression 为 True ，则返回第一个失败的表达式）。
evalf([n, subs, maxn, chop, strict, quad, ...])	对 self 的每个元素应用 evalf()。
exp()	返回一个方阵的指数。
expand([deep, modulus, power_base, ...])	对矩阵的每个条目应用 core.function.expand。
extract(rowsList, colsList)	通过指定行和列的列表返回一个子矩阵。
eye(rows[, cols])	返回一个单位矩阵。
fill(value)	用给定的值填充自身。
flat()
from_dok(rows, cols, dok)	从键的字典创建一个矩阵。
gauss_jordan_solve(B[, freevar])	使用高斯-约旦消元法求解 Ax = B。
get_diag_blocks()	获取方阵主对角线上的子方阵。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
hat()	返回表示叉积的反对称矩阵，使得 self.hat() * b 等价于 self.cross(b)。
hstack(*args)	返回一个矩阵，该矩阵通过水平连接参数（即通过重复应用 row_join）形成。
integrate(*args, **kwargs)	积分矩阵的每个元素。
inv([method, iszerofunc, try_block_diag])	使用指定方法返回矩阵的逆。
inv_mod(m)	返回整数矩阵 M 模 m 的逆。
inverse_ADJ([iszerofunc])	使用伴随矩阵和行列式计算逆矩阵。
inverse_BLOCK([iszerofunc])	使用块状逆运算计算逆矩阵。
inverse_CH([iszerofunc])	使用 Cholesky 分解计算逆矩阵。
inverse_GE([iszerofunc])	使用高斯消去法计算逆矩阵。
inverse_LDL([iszerofunc])	使用 LDL 分解计算逆矩阵。
inverse_LU([iszerofunc])	使用LU分解计算逆矩阵。
inverse_QR([iszerofunc])	使用QR分解计算逆矩阵。
irregular(ntop, *matrices, **kwargs)	返回一个矩阵，该矩阵由给定的矩阵填充，这些矩阵按从左到右、从上到下的顺序依次出现，与它们在矩阵中首次出现的位置一致。
is_anti_symmetric([simplify])	检查矩阵 M 是否为反对称矩阵，即，M 是一个方阵，且所有 M[i, j] == -M[j, i]。
is_diagonal()	检查矩阵是否为对角矩阵，即主对角线以外的所有元素均为零的矩阵。
is_diagonalizable([reals_only])	如果矩阵可对角化，则返回 True。
is_nilpotent()	检查矩阵是否为幂零矩阵。
is_symbolic()	检查是否有元素包含符号。
is_symmetric([simplify])	检查矩阵是否为对称矩阵，即方阵且等于其转置矩阵。
iter_items()	遍历非零项的索引和值。
iter_values()	遍历 self 的非零值
jacobian(X)	计算雅可比矩阵（向量值函数的导数）。
jordan_block([size, eigenvalue, band])	返回一个 Jordan 块
jordan_form([calc_transform])	返回 $(P, J)$，其中 $J$ 是一个约旦块矩阵，$P$ 是一个矩阵，使得 $M = P J P^{-1}$
key2bounds(keys)	将一个可能包含混合类型键（整数和切片）的键转换为范围元组，如果任何索引超出 self 的范围，则引发错误。
key2ij(key)	将键转换为规范形式，将整数或可索引项转换为 self 范围内的有效整数，或者返回切片不变。
left_eigenvects(**flags)	返回左特征向量和特征值。
limit(*args)	计算矩阵中每个元素的极限。
lll([delta])	LLL-约化基用于整数矩阵行空间的基。
lll_transform([delta])	LLL-约化基和变换矩阵。
log([simplify])	返回一个方阵的对数。
lower_triangular([k])	返回矩阵中第k条对角线及其以下的元素。
lower_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个下三角矩阵。
minor(i, j[, method])	返回 M 的 (i,j) 子式。
minor_submatrix(i, j)	返回通过从 M 中移除第 \(i\) 行和第 \(j\) 列得到的子矩阵（适用于Python风格的负索引）。
multiply(other[, dotprodsimp])	与 __mul__() 相同，但带有可选的简化。
multiply_elementwise(other)	返回 A 和 B 的 Hadamard 积（逐元素乘积）
n(*args, **kwargs)	对 self 的每个元素应用 evalf()。
norm([ord])	返回矩阵或向量的范数。
normalized([iszerofunc])	返回 self 的规范化版本。
nullspace([simplify, iszerofunc])	返回一个向量列表（Matrix 对象），这些向量跨越 M 的零空间
ones(rows[, cols])	返回一个全为1的矩阵。
orthogonalize(*vecs, **kwargs)	对 vecs 中的向量应用格拉姆-施密特正交化过程。
per()	返回矩阵的永久值。
permute(perm[, orientation, direction])	通过给定的交换列表置换矩阵的行或列。
permuteBkwd(perm)	使用给定的排列逆序排列矩阵的行。
permuteFwd(perm)	使用给定的排列来置换矩阵的行。
permute_cols(swaps[, direction])	self.permute(swaps, orientation='cols', direction=direction) 的别名
permute_rows(swaps[, direction])	self.permute(swaps, orientation='rows', direction=direction) 的别名
pinv([method])	计算矩阵的 Moore-Penrose 伪逆。
pinv_solve(B[, arbitrary_matrix])	使用 Moore-Penrose 伪逆求解 Ax = B。
pow(exp[, method])	返回 self**exp，其中 exp 是一个标量或符号。
print_nonzero([symb])	显示非零条目的位置，以便快速查找形状。
project(v)	返回 self 在包含 v 的直线上的投影。
rank([iszerofunc, simplify])	返回矩阵的秩。
rank_decomposition([iszerofunc, simplify])	返回一对矩阵 (\(C\), \(F\))，它们具有匹配的秩，使得 \(A = C F\)。
refine([assumptions])	对矩阵的每个元素应用细化。
replace(F, G[, map, simultaneous, exact])	将矩阵条目中的函数 F 替换为函数 G。
reshape(rows, cols)	重塑矩阵。
rmultiply(other[, dotprodsimp])	与 __rmul__() 相同，但带有可选的简化功能。
rot90([k])	将矩阵旋转90度
row(i)	基本行选择器。
row_add(s, t, k)	将行 s（源）的 k 倍加到行 t（目标）上，原地操作。
row_del(row)	删除指定的行。
row_insert(pos, other)	在给定的行位置插入一行或多行。
row_join(other)	将两个矩阵沿着自身的最后一列和rhs的第一列进行连接
row_mult(i, factor)	将给定的行按给定的因子就地乘以。
row_op(i, f)	在行 i 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], j)。
row_swap(i, j)	在原地交换矩阵的两行。
rowspace([simplify])	返回一个向量列表，这些向量跨越矩阵 M 的行空间。
rref([iszerofunc, simplify, pivots, ...])	返回矩阵的简化行阶梯形式和主元变量的索引。
rref_rhs(rhs)	返回矩阵的简化行阶梯形式，显示简化步骤后的右侧矩阵。
simplify(**kwargs)	对矩阵的元素就地应用简化。
singular_value_decomposition()	返回一个压缩的奇异值分解。
singular_values()	计算矩阵的奇异值
solve(rhs[, method])	求解存在唯一解的线性方程。
solve_least_squares(rhs[, method])	返回对数据的最小二乘拟合。
strongly_connected_components()	当将方阵视为加权图时，返回图中强连通顶点的列表。
strongly_connected_components_decomposition([lower])	仅使用排列将一个方阵分解为块三角形式。
subs(*args, **kwargs)	返回一个新的矩阵，其中每个条目都应用了subs。
table(printer[, rowstart, rowend, rowsep, ...])	以表格形式表示的矩阵字符串。
to_DM([domain])	转换为 DomainMatrix。
todod()	返回矩阵为包含矩阵非零元素的字典的字典
todok()	返回矩阵作为键的字典。
tolist()	返回矩阵作为嵌套的 Python 列表。
trace()	返回一个方阵的迹，即对角元素之和。
transpose()	返回矩阵的转置。
upper_hessenberg_decomposition()	将矩阵转换为Hessenberg矩阵H。
upper_triangular([k])	返回矩阵中第k条对角线及其以上的元素。
upper_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个上三角矩阵。
values()	返回 self 的非零值。
vec()	通过堆叠列将矩阵转换为一列矩阵
vech([diagonal, check_symmetry])	通过堆叠下三角中的元素，将矩阵重塑为列向量。
vee()	从表示叉积的反对称矩阵返回一个3x1向量，使得 self * b 等价于 self.vee().cross(b)。
vstack(*args)	返回一个矩阵，该矩阵是通过垂直连接参数（即通过重复应用 col_join）形成的。
wilkinson(n, **kwargs)	返回两个大小为 2*n + 1 的平方 Wilkinson 矩阵 $W_{2n + 1}^-, W_{2n + 1}^+ =$ Wilkinson(n)
xreplace(rule)	返回一个新的矩阵，其中每个条目都应用了 xreplace。
zeros(rows[, cols])	返回一个全零矩阵。
zip_row_op(i, k, f)	使用双参数仿函数对行 i 进行就地操作，其参数被解释为 (self[i, j], self[k, j])。

berkowitz
berkowitz_charpoly
cofactorMatrix
det_bareis
执行
jordan_cell
jordan_cells
minorEntry
minorMatrix

参见

RayTransferMatrix

示例

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

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

折射的射线传输矩阵。

参数:

n1

一种介质的折射率。

n2

其他介质的折射率。

属性:

A

矩阵的A参数。

B

Matrix 的 B 参数。

C

Matrix 的 C 参数。

D

Matrix 的 D 参数。

H

返回厄米共轭。

T

矩阵转置

cols

free_symbols

返回矩阵中的自由符号。

is_Identity

is_echelon

如果矩阵是阶梯形式，则返回 \(True\)。

is_hermitian

检查矩阵是否为厄米矩阵。

is_indefinite

找出矩阵的确定性。

is_lower

检查矩阵是否为下三角矩阵。

is_lower_hessenberg

检查矩阵是否为下Hessenberg形式。

is_negative_definite

找出矩阵的确定性。

is_negative_semidefinite

找出矩阵的确定性。

is_positive_definite

找出矩阵的确定性。

is_positive_semidefinite

找出矩阵的确定性。

is_square

检查矩阵是否为方阵。

is_strongly_diagonally_dominant

测试矩阵是否为行强对角占优。

is_upper

检查矩阵是否为上三角矩阵。

is_upper_hessenberg

检查矩阵是否为上Hessenberg形式。

is_weakly_diagonally_dominant

测试矩阵是否为行弱对角占优。

is_zero_matrix

检查一个矩阵是否为零矩阵。

种类

行

shape

矩阵的形状（维度）作为 2 元组 (行数, 列数)。

方法

LDLdecomposition([hermitian])	返回矩阵 A 的 LDL 分解 (L, D)，使得如果 hermitian 标志为 True，则 L * D * L.H == A，或者如果 hermitian 为 False，则 L * D * L.T == A。
LDLsolve(rhs)	使用LDL分解求解 Ax = B，适用于一般的方阵和非奇异矩阵。
LUdecomposition([iszerofunc, simpfunc, ...])	返回 (L, U, perm)，其中 L 是一个对角线为单位矩阵的下三角矩阵，U 是一个上三角矩阵，perm 是一个行交换索引对的列表。
LUdecompositionFF()	计算一个无分数的LU分解。
LUdecomposition_Simple([iszerofunc, ...])	计算矩阵的 PLU 分解。
LUsolve(rhs[, iszerofunc])	求解线性系统 Ax = rhs 中的 x，其中 A = M。
QRdecomposition()	返回一个QR分解。
QRsolve(b)	求解线性系统 Ax = b。
add(b)	返回 self + b。
adjoint()	共轭转置或厄米共轭。
adjugate([method])	返回矩阵的伴随矩阵，或经典伴随矩阵。
analytic_func(f, x)	计算 f(A)，其中 A 是一个方阵，f 是一个解析函数。
applyfunc(f)	对矩阵的每个元素应用一个函数。
as_immutable()	返回此矩阵的不可变版本
as_mutable()	返回此矩阵的可变版本
as_real_imag([deep])	返回一个包含矩阵的（实部，虚部）部分的元组。
atoms(*types)	返回构成当前对象的原子。
berkowitz_det()	使用Berkowitz方法计算行列式。
berkowitz_eigenvals(**flags)	使用Berkowitz方法计算矩阵的特征值。
berkowitz_minors()	使用Berkowitz方法计算主子式。
bidiagonal_decomposition([upper])	返回 $(U,B,V.H)$ 用于
bidiagonalize([upper])	返回 $B$，即输入矩阵的双对角化形式。
charpoly([x, simplify])	计算特征多项式 det(x*I - M)，其中 I 是单位矩阵。
cholesky([hermitian])	返回矩阵 A 的 Cholesky 类型分解 L，使得如果 hermitian 标志为 True，则 L * L.H == A，或者如果 hermitian 为 False，则 L * L.T == A。
cholesky_solve(rhs)	使用 Cholesky 分解求解 Ax = B，适用于一般的非奇异方阵。
cofactor(i, j[, method])	计算元素的余子式。
cofactor_matrix([method])	返回一个包含每个元素的余子式的矩阵。
col(j)	基本列选择器。
col_del(col)	删除指定的列。
col_insert(pos, other)	在给定的列位置插入一列或多列。
col_join(other)	将两个矩阵沿着自身的最后一行和另一个矩阵的第一行进行连接。
col_op(j, f)	在列 j 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], i)。
col_swap(i, j)	就地交换矩阵中的两个给定列。
columnspace([simplify])	返回一个向量列表（矩阵对象），这些向量跨越 M 的列空间
companion(poly)	返回多项式的伴随矩阵。
condition_number()	返回矩阵的条件数。
conjugate()	返回按元素的共轭。
connected_components()	当一个方阵被视为加权图时，返回图中连接顶点的列表。
connected_components_decomposition()	仅使用排列将一个方阵分解为块对角形式。
copy()
copyin_list(key, value)	从列表中复制元素。
copyin_matrix(key, value)	将矩阵中的值复制到给定的边界内。
cramer_solve(rhs[, det_method])	使用克莱姆法则求解线性方程组。
cross(b)	返回 self 和 b 的叉积，放松兼容维度的条件：如果每个都有3个元素，将返回与 self 相同类型和形状的矩阵。
det([method, iszerofunc])	如果 M 是一个具体的矩阵对象，则计算其行列式；否则，如果 M 是一个 MatrixSymbol 或其他表达式，则返回表达式 Determinant(M)。
det_LU_decomposition()	使用LU分解计算矩阵行列式。
diag(*args[, strict, unpack, rows, cols])	返回具有指定对角线的矩阵。
diagonal([k])	返回自身的第 k 个对角线。
diagonal_solve(rhs)	高效求解 Ax = B，其中 A 是一个对角矩阵，且对角元素非零。
diagonalize([reals_only, sort, normalize])	返回 (P, D)，其中 D 是对角矩阵。
diff(*args[, evaluate])	计算矩阵中每个元素的导数。
dot(b[, hermitian, conjugate_convention])	返回两个长度相等的向量的点积或内积。
dual()	返回矩阵的对偶。
echelon_form([iszerofunc, simplify, with_pivots])	返回一个与 M 行等价的矩阵，该矩阵为阶梯形式。
eigenvals([error_when_incomplete])	计算矩阵的特征值。
eigenvects([error_when_incomplete, iszerofunc])	计算矩阵的特征向量。
elementary_col_op([op, col, k, col1, col2])	执行基本列操作 \(op\)。
elementary_row_op([op, row, k, row1, row2])	执行基本行操作 \(op\)。
equals(other[, failing_expression])	对矩阵的对应元素应用 equals ，试图证明这些元素是等价的，如果它们是等价的则返回 True ，如果有任何一对不等价则返回 False ，如果无法确定表达式是否等价，则返回 None （或者如果 failing_expression 为 True ，则返回第一个失败的表达式）。
evalf([n, subs, maxn, chop, strict, quad, ...])	对 self 的每个元素应用 evalf()。
exp()	返回一个方阵的指数。
expand([deep, modulus, power_base, ...])	对矩阵的每个条目应用 core.function.expand。
extract(rowsList, colsList)	通过指定行和列的列表返回一个子矩阵。
eye(rows[, cols])	返回一个单位矩阵。
fill(value)	用给定的值填充自身。
flat()
from_dok(rows, cols, dok)	从键的字典创建一个矩阵。
gauss_jordan_solve(B[, freevar])	使用高斯-约旦消元法求解 Ax = B。
get_diag_blocks()	获取方阵主对角线上的子方阵。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
hat()	返回表示叉积的反对称矩阵，使得 self.hat() * b 等价于 self.cross(b)。
hstack(*args)	返回一个矩阵，该矩阵通过水平连接参数（即通过重复应用 row_join）形成。
integrate(*args, **kwargs)	积分矩阵的每个元素。
inv([method, iszerofunc, try_block_diag])	使用指定方法返回矩阵的逆。
inv_mod(m)	返回整数矩阵 M 模 m 的逆。
inverse_ADJ([iszerofunc])	使用伴随矩阵和行列式计算逆矩阵。
inverse_BLOCK([iszerofunc])	使用块状逆运算计算逆矩阵。
inverse_CH([iszerofunc])	使用 Cholesky 分解计算逆矩阵。
inverse_GE([iszerofunc])	使用高斯消去法计算逆矩阵。
inverse_LDL([iszerofunc])	使用 LDL 分解计算逆矩阵。
inverse_LU([iszerofunc])	使用LU分解计算逆矩阵。
inverse_QR([iszerofunc])	使用QR分解计算逆矩阵。
irregular(ntop, *matrices, **kwargs)	返回一个矩阵，该矩阵由给定的矩阵填充，这些矩阵按从左到右、从上到下的顺序依次出现，与它们在矩阵中首次出现的位置一致。
is_anti_symmetric([simplify])	检查矩阵 M 是否为反对称矩阵，即，M 是一个方阵，且所有 M[i, j] == -M[j, i]。
is_diagonal()	检查矩阵是否为对角矩阵，即主对角线以外的所有元素均为零的矩阵。
is_diagonalizable([reals_only])	如果矩阵可对角化，则返回 True。
is_nilpotent()	检查矩阵是否为幂零矩阵。
is_symbolic()	检查是否有元素包含符号。
is_symmetric([simplify])	检查矩阵是否为对称矩阵，即方阵且等于其转置矩阵。
iter_items()	遍历非零项的索引和值。
iter_values()	遍历 self 的非零值
jacobian(X)	计算雅可比矩阵（向量值函数的导数）。
jordan_block([size, eigenvalue, band])	返回一个 Jordan 块
jordan_form([calc_transform])	返回 $(P, J)$，其中 $J$ 是一个约旦块矩阵，$P$ 是一个矩阵，使得 $M = P J P^{-1}$
key2bounds(keys)	将一个可能包含混合类型键（整数和切片）的键转换为范围元组，如果任何索引超出 self 的范围，则引发错误。
key2ij(key)	将键转换为规范形式，将整数或可索引项转换为 self 范围内的有效整数，或者返回切片不变。
left_eigenvects(**flags)	返回左特征向量和特征值。
limit(*args)	计算矩阵中每个元素的极限。
lll([delta])	LLL-约化基用于整数矩阵行空间的基。
lll_transform([delta])	LLL-约化基和变换矩阵。
log([simplify])	返回一个方阵的对数。
lower_triangular([k])	返回矩阵中第k条对角线及其以下的元素。
lower_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个下三角矩阵。
minor(i, j[, method])	返回 M 的 (i,j) 子式。
minor_submatrix(i, j)	返回通过从 M 中移除第 \(i\) 行和第 \(j\) 列得到的子矩阵（适用于Python风格的负索引）。
multiply(other[, dotprodsimp])	与 __mul__() 相同，但带有可选的简化。
multiply_elementwise(other)	返回 A 和 B 的 Hadamard 积（逐元素乘积）
n(*args, **kwargs)	对 self 的每个元素应用 evalf()。
norm([ord])	返回矩阵或向量的范数。
normalized([iszerofunc])	返回 self 的规范化版本。
nullspace([simplify, iszerofunc])	返回一个向量列表（Matrix 对象），这些向量跨越 M 的零空间
ones(rows[, cols])	返回一个全为1的矩阵。
orthogonalize(*vecs, **kwargs)	对 vecs 中的向量应用格拉姆-施密特正交化过程。
per()	返回矩阵的永久值。
permute(perm[, orientation, direction])	通过给定的交换列表置换矩阵的行或列。
permuteBkwd(perm)	使用给定的排列逆序排列矩阵的行。
permuteFwd(perm)	使用给定的排列来置换矩阵的行。
permute_cols(swaps[, direction])	self.permute(swaps, orientation='cols', direction=direction) 的别名
permute_rows(swaps[, direction])	self.permute(swaps, orientation='rows', direction=direction) 的别名
pinv([method])	计算矩阵的 Moore-Penrose 伪逆。
pinv_solve(B[, arbitrary_matrix])	使用 Moore-Penrose 伪逆求解 Ax = B。
pow(exp[, method])	返回 self**exp，其中 exp 是一个标量或符号。
print_nonzero([symb])	显示非零条目的位置，以便快速查找形状。
project(v)	返回 self 在包含 v 的直线上的投影。
rank([iszerofunc, simplify])	返回矩阵的秩。
rank_decomposition([iszerofunc, simplify])	返回一对矩阵 (\(C\), \(F\))，它们具有匹配的秩，使得 \(A = C F\)。
refine([assumptions])	对矩阵的每个元素应用细化。
replace(F, G[, map, simultaneous, exact])	将矩阵条目中的函数 F 替换为函数 G。
reshape(rows, cols)	重塑矩阵。
rmultiply(other[, dotprodsimp])	与 __rmul__() 相同，但带有可选的简化功能。
rot90([k])	将矩阵旋转90度
row(i)	基本行选择器。
row_add(s, t, k)	将行 s（源）的 k 倍加到行 t（目标）上，原地操作。
row_del(row)	删除指定的行。
row_insert(pos, other)	在给定的行位置插入一行或多行。
row_join(other)	将两个矩阵沿着自身的最后一列和rhs的第一列进行连接
row_mult(i, factor)	将给定的行按给定的因子就地乘以。
row_op(i, f)	在行 i 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], j)。
row_swap(i, j)	在原地交换矩阵的两行。
rowspace([simplify])	返回一个向量列表，这些向量跨越矩阵 M 的行空间。
rref([iszerofunc, simplify, pivots, ...])	返回矩阵的简化行阶梯形式和主元变量的索引。
rref_rhs(rhs)	返回矩阵的简化行阶梯形式，显示简化步骤后的右侧矩阵。
simplify(**kwargs)	对矩阵的元素就地应用简化。
singular_value_decomposition()	返回一个压缩的奇异值分解。
singular_values()	计算矩阵的奇异值
solve(rhs[, method])	求解存在唯一解的线性方程。
solve_least_squares(rhs[, method])	返回对数据的最小二乘拟合。
strongly_connected_components()	当将方阵视为加权图时，返回图中强连通顶点的列表。
strongly_connected_components_decomposition([lower])	仅使用排列将一个方阵分解为块三角形式。
subs(*args, **kwargs)	返回一个新的矩阵，其中每个条目都应用了subs。
table(printer[, rowstart, rowend, rowsep, ...])	以表格形式表示的矩阵字符串。
to_DM([domain])	转换为 DomainMatrix。
todod()	返回矩阵为包含矩阵非零元素的字典的字典
todok()	返回矩阵作为键的字典。
tolist()	返回矩阵作为嵌套的 Python 列表。
trace()	返回一个方阵的迹，即对角元素之和。
transpose()	返回矩阵的转置。
upper_hessenberg_decomposition()	将矩阵转换为Hessenberg矩阵H。
upper_triangular([k])	返回矩阵中第k条对角线及其以上的元素。
upper_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个上三角矩阵。
values()	返回 self 的非零值。
vec()	通过堆叠列将矩阵转换为一列矩阵
vech([diagonal, check_symmetry])	通过堆叠下三角中的元素，将矩阵重塑为列向量。
vee()	从表示叉积的反对称矩阵返回一个3x1向量，使得 self * b 等价于 self.vee().cross(b)。
vstack(*args)	返回一个矩阵，该矩阵是通过垂直连接参数（即通过重复应用 col_join）形成的。
wilkinson(n, **kwargs)	返回两个大小为 2*n + 1 的平方 Wilkinson 矩阵 $W_{2n + 1}^-, W_{2n + 1}^+ =$ Wilkinson(n)
xreplace(rule)	返回一个新的矩阵，其中每个条目都应用了 xreplace。
zeros(rows[, cols])	返回一个全零矩阵。
zip_row_op(i, k, f)	使用双参数仿函数对行 i 进行就地操作，其参数被解释为 (self[i, j], self[k, j])。

berkowitz
berkowitz_charpoly
cofactorMatrix
det_bareis
执行
jordan_cell
jordan_cells
minorEntry
minorMatrix

参见

RayTransferMatrix

示例

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

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

自由空间的射线传输矩阵。

参数:

距离

属性:

A

矩阵的A参数。

B

Matrix 的 B 参数。

C

Matrix 的 C 参数。

D

Matrix 的 D 参数。

H

返回厄米共轭。

T

矩阵转置

cols

free_symbols

返回矩阵中的自由符号。

is_Identity

is_echelon

如果矩阵是阶梯形式，则返回 \(True\)。

is_hermitian

检查矩阵是否为厄米矩阵。

is_indefinite

找出矩阵的确定性。

is_lower

检查矩阵是否为下三角矩阵。

is_lower_hessenberg

检查矩阵是否为下Hessenberg形式。

is_negative_definite

找出矩阵的确定性。

is_negative_semidefinite

找出矩阵的确定性。

is_positive_definite

找出矩阵的确定性。

is_positive_semidefinite

找出矩阵的确定性。

is_square

检查矩阵是否为方阵。

is_strongly_diagonally_dominant

测试矩阵是否为行强对角占优。

is_upper

检查矩阵是否为上三角矩阵。

is_upper_hessenberg

检查矩阵是否为上Hessenberg形式。

is_weakly_diagonally_dominant

测试矩阵是否为行弱对角占优。

is_zero_matrix

检查一个矩阵是否为零矩阵。

种类

行

shape

矩阵的形状（维度）作为 2 元组 (行数, 列数)。

方法

LDLdecomposition([hermitian])	返回矩阵 A 的 LDL 分解 (L, D)，使得如果 hermitian 标志为 True，则 L * D * L.H == A，或者如果 hermitian 为 False，则 L * D * L.T == A。
LDLsolve(rhs)	使用LDL分解求解 Ax = B，适用于一般的方阵和非奇异矩阵。
LUdecomposition([iszerofunc, simpfunc, ...])	返回 (L, U, perm)，其中 L 是一个对角线为单位矩阵的下三角矩阵，U 是一个上三角矩阵，perm 是一个行交换索引对的列表。
LUdecompositionFF()	计算一个无分数的LU分解。
LUdecomposition_Simple([iszerofunc, ...])	计算矩阵的 PLU 分解。
LUsolve(rhs[, iszerofunc])	求解线性系统 Ax = rhs 中的 x，其中 A = M。
QRdecomposition()	返回一个QR分解。
QRsolve(b)	求解线性系统 Ax = b。
add(b)	返回 self + b。
adjoint()	共轭转置或厄米共轭。
adjugate([method])	返回矩阵的伴随矩阵，或经典伴随矩阵。
analytic_func(f, x)	计算 f(A)，其中 A 是一个方阵，f 是一个解析函数。
applyfunc(f)	对矩阵的每个元素应用一个函数。
as_immutable()	返回此矩阵的不可变版本
as_mutable()	返回此矩阵的可变版本
as_real_imag([deep])	返回一个包含矩阵的（实部，虚部）部分的元组。
atoms(*types)	返回构成当前对象的原子。
berkowitz_det()	使用Berkowitz方法计算行列式。
berkowitz_eigenvals(**flags)	使用Berkowitz方法计算矩阵的特征值。
berkowitz_minors()	使用Berkowitz方法计算主子式。
bidiagonal_decomposition([upper])	返回 $(U,B,V.H)$ 用于
bidiagonalize([upper])	返回 $B$，即输入矩阵的双对角化形式。
charpoly([x, simplify])	计算特征多项式 det(x*I - M)，其中 I 是单位矩阵。
cholesky([hermitian])	返回矩阵 A 的 Cholesky 类型分解 L，使得如果 hermitian 标志为 True，则 L * L.H == A，或者如果 hermitian 为 False，则 L * L.T == A。
cholesky_solve(rhs)	使用 Cholesky 分解求解 Ax = B，适用于一般的非奇异方阵。
cofactor(i, j[, method])	计算元素的余子式。
cofactor_matrix([method])	返回一个包含每个元素的余子式的矩阵。
col(j)	基本列选择器。
col_del(col)	删除指定的列。
col_insert(pos, other)	在给定的列位置插入一列或多列。
col_join(other)	将两个矩阵沿着自身的最后一行和另一个矩阵的第一行进行连接。
col_op(j, f)	在列 j 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], i)。
col_swap(i, j)	就地交换矩阵中的两个给定列。
columnspace([simplify])	返回一个向量列表（矩阵对象），这些向量跨越 M 的列空间
companion(poly)	返回多项式的伴随矩阵。
condition_number()	返回矩阵的条件数。
conjugate()	返回按元素的共轭。
connected_components()	当一个方阵被视为加权图时，返回图中连接顶点的列表。
connected_components_decomposition()	仅使用排列将一个方阵分解为块对角形式。
copy()
copyin_list(key, value)	从列表中复制元素。
copyin_matrix(key, value)	将矩阵中的值复制到给定的边界内。
cramer_solve(rhs[, det_method])	使用克莱姆法则求解线性方程组。
cross(b)	返回 self 和 b 的叉积，放松兼容维度的条件：如果每个都有3个元素，将返回与 self 相同类型和形状的矩阵。
det([method, iszerofunc])	如果 M 是一个具体的矩阵对象，则计算其行列式；否则，如果 M 是一个 MatrixSymbol 或其他表达式，则返回表达式 Determinant(M)。
det_LU_decomposition()	使用LU分解计算矩阵行列式。
diag(*args[, strict, unpack, rows, cols])	返回具有指定对角线的矩阵。
diagonal([k])	返回自身的第 k 个对角线。
diagonal_solve(rhs)	高效求解 Ax = B，其中 A 是一个对角矩阵，且对角元素非零。
diagonalize([reals_only, sort, normalize])	返回 (P, D)，其中 D 是对角矩阵。
diff(*args[, evaluate])	计算矩阵中每个元素的导数。
dot(b[, hermitian, conjugate_convention])	返回两个长度相等的向量的点积或内积。
dual()	返回矩阵的对偶。
echelon_form([iszerofunc, simplify, with_pivots])	返回一个与 M 行等价的矩阵，该矩阵为阶梯形式。
eigenvals([error_when_incomplete])	计算矩阵的特征值。
eigenvects([error_when_incomplete, iszerofunc])	计算矩阵的特征向量。
elementary_col_op([op, col, k, col1, col2])	执行基本列操作 \(op\)。
elementary_row_op([op, row, k, row1, row2])	执行基本行操作 \(op\)。
equals(other[, failing_expression])	对矩阵的对应元素应用 equals ，试图证明这些元素是等价的，如果它们是等价的则返回 True ，如果有任何一对不等价则返回 False ，如果无法确定表达式是否等价，则返回 None （或者如果 failing_expression 为 True ，则返回第一个失败的表达式）。
evalf([n, subs, maxn, chop, strict, quad, ...])	对 self 的每个元素应用 evalf()。
exp()	返回一个方阵的指数。
expand([deep, modulus, power_base, ...])	对矩阵的每个条目应用 core.function.expand。
extract(rowsList, colsList)	通过指定行和列的列表返回一个子矩阵。
eye(rows[, cols])	返回一个单位矩阵。
fill(value)	用给定的值填充自身。
flat()
from_dok(rows, cols, dok)	从键的字典创建一个矩阵。
gauss_jordan_solve(B[, freevar])	使用高斯-约旦消元法求解 Ax = B。
get_diag_blocks()	获取方阵主对角线上的子方阵。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
hat()	返回表示叉积的反对称矩阵，使得 self.hat() * b 等价于 self.cross(b)。
hstack(*args)	返回一个矩阵，该矩阵通过水平连接参数（即通过重复应用 row_join）形成。
integrate(*args, **kwargs)	积分矩阵的每个元素。
inv([method, iszerofunc, try_block_diag])	使用指定方法返回矩阵的逆。
inv_mod(m)	返回整数矩阵 M 模 m 的逆。
inverse_ADJ([iszerofunc])	使用伴随矩阵和行列式计算逆矩阵。
inverse_BLOCK([iszerofunc])	使用块状逆运算计算逆矩阵。
inverse_CH([iszerofunc])	使用 Cholesky 分解计算逆矩阵。
inverse_GE([iszerofunc])	使用高斯消去法计算逆矩阵。
inverse_LDL([iszerofunc])	使用 LDL 分解计算逆矩阵。
inverse_LU([iszerofunc])	使用LU分解计算逆矩阵。
inverse_QR([iszerofunc])	使用QR分解计算逆矩阵。
irregular(ntop, *matrices, **kwargs)	返回一个矩阵，该矩阵由给定的矩阵填充，这些矩阵按从左到右、从上到下的顺序依次出现，与它们在矩阵中首次出现的位置一致。
is_anti_symmetric([simplify])	检查矩阵 M 是否为反对称矩阵，即，M 是一个方阵，且所有 M[i, j] == -M[j, i]。
is_diagonal()	检查矩阵是否为对角矩阵，即主对角线以外的所有元素均为零的矩阵。
is_diagonalizable([reals_only])	如果矩阵可对角化，则返回 True。
is_nilpotent()	检查矩阵是否为幂零矩阵。
is_symbolic()	检查是否有元素包含符号。
is_symmetric([simplify])	检查矩阵是否为对称矩阵，即方阵且等于其转置矩阵。
iter_items()	遍历非零项的索引和值。
iter_values()	遍历 self 的非零值
jacobian(X)	计算雅可比矩阵（向量值函数的导数）。
jordan_block([size, eigenvalue, band])	返回一个 Jordan 块
jordan_form([calc_transform])	返回 $(P, J)$，其中 $J$ 是一个约旦块矩阵，$P$ 是一个矩阵，使得 $M = P J P^{-1}$
key2bounds(keys)	将一个可能包含混合类型键（整数和切片）的键转换为范围元组，如果任何索引超出 self 的范围，则引发错误。
key2ij(key)	将键转换为规范形式，将整数或可索引项转换为 self 范围内的有效整数，或者返回切片不变。
left_eigenvects(**flags)	返回左特征向量和特征值。
limit(*args)	计算矩阵中每个元素的极限。
lll([delta])	LLL-约化基用于整数矩阵行空间的基。
lll_transform([delta])	LLL-约化基和变换矩阵。
log([simplify])	返回一个方阵的对数。
lower_triangular([k])	返回矩阵中第k条对角线及其以下的元素。
lower_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个下三角矩阵。
minor(i, j[, method])	返回 M 的 (i,j) 子式。
minor_submatrix(i, j)	返回通过从 M 中移除第 \(i\) 行和第 \(j\) 列得到的子矩阵（适用于Python风格的负索引）。
multiply(other[, dotprodsimp])	与 __mul__() 相同，但带有可选的简化。
multiply_elementwise(other)	返回 A 和 B 的 Hadamard 积（逐元素乘积）
n(*args, **kwargs)	对 self 的每个元素应用 evalf()。
norm([ord])	返回矩阵或向量的范数。
normalized([iszerofunc])	返回 self 的规范化版本。
nullspace([simplify, iszerofunc])	返回一个向量列表（Matrix 对象），这些向量跨越 M 的零空间
ones(rows[, cols])	返回一个全为1的矩阵。
orthogonalize(*vecs, **kwargs)	对 vecs 中的向量应用格拉姆-施密特正交化过程。
per()	返回矩阵的永久值。
permute(perm[, orientation, direction])	通过给定的交换列表置换矩阵的行或列。
permuteBkwd(perm)	使用给定的排列逆序排列矩阵的行。
permuteFwd(perm)	使用给定的排列来置换矩阵的行。
permute_cols(swaps[, direction])	self.permute(swaps, orientation='cols', direction=direction) 的别名
permute_rows(swaps[, direction])	self.permute(swaps, orientation='rows', direction=direction) 的别名
pinv([method])	计算矩阵的 Moore-Penrose 伪逆。
pinv_solve(B[, arbitrary_matrix])	使用 Moore-Penrose 伪逆求解 Ax = B。
pow(exp[, method])	返回 self**exp，其中 exp 是一个标量或符号。
print_nonzero([symb])	显示非零条目的位置，以便快速查找形状。
project(v)	返回 self 在包含 v 的直线上的投影。
rank([iszerofunc, simplify])	返回矩阵的秩。
rank_decomposition([iszerofunc, simplify])	返回一对矩阵 (\(C\), \(F\))，它们具有匹配的秩，使得 \(A = C F\)。
refine([assumptions])	对矩阵的每个元素应用细化。
replace(F, G[, map, simultaneous, exact])	将矩阵条目中的函数 F 替换为函数 G。
reshape(rows, cols)	重塑矩阵。
rmultiply(other[, dotprodsimp])	与 __rmul__() 相同，但带有可选的简化功能。
rot90([k])	将矩阵旋转90度
row(i)	基本行选择器。
row_add(s, t, k)	将行 s（源）的 k 倍加到行 t（目标）上，原地操作。
row_del(row)	删除指定的行。
row_insert(pos, other)	在给定的行位置插入一行或多行。
row_join(other)	将两个矩阵沿着自身的最后一列和rhs的第一列进行连接
row_mult(i, factor)	将给定的行按给定的因子就地乘以。
row_op(i, f)	在行 i 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], j)。
row_swap(i, j)	在原地交换矩阵的两行。
rowspace([simplify])	返回一个向量列表，这些向量跨越矩阵 M 的行空间。
rref([iszerofunc, simplify, pivots, ...])	返回矩阵的简化行阶梯形式和主元变量的索引。
rref_rhs(rhs)	返回矩阵的简化行阶梯形式，显示简化步骤后的右侧矩阵。
simplify(**kwargs)	对矩阵的元素就地应用简化。
singular_value_decomposition()	返回一个压缩的奇异值分解。
singular_values()	计算矩阵的奇异值
solve(rhs[, method])	求解存在唯一解的线性方程。
solve_least_squares(rhs[, method])	返回对数据的最小二乘拟合。
strongly_connected_components()	当将方阵视为加权图时，返回图中强连通顶点的列表。
strongly_connected_components_decomposition([lower])	仅使用排列将一个方阵分解为块三角形式。
subs(*args, **kwargs)	返回一个新的矩阵，其中每个条目都应用了subs。
table(printer[, rowstart, rowend, rowsep, ...])	以表格形式表示的矩阵字符串。
to_DM([domain])	转换为 DomainMatrix。
todod()	返回矩阵为包含矩阵非零元素的字典的字典
todok()	返回矩阵作为键的字典。
tolist()	返回矩阵作为嵌套的 Python 列表。
trace()	返回一个方阵的迹，即对角元素之和。
transpose()	返回矩阵的转置。
upper_hessenberg_decomposition()	将矩阵转换为Hessenberg矩阵H。
upper_triangular([k])	返回矩阵中第k条对角线及其以上的元素。
upper_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个上三角矩阵。
values()	返回 self 的非零值。
vec()	通过堆叠列将矩阵转换为一列矩阵
vech([diagonal, check_symmetry])	通过堆叠下三角中的元素，将矩阵重塑为列向量。
vee()	从表示叉积的反对称矩阵返回一个3x1向量，使得 self * b 等价于 self.vee().cross(b)。
vstack(*args)	返回一个矩阵，该矩阵是通过垂直连接参数（即通过重复应用 col_join）形成的。
wilkinson(n, **kwargs)	返回两个大小为 2*n + 1 的平方 Wilkinson 矩阵 $W_{2n + 1}^-, W_{2n + 1}^+ =$ Wilkinson(n)
xreplace(rule)	返回一个新的矩阵，其中每个条目都应用了 xreplace。
zeros(rows[, cols])	返回一个全零矩阵。
zip_row_op(i, k, f)	使用双参数仿函数对行 i 进行就地操作，其参数被解释为 (self[i, j], self[k, j])。

berkowitz
berkowitz_charpoly
cofactorMatrix
det_bareis
执行
jordan_cell
jordan_cells
minorEntry
minorMatrix

参见

RayTransferMatrix

示例

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

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

Ray Transfer Matrix 形式体系中几何光线的表示。

参数:

h高度，以及

角度角度，或

矩阵一个2x1矩阵 (Matrix(2, 1, [高度, 角度]))

属性:

C

逐元素共轭

D

返回Dirac共轭（如果 self.rows == 4）。

H

返回厄米共轭。

T

矩阵转置

angle

与光轴的夹角。

cols

free_symbols

返回矩阵中的自由符号。

height

与光轴的距离。

is_Identity

is_echelon

如果矩阵是阶梯形式，则返回 \(True\)。

is_hermitian

检查矩阵是否为厄米矩阵。

is_indefinite

找出矩阵的确定性。

is_lower

检查矩阵是否为下三角矩阵。

is_lower_hessenberg

检查矩阵是否为下Hessenberg形式。

is_negative_definite

找出矩阵的确定性。

is_negative_semidefinite

找出矩阵的确定性。

is_positive_definite

找出矩阵的确定性。

is_positive_semidefinite

找出矩阵的确定性。

is_square

检查矩阵是否为方阵。

is_strongly_diagonally_dominant

测试矩阵是否为行强对角占优。

is_upper

检查矩阵是否为上三角矩阵。

is_upper_hessenberg

检查矩阵是否为上Hessenberg形式。

is_weakly_diagonally_dominant

测试矩阵是否为行弱对角占优。

is_zero_matrix

检查一个矩阵是否为零矩阵。

种类

行

shape

矩阵的形状（维度）作为 2 元组 (行数, 列数)。

方法

LDLdecomposition([hermitian])	返回矩阵 A 的 LDL 分解 (L, D)，使得如果 hermitian 标志为 True，则 L * D * L.H == A，或者如果 hermitian 为 False，则 L * D * L.T == A。
LDLsolve(rhs)	使用LDL分解求解 Ax = B，适用于一般的方阵和非奇异矩阵。
LUdecomposition([iszerofunc, simpfunc, ...])	返回 (L, U, perm)，其中 L 是一个对角线为单位矩阵的下三角矩阵，U 是一个上三角矩阵，perm 是一个行交换索引对的列表。
LUdecompositionFF()	计算一个无分数的LU分解。
LUdecomposition_Simple([iszerofunc, ...])	计算矩阵的 PLU 分解。
LUsolve(rhs[, iszerofunc])	求解线性系统 Ax = rhs 中的 x，其中 A = M。
QRdecomposition()	返回一个QR分解。
QRsolve(b)	求解线性系统 Ax = b。
add(b)	返回 self + b。
adjoint()	共轭转置或厄米共轭。
adjugate([method])	返回矩阵的伴随矩阵，或经典伴随矩阵。
analytic_func(f, x)	计算 f(A)，其中 A 是一个方阵，f 是一个解析函数。
applyfunc(f)	对矩阵的每个元素应用一个函数。
as_immutable()	返回此矩阵的不可变版本
as_mutable()	返回此矩阵的可变版本
as_real_imag([deep])	返回一个包含矩阵的（实部，虚部）部分的元组。
atoms(*types)	返回构成当前对象的原子。
berkowitz_det()	使用Berkowitz方法计算行列式。
berkowitz_eigenvals(**flags)	使用Berkowitz方法计算矩阵的特征值。
berkowitz_minors()	使用Berkowitz方法计算主子式。
bidiagonal_decomposition([upper])	返回 $(U,B,V.H)$ 用于
bidiagonalize([upper])	返回 $B$，即输入矩阵的双对角化形式。
charpoly([x, simplify])	计算特征多项式 det(x*I - M)，其中 I 是单位矩阵。
cholesky([hermitian])	返回矩阵 A 的 Cholesky 类型分解 L，使得如果 hermitian 标志为 True，则 L * L.H == A，或者如果 hermitian 为 False，则 L * L.T == A。
cholesky_solve(rhs)	使用 Cholesky 分解求解 Ax = B，适用于一般的非奇异方阵。
cofactor(i, j[, method])	计算元素的余子式。
cofactor_matrix([method])	返回一个包含每个元素的余子式的矩阵。
col(j)	基本列选择器。
col_del(col)	删除指定的列。
col_insert(pos, other)	在给定的列位置插入一列或多列。
col_join(other)	将两个矩阵沿着自身的最后一行和另一个矩阵的第一行进行连接。
col_op(j, f)	在列 j 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], i)。
col_swap(i, j)	就地交换矩阵中的两个给定列。
columnspace([simplify])	返回一个向量列表（矩阵对象），这些向量跨越 M 的列空间
companion(poly)	返回多项式的伴随矩阵。
condition_number()	返回矩阵的条件数。
conjugate()	返回按元素的共轭。
connected_components()	当一个方阵被视为加权图时，返回图中连接顶点的列表。
connected_components_decomposition()	仅使用排列将一个方阵分解为块对角形式。
copy()
copyin_list(key, value)	从列表中复制元素。
copyin_matrix(key, value)	将矩阵中的值复制到给定的边界内。
cramer_solve(rhs[, det_method])	使用克莱姆法则求解线性方程组。
cross(b)	返回 self 和 b 的叉积，放松兼容维度的条件：如果每个都有3个元素，将返回与 self 相同类型和形状的矩阵。
det([method, iszerofunc])	如果 M 是一个具体的矩阵对象，则计算其行列式；否则，如果 M 是一个 MatrixSymbol 或其他表达式，则返回表达式 Determinant(M)。
det_LU_decomposition()	使用LU分解计算矩阵行列式。
diag(*args[, strict, unpack, rows, cols])	返回具有指定对角线的矩阵。
diagonal([k])	返回自身的第 k 个对角线。
diagonal_solve(rhs)	高效求解 Ax = B，其中 A 是一个对角矩阵，且对角元素非零。
diagonalize([reals_only, sort, normalize])	返回 (P, D)，其中 D 是对角矩阵。
diff(*args[, evaluate])	计算矩阵中每个元素的导数。
dot(b[, hermitian, conjugate_convention])	返回两个长度相等的向量的点积或内积。
dual()	返回矩阵的对偶。
echelon_form([iszerofunc, simplify, with_pivots])	返回一个与 M 行等价的矩阵，该矩阵为阶梯形式。
eigenvals([error_when_incomplete])	计算矩阵的特征值。
eigenvects([error_when_incomplete, iszerofunc])	计算矩阵的特征向量。
elementary_col_op([op, col, k, col1, col2])	执行基本列操作 \(op\)。
elementary_row_op([op, row, k, row1, row2])	执行基本行操作 \(op\)。
equals(other[, failing_expression])	对矩阵的对应元素应用 equals ，试图证明这些元素是等价的，如果它们是等价的则返回 True ，如果有任何一对不等价则返回 False ，如果无法确定表达式是否等价，则返回 None （或者如果 failing_expression 为 True ，则返回第一个失败的表达式）。
evalf([n, subs, maxn, chop, strict, quad, ...])	对 self 的每个元素应用 evalf()。
exp()	返回一个方阵的指数。
expand([deep, modulus, power_base, ...])	对矩阵的每个条目应用 core.function.expand。
extract(rowsList, colsList)	通过指定行和列的列表返回一个子矩阵。
eye(rows[, cols])	返回一个单位矩阵。
fill(value)	用给定的值填充自身。
flat()
from_dok(rows, cols, dok)	从键的字典创建一个矩阵。
gauss_jordan_solve(B[, freevar])	使用高斯-约旦消元法求解 Ax = B。
get_diag_blocks()	获取方阵主对角线上的子方阵。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
hat()	返回表示叉积的反对称矩阵，使得 self.hat() * b 等价于 self.cross(b)。
hstack(*args)	返回一个矩阵，该矩阵通过水平连接参数（即通过重复应用 row_join）形成。
integrate(*args, **kwargs)	积分矩阵的每个元素。
inv([method, iszerofunc, try_block_diag])	使用指定方法返回矩阵的逆。
inv_mod(m)	返回整数矩阵 M 模 m 的逆。
inverse_ADJ([iszerofunc])	使用伴随矩阵和行列式计算逆矩阵。
inverse_BLOCK([iszerofunc])	使用块状逆运算计算逆矩阵。
inverse_CH([iszerofunc])	使用 Cholesky 分解计算逆矩阵。
inverse_GE([iszerofunc])	使用高斯消去法计算逆矩阵。
inverse_LDL([iszerofunc])	使用 LDL 分解计算逆矩阵。
inverse_LU([iszerofunc])	使用LU分解计算逆矩阵。
inverse_QR([iszerofunc])	使用QR分解计算逆矩阵。
irregular(ntop, *matrices, **kwargs)	返回一个矩阵，该矩阵由给定的矩阵填充，这些矩阵按从左到右、从上到下的顺序依次出现，与它们在矩阵中首次出现的位置一致。
is_anti_symmetric([simplify])	检查矩阵 M 是否为反对称矩阵，即，M 是一个方阵，且所有 M[i, j] == -M[j, i]。
is_diagonal()	检查矩阵是否为对角矩阵，即主对角线以外的所有元素均为零的矩阵。
is_diagonalizable([reals_only])	如果矩阵可对角化，则返回 True。
is_nilpotent()	检查矩阵是否为幂零矩阵。
is_symbolic()	检查是否有元素包含符号。
is_symmetric([simplify])	检查矩阵是否为对称矩阵，即方阵且等于其转置矩阵。
iter_items()	遍历非零项的索引和值。
iter_values()	遍历 self 的非零值
jacobian(X)	计算雅可比矩阵（向量值函数的导数）。
jordan_block([size, eigenvalue, band])	返回一个 Jordan 块
jordan_form([calc_transform])	返回 $(P, J)$，其中 $J$ 是一个约旦块矩阵，$P$ 是一个矩阵，使得 $M = P J P^{-1}$
key2bounds(keys)	将一个可能包含混合类型键（整数和切片）的键转换为范围元组，如果任何索引超出 self 的范围，则引发错误。
key2ij(key)	将键转换为规范形式，将整数或可索引项转换为 self 范围内的有效整数，或者返回切片不变。
left_eigenvects(**flags)	返回左特征向量和特征值。
limit(*args)	计算矩阵中每个元素的极限。
lll([delta])	LLL-约化基用于整数矩阵行空间的基。
lll_transform([delta])	LLL-约化基和变换矩阵。
log([simplify])	返回一个方阵的对数。
lower_triangular([k])	返回矩阵中第k条对角线及其以下的元素。
lower_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个下三角矩阵。
minor(i, j[, method])	返回 M 的 (i,j) 子式。
minor_submatrix(i, j)	返回通过从 M 中移除第 \(i\) 行和第 \(j\) 列得到的子矩阵（适用于Python风格的负索引）。
multiply(other[, dotprodsimp])	与 __mul__() 相同，但带有可选的简化。
multiply_elementwise(other)	返回 A 和 B 的 Hadamard 积（逐元素乘积）
n(*args, **kwargs)	对 self 的每个元素应用 evalf()。
norm([ord])	返回矩阵或向量的范数。
normalized([iszerofunc])	返回 self 的规范化版本。
nullspace([simplify, iszerofunc])	返回一个向量列表（Matrix 对象），这些向量跨越 M 的零空间
ones(rows[, cols])	返回一个全为1的矩阵。
orthogonalize(*vecs, **kwargs)	对 vecs 中的向量应用格拉姆-施密特正交化过程。
per()	返回矩阵的永久值。
permute(perm[, orientation, direction])	通过给定的交换列表置换矩阵的行或列。
permuteBkwd(perm)	使用给定的排列逆序排列矩阵的行。
permuteFwd(perm)	使用给定的排列来置换矩阵的行。
permute_cols(swaps[, direction])	self.permute(swaps, orientation='cols', direction=direction) 的别名
permute_rows(swaps[, direction])	self.permute(swaps, orientation='rows', direction=direction) 的别名
pinv([method])	计算矩阵的 Moore-Penrose 伪逆。
pinv_solve(B[, arbitrary_matrix])	使用 Moore-Penrose 伪逆求解 Ax = B。
pow(exp[, method])	返回 self**exp，其中 exp 是一个标量或符号。
print_nonzero([symb])	显示非零条目的位置，以便快速查找形状。
project(v)	返回 self 在包含 v 的直线上的投影。
rank([iszerofunc, simplify])	返回矩阵的秩。
rank_decomposition([iszerofunc, simplify])	返回一对矩阵 (\(C\), \(F\))，它们具有匹配的秩，使得 \(A = C F\)。
refine([assumptions])	对矩阵的每个元素应用细化。
replace(F, G[, map, simultaneous, exact])	将矩阵条目中的函数 F 替换为函数 G。
reshape(rows, cols)	重塑矩阵。
rmultiply(other[, dotprodsimp])	与 __rmul__() 相同，但带有可选的简化功能。
rot90([k])	将矩阵旋转90度
row(i)	基本行选择器。
row_add(s, t, k)	将行 s（源）的 k 倍加到行 t（目标）上，原地操作。
row_del(row)	删除指定的行。
row_insert(pos, other)	在给定的行位置插入一行或多行。
row_join(other)	将两个矩阵沿着自身的最后一列和rhs的第一列进行连接
row_mult(i, factor)	将给定的行按给定的因子就地乘以。
row_op(i, f)	在行 i 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], j)。
row_swap(i, j)	在原地交换矩阵的两行。
rowspace([simplify])	返回一个向量列表，这些向量跨越矩阵 M 的行空间。
rref([iszerofunc, simplify, pivots, ...])	返回矩阵的简化行阶梯形式和主元变量的索引。
rref_rhs(rhs)	返回矩阵的简化行阶梯形式，显示简化步骤后的右侧矩阵。
simplify(**kwargs)	对矩阵的元素就地应用简化。
singular_value_decomposition()	返回一个压缩的奇异值分解。
singular_values()	计算矩阵的奇异值
solve(rhs[, method])	求解存在唯一解的线性方程。
solve_least_squares(rhs[, method])	返回对数据的最小二乘拟合。
strongly_connected_components()	当将方阵视为加权图时，返回图中强连通顶点的列表。
strongly_connected_components_decomposition([lower])	仅使用排列将一个方阵分解为块三角形式。
subs(*args, **kwargs)	返回一个新的矩阵，其中每个条目都应用了subs。
table(printer[, rowstart, rowend, rowsep, ...])	以表格形式表示的矩阵字符串。
to_DM([domain])	转换为 DomainMatrix。
todod()	返回矩阵为包含矩阵非零元素的字典的字典
todok()	返回矩阵作为键的字典。
tolist()	返回矩阵作为嵌套的 Python 列表。
trace()	返回一个方阵的迹，即对角元素之和。
transpose()	返回矩阵的转置。
upper_hessenberg_decomposition()	将矩阵转换为Hessenberg矩阵H。
upper_triangular([k])	返回矩阵中第k条对角线及其以上的元素。
upper_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个上三角矩阵。
values()	返回 self 的非零值。
vec()	通过堆叠列将矩阵转换为一列矩阵
vech([diagonal, check_symmetry])	通过堆叠下三角中的元素，将矩阵重塑为列向量。
vee()	从表示叉积的反对称矩阵返回一个3x1向量，使得 self * b 等价于 self.vee().cross(b)。
vstack(*args)	返回一个矩阵，该矩阵是通过垂直连接参数（即通过重复应用 col_join）形成的。
wilkinson(n, **kwargs)	返回两个大小为 2*n + 1 的平方 Wilkinson 矩阵 $W_{2n + 1}^-, W_{2n + 1}^+ =$ Wilkinson(n)
xreplace(rule)	返回一个新的矩阵，其中每个条目都应用了 xreplace。
zeros(rows[, cols])	返回一个全零矩阵。
zip_row_op(i, k, f)	使用双参数仿函数对行 i 进行就地操作，其参数被解释为 (self[i, j], self[k, j])。

berkowitz
berkowitz_charpoly
cofactorMatrix
det_bareis
执行
jordan_cell
jordan_cells
minorEntry
minorMatrix

参见

RayTransferMatrix

示例

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

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

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

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

property angle

与光轴的夹角。

示例

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

property height

与光轴的距离。

示例

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

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

用于光线传输矩阵的基类。

如果没有在“另请参阅”中提到更具体的子类，则应使用此项。

参数:

参数

A, B, C 和 D 或 2x2 矩阵 (Matrix(2, 2, [A, B, C, D]))

属性:

A

矩阵的A参数。

B

Matrix 的 B 参数。

C

Matrix 的 C 参数。

D

Matrix 的 D 参数。

H

返回厄米共轭。

T

矩阵转置

cols

free_symbols

返回矩阵中的自由符号。

is_Identity

is_echelon

如果矩阵是阶梯形式，则返回 \(True\)。

is_hermitian

检查矩阵是否为厄米矩阵。

is_indefinite

找出矩阵的确定性。

is_lower

检查矩阵是否为下三角矩阵。

is_lower_hessenberg

检查矩阵是否为下Hessenberg形式。

is_negative_definite

找出矩阵的确定性。

is_negative_semidefinite

找出矩阵的确定性。

is_positive_definite

找出矩阵的确定性。

is_positive_semidefinite

找出矩阵的确定性。

is_square

检查矩阵是否为方阵。

is_strongly_diagonally_dominant

测试矩阵是否为行强对角占优。

is_upper

检查矩阵是否为上三角矩阵。

is_upper_hessenberg

检查矩阵是否为上Hessenberg形式。

is_weakly_diagonally_dominant

测试矩阵是否为行弱对角占优。

is_zero_matrix

检查一个矩阵是否为零矩阵。

种类

行

shape

矩阵的形状（维度）作为 2 元组 (行数, 列数)。

方法

LDLdecomposition([hermitian])	返回矩阵 A 的 LDL 分解 (L, D)，使得如果 hermitian 标志为 True，则 L * D * L.H == A，或者如果 hermitian 为 False，则 L * D * L.T == A。
LDLsolve(rhs)	使用LDL分解求解 Ax = B，适用于一般的方阵和非奇异矩阵。
LUdecomposition([iszerofunc, simpfunc, ...])	返回 (L, U, perm)，其中 L 是一个对角线为单位矩阵的下三角矩阵，U 是一个上三角矩阵，perm 是一个行交换索引对的列表。
LUdecompositionFF()	计算一个无分数的LU分解。
LUdecomposition_Simple([iszerofunc, ...])	计算矩阵的 PLU 分解。
LUsolve(rhs[, iszerofunc])	求解线性系统 Ax = rhs 中的 x，其中 A = M。
QRdecomposition()	返回一个QR分解。
QRsolve(b)	求解线性系统 Ax = b。
add(b)	返回 self + b。
adjoint()	共轭转置或厄米共轭。
adjugate([method])	返回矩阵的伴随矩阵，或经典伴随矩阵。
analytic_func(f, x)	计算 f(A)，其中 A 是一个方阵，f 是一个解析函数。
applyfunc(f)	对矩阵的每个元素应用一个函数。
as_immutable()	返回此矩阵的不可变版本
as_mutable()	返回此矩阵的可变版本
as_real_imag([deep])	返回一个包含矩阵的（实部，虚部）部分的元组。
atoms(*types)	返回构成当前对象的原子。
berkowitz_det()	使用Berkowitz方法计算行列式。
berkowitz_eigenvals(**flags)	使用Berkowitz方法计算矩阵的特征值。
berkowitz_minors()	使用Berkowitz方法计算主子式。
bidiagonal_decomposition([upper])	返回 $(U,B,V.H)$ 用于
bidiagonalize([upper])	返回 $B$，即输入矩阵的双对角化形式。
charpoly([x, simplify])	计算特征多项式 det(x*I - M)，其中 I 是单位矩阵。
cholesky([hermitian])	返回矩阵 A 的 Cholesky 类型分解 L，使得如果 hermitian 标志为 True，则 L * L.H == A，或者如果 hermitian 为 False，则 L * L.T == A。
cholesky_solve(rhs)	使用 Cholesky 分解求解 Ax = B，适用于一般的非奇异方阵。
cofactor(i, j[, method])	计算元素的余子式。
cofactor_matrix([method])	返回一个包含每个元素的余子式的矩阵。
col(j)	基本列选择器。
col_del(col)	删除指定的列。
col_insert(pos, other)	在给定的列位置插入一列或多列。
col_join(other)	将两个矩阵沿着自身的最后一行和另一个矩阵的第一行进行连接。
col_op(j, f)	在列 j 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], i)。
col_swap(i, j)	就地交换矩阵中的两个给定列。
columnspace([simplify])	返回一个向量列表（矩阵对象），这些向量跨越 M 的列空间
companion(poly)	返回多项式的伴随矩阵。
condition_number()	返回矩阵的条件数。
conjugate()	返回按元素的共轭。
connected_components()	当一个方阵被视为加权图时，返回图中连接顶点的列表。
connected_components_decomposition()	仅使用排列将一个方阵分解为块对角形式。
copy()
copyin_list(key, value)	从列表中复制元素。
copyin_matrix(key, value)	将矩阵中的值复制到给定的边界内。
cramer_solve(rhs[, det_method])	使用克莱姆法则求解线性方程组。
cross(b)	返回 self 和 b 的叉积，放松兼容维度的条件：如果每个都有3个元素，将返回与 self 相同类型和形状的矩阵。
det([method, iszerofunc])	如果 M 是一个具体的矩阵对象，则计算其行列式；否则，如果 M 是一个 MatrixSymbol 或其他表达式，则返回表达式 Determinant(M)。
det_LU_decomposition()	使用LU分解计算矩阵行列式。
diag(*args[, strict, unpack, rows, cols])	返回具有指定对角线的矩阵。
diagonal([k])	返回自身的第 k 个对角线。
diagonal_solve(rhs)	高效求解 Ax = B，其中 A 是一个对角矩阵，且对角元素非零。
diagonalize([reals_only, sort, normalize])	返回 (P, D)，其中 D 是对角矩阵。
diff(*args[, evaluate])	计算矩阵中每个元素的导数。
dot(b[, hermitian, conjugate_convention])	返回两个长度相等的向量的点积或内积。
dual()	返回矩阵的对偶。
echelon_form([iszerofunc, simplify, with_pivots])	返回一个与 M 行等价的矩阵，该矩阵为阶梯形式。
eigenvals([error_when_incomplete])	计算矩阵的特征值。
eigenvects([error_when_incomplete, iszerofunc])	计算矩阵的特征向量。
elementary_col_op([op, col, k, col1, col2])	执行基本列操作 \(op\)。
elementary_row_op([op, row, k, row1, row2])	执行基本行操作 \(op\)。
equals(other[, failing_expression])	对矩阵的对应元素应用 equals ，试图证明这些元素是等价的，如果它们是等价的则返回 True ，如果有任何一对不等价则返回 False ，如果无法确定表达式是否等价，则返回 None （或者如果 failing_expression 为 True ，则返回第一个失败的表达式）。
evalf([n, subs, maxn, chop, strict, quad, ...])	对 self 的每个元素应用 evalf()。
exp()	返回一个方阵的指数。
expand([deep, modulus, power_base, ...])	对矩阵的每个条目应用 core.function.expand。
extract(rowsList, colsList)	通过指定行和列的列表返回一个子矩阵。
eye(rows[, cols])	返回一个单位矩阵。
fill(value)	用给定的值填充自身。
flat()
from_dok(rows, cols, dok)	从键的字典创建一个矩阵。
gauss_jordan_solve(B[, freevar])	使用高斯-约旦消元法求解 Ax = B。
get_diag_blocks()	获取方阵主对角线上的子方阵。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
hat()	返回表示叉积的反对称矩阵，使得 self.hat() * b 等价于 self.cross(b)。
hstack(*args)	返回一个矩阵，该矩阵通过水平连接参数（即通过重复应用 row_join）形成。
integrate(*args, **kwargs)	积分矩阵的每个元素。
inv([method, iszerofunc, try_block_diag])	使用指定方法返回矩阵的逆。
inv_mod(m)	返回整数矩阵 M 模 m 的逆。
inverse_ADJ([iszerofunc])	使用伴随矩阵和行列式计算逆矩阵。
inverse_BLOCK([iszerofunc])	使用块状逆运算计算逆矩阵。
inverse_CH([iszerofunc])	使用 Cholesky 分解计算逆矩阵。
inverse_GE([iszerofunc])	使用高斯消去法计算逆矩阵。
inverse_LDL([iszerofunc])	使用 LDL 分解计算逆矩阵。
inverse_LU([iszerofunc])	使用LU分解计算逆矩阵。
inverse_QR([iszerofunc])	使用QR分解计算逆矩阵。
irregular(ntop, *matrices, **kwargs)	返回一个矩阵，该矩阵由给定的矩阵填充，这些矩阵按从左到右、从上到下的顺序依次出现，与它们在矩阵中首次出现的位置一致。
is_anti_symmetric([simplify])	检查矩阵 M 是否为反对称矩阵，即，M 是一个方阵，且所有 M[i, j] == -M[j, i]。
is_diagonal()	检查矩阵是否为对角矩阵，即主对角线以外的所有元素均为零的矩阵。
is_diagonalizable([reals_only])	如果矩阵可对角化，则返回 True。
is_nilpotent()	检查矩阵是否为幂零矩阵。
is_symbolic()	检查是否有元素包含符号。
is_symmetric([simplify])	检查矩阵是否为对称矩阵，即方阵且等于其转置矩阵。
iter_items()	遍历非零项的索引和值。
iter_values()	遍历 self 的非零值
jacobian(X)	计算雅可比矩阵（向量值函数的导数）。
jordan_block([size, eigenvalue, band])	返回一个 Jordan 块
jordan_form([calc_transform])	返回 $(P, J)$，其中 $J$ 是一个约旦块矩阵，$P$ 是一个矩阵，使得 $M = P J P^{-1}$
key2bounds(keys)	将一个可能包含混合类型键（整数和切片）的键转换为范围元组，如果任何索引超出 self 的范围，则引发错误。
key2ij(key)	将键转换为规范形式，将整数或可索引项转换为 self 范围内的有效整数，或者返回切片不变。
left_eigenvects(**flags)	返回左特征向量和特征值。
limit(*args)	计算矩阵中每个元素的极限。
lll([delta])	LLL-约化基用于整数矩阵行空间的基。
lll_transform([delta])	LLL-约化基和变换矩阵。
log([simplify])	返回一个方阵的对数。
lower_triangular([k])	返回矩阵中第k条对角线及其以下的元素。
lower_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个下三角矩阵。
minor(i, j[, method])	返回 M 的 (i,j) 子式。
minor_submatrix(i, j)	返回通过从 M 中移除第 \(i\) 行和第 \(j\) 列得到的子矩阵（适用于Python风格的负索引）。
multiply(other[, dotprodsimp])	与 __mul__() 相同，但带有可选的简化。
multiply_elementwise(other)	返回 A 和 B 的 Hadamard 积（逐元素乘积）
n(*args, **kwargs)	对 self 的每个元素应用 evalf()。
norm([ord])	返回矩阵或向量的范数。
normalized([iszerofunc])	返回 self 的规范化版本。
nullspace([simplify, iszerofunc])	返回一个向量列表（Matrix 对象），这些向量跨越 M 的零空间
ones(rows[, cols])	返回一个全为1的矩阵。
orthogonalize(*vecs, **kwargs)	对 vecs 中的向量应用格拉姆-施密特正交化过程。
per()	返回矩阵的永久值。
permute(perm[, orientation, direction])	通过给定的交换列表置换矩阵的行或列。
permuteBkwd(perm)	使用给定的排列逆序排列矩阵的行。
permuteFwd(perm)	使用给定的排列来置换矩阵的行。
permute_cols(swaps[, direction])	self.permute(swaps, orientation='cols', direction=direction) 的别名
permute_rows(swaps[, direction])	self.permute(swaps, orientation='rows', direction=direction) 的别名
pinv([method])	计算矩阵的 Moore-Penrose 伪逆。
pinv_solve(B[, arbitrary_matrix])	使用 Moore-Penrose 伪逆求解 Ax = B。
pow(exp[, method])	返回 self**exp，其中 exp 是一个标量或符号。
print_nonzero([symb])	显示非零条目的位置，以便快速查找形状。
project(v)	返回 self 在包含 v 的直线上的投影。
rank([iszerofunc, simplify])	返回矩阵的秩。
rank_decomposition([iszerofunc, simplify])	返回一对矩阵 (\(C\), \(F\))，它们具有匹配的秩，使得 \(A = C F\)。
refine([assumptions])	对矩阵的每个元素应用细化。
replace(F, G[, map, simultaneous, exact])	将矩阵条目中的函数 F 替换为函数 G。
reshape(rows, cols)	重塑矩阵。
rmultiply(other[, dotprodsimp])	与 __rmul__() 相同，但带有可选的简化功能。
rot90([k])	将矩阵旋转90度
row(i)	基本行选择器。
row_add(s, t, k)	将行 s（源）的 k 倍加到行 t（目标）上，原地操作。
row_del(row)	删除指定的行。
row_insert(pos, other)	在给定的行位置插入一行或多行。
row_join(other)	将两个矩阵沿着自身的最后一列和rhs的第一列进行连接
row_mult(i, factor)	将给定的行按给定的因子就地乘以。
row_op(i, f)	在行 i 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], j)。
row_swap(i, j)	在原地交换矩阵的两行。
rowspace([simplify])	返回一个向量列表，这些向量跨越矩阵 M 的行空间。
rref([iszerofunc, simplify, pivots, ...])	返回矩阵的简化行阶梯形式和主元变量的索引。
rref_rhs(rhs)	返回矩阵的简化行阶梯形式，显示简化步骤后的右侧矩阵。
simplify(**kwargs)	对矩阵的元素就地应用简化。
singular_value_decomposition()	返回一个压缩的奇异值分解。
singular_values()	计算矩阵的奇异值
solve(rhs[, method])	求解存在唯一解的线性方程。
solve_least_squares(rhs[, method])	返回对数据的最小二乘拟合。
strongly_connected_components()	当将方阵视为加权图时，返回图中强连通顶点的列表。
strongly_connected_components_decomposition([lower])	仅使用排列将一个方阵分解为块三角形式。
subs(*args, **kwargs)	返回一个新的矩阵，其中每个条目都应用了subs。
table(printer[, rowstart, rowend, rowsep, ...])	以表格形式表示的矩阵字符串。
to_DM([domain])	转换为 DomainMatrix。
todod()	返回矩阵为包含矩阵非零元素的字典的字典
todok()	返回矩阵作为键的字典。
tolist()	返回矩阵作为嵌套的 Python 列表。
trace()	返回一个方阵的迹，即对角元素之和。
transpose()	返回矩阵的转置。
upper_hessenberg_decomposition()	将矩阵转换为Hessenberg矩阵H。
upper_triangular([k])	返回矩阵中第k条对角线及其以上的元素。
upper_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个上三角矩阵。
values()	返回 self 的非零值。
vec()	通过堆叠列将矩阵转换为一列矩阵
vech([diagonal, check_symmetry])	通过堆叠下三角中的元素，将矩阵重塑为列向量。
vee()	从表示叉积的反对称矩阵返回一个3x1向量，使得 self * b 等价于 self.vee().cross(b)。
vstack(*args)	返回一个矩阵，该矩阵是通过垂直连接参数（即通过重复应用 col_join）形成的。
wilkinson(n, **kwargs)	返回两个大小为 2*n + 1 的平方 Wilkinson 矩阵 $W_{2n + 1}^-, W_{2n + 1}^+ =$ Wilkinson(n)
xreplace(rule)	返回一个新的矩阵，其中每个条目都应用了 xreplace。
zeros(rows[, cols])	返回一个全零矩阵。
zip_row_op(i, k, f)	使用双参数仿函数对行 i 进行就地操作，其参数被解释为 (self[i, j], self[k, j])。

berkowitz
berkowitz_charpoly
cofactorMatrix
det_bareis
执行
jordan_cell
jordan_cells
minorEntry
minorMatrix

参见

GeometricRay, BeamParameter

FreeSpace, FlatRefraction, CurvedRefraction

FlatMirror, CurvedMirror, ThinLens

参考文献

[1]

https://en.wikipedia.org/wiki/光传输矩阵分析

示例

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

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

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

>>> mat.A
1

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

>>> lens.C
-1/f

property A

矩阵的A参数。

示例

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

property B

Matrix 的 B 参数。

示例

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

property C

Matrix 的 C 参数。

示例

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

property D

Matrix 的 D 参数。

示例

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

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

薄透镜的射线传输矩阵。

参数:

f

焦距。

属性:

A

矩阵的A参数。

B

Matrix 的 B 参数。

C

Matrix 的 C 参数。

D

Matrix 的 D 参数。

H

返回厄米共轭。

T

矩阵转置

cols

free_symbols

返回矩阵中的自由符号。

is_Identity

is_echelon

如果矩阵是阶梯形式，则返回 \(True\)。

is_hermitian

检查矩阵是否为厄米矩阵。

is_indefinite

找出矩阵的确定性。

is_lower

检查矩阵是否为下三角矩阵。

is_lower_hessenberg

检查矩阵是否为下Hessenberg形式。

is_negative_definite

找出矩阵的确定性。

is_negative_semidefinite

找出矩阵的确定性。

is_positive_definite

找出矩阵的确定性。

is_positive_semidefinite

找出矩阵的确定性。

is_square

检查矩阵是否为方阵。

is_strongly_diagonally_dominant

测试矩阵是否为行强对角占优。

is_upper

检查矩阵是否为上三角矩阵。

is_upper_hessenberg

检查矩阵是否为上Hessenberg形式。

is_weakly_diagonally_dominant

测试矩阵是否为行弱对角占优。

is_zero_matrix

检查一个矩阵是否为零矩阵。

种类

行

shape

矩阵的形状（维度）作为 2 元组 (行数, 列数)。

方法

LDLdecomposition([hermitian])	返回矩阵 A 的 LDL 分解 (L, D)，使得如果 hermitian 标志为 True，则 L * D * L.H == A，或者如果 hermitian 为 False，则 L * D * L.T == A。
LDLsolve(rhs)	使用LDL分解求解 Ax = B，适用于一般的方阵和非奇异矩阵。
LUdecomposition([iszerofunc, simpfunc, ...])	返回 (L, U, perm)，其中 L 是一个对角线为单位矩阵的下三角矩阵，U 是一个上三角矩阵，perm 是一个行交换索引对的列表。
LUdecompositionFF()	计算一个无分数的LU分解。
LUdecomposition_Simple([iszerofunc, ...])	计算矩阵的 PLU 分解。
LUsolve(rhs[, iszerofunc])	求解线性系统 Ax = rhs 中的 x，其中 A = M。
QRdecomposition()	返回一个QR分解。
QRsolve(b)	求解线性系统 Ax = b。
add(b)	返回 self + b。
adjoint()	共轭转置或厄米共轭。
adjugate([method])	返回矩阵的伴随矩阵，或经典伴随矩阵。
analytic_func(f, x)	计算 f(A)，其中 A 是一个方阵，f 是一个解析函数。
applyfunc(f)	对矩阵的每个元素应用一个函数。
as_immutable()	返回此矩阵的不可变版本
as_mutable()	返回此矩阵的可变版本
as_real_imag([deep])	返回一个包含矩阵的（实部，虚部）部分的元组。
atoms(*types)	返回构成当前对象的原子。
berkowitz_det()	使用Berkowitz方法计算行列式。
berkowitz_eigenvals(**flags)	使用Berkowitz方法计算矩阵的特征值。
berkowitz_minors()	使用Berkowitz方法计算主子式。
bidiagonal_decomposition([upper])	返回 $(U,B,V.H)$ 用于
bidiagonalize([upper])	返回 $B$，即输入矩阵的双对角化形式。
charpoly([x, simplify])	计算特征多项式 det(x*I - M)，其中 I 是单位矩阵。
cholesky([hermitian])	返回矩阵 A 的 Cholesky 类型分解 L，使得如果 hermitian 标志为 True，则 L * L.H == A，或者如果 hermitian 为 False，则 L * L.T == A。
cholesky_solve(rhs)	使用 Cholesky 分解求解 Ax = B，适用于一般的非奇异方阵。
cofactor(i, j[, method])	计算元素的余子式。
cofactor_matrix([method])	返回一个包含每个元素的余子式的矩阵。
col(j)	基本列选择器。
col_del(col)	删除指定的列。
col_insert(pos, other)	在给定的列位置插入一列或多列。
col_join(other)	将两个矩阵沿着自身的最后一行和另一个矩阵的第一行进行连接。
col_op(j, f)	在列 j 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], i)。
col_swap(i, j)	就地交换矩阵中的两个给定列。
columnspace([simplify])	返回一个向量列表（矩阵对象），这些向量跨越 M 的列空间
companion(poly)	返回多项式的伴随矩阵。
condition_number()	返回矩阵的条件数。
conjugate()	返回按元素的共轭。
connected_components()	当一个方阵被视为加权图时，返回图中连接顶点的列表。
connected_components_decomposition()	仅使用排列将一个方阵分解为块对角形式。
copy()
copyin_list(key, value)	从列表中复制元素。
copyin_matrix(key, value)	将矩阵中的值复制到给定的边界内。
cramer_solve(rhs[, det_method])	使用克莱姆法则求解线性方程组。
cross(b)	返回 self 和 b 的叉积，放松兼容维度的条件：如果每个都有3个元素，将返回与 self 相同类型和形状的矩阵。
det([method, iszerofunc])	如果 M 是一个具体的矩阵对象，则计算其行列式；否则，如果 M 是一个 MatrixSymbol 或其他表达式，则返回表达式 Determinant(M)。
det_LU_decomposition()	使用LU分解计算矩阵行列式。
diag(*args[, strict, unpack, rows, cols])	返回具有指定对角线的矩阵。
diagonal([k])	返回自身的第 k 个对角线。
diagonal_solve(rhs)	高效求解 Ax = B，其中 A 是一个对角矩阵，且对角元素非零。
diagonalize([reals_only, sort, normalize])	返回 (P, D)，其中 D 是对角矩阵。
diff(*args[, evaluate])	计算矩阵中每个元素的导数。
dot(b[, hermitian, conjugate_convention])	返回两个长度相等的向量的点积或内积。
dual()	返回矩阵的对偶。
echelon_form([iszerofunc, simplify, with_pivots])	返回一个与 M 行等价的矩阵，该矩阵为阶梯形式。
eigenvals([error_when_incomplete])	计算矩阵的特征值。
eigenvects([error_when_incomplete, iszerofunc])	计算矩阵的特征向量。
elementary_col_op([op, col, k, col1, col2])	执行基本列操作 \(op\)。
elementary_row_op([op, row, k, row1, row2])	执行基本行操作 \(op\)。
equals(other[, failing_expression])	对矩阵的对应元素应用 equals ，试图证明这些元素是等价的，如果它们是等价的则返回 True ，如果有任何一对不等价则返回 False ，如果无法确定表达式是否等价，则返回 None （或者如果 failing_expression 为 True ，则返回第一个失败的表达式）。
evalf([n, subs, maxn, chop, strict, quad, ...])	对 self 的每个元素应用 evalf()。
exp()	返回一个方阵的指数。
expand([deep, modulus, power_base, ...])	对矩阵的每个条目应用 core.function.expand。
extract(rowsList, colsList)	通过指定行和列的列表返回一个子矩阵。
eye(rows[, cols])	返回一个单位矩阵。
fill(value)	用给定的值填充自身。
flat()
from_dok(rows, cols, dok)	从键的字典创建一个矩阵。
gauss_jordan_solve(B[, freevar])	使用高斯-约旦消元法求解 Ax = B。
get_diag_blocks()	获取方阵主对角线上的子方阵。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
hat()	返回表示叉积的反对称矩阵，使得 self.hat() * b 等价于 self.cross(b)。
hstack(*args)	返回一个矩阵，该矩阵通过水平连接参数（即通过重复应用 row_join）形成。
integrate(*args, **kwargs)	积分矩阵的每个元素。
inv([method, iszerofunc, try_block_diag])	使用指定方法返回矩阵的逆。
inv_mod(m)	返回整数矩阵 M 模 m 的逆。
inverse_ADJ([iszerofunc])	使用伴随矩阵和行列式计算逆矩阵。
inverse_BLOCK([iszerofunc])	使用块状逆运算计算逆矩阵。
inverse_CH([iszerofunc])	使用 Cholesky 分解计算逆矩阵。
inverse_GE([iszerofunc])	使用高斯消去法计算逆矩阵。
inverse_LDL([iszerofunc])	使用 LDL 分解计算逆矩阵。
inverse_LU([iszerofunc])	使用LU分解计算逆矩阵。
inverse_QR([iszerofunc])	使用QR分解计算逆矩阵。
irregular(ntop, *matrices, **kwargs)	返回一个矩阵，该矩阵由给定的矩阵填充，这些矩阵按从左到右、从上到下的顺序依次出现，与它们在矩阵中首次出现的位置一致。
is_anti_symmetric([simplify])	检查矩阵 M 是否为反对称矩阵，即，M 是一个方阵，且所有 M[i, j] == -M[j, i]。
is_diagonal()	检查矩阵是否为对角矩阵，即主对角线以外的所有元素均为零的矩阵。
is_diagonalizable([reals_only])	如果矩阵可对角化，则返回 True。
is_nilpotent()	检查矩阵是否为幂零矩阵。
is_symbolic()	检查是否有元素包含符号。
is_symmetric([simplify])	检查矩阵是否为对称矩阵，即方阵且等于其转置矩阵。
iter_items()	遍历非零项的索引和值。
iter_values()	遍历 self 的非零值
jacobian(X)	计算雅可比矩阵（向量值函数的导数）。
jordan_block([size, eigenvalue, band])	返回一个 Jordan 块
jordan_form([calc_transform])	返回 $(P, J)$，其中 $J$ 是一个约旦块矩阵，$P$ 是一个矩阵，使得 $M = P J P^{-1}$
key2bounds(keys)	将一个可能包含混合类型键（整数和切片）的键转换为范围元组，如果任何索引超出 self 的范围，则引发错误。
key2ij(key)	将键转换为规范形式，将整数或可索引项转换为 self 范围内的有效整数，或者返回切片不变。
left_eigenvects(**flags)	返回左特征向量和特征值。
limit(*args)	计算矩阵中每个元素的极限。
lll([delta])	LLL-约化基用于整数矩阵行空间的基。
lll_transform([delta])	LLL-约化基和变换矩阵。
log([simplify])	返回一个方阵的对数。
lower_triangular([k])	返回矩阵中第k条对角线及其以下的元素。
lower_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个下三角矩阵。
minor(i, j[, method])	返回 M 的 (i,j) 子式。
minor_submatrix(i, j)	返回通过从 M 中移除第 \(i\) 行和第 \(j\) 列得到的子矩阵（适用于Python风格的负索引）。
multiply(other[, dotprodsimp])	与 __mul__() 相同，但带有可选的简化。
multiply_elementwise(other)	返回 A 和 B 的 Hadamard 积（逐元素乘积）
n(*args, **kwargs)	对 self 的每个元素应用 evalf()。
norm([ord])	返回矩阵或向量的范数。
normalized([iszerofunc])	返回 self 的规范化版本。
nullspace([simplify, iszerofunc])	返回一个向量列表（Matrix 对象），这些向量跨越 M 的零空间
ones(rows[, cols])	返回一个全为1的矩阵。
orthogonalize(*vecs, **kwargs)	对 vecs 中的向量应用格拉姆-施密特正交化过程。
per()	返回矩阵的永久值。
permute(perm[, orientation, direction])	通过给定的交换列表置换矩阵的行或列。
permuteBkwd(perm)	使用给定的排列逆序排列矩阵的行。
permuteFwd(perm)	使用给定的排列来置换矩阵的行。
permute_cols(swaps[, direction])	self.permute(swaps, orientation='cols', direction=direction) 的别名
permute_rows(swaps[, direction])	self.permute(swaps, orientation='rows', direction=direction) 的别名
pinv([method])	计算矩阵的 Moore-Penrose 伪逆。
pinv_solve(B[, arbitrary_matrix])	使用 Moore-Penrose 伪逆求解 Ax = B。
pow(exp[, method])	返回 self**exp，其中 exp 是一个标量或符号。
print_nonzero([symb])	显示非零条目的位置，以便快速查找形状。
project(v)	返回 self 在包含 v 的直线上的投影。
rank([iszerofunc, simplify])	返回矩阵的秩。
rank_decomposition([iszerofunc, simplify])	返回一对矩阵 (\(C\), \(F\))，它们具有匹配的秩，使得 \(A = C F\)。
refine([assumptions])	对矩阵的每个元素应用细化。
replace(F, G[, map, simultaneous, exact])	将矩阵条目中的函数 F 替换为函数 G。
reshape(rows, cols)	重塑矩阵。
rmultiply(other[, dotprodsimp])	与 __rmul__() 相同，但带有可选的简化功能。
rot90([k])	将矩阵旋转90度
row(i)	基本行选择器。
row_add(s, t, k)	将行 s（源）的 k 倍加到行 t（目标）上，原地操作。
row_del(row)	删除指定的行。
row_insert(pos, other)	在给定的行位置插入一行或多行。
row_join(other)	将两个矩阵沿着自身的最后一列和rhs的第一列进行连接
row_mult(i, factor)	将给定的行按给定的因子就地乘以。
row_op(i, f)	在行 i 上进行原地操作，使用双参数仿函数，其参数被解释为 (self[i, j], j)。
row_swap(i, j)	在原地交换矩阵的两行。
rowspace([simplify])	返回一个向量列表，这些向量跨越矩阵 M 的行空间。
rref([iszerofunc, simplify, pivots, ...])	返回矩阵的简化行阶梯形式和主元变量的索引。
rref_rhs(rhs)	返回矩阵的简化行阶梯形式，显示简化步骤后的右侧矩阵。
simplify(**kwargs)	对矩阵的元素就地应用简化。
singular_value_decomposition()	返回一个压缩的奇异值分解。
singular_values()	计算矩阵的奇异值
solve(rhs[, method])	求解存在唯一解的线性方程。
solve_least_squares(rhs[, method])	返回对数据的最小二乘拟合。
strongly_connected_components()	当将方阵视为加权图时，返回图中强连通顶点的列表。
strongly_connected_components_decomposition([lower])	仅使用排列将一个方阵分解为块三角形式。
subs(*args, **kwargs)	返回一个新的矩阵，其中每个条目都应用了subs。
table(printer[, rowstart, rowend, rowsep, ...])	以表格形式表示的矩阵字符串。
to_DM([domain])	转换为 DomainMatrix。
todod()	返回矩阵为包含矩阵非零元素的字典的字典
todok()	返回矩阵作为键的字典。
tolist()	返回矩阵作为嵌套的 Python 列表。
trace()	返回一个方阵的迹，即对角元素之和。
transpose()	返回矩阵的转置。
upper_hessenberg_decomposition()	将矩阵转换为Hessenberg矩阵H。
upper_triangular([k])	返回矩阵中第k条对角线及其以上的元素。
upper_triangular_solve(rhs)	求解 Ax = B，其中 A 是一个上三角矩阵。
values()	返回 self 的非零值。
vec()	通过堆叠列将矩阵转换为一列矩阵
vech([diagonal, check_symmetry])	通过堆叠下三角中的元素，将矩阵重塑为列向量。
vee()	从表示叉积的反对称矩阵返回一个3x1向量，使得 self * b 等价于 self.vee().cross(b)。
vstack(*args)	返回一个矩阵，该矩阵是通过垂直连接参数（即通过重复应用 col_join）形成的。
wilkinson(n, **kwargs)	返回两个大小为 2*n + 1 的平方 Wilkinson 矩阵 $W_{2n + 1}^-, W_{2n + 1}^+ =$ Wilkinson(n)
xreplace(rule)	返回一个新的矩阵，其中每个条目都应用了 xreplace。
zeros(rows[, cols])	返回一个全零矩阵。
zip_row_op(i, k, f)	使用双参数仿函数对行 i 进行就地操作，其参数被解释为 (self[i, j], self[k, j])。

berkowitz
berkowitz_charpoly
cofactorMatrix
det_bareis
执行
jordan_cell
jordan_cells
minorEntry
minorMatrix

参见

RayTransferMatrix

示例

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

sympy.physics.optics.gaussopt.conjugate_gauss_beams(

wavelen,

waist_in,

waist_out,

**kwargs,

)

找到光路设置，使物体/图像腰部共轭。

参数:

wavelen

光束的波长。

waist_in 和 waist_out

要结合的腰围。

f

用于共轭的元素的焦距。

返回:

包含 (s_in, s_out, f) 的元组

s_in

光学元件前的距离。

s_out

光学元件后的距离。

f

光学元件的焦距。

示例

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

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

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

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

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

高斯光束的共轭关系。

参数:

s_in

从束腰到光学元件的距离。

z_r_in

入射光束的瑞利范围。

f

光学元件的焦距。

返回:

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

s_out

新腰位置与光学元件之间的距离。

z_r_out

出射光束的瑞利范围。

m

新旧腰围的比例。

示例

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

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

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

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

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

在近轴条件下几何光束的共轭关系。

参见

geometric_conj_af, geometric_conj_bf

示例

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

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

在近轴条件下几何光束的共轭关系。

参见

geometric_conj_ab

示例

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

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

在近轴条件下几何光束的共轭关系。

参见

geometric_conj_ab

示例

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

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

计算高斯光束的瑞利范围以确定其腰斑。

参见

waist2rayleigh, BeamParameter

示例

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

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

从高斯光束的腰部计算瑞利范围。

参见

rayleigh2waist, BeamParameter

示例

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