方法#

具有在IndexedBase、Indexed和Idx对象上操作函数的模块

  • 检查形状一致性

  • 确定结果表达式中的索引

等。

这个模块中的方法可以通过调用Expr对象上的方法来实现。当事情稳定下来时，这可能是一个有用的重构。

sympy.tensor.index_methods.get_contraction_structure(expr)[源代码]#

确定虚拟指标 expr 并描述其结构

通过 笨蛋 我们指的是求和指数。

表达式的结构被确定并描述如下：

  1. 索引对象的一致性求和用dict描述，其中键是求和索引，对应的值是包含求和适用的所有项的集合。SymPy表达式树中的所有Add对象都是这样描述的。

  2. 对于SymPy表达式树中的所有节点 not 对于Add类型，以下内容适用：

    如果每个节点的一个键都是一个递归的dict，那么它将把一个dict（）的值存储在它的一个键结构中。该列表只包含非平凡的深层收缩的dict，省略了None作为唯一键的dicts。

备注

字典键中的表达式表示索引收缩的多个级别。嵌套dict显示嵌套的缩略语，它本身可能包含更深层次的dict。在实际计算中，必须首先计算最深嵌套级别的总和，以便外部表达式可以访问结果索引对象。

实例

>>> from sympy.tensor.index_methods import get_contraction_structure
>>> from sympy import default_sort_key
>>> from sympy.tensor import IndexedBase, Idx
>>> x, y, A = map(IndexedBase, ['x', 'y', 'A'])
>>> i, j, k, l = map(Idx, ['i', 'j', 'k', 'l'])
>>> get_contraction_structure(x[i]*y[i] + A[j, j])
{(i,): {x[i]*y[i]}, (j,): {A[j, j]}}
>>> get_contraction_structure(x[i]*y[j])
{None: {x[i]*y[j]}}

收缩因子的乘法导致嵌套的dicts表示内部收缩。

>>> d = get_contraction_structure(x[i, i]*y[j, j])
>>> sorted(d.keys(), key=default_sort_key)
[None, x[i, i]*y[j, j]]

在这种情况下，产品没有收缩：

>>> d[None]
{x[i, i]*y[j, j]}

“先”收缩因子：

>>> sorted(d[x[i, i]*y[j, j]], key=default_sort_key)
[{(i,): {x[i, i]}}, {(j,): {y[j, j]}}]

带圆括号的Add对象也作为嵌套字典返回。包含括号的项是一个Mul，在参数之间有一个收缩，因此它将作为结果中的键找到。它存储对Add表达式的递归调用产生的字典。

>>> d = get_contraction_structure(x[i]*(y[i] + A[i, j]*x[j]))
>>> sorted(d.keys(), key=default_sort_key)
[(A[i, j]*x[j] + y[i])*x[i], (i,)]
>>> d[(i,)]
{(A[i, j]*x[j] + y[i])*x[i]}
>>> d[x[i]*(A[i, j]*x[j] + y[i])]
[{None: {y[i]}, (j,): {A[i, j]*x[j]}}]

在字典中，还可以在字典中找到以基或指数形式收缩的幂，映射到递归调用的结果列表：

>>> d = get_contraction_structure(A[j, j]**A[i, i])
>>> d[None]
{A[j, j]**A[i, i]}
>>> nested_contractions = d[A[j, j]**A[i, i]]
>>> nested_contractions[0]
{(j,): {A[j, j]}}
>>> nested_contractions[1]
{(i,): {A[i, i]}}

在上述示例中，用字符串表示收缩结构的描述可能会显得复杂，但很容易重复：

>>> from sympy import Expr
>>> for key in d:
...     if isinstance(key, Expr):
...         continue
...     for term in d[key]:
...         if term in d:
...             # treat deepest contraction first
...             pass
...     # treat outermost contactions here
sympy.tensor.index_methods.get_indices(expr)[源代码]#

确定表达的外部指标 expr

通过 外面的 我们指的是不是求和指数的指数。返回一个集合和一个dict。该集合包含外部索引，dict包含有关索引对称性的信息。

实例

>>> from sympy.tensor.index_methods import get_indices
>>> from sympy import symbols
>>> from sympy.tensor import IndexedBase
>>> x, y, A = map(IndexedBase, ['x', 'y', 'A'])
>>> i, j, a, z = symbols('i j a z', integer=True)

确定总表达式的指数，重复的指数意味着求和，例如矩阵a的轨迹：

>>> get_indices(A[i, i])
(set(), {})

在许多术语的情况下，要求这些术语具有相同的外部索引。否则将引发IndexConformanceException。

>>> get_indices(x[i] + A[i, j]*y[j])
({i}, {})
例外情况:

IndexConformanceException意味着术语ar不兼容，例如。

>>> get_indices(x[i] + y[j])                
        (...)
IndexConformanceException: Indices are not consistent: x(i) + y(j)

警告

概念 外面的 索引从最深层开始递归应用。这意味着假定先对括号内的伪数求和，以便优雅地处理以下表达式：

>>> get_indices((x[i] + A[i, j]*y[j])*x[j])
({i, j}, {})

这是正确的，可能看起来很方便，但您需要小心，因为SymPy会很乐意的。如果需要，请展开产品。结果表达式将混合外部 j 括号内有假人，这使它成为一个不同的表达式。为了安全起见，最好通过对所有应该分开的收缩使用唯一的指数来避免这种含糊不清。