标签: symbolic-computation

有没有人知道有关计算机代数系统一般理论的任何资源(书籍,课程,讲义或任何内容)(例如mathematica,sympy)？

"介绍性"材料是首选,但我意识到,对于这样一个专门的主题,任何东西都必定相当先进.

我需要在C++中进行分析集成.例如,我应该整合这样的表达式:exp[I(x-y)],I是一个虚数.

我怎么能用C++做到这一点？

我尝试了GiNaC但它可以只集成多项式.我也试过SymbolicC++.它可以集成功能,如sine,cosine或exp(x)和ln(x),但它是不是很厉害.例如,它无法集成x*ln(x),可以通过使用Mathematica或通过部件集成轻松获得.

是否有其他工具或库能够进行符号计算,如C++中的分析集成？

同情我有一个积分返回一个Piecewise对象,例如

In [2]: from sympy.abc import x,y,z

In [3]: test = exp(-x**2/z**2)

In [4]: itest = integrate(test,(x,0,oo))

In [5]: itest
Out[5]: 
?   ___                                                   
? ?? ? ?z       ?                 ?      1          ??   ?
? ???????   for ?periodic_argument???????????????, ??? ? ?
?    2          ?                 ?          2      ??   2
?               ?                 ?polar_lift (z)   ??    
?                                                         
??                                                        
??                                                        
??    2                                                   
??  -x                                                    
??  ???                                                   
??    2                                                   
??   z                                                    
?? ?    dx                    otherwise                   
??                                                        
?0                                                        
?    

我想提取这个分段方程的第一个分支,换句话说,我希望能够做一些itest.parts(0)简单的提取sqrt(pi)*z/2.我似乎无法找到任何方法来做到这一点,但也许我在文档中使用了错误的搜索词.有任何想法吗？

编辑

稍微探讨一下,我已经设法发现,如果我这样做,itest.args[0][0]我可以提取这个表达式.然而,这看起来有点像黑客.有更好的方法吗？

我有一个等式:

     R??V? + R??V? - R??V?
i? = ?????????????????????
     R??R? + R??R? + R??R?

已定义,我想将其拆分为仅包含单个变量的因子 - 在本例中为V1和V2.

所以我希望如此

        -R?                        (R? + R?)
i? = V??????????????????????? + V???????????????????????
        R??R? + R??R? + R??R?      R??R? + R??R? + R??R?

但到目前为止我能做到的最好的是

     -R??V? + V??(R? + R?)
i? = ?????????????????????
     R??R? + R??R? + R??R?

使用equation.factor(V1,V2).因果或其他方法还有一些其他选项可以进一步分离变量吗？

我最近读了EJ Schwartz博士的一篇题为"所有你想要了解动态污点分析和前进符号执行(但可能不得不提出来)"的论文.在本文中,他主要讨论了它们在二进制级安全上下文中的应用.

我很好奇动态污点分析和前向符号执行之间的确切差异.

从我所看到的,每当存储在x中的信息被传送到对象y时,污点分析就跟踪从对象x(源)到对象y(接收器)的信息流.因此,主要关注的是对象可以受到源的传递影响.符号执行将某些输入视为符号值,并尝试用符号表示其他变量; 因此它回答了什么条件的符号输入影响后续的程序.

我可以看到,在二进制级别,通常会提到污点分析,其中包含由覆盖返回地址引起的漏洞; 而符号执行可以处理更多类型的易受攻击的问题,如整数溢出,运行时断言错误,资源泄漏(例如,内存泄漏,文件打开/关闭),缓冲区溢出.

然而,现代污点分析似乎不仅涉及数据流分析,而且大多数都将跟踪控制流条件; 在一些漏洞检测场景中,受污染的输入也表示为符号值,并像符号执行一样传播.另一方面,由于底层约束求解器和执行/解释运行时的限制,符号执行引擎不能完全使用由不同路径条件分隔的符号值; 因此,它们无法达到预期的高分支或路径覆盖.

所以在一般情况下,我们可以说污点分析是一种粗略的符号执行,还是符号执行是一种精确的污点分析？

DO方言使用PAREN系列!对于优先级,通常会在调用函数之前烧掉底层括号结构.

但是,Rebol 2中曾经有可能在函数的定义中指定您希望它抑制在调用点上对括号的评估.您通过在参数上使用"文字单词"撇号来完成此操作:

evaluated: func [param] [probe param]

non-evaluated: func ['param] [probe param]

>> evaluated (1 + 2)
3

>> non-evaluated (1 + 2)
(1 + 2)

所以你通过了系列!分类型,类PAREN的......在这种情况下,与内部的三个标志性元素:1,+,2.这在Rebol 3中不起作用:

>> non-evaluated (1 + 2)
3

这是一个错误还是一个有目的的设计决定？有解决方法吗？请注意,将引号操作符放在callsite上是行不通的,因为它是quote引用的符号词,然后是paren!得到自己的评估,成为表达式的最终值: - /

>> non-evaluated quote (1 + 2)
quote
== 3

的象征库重载算术运算符.虽然它是用C#编写的,但我可以在F#中使用它:

open Symbolism

let x = new Symbol("x")
let y = new Symbol("y")
let z = new Symbol("z")

printfn "%A" (2*x + 3 + 4*x + 5*y + z + 8*y)

输出:

3 + 6 * x + 13 * y + z

但是,它也会超负荷^.这当然不适合F#.

作为解决方法的一步,我导出了一个权限的方法组:

printfn "%A" (Aux.Pow(x, 2) * x)

输出:

x ^ 3

如何重载**以使用Aux.Pow方法组？

我可以这样做:

let ( ** ) (a: MathObject) (b: MathObject) = Aux.Pow(a, b)

这对MathObject价值观有效:

> …

我有以下表达式:

from sympy import pi, sin, cos, var, simplify
var('j,u,v,w,vt,wt,a2,t,phi')

u0 = v*a2*sin(pi*j/2 + pi*j*t*phi**(-1)/2) + pi*vt*a2*cos(pi*j/2 + pi*j*t*phi**(-1)/2)*j*phi**(-1)/2 + pi*w*a2*cos(pi*j/2 + pi*j*t*phi**(-1)/2)*j*phi**(-1)

哪个可以简化:

print simplify(u0)
#a2*(pi*j*vt*cos(pi*j*(phi + t)/(2*phi)) + 2*pi*j*w*cos(pi*j*(phi + t)/(2*phi)) + 2*phi*v*sin(pi*j*(phi + t)/(2*phi)))/(2*phi)

给出子表达式:

bj = pi*j*(phi + t)/(2*phi)
cj = j*pi/(2*phi)

目前我手动替换bj并cj在简化u0表达式中获取:

u0 = a2*(v*sin(bj) + cj*vt*cos(bj) + 2*cj*w*cos(bj))

是否可以使用SymPy来实现这一点,避免手动替换？

我的目标是使用sympy哪个来编写多维泰勒近似

• 使用尽可能多的内置代码,
• 计算两个变量的给定函数的截断泰勒近似
• 返回没有 Big-O-remainder项的结果,例如in sin(x)=x - x**3/6 + O(x**4).

这是我到目前为止尝试的内容:

方法1

天真地,人们可以只series为每个变量组合两次命令,遗憾的是这不起作用,如本例所示sin(x*cos(y)):

sp.sin(x*sp.cos(y)).series(x,x0=0,n=3).series(y,x0=0,n=3)
>>> NotImplementedError: not sure of order of O(y**3) + O(x**3)

方法2

基于这篇文章,我首先写了一个1D泰勒近似:

def taylor_approximation(expr, x, max_order):
    taylor_series = expr.series(x=x, n=None)
    return sum([next(taylor_series) for i in range(max_order)])

用1D示例检查它可以正常工作

mport sympy as sp
x=sp.Symbol('x')
y=sp.Symbol('y')
taylor_approximation(sp.sin(x*sp.cos(y)),x,3)

>>> x**5*cos(y)**5/120 - x**3*cos(y)**3/6 + x*cos(y)

不过,如果我知道这样做既扩张做一个链接调用x和y,sympy挂断

# this does not work
taylor_approximation(taylor_approximation(sp.sin(x*sp.cos(y)),x,3),y,3)

有人知道如何解决这个问题或以另一种方式实现它吗？

你如何编程以下算法？

想象一下像这样的"事实"列表,其中字母表示绑定到数值的变量:

x = 1
y = 2
z = 3
a = 1
b = 2
c = 3
a = x
b = z
c = z

这些"事实"显然不一定都是"真实的":当b = 2且z = 3时,b = z是不可能的.如果删除b = z或b = 2,则所有事实都是一致的.如果z = 3且b = z或c = z被移除,那么所有事实都是一致的,但事实上会比上面少一个.该集包含许多这样的一致子集.例如,a = 1,b = 2,c = 3是一致的子集,许多其他子集也是如此.

在此示例中,两个一致的子集大于任何其他一致的子集:

x = 1
y = 2
z = 3
a = 1
b = 2
c = 3
a = x
c = z

和

x = …