Vector 同余向量积求和

下面的代码首先以符号方式计算$\sum{i=1}^3 x_i y_i$，然后将特定的数值替换到表达式中以生成单个数字。（我还添加了一些行来显示中间结果。）

我一直试图把这个想法转移到一个案例中，涉及向量而不是标量，交叉积而不是乘法，但没有成功

In [12]: from sympy.vector import *                                                                                     
In [13]: N = CoordSys3D('N')                                                                                            
In [14]: r = IndexedBase('r')                                                                                           
In [15]: F = IndexedBase('F')                                                                                           
In [16]: rs = [(r[1], N.i + 2*N.j + 4*N.k), (r[2], 3*N.i - 3*N.j + 4*N.k), (r[3], -N.i + 5*N.j + 2*N.k)]                
In [17]: Fs = [(F[1], -2*N.i - 1*N.j + 4*N.k), (F[2], -3*N.i - 2*N.j + 1*N.k), (F[3], N.i - 2*N.j - 3*N.k)]             
In [18]: rs[0][1] ^ Fs[0][1]                                                                                            
Out[18]: 12*N.i + (-12)*N.j + 3*N.k
In [19]: Svec = Sum(r[i] ^ F[i],(i,1,3))                                                                                
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-19-08e9d4fdd092> in <module>
----> 1 Svec = Sum(r[i] ^ F[i],(i,1,3))

TypeError: unsupported operand type(s) for ^: 'Indexed' and 'Indexed'

[12]中的

：来自sympy.vector导入*
在[13]中：N=CoordSys3D（'N'）
在[14]中：r=IndexedBase（'r'）
在[15]中：F=IndexedBase（'F'）
在[16]中：rs=[（r[1]，N.i+2*N.j+4*N.k），（r[2]，3*N.i-3*N.j+4*N.k），（r[3]，-N.i+5*N.j+2*N.k）]
在[17]中，Fs=[（F[1]，-2*N.i-1*N.j+4*N.k），（F[2]，-3*N.i-2*N.j+1*N.k），（F[3]，N.i-2*N.j-3*N.k）]
[18]：rs[0][1]^Fs[0][1]
Out[18]：12*N.i+（-12）*N.j+3*N.k
在[19]中：Svec=Sum（r[i]^F[i]，（i，1,3））
---------------------------------------------------------------------------
TypeError回溯（最近一次调用上次）
在里面
---->1 Svec=和（r[i]^F[i]，（i，1,3））
TypeError:不支持^“已索引”和“已索引”的操作数类型

索引对象似乎不支持像叉积这样的向量运算

---

我的问题是，在Symphy中是否有任何方法可以执行类似于我上面的纯数值示例的计算，其中涉及向量和向量运算？我想计算$T=\sum{I=1}^3 r_I x F_I$，首先我得到r_1 x F_1+r_2 x F_2+r_3 x F_3，然后我可以进行适当的替换，得到一个向量6*N.I+（-28）*N.j+（-15）*N.k。这可能吗？如果是这样，如何计算？

您可以将求和作为乘积，然后计算结果。替换（lambda x:x.is_Mul，lambda x:reps[x.args[0]^reps[x.args[1]]）其中

reps=dict（rs）；代表更新（dict（Fs））

？e、 g.使用整数和位运算可以：

>>> rs = [(r[1], 1), (r[2], 2), (r[3], 3)]
>>> Fs = [(F[1], 4), (F[2], 5), (F[3], 6)]
>>> Sum(r[i]*F[i], (i, 1, 3)).doit().replace(
...    lambda x: x.is_Mul,
...    lambda x: int(reps[x.args[0]])^int(reps[x.args[1]]))
... 
17

然而，这样做的一个问题是（目前）IndexedBase不能声明为非交换的。您可以使用以下函数代替IndexedBase：

>>> f=Function('f', commutative=False)
>>> g=Function('g', commutative=False)
>>> Sum(f(i)*g(i), (i, 1, 3)).doit()
f(1)*g(1) + f(2)*g(2) + f(3)*g(3)
>>> Sum(g(i)*f(i), (i, 1, 3)).doit()
g(1)*f(1) + g(2)*f(2) + g(3)*f(3)

在您的例子中，您将它们命名为

r

和

F

，而不是

F

和

g

，并将它们映射到*向量，如

rs=[（r（1），N.i+2*N.j+4*N.k），…

如果将以下差异应用于Symphy，那么我认为声明为

可交换=False

的

索引数据库将起作用：

diff --git a/sympy/tensor/indexed.py b/sympy/tensor/indexed.py
index 9024f21..f02aa3e 100644
--- a/sympy/tensor/indexed.py
+++ b/sympy/tensor/indexed.py
@@ -138,7 +138,6 @@ class Indexed(Expr):
     True

     """
-    is_commutative = True
     is_Indexed = True
     is_symbol = True
     is_Atom = True
@@ -419,7 +418,6 @@ class IndexedBase(Expr, NotIterable):
     >>> C_inherit == C_explicit
     True
     """
-    is_commutative = True
     is_symbol = True
     is_Atom = True

例如：

>>> I=IndexedBase('i', commutative=False)
>>> I[1]*I[2]
i[1]*i[2]
>>> I[2]*I[1]
i[2]*i[1]

您可能想为此打开一个问题。
您可以将求和作为一个乘积进行，但随后是
结果。替换（lambda x:x.is_Mul，lambda x:reps[x.args[0]^reps[x.args[1]]）
其中
reps=dict（rs）；reps.update（dict（Fs））
？例如，使用int和按位操作可以：

>>> rs = [(r[1], 1), (r[2], 2), (r[3], 3)]
>>> Fs = [(F[1], 4), (F[2], 5), (F[3], 6)]
>>> Sum(r[i]*F[i], (i, 1, 3)).doit().replace(
...    lambda x: x.is_Mul,
...    lambda x: int(reps[x.args[0]])^int(reps[x.args[1]]))
... 
17

但是，这样做的一个问题是（当前）无法将IndexedBase声明为非交换。您可以使用以下函数代替IndexedBase：

>>> f=Function('f', commutative=False)
>>> g=Function('g', commutative=False)
>>> Sum(f(i)*g(i), (i, 1, 3)).doit()
f(1)*g(1) + f(2)*g(2) + f(3)*g(3)
>>> Sum(g(i)*f(i), (i, 1, 3)).doit()
g(1)*f(1) + g(2)*f(2) + g(3)*f(3)

在您的例子中，您将它们命名为
r
和
F
，而不是
F
和
g
，并将它们映射到*向量，如
rs=[（r（1），N.i+2*N.j+4*N.k），…

如果将以下差异应用于Symphy，那么我认为声明为
可交换=False
的
索引数据库将起作用：

diff --git a/sympy/tensor/indexed.py b/sympy/tensor/indexed.py
index 9024f21..f02aa3e 100644
--- a/sympy/tensor/indexed.py
+++ b/sympy/tensor/indexed.py
@@ -138,7 +138,6 @@ class Indexed(Expr):
     True

     """
-    is_commutative = True
     is_Indexed = True
     is_symbol = True
     is_Atom = True
@@ -419,7 +418,6 @@ class IndexedBase(Expr, NotIterable):
     >>> C_inherit == C_explicit
     True
     """
-    is_commutative = True
     is_symbol = True
     is_Atom = True

例如：

>>> I=IndexedBase('i', commutative=False)
>>> I[1]*I[2]
i[1]*i[2]
>>> I[2]*I[1]
i[2]*i[1]

您可能需要为此打开一个问题。
谢谢您的回答；它可以工作并生成正确的-6⋅N_i+（28）N_j+（15）N_k值编辑：我太仓促了。我只是注意到结果正好是正确和的（-1）倍6*N_i+（-28）*N_j+（-15）*N_k。我想这是一个事实的结果，与实积相反，叉积是不可交换的，即a x b=-（b x a）。显然，评估没有考虑到这一事实。不过，您的建议是朝着正确方向迈出的非常有用的一步，再次感谢。尽管IndexedBase似乎是正确的使用类型，但一个能够保留可交换性假设的简单函数将更有效。我将给出答案。感谢您的答案；它很有效雅思考试正确-6分⋅N_i+（28）N_j+（15）N_k值编辑：我太仓促了。我只是注意到结果正好是正确和的（-1）倍6*N_i+（-28）*N_j+（-15）*N_k。我想这是一个事实的结果，与实积相反，叉积是不可交换的，即a x b=-（b x a）。显然，评估没有考虑到这一事实。不过，您的建议是朝着正确方向迈出的非常有用的一步，再次感谢。尽管IndexedBase似乎是正确的使用类型，但一个能够保留可交换性假设的简单函数将更有效。我将给出答案。