索引对象¶
定义索引对象的模块。
类 IndexedBase、Indexed 和 Idx 表示矩阵元素 M[i, j] ，如下面的图示所示:
1) The Indexed class represents the entire indexed object.
|
___|___
' '
M[i, j]
/ \__\______
| |
| |
| 2) The Idx class represents indices; each Idx can
| optionally contain information about its range.
|
3) IndexedBase represents the 'stem' of an indexed object, here `M`.
The stem used by itself is usually taken to represent the entire
array.
在 Indexed 对象上可以有任意数量的索引。这些 Base 对象中没有实现任何变换属性，但支持重复索引的隐式收缩。
请注意，对复杂（即非原子）整数表达式作为索引的支持是有限的。（这将在未来的版本中得到改进。）
示例
要表达上述矩阵元素示例，您可以这样写：
>>> from sympy import symbols, IndexedBase, Idx
>>> M = IndexedBase('M')
>>> i, j = symbols('i j', cls=Idx)
>>> M[i, j]
M[i, j]
乘积中的重复指标意味着求和，因此要用 Indexed 对象表示矩阵-向量乘积：
>>> x = IndexedBase('x')
>>> M[i, j]*x[j]
M[i, j]*x[j]
如果索引对象将被转换为基于组件的数组，例如使用代码打印机或 autowrap 框架，您还需要提供（符号或数值）维度。这可以通过在构造 IndexedBase 时传递一个可选的 shape 参数来完成：
>>> dim1, dim2 = symbols('dim1 dim2', integer=True)
>>> A = IndexedBase('A', shape=(dim1, 2*dim1, dim2))
>>> A.shape
(dim1, 2*dim1, dim2)
>>> A[i, j, 3].shape
(dim1, 2*dim1, dim2)
如果一个 IndexedBase 对象没有形状信息，则假定该数组的大小与其索引的范围相同：
>>> n, m = symbols('n m', integer=True)
>>> i = Idx('i', m)
>>> j = Idx('j', n)
>>> M[i, j].shape
(m, n)
>>> M[i, j].ranges
[(0, m - 1), (0, n - 1)]
上述内容可以与以下内容进行比较：
>>> A[i, 2, j].shape
(dim1, 2*dim1, dim2)
>>> A[i, 2, j].ranges
[(0, m - 1), None, (0, n - 1)]
要分析索引表达式的结构，可以使用方法 get_indices() 和 get_contraction_structure()：
>>> from sympy.tensor import get_indices, get_contraction_structure
>>> get_indices(A[i, j, j])
({i}, {})
>>> get_contraction_structure(A[i, j, j])
{(j,): {A[i, j, j]}}
有关输出的详细解释，请参阅相应的文档字符串。
- class sympy.tensor.indexed.Idx(label, range=None, **kw_args)[源代码][源代码]¶
将整数索引表示为
Integer或整数表达式。创建
Idx对象有多种方法。构造函数接受两个参数：label一个整数或符号，用于标记索引。
range你可以选择性地指定一个范围，无论是
Symbol或整数：这被解释为一个维度。下限和上限分别设置为0和range - 1。tuple: 这两个元素分别被解释为范围的下限和上限。
注意：范围的边界假定为整数或无穷大（允许使用 oo 和 -oo 来指定无界范围）。如果
n作为边界给出，那么n.is_integer必须不返回 false。为了方便，如果标签以字符串形式给出，它会自动转换为整数符号。（注意：此转换不适用于范围或维度参数。）
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- is_antihermitian
is_comparable如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
- is_composite
- is_even
- is_extended_negative
- is_extended_nonnegative
- is_extended_nonpositive
- is_extended_nonzero
- is_extended_positive
- is_negative
- is_nonnegative
- is_nonpositive
- is_nonzero
is_number如果
self没有自由符号且没有未定义的函数（确切地说，是 AppliedUndef），则返回 True。- is_odd
- is_polar
- is_positive
- is_prime
- is_zero
label返回 Idx 对象的标签（整数或整数表达式）。
lower返回
Idx的下限。- 名称
upper返回
Idx的上限。
方法
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 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
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
转置
示例
>>> from sympy import Idx, symbols, oo >>> n, i, L, U = symbols('n i L U', integer=True)
如果为标签提供了一个字符串，则会创建一个整数
Symbol，并且边界均为None：>>> idx = Idx('qwerty'); idx qwerty >>> idx.lower, idx.upper (None, None)
可以指定上下限：
>>> idx = Idx(i, (L, U)); idx i >>> idx.lower, idx.upper (L, U)
当只给出一个边界时，它被解释为维度，下界默认为0：
>>> idx = Idx(i, n); idx.lower, idx.upper (0, n - 1) >>> idx = Idx(i, 4); idx.lower, idx.upper (0, 3) >>> idx = Idx(i, oo); idx.lower, idx.upper (0, oo)
- property label¶
返回 Idx 对象的标签（整数或整数表达式）。
示例
>>> from sympy import Idx, Symbol >>> x = Symbol('x', integer=True) >>> Idx(x).label x >>> j = Symbol('j', integer=True) >>> Idx(j).label j >>> Idx(j + 1).label j + 1
- property lower¶
返回
Idx的下限。示例
>>> from sympy import Idx >>> Idx('j', 2).lower 0 >>> Idx('j', 5).lower 0 >>> Idx('j').lower is None True
- property upper¶
返回
Idx的上限。示例
>>> from sympy import Idx >>> Idx('j', 2).upper 1 >>> Idx('j', 5).upper 4 >>> Idx('j').upper is None True
- class sympy.tensor.indexed.Indexed(base, *args, **kw_args)[源代码][源代码]¶
表示带有索引的数学对象。
>>> from sympy import Indexed, IndexedBase, Idx, symbols >>> i, j = symbols('i j', cls=Idx) >>> Indexed('A', i, j) A[i, j]
建议通过索引
IndexedBase来创建Indexed对象：IndexedBase('A')[i, j]而不是Indexed(IndexedBase('A'), i, j)。>>> A = IndexedBase('A') >>> a_ij = A[i, j] # Prefer this, >>> b_ij = Indexed(A, i, j) # over this. >>> a_ij == b_ij True
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
base返回
Indexed对象的IndexedBase。canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
indices返回
Indexed对象的索引。- 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
- 名称
ranges返回一个包含每个索引的下限和上限范围的元组列表。
rank返回
Indexed对象的等级。shape返回一个包含每个索引维度的列表。
方法
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 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
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
转置
- property base¶
返回
Indexed对象的IndexedBase。示例
>>> from sympy import Indexed, IndexedBase, Idx, symbols >>> i, j = symbols('i j', cls=Idx) >>> Indexed('A', i, j).base A >>> B = IndexedBase('B') >>> B == B[i, j].base True
- property indices¶
返回
Indexed对象的索引。示例
>>> from sympy import Indexed, Idx, symbols >>> i, j = symbols('i j', cls=Idx) >>> Indexed('A', i, j).indices (i, j)
- property ranges¶
返回一个包含每个索引的下限和上限范围的元组列表。
如果一个索引没有定义数据成员 upper 和 lower，列表中对应的槽位将包含
None而不是一个元组。示例
>>> from sympy import Indexed,Idx, symbols >>> Indexed('A', Idx('i', 2), Idx('j', 4), Idx('k', 8)).ranges [(0, 1), (0, 3), (0, 7)] >>> Indexed('A', Idx('i', 3), Idx('j', 3), Idx('k', 3)).ranges [(0, 2), (0, 2), (0, 2)] >>> x, y, z = symbols('x y z', integer=True) >>> Indexed('A', x, y, z).ranges [None, None, None]
- property rank¶
返回
Indexed对象的等级。示例
>>> from sympy import Indexed, Idx, symbols >>> i, j, k, l, m = symbols('i:m', cls=Idx) >>> Indexed('A', i, j).rank 2 >>> q = Indexed('A', i, j, k, l, m) >>> q.rank 5 >>> q.rank == len(q.indices) True
- property shape¶
返回一个包含每个索引维度的列表。
维度是数组的一个属性，而不是索引的属性。尽管如此，如果
IndexedBase没有定义形状属性，则假定索引的范围对应于数组的形状。>>> from sympy import IndexedBase, Idx, symbols >>> n, m = symbols('n m', integer=True) >>> i = Idx('i', m) >>> j = Idx('j', m) >>> A = IndexedBase('A', shape=(n, n)) >>> B = IndexedBase('B') >>> A[i, j].shape (n, n) >>> B[i, j].shape (m, m)
- class sympy.tensor.indexed.IndexedBase(
- label,
- shape=None,
- *,
- offset=0,
- strides=None,
- **kw_args,
表示索引对象的基或词干
IndexedBase 类表示一个包含元素的数组。该类的主要目的是方便地创建 Indexed 类的对象。IndexedBase 的 __getitem__ 方法返回一个 Indexed 实例。单独使用时，没有索引的情况下，IndexedBase 类可以用作例如矩阵方程的符号表示，类似于使用 Symbol 类可以实现的功能。但是，IndexedBase 类增加了 Symbol 实例不可用的功能：
IndexedBase 对象可以选择性地存储形状信息。这可以用于检查数组的一致性和 numpy 广播的条件。（待办）
IndexedBase 对象实现了语法糖，允许使用重复索引的隐式求和轻松表示数组操作的符号。
IndexedBase 对象象征着一种等同于数组的数学结构，并且在代码生成和自动编译与封装中被识别为这样的结构。
>>> from sympy.tensor import IndexedBase, Idx >>> from sympy import symbols >>> A = IndexedBase('A'); A A >>> type(A) <class 'sympy.tensor.indexed.IndexedBase'>
当一个 IndexedBase 对象接收到索引时，它会返回一个带有命名轴的数组，由一个 Indexed 对象表示：
>>> i, j = symbols('i j', integer=True) >>> A[i, j, 2] A[i, j, 2] >>> type(A[i, j, 2]) <class 'sympy.tensor.indexed.Indexed'>
IndexedBase 构造函数接受一个可选的 shape 参数。如果提供，它将覆盖索引中的任何形状信息。（但不会覆盖索引范围！）
>>> m, n, o, p = symbols('m n o p', integer=True) >>> i = Idx('i', m) >>> j = Idx('j', n) >>> A[i, j].shape (m, n) >>> B = IndexedBase('B', shape=(o, p)) >>> B[i, j].shape (o, p)
假设可以通过关键字参数以与符号相同的方式指定：
>>> A_real = IndexedBase('A', real=True) >>> A_real.is_real True >>> A != A_real True
如果使用符号来初始化 IndexedBase，假设也可以被继承：
>>> I = symbols('I', integer=True) >>> C_inherit = IndexedBase(I) >>> C_explicit = IndexedBase('I', integer=True) >>> C_inherit == C_explicit True
- 属性:
args返回 ‘self’ 的参数元组。
assumptions0返回对象 \(type\) 假设。
canonical_variables返回一个字典，将
self.bound_symbols中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。expr_free_symbols类似于
free_symbols，但仅在自由符号包含在表达式节点中时返回它们。free_symbols从自身的原子中返回那些自由符号。
func表达式中的顶级函数。
- 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
label返回
IndexedBase对象的标签。- 名称
offset返回
IndexedBase对象的偏移量。shape返回
IndexedBase对象的形状。strides返回
IndexedBase对象的跨步方案。
方法
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 中的表达式之间寻找匹配。
n([n, subs, maxn, chop, strict, quad, verbose])将给定的公式计算到 n 位精度。
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
转置
- property label¶
返回
IndexedBase对象的标签。示例
>>> from sympy import IndexedBase >>> from sympy.abc import x, y >>> IndexedBase('A', shape=(x, y)).label A
- property offset¶
返回
IndexedBase对象的偏移量。这是当二维索引对象展开为一维形式时，添加到结果索引中的值。用于代码生成。
示例
>>> from sympy.printing import ccode >>> from sympy.tensor import IndexedBase, Idx >>> from sympy import symbols >>> l, m, n, o = symbols('l m n o', integer=True) >>> A = IndexedBase('A', strides=(l, m, n), offset=o) >>> i, j, k = map(Idx, 'ijk') >>> ccode(A[i, j, k]) 'A[l*i + m*j + n*k + o]'
- property shape¶
返回
IndexedBase对象的形状。示例
>>> from sympy import IndexedBase, Idx >>> from sympy.abc import x, y >>> IndexedBase('A', shape=(x, y)).shape (x, y)
注意：如果
IndexedBase的形状被指定，它将覆盖由索引提供的任何形状信息。>>> A = IndexedBase('A', shape=(x, y)) >>> B = IndexedBase('B') >>> i = Idx('i', 2) >>> j = Idx('j', 1) >>> A[i, j].shape (x, y) >>> B[i, j].shape (2, 1)
- property strides¶
返回
IndexedBase对象的跨步方案。通常这是一个元组，表示在遍历数组时在各个维度上要采取的步数。为了代码生成目的，也可以使用 strides=’C’ 和 strides=’F’。
strides='C'意味着代码打印机将按行主序展开，而'F'意味着按列主序展开。