SymPy-1-13-中文文档-三十九-

布客飞龙
56 阅读28分钟

SymPy 1.13 中文文档（三十九）

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

State

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

状态的 Dirac 符号表示法。

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

量子力学中的一般时间无关的 Bra。

继承自 State 和 BraBase。Bra 是 Ket 的对偶[R769]。这个类及其子类将是用户表达 Dirac 符号表示法中 Bras 的主要类。

参数：

args：元组

一组唯一指定 Ket 的数字或参数列表。这通常是其符号或量子数。对于时间相关状态，这将包括时间。

例子

创建一个简单的 Bra 并查看其属性：

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

Bra 的知道它们对偶 Ket 的：

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

和 Kets 一样，Bras 可以有复合标签，并且可以以类似的方式进行操作：

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

可以使用.subs替换 Bra 中的符号。

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

参考资料

[R769] (1,2)

en.wikipedia.org/wiki/Bra-ket_notation

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

Bras 的基类。

该类定义了对偶属性和打印时的括号。这是一个抽象基类，不应直接实例化，而是使用 Bra。

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

量子力学中的一般时间无关的 Ket。

继承自 State 和 KetBase。这个类应该作为系统中所有物理、时间无关的 Ket 的基类使用。这个类及其子类将是用户表达 Dirac 符号表示法中 Kets 的主要类。

参数：

args：元组

一组唯一指定 Ket 的数字或参数列表。这通常是其符号或量子数。对于时间相关状态，这将包括时间。

例子

创建一个简单的 Ket 并查看其属性：

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

Ket 知道其关联的 Bra：

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

取两个 Ket 的线性组合：

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

复合标签作为元组传递：

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

参考资料

[R770] (1,2)

en.wikipedia.org/wiki/Bra-ket_notation

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

Kets 的基类。

该类定义了对偶属性和打印时的括号。这是一个抽象基类，不应直接实例化，而是使用 Ket。

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

量子力学中的正交 Bra。

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

量子力学中的正交 Ket。

两个具有不同标签的态的内积为零，具有相同标签的态的内积为一。

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

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

用作 Ket 和 Bra 的基类的一般抽象量子态。

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

用作 Ket 和 Bra 的基类的一般抽象量子态。

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

量子力学中一般抽象态的抽象基类。

所有其他定义的状态类都需要从此类继承。它承载了所有其他状态的基本结构，如对偶、_eval_adjoint 和标签。

这是一个抽象基类，不应直接实例化，而是使用 State。

property dual

返回此态的对偶态。

classmethod dual_class()

返回用于构造对偶的类。

property operators

返回这个态是本征态的算符（们）。

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

量子力学中的通用时间依赖Bra。

这继承自TimeDepState和BraBase，是应该用于随时间变化的Bra的主要类。其对偶体是一个TimeDepBra。

参数：

args：元组

列出唯一指定ket的数字或参数的列表。通常将是其符号或量子数。对于时间依赖状态，这将包括时间作为最后一个参数。

例子

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

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

量子力学中的通用时间依赖Ket。

这继承自TimeDepState和KetBase，是应该用于随时间变化的Ket的主要类。其对偶体是一个TimeDepBra。

参数：

args：元组

列出唯一指定ket的数字或参数的列表。通常将是其符号或量子数。对于时间依赖状态，这将包括时间作为最后一个参数。

例子

创建一个TimeDepKet并查看其属性：

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

TimeDepKets 知道它们的对偶bra：

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

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

通用时间依赖量子态的基类。

此类用作任何时间依赖状态的基类。此类与时间独立状态的主要区别在于，此类除了通常的标签参数外，还接受第二个参数作为时间。

参数：

args：元组

列出唯一指定ket的数字或参数的列表。通常将是其符号或量子数。对于时间依赖状态，这将包括时间作为最后一个参数。

property label

状态的标签。

property time

状态的时间。

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

连续基底表示的类

此类在其构造函数中接受表达式和坐标。可用于轻松计算标准化和概率。

参数：

expr：表达式

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

coords：符号或元组

要进行积分的坐标及其边界

例子

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

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

此外，您可以以更紧凑的方式指定函数的边界和指数：

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

所有参数都会自动转换为sympy对象，因此您可以将变量定义为字符串，而不是符号：

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

波函数的导数将返回波函数：

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

property expr

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

例子

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

property is_commutative

覆盖函数的is_commutative，以保持表达式中的顺序

property is_normalized

如果波函数正确归一化则返回真

例子

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

property limits

返回波函数依赖的坐标的限制。如果未指定限制，则默认为(-oo, oo)。

例子

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

property norm

返回指定函数形式的归一化。

此函数对Wavefunction的坐标进行积分，指定了边界。

例子

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

normalize()

返回波函数的归一化版本

例子

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

prob()

返回波函数的绝对幅度，(|\psi(x)|²)

例子

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

property variables

返回波函数依赖的坐标

例子

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

电路绘图

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

基于 Matplotlib 的量子电路绘图。

待办事项：

  • 优化大电路的打印。

  • 使其与单门一起工作。

  • 更好地检查电路形式，以确保它是 Gates 的乘积。

  • 获取多目标门绘图。

  • 获取初始状态和最终状态以绘制。

  • 获取用于绘制的测量值。可能需要重新考虑测量作为一个门的问题。

  • 更好地处理比例和 figsize。

  • 编写一些测试/示例！

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

一个管理电路图的类。

control_line(gate_idx, min_wire, max_wire)

绘制垂直控制线。

control_point(gate_idx, wire_idx)

绘制一个控制点。

not_point(gate_idx, wire_idx)

绘制 NOT 门，作为中间带加号的圆圈。

one_qubit_box(t, gate_idx, wire_idx)

为单量子比特门绘制一个框。

swap_point(gate_idx, wire_idx)

将交换点绘制为十字架。

two_qubit_box(t, gate_idx, wire_idx)

为两量子比特门绘制一个框。目前还不能正常工作。

update(kwargs)

将 kwargs 加载到实例字典中。

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

使用词法闭包制作一个受控门。

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

一个 x 测量门的草图。

这是在 circuitplot 中而不是 gate.py 中，因为它不是一个真正的门，它只是画了一个门。

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

一个 z 测量门的草图。

这是在 circuitplot 中而不是 gate.py 中，因为它不是一个真正的门，它只是画了一个门。

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

绘制具有 n 量子比特电路的电路图。

参数：

c：电路

要绘制的电路。应该是 Gate 实例的乘积。

nqubits：整数

要包括在电路中的量子比特数。必须至少与门的最大min_qubits一样大。

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

为量子电路的线自动生成标签。

参数：

n：整数

电路中的量子比特数。

符号：字符串

一个字符字符串，用于所有门标签之前。例如‘q_0’，‘q_1’等。

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

>>> labeller(2)

['q_1', 'q_0']

>>> labeller(3,'j')

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

门

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

作用于量子比特的门的实现。

门是作用于量子比特空间的幺正算符。

中期待办事项：

  • 优化 Gate._apply_operators_Qubit 以消除许多中间 Qubit 对象的创建。

  • 为所有操作符添加交换关系，并在 gate_sort 中使用。

  • 修复 gate_sort 和 gate_simp。

  • 正确地绘制多目标 UGates。

  • 使用 sympy/numpy 矩阵中的 UGate，并输出任意格式。这也应该使用矩阵槽。

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

带有控制量子比特的通用幺正门。

通用控制门在所有控制量子比特具有特定值时（由CGate.control_value设置）对一组目标执行目标门。

参数：

标签：tuple

在此情况下，标签的形式为(control, gate)，其中 control 是控制量子比特的元组/列表（作为整数），gate 是目标操作符的Gate实例。

property controls

一个控制量子比特的元组。

decompose(**options)

将受控门分解为 CNOT 门和单量子比特门。

eval_controls(qubit)

返回 True/False 以指示是否满足控制条件。

property gate

将应用于目标的非受控门。

property min_qubits

该门需要作用的最小量子比特数。

property nqubits

该门作用的总量子比特数。

对于受控门子类，包括目标和控制量子比特，例如 CNOT 门作用于 2 个量子比特。

plot_gate(circ_plot, gate_idx)

绘制受控门。如果simplify_cgate为 true，则将 C-X 和 C-Z 门简化为它们更熟悉的形式。

property targets

一个目标量子比特的元组。

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

允许门简化的 CGate 版本。例如，cnot 看起来像 oplus，cphase 有点等等。

sympy.physics.quantum.gate.CNOT

CNotGate的别名

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

两量子比特控制 NOT 门。

如果所有控制量子比特的值都为 1，则该门在目标量子比特上执行 NOT 或 X 门。

参数：

标签：tuple

一个形如(control, target)的元组。

示例

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

property controls

一个控制量子比特的元组。

property gate

将应用于目标的非受控门。

property min_qubits

该门需要作用的最小量子比特数。

property targets

一个目标量子比特的元组。

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

非控制幺正门操作符，作用于量子比特。

这是一个一般的抽象门，需要子类化才能有用。

参数：

标签：tuple, int

将门应用于的目标量子比特的列表（作为整数）。

get_target_matrix(format='sympy')

门的目标部分的矩阵表示。

参数：

格式：str

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

property min_qubits

该门需要作用的最小量子比特数。

property nqubits

该门作用的总量子比特数。

对于受控门子类，包括目标和控制量子比特，例如 CNOT 门作用于 2 个量子比特。

property targets

一个目标量子比特的元组。

sympy.physics.quantum.gate.H

HadamardGate的别名

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

单量子比特 Hadamard 门。

参数：

目标：int

此门将应用于的目标量子比特。

示例

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

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

单量子比特恒等门。

参数：

目标 : 整数

此门将应用于的目标量子比特。

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

单量子比特酉门基类。

sympy.physics.quantum.gate.Phase

PhaseGate 的别名。

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

单量子比特相位或 S 门。

此门在状态为 |1> 时将状态相位旋转 π/2，如果状态为 |0> 则不做任何操作。

参数：

目标 : 整数

此门将应用于的目标量子比特。

sympy.physics.quantum.gate.S

PhaseGate 的别名。

sympy.physics.quantum.gate.SWAP

SwapGate 的别名。

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

两量子比特 SWAP 门。

此门交换两个量子比特的值。

参数：

标签 : 元组

一个形如 (目标 1, 目标 2) 的元组。

decompose(**options)

将 SWAP 门分解为 CNOT 门。

sympy.physics.quantum.gate.T

TGate 的别名。

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

单量子比特 π/8 门。

此门在状态为 |1> 时将状态相位旋转 π/4，如果状态为 |0> 则不做任何操作。

参数：

目标 : 整数

此门将应用于的目标量子比特。

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

两量子比特酉门基类。

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

由一组目标和目标矩阵指定的通用门。

参数：

标签 : 元组

一个形如 (目标, U) 的元组，其中目标是目标量子比特的一个元组，U 是一个维度为 len(targets) 的酉矩阵。

get_target_matrix(format='sympy')

目标部分门的矩阵表示。

参数：

格式 : 字符串

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

property targets

目标量子比特的一个元组。

sympy.physics.quantum.gate.X

XGate 的别名。

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

单量子比特 X 或 NOT 门。

参数：

目标 : 整数

此门将应用于的目标量子比特。

sympy.physics.quantum.gate.Y

YGate 的别名。

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

单量子比特 Y 门。

参数：

目标 : 整数

此门将应用于的目标量子比特。

sympy.physics.quantum.gate.Z

ZGate 的别名。

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

单量子比特 Z 门。

参数：

目标 : 整数

此门将应用于的目标量子比特。

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

符号化简门。

首先使用 gate_sort 对门进行排序。然后应用基本简化规则到电路，例如 XGate**2 = Identity。

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

在保持对易关系的同时对门进行排序。

此函数使用冒泡排序重新排列门的应用顺序。跟踪量子计算的特殊对易关系（例如，应用于同一量子比特的事物不会相互对易）。

电路是要排序的门的乘积。

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

设置标志，控制 Hadamard 门通过 (1/\sqrt{2}) 进行归一化。

这是一个全局设置，可以通过省略 Hadamard 门的前导 (1/\sqrt{2}) 来简化各种表达式的外观。

参数：

归一化 : 布尔值

哈达玛门是否应包括 (1/\sqrt{2}) 的归一化因子？当为 True 时，哈达玛门将包括 (1/\sqrt{2})。当为 False 时，则不包括此因子。

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

返回一个 ngates 和 nqubits 的随机电路。

这使用了等权重的样本（X, Y, Z, S, T, H, CNOT, SWAP）门。

参数：

ngates : 整数

电路中的门数量。

nqubits : 整数

电路中的量子比特数量。

gate_space : 元组

一个元组，包含将在电路中使用的门类。在此元组中多次重复门类将增加它们在随机电路中出现的频率。

Grover 算法

原文链接：docs.sympy.org/latest/modules/physics/quantum/grover.html

Grover 算法和辅助函数。

待办事项：

  • W 门的构造（或者根据 Mermin 的书可能是 -W 门）

  • 为返回多量子比特状态为 1 的未知函数泛化算法。

  • 在 OracleGate 中实现 _represent_ZGate

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

一个黑盒门。

该门通过翻转量子位的符号来标记未知函数的所需量子比特。当未知函数找到所需量子比特时返回 true，否则返回 false。

参数：

qubits : 整数

量子比特的数量。

oracle : 可调用对象

返回一个在计算基上返回布尔值的可调用函数。

示例

在不同量子比特上应用翻转 |2> 的 Oracle 门：

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

property search_function

帮助找到所需量子比特的未知函数。

property targets

目标量子比特的元组。

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

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

该门在某些量子比特上执行操作 2|phi><phi| - 1。|phi> = (n 个 Hadamard 的张量积)*(n 量子比特的 |0>)

参数：

nqubits : 整数

操作的量子比特数

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

应用 Grover 算法。

参数：

oracle : 可调用对象

未知的可调用函数，在应用于所需的量子比特时返回 true，否则返回 false。

返回：

state : 表达式

Grover 算法迭代后的结果状态。

示例

将 Grover 算法应用于两个量子比特的均匀叠加：

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

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

应用一次 Oracle 和 W 门，WV。

参数：

qstate : 量子位

量子比特的叠加态。

oracle : OracleGate

黑盒运算符，翻转所需基础量子位的符号。

返回：

Qubit : 在应用 Oracle 和 W 门后的量子比特。

示例

执行一次 Grover 算法迭代以查看相位变化：

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

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

创建计算基的等幺角叠加。

参数：

nqubits : 整数

量子比特的数量。

返回：

state : 量子位

用 nqubits 创建计算基的等幺角叠加。

示例

创建两个量子比特的等幺角叠加：

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

QFT

原文链接：docs.sympy.org/latest/modules/physics/quantum/qft.html

一个作用于量子比特及其门的实现。

待办事项：

  • 更新文档字符串。

  • 更新测试。

  • 使用分解实现应用。

  • 使用分解或更智能的方法来实现 represent。为此，我们首先必须为 SWAP 实现 represent。

  • 决定是否要在构造函数中包含上限索引。

  • 修复绘图中 Rk 门的打印。

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

量子傅里叶逆变换。

decompose()

将 IQFT 分解为基本门。

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

正向量子傅里叶变换。

decompose()

将 QFT 分解为基本门。

sympy.physics.quantum.qft.Rk

RkGate 的别名。

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

这是 QTF 的 R_k 门。

Qubit

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

量子计算的 Qubit。

Todo: * 完成实现测量逻辑。这应包括 POVM。 * 更新文档字符串。 * 更新测试。

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

存储整数作为 qubit 值的 qubit ket。

此类与 Qubit 之间的区别是：

  • 构造函数的形式。

  • qubit 值以其相应的整数形式打印，而不是原始 qubit 值。qubit 值的内部存储格式与 Qubit 相同。

参数：

values : 整数，元组

如果是单个参数，是我们想要表示在 qubit 值中的整数。这个整数将使用尽可能少的 qubit 数来表示。如果是一对整数，第二个值超过一个，那么第一个整数以二进制形式表示我们要表示的整数，第二个整数给出要使用的 qubit 数量。也接受零和一的列表以按位模式生成 qubit。

nqubits : 整数

表示 qubit 数量的整数。应使用关键字 nqubits=N 传递此数字。您可以使用此功能来避免 Qubit 样式的位元组的歧义。有关更多详细信息，请参见下面的示例。

示例

创建整数 5 的 qubit：

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

我们还可以通过传递 Qubit 实例来创建 IntQubit。

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

我们可以回到常规的 qubit 形式。

>>> Qubit(q)
|101>

请注意，IntQubit 还接受 Qubit 风格的位列表。因此，下面的代码产生的是 3 个 qubits，而不是单个位 1。

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

为避免歧义，请使用 nqubits 参数。特别是在通过变量提供值时，建议使用此关键字。

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

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

存储整数作为 qubit 值的 qubit bra。

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

在计算（z）基础上的多 qubit ket。

我们使用正常约定，即最低有效 qubit 在右侧，因此 |00001> 在最低有效 qubit 中有 1。

参数：

values : 列表，字符串

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

示例

以几种不同的方式创建 qubit 并查看它们的属性：

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

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

我们可以翻转单个 qubit 的值：

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

我们可以取 Qubit 的 dagger 来得到一个 bra：

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

内积按预期工作：

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

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

在计算（z）基础上的多 qubit bra。

我们使用正常约定，即最低有效 qubit 在右侧，因此 |00001> 在最低有效 qubit 中有 1。

参数：

values : 列表，字符串

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

参见

Qubit

使用 qubits 的示例

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

通过找到矩阵的特征向量和特征值来工作。我们知道可以通过以下方式分解 rho：sum(EigenVal*|Eigenvect><Eigenvect|)

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

从矩阵表示转换为一组 Qubit 对象的总和。

参数：

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

构建 Qubit 表示的矩阵。适用于 SymPy 矩阵、numpy 矩阵和 scipy.sparse 稀疏矩阵。

示例

表示一个状态，然后返回其 Qubit 形式：

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

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

对所有量子位执行集合测量。

参数：

qubit : Qubit, Add

要测量的量子位（qubit）。可以是任何量子位或它们的线性组合。

format : 字符串

要使用的中间矩阵的格式。可能的值为（‘sympy’，‘numpy’，‘scipy.sparse’）。目前只实现了‘sympy’。

返回：

result : 列表

由原始状态及其概率组成的列表。

示例

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

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

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

对所有量子位执行一次性集合测量。

一次性测量等同于对量子系统进行测量。这种类型的测量不像集合测量那样返回概率，而是返回可能结果中的一个。返回的确切状态是根据集合概率随机选择的。

参数：

qubits : Qubit

要测量的量子位。可以是任何量子位或它们的线性组合。

format : 字符串

要使用的中间矩阵的格式。可能的值为（‘sympy’，‘numpy’，‘scipy.sparse’）。目前只实现了‘sympy’。

返回：

result : Qubit

系统在测量时崩溃到的量子位。

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

对指定量子位执行部分集合测量。

参数：

qubits : Qubit

要测量的量子位。可以是任何量子位或它们的线性组合。

bits : 元组

要测量的量子位。

format : 字符串

要使用的中间矩阵的格式。可能的值为（‘sympy’，‘numpy’，‘scipy.sparse’）。目前只实现了‘sympy’。

返回：

result : 列表

由原始状态及其概率组成的列表。

示例

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

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

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

对指定量子位执行部分一次性测量。

一次性测量等同于对量子系统进行测量。这种类型的测量不像集合测量那样返回概率，而是返回可能结果中的一个。返回的确切状态是根据集合概率随机选择的。

参数：

qubits : Qubit

要测量的量子位。可以是任何量子位或它们的线性组合。

bits : 元组

要测量的量子位。

format : 字符串

要使用的中间矩阵的格式。可能的值为（‘sympy’，‘numpy’，‘scipy.sparse’）。目前只实现了‘sympy’。

返回：

result : Qubit

系统在测量时崩溃到的量子位。

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

将 Qubit 对象的 Add/Mul 转换为其矩阵表示

此函数是matrix_to_qubit的反函数，是represent(qubit)的简写。

Shor 算法

原文链接：docs.sympy.org/latest/modules/physics/quantum/shor.html

Shor 算法及其辅助函数。

待办事项：

  • 使用新的 Gate API 重新使 CMod 门工作。

  • 修复一切。

  • 更新文档字符串并重新格式化。

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

一个控制的模门。

这是用于 Shor 算法的黑盒子控制模函数。TODO：实现一个 decompose 属性，以元素门的术语返回如何执行此操作。

property N

N 是我们进行的模算术的类型。

property a

控制模函数的基础。

property t

1/2 输入寄存器的大小。前半部分保存输出。

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

在模 N 算术中找到 a 的周期

这是 Shor 算法的量子部分。它接受两个寄存器，将第一个置于哈达玛德变换的状态叠加中：|k>|0>，其中 k 是所有可能的选择。然后进行一个控制模门和一个量子傅立叶变换以确定 a 的阶。

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

这个函数在整数 N 上实现了 Shor 的因数分解算法。

算法首先随机选择一个数（a），并检查它是否与 N 互质。如果不是，则两个数的最大公约数是一个因子，我们完成了。否则，它开始执行 period_finding 子例程，用于找到在模 N 算术中 a 的周期。如果这个周期是偶数，可以通过取 a**(r/2)-1 和 a**(r/2)+1 来计算因子。这些值被返回。

盒中的粒子

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

1D 量子盒子中的粒子。

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

粒子在盒子中的本征矢。

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

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

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

粒子在盒子中的本征态。

光学模块

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

  • 高斯光学

  • 介质

  • 极化

  • 实用工具

  • 波

高斯光学

原文链接：docs.sympy.org/latest/modules/physics/optics/gaussopt.html

高斯光学。

模块实现：

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

    参见 RayTransferMatrix，GeometricRay 和 BeamParameter

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

    查看 geometric_conj*, gauss_conj 和 conjugate_gauss_beams

距离的惯例如下：

焦距

对于会聚透镜为正

物体距离

对于真实物体为正

图像距离

对于真实图像为正

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

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

参数：

wavelen : 波长，

z : 腰部距离，以及

w : 腰部，或

z_r : 雷利范围。

n : 介质的折射率。

示例

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

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

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

另见

RayTransferMatrix

参考文献

[R740]

en.wikipedia.org/wiki/Complex_beam_parameter

[R741]

en.wikipedia.org/wiki/Gaussian_beam

property divergence

总角度扩展的一半。

示例

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

property gouy

Gouy 相位。

示例

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

property q

表示光束的复参数。

示例

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

property radius

相位前沿的曲率半径。

示例

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

property w

在光束沿着光束的任何位置 z 处的光束半径 w(z)。光束半径在(1/e²)强度（轴向值）处。

示例

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

另见

w_0

光束的最小半径。

property w_0

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

示例

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

另见

w

光束在(1/e²)强度（轴向值）处的光束半径。

property waist_approximation_limit

适用于高斯光束近似有效的最小腰部。

解释

高斯光束是抛物近轴方程的解。对于曲率太大的情况，这不是一个有效的近似。

示例

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

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

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

参数：

R : 曲率半径（凹面为正）

示例

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

另见

RayTransferMatrix

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

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

参数：

R :

曲率半径（凹面为正）。

n1 :

单个介质的折射率。

n2 :

其他介质的折射率。

示例

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

另见

RayTransferMatrix

class sympy.physics.optics.gaussopt.FlatMirror

反射的射线传输矩阵。

示例

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

另见

RayTransferMatrix

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

折射的射线传输矩阵。

参数：

n1 :

单个介质的折射率。

n2 :

其他介质的折射率。

示例

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

另见

RayTransferMatrix

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

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

参数：

distance

示例

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

另见

RayTransferMatrix

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

几何光线在射线传输矩阵形式化中的表示。

参数：

h : 高度，和

angle : 角度，或

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

示例

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

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

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

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

另见

RayTransferMatrix

property angle

光轴角度。

示例

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

property height

光轴距离。

示例

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

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

射线传输矩阵的基类。

如果“参见”中没有更具体的子类，则应使用此选项。

参数：

parameters :

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

示例

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

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

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

>>> mat.A
1 

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

>>> lens.C
-1/f

另见

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

参考文献

[R742]

en.wikipedia.org/wiki/Ray_transfer_matrix_analysis

property A

矩阵的参数 A。

示例

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

property B

矩阵的参数 B。

示例

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

property C

矩阵的参数 C。

示例

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

property D

矩阵的参数 D。

示例

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

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

薄透镜的光线传输矩阵。

参数：

f :

焦距。

示例

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

另见

RayTransferMatrix

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

找到将物体/像腰部共轭的光学设置。

参数：

wavelen :

光束的波长。

waist_in and waist_out :

要共轭的腰部。

f :

用于共轭中使用的元件的焦距。

返回：

一个包含（s_in, s_out, f）的元组。

s_in :

光学元件前的距离。

s_out :

光学元件后的距离。

f :

光学元件的焦距。

示例

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

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

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

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

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

高斯光束的共轭关系。

参数：

s_in :

光学元件距离腰部的距离。

z_r_in :

入射光束的瑞利范围。

f :

光学元件的焦距。

返回：

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

s_out :

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

z_r_out :

出射光束的瑞利范围。

m :

新旧腰部之间的比率。

示例

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

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

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

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

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

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

解释

获取到光学元件的距离，并返回所需的焦距。

示例

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

参见

geometric_conj_af, geometric_conj_bf

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

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

解释

获取光学元件的物距（用于 geometric_conj_af）或像距（用于 geometric_conj_bf）和焦距。然后返回共轭所需的另一个距离。

示例

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

参见

geometric_conj_ab

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

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

解释

获取光学元件的物距（用于 geometric_conj_af）或像距（用于 geometric_conj_bf）和焦距。然后返回共轭所需的另一个距离。

示例

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

参见

geometric_conj_ab

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

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

示例

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

参见

waist2rayleigh, BeamParameter

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

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

示例

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

参见

rayleigh2waist, BeamParameter

avatar
文章
阅读
粉丝