天道酬勤,学无止境

Sympy中的多元泰勒近似(Multivariate Taylor approximation in sympy)

问题

我的目标是使用sympy编写sympy ,其中

  • 使用尽可能多的内置代码,
  • 计算两个变量的给定函数的截断泰勒逼近
  • 返回包含Big-O-remainder项的结果,例如,在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

根据这篇文章,我首先写了一维泰勒近似值:

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)])

用一维示例检查它可以正常工作

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)

但是,如果我知道要对xy进行两个扩展都进行链式调用,则sympy会挂断

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

有人知道如何解决此问题或以其他方式实现它吗?

回答1

您可以使用expr.removeO()从表达式中删除大O。


Oneliner: expr.series(x, 0, 3).removeO().series(y, 0, 3).removeO()

回答2

这是与Sympy一起使用的多元泰勒级数展开式:

def Taylor_polynomial_sympy(function_expression, variable_list, evaluation_point, degree):
    """
    Mathematical formulation reference:
    https://math.libretexts.org/Bookshelves/Calculus/Supplemental_Modules_(Calculus)/Multivariable_Calculus/3%3A_Topics_in_Partial_Derivatives/Taylor__Polynomials_of_Functions_of_Two_Variables
    :param function_expression: Sympy expression of the function
    :param variable_list: list. All variables to be approximated (to be "Taylorized")
    :param evaluation_point: list. Coordinates, where the function will be expressed
    :param degree: int. Total degree of the Taylor polynomial
    :return: Returns a Sympy expression of the Taylor series up to a given degree, of a given multivariate expression, approximated as a multivariate polynomial evaluated at the evaluation_point
    """
    from sympy import factorial, Matrix, prod
    import itertools

    n_var = len(variable_list)
    point_coordinates = [(i, j) for i, j in (zip(variable_list, evaluation_point))]  # list of tuples with variables and their evaluation_point coordinates, to later perform substitution

    deriv_orders = list(itertools.product(range(degree + 1), repeat=n_var))  # list with exponentials of the partial derivatives
    deriv_orders = [deriv_orders[i] for i in range(len(deriv_orders)) if sum(deriv_orders[i]) <= degree]  # Discarding some higher-order terms
    n_terms = len(deriv_orders)
    deriv_orders_as_input = [list(sum(list(zip(variable_list, deriv_orders[i])), ())) for i in range(n_terms)]  # Individual degree of each partial derivative, of each term

    polynomial = 0
    for i in range(n_terms):
        partial_derivatives_at_point = function_expression.diff(*deriv_orders_as_input[i]).subs(point_coordinates)  # e.g. df/(dx*dy**2)
        denominator = prod([factorial(j) for j in deriv_orders[i]])  # e.g. (1! * 2!)
        distances_powered = prod([(Matrix(variable_list) - Matrix(evaluation_point))[j] ** deriv_orders[i][j] for j in range(n_var)])  # e.g. (x-x0)*(y-y0)**2
        polynomial += partial_derivatives_at_point / denominator * distances_powered
    return polynomial

以下是对两个变量的问题的验证,并遵循以下练习和答案:https://math.libretexts.org/Bookshelves/Calculus/Supplemental_Modules_(Calculus)/Multivariable_Calculus/3%3A_Topics_in_Partial_Derivatives/Taylor__Polynomials_of_Variable_Variables_of_Functions_of

# Solving the exercises in section 13.7 of https://math.libretexts.org/Bookshelves/Calculus/Supplemental_Modules_(Calculus)/Multivariable_Calculus/3%3A_Topics_in_Partial_Derivatives/Taylor__Polynomials_of_Functions_of_Two_Variables
from sympy import symbols, sqrt, atan, ln

# Exercise 1
x = symbols('x')
y = symbols('y')
function_expression = x*sqrt(y)
variable_list = [x,y]
evaluation_point = [1,4]
degree=1
print(Taylor_polynomial_sympy(function_expression, variable_list, evaluation_point, degree))
degree=2
print(Taylor_polynomial_sympy(function_expression, variable_list, evaluation_point, degree))

# Exercise 3
x = symbols('x')
y = symbols('y')
function_expression = atan(x+2*y)
variable_list = [x,y]
evaluation_point = [1,0]
degree=1
print(Taylor_polynomial_sympy(function_expression, variable_list, evaluation_point, degree))
degree=2
print(Taylor_polynomial_sympy(function_expression, variable_list, evaluation_point, degree))

# Exercise 5
x = symbols('x')
y = symbols('y')
function_expression = x**2*y + y**2
variable_list = [x,y]
evaluation_point = [1,3]
degree=1
print(Taylor_polynomial_sympy(function_expression, variable_list, evaluation_point, degree))
degree=2
print(Taylor_polynomial_sympy(function_expression, variable_list, evaluation_point, degree))

# Exercise 7
x = symbols('x')
y = symbols('y')
function_expression = ln(x**2+y**2+1)
variable_list = [x,y]
evaluation_point = [0,0]
degree=1
print(Taylor_polynomial_sympy(function_expression, variable_list, evaluation_point, degree))
degree=2
print(Taylor_polynomial_sympy(function_expression, variable_list, evaluation_point, degree))

对结果执行simplify()可能很有用。

回答3

多元泰勒展开

def mtaylor(funexpr,x,mu,order=1):

    nvars = len(x)
    hlist = ['__h' + str(i+1) for i in range(nvars)]
    command=''
    command="symbols('"+'  '.join(hlist) +"')"
    hvar = eval(command)
    #mtaylor is utaylor for specificly defined function
    t = symbols('t')
    #substitution
    loc_funexpr = funexpr
    for i in range(nvars):
        locvar = x[i]
        locsubs = mu[i]+t*hvar[i]
        loc_funexpr = loc_funexpr.subs(locvar,locsubs)
    #calculate taylorseries
    g = 0
    for i in range(order+1):
        g+=loc_funexpr.diff(t,i).subs(t,0)*t**i/math.factorial(i)

    #resubstitute
    for i in range(nvars):
        g = g.subs(hlist[i],x[i]-mu[i])

    g = g.subs(t,1)    
    return g

测试某些功能

x1,x2,x3,x4,x5 = symbols('x1 x2 x3 x4 x5')
funexpr=1+x1+x2+x1*x2+x1**3
funexpr=cos(funexpr)
x=[x1,x2,x3,x4,x5]
mu=[1,1,1,1,1]
mygee = mtaylor(funexpr,x,mu,order=4)
print(mygee)

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • 需要使用泰勒级数在python中逼近正弦函数的帮助(Need help approximating sine function in python using Taylor Series)
    问题 我是Python的新手,并且正在尝试使用本系列来近似正弦函数。 我的代码如下所示: import math def sin(x,n): sine = 0 for i in range(n): sign = (-1)**i sine = sine + ((x**(2.0*i-1))/factorial(2**i-1))*sign return sine 这不会返回我希望的答案,但是我非常困惑,无法找到我的错误……或者我可能只是完全以错误的方式来解决这个问题(正如我说的那样,我很新python和一般编程)。 似乎与我之前写过的程序类似,鉴于这个系列,我近似于pi: def piApprox(n): pi = 0 for i in range(n): sign = (-1)**i pi = pi + 1.0/(2*i+1)*sign return 4*pi 我不知道这是否有任何用处,但这就是我试图用它来找出我的正弦方法的目的。 任何帮助解决此问题或为我指明正确方向的帮助将不胜感激! 回答1 sin( x )的泰勒级数为: 将您的代码与该定义进行比较,这两个部分有一些错误: x**(2.0*i-1) factorial(2**i-1) 负号应该是加号,阶乘中的指数应该是乘法。 x**(2.0*i+1) factorial(2*i+1) 回答2
  • Multivariate Taylor approximation in sympy
    I aim to write a multidimensional Taylor approximation using sympy, which uses as many builtin code as possible, computes the truncated Taylor approximation of a given function of two variables returns the result without the Big-O-remainder term, as e.g. in sin(x)=x - x**3/6 + O(x**4). Here is what I tryed so far: Approach 1 Naively, one could just combine the series command twice for each variable, which unfortunately does not work, as this example shows for the function 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*
  • 在Sympy中隔离多元多项式的一个系数的最佳方法(Best way to isolate one coefficient of a multivariate polynomial in sympy)
    问题 我有一个多元多项式(在一般情况下,它包含许多变量),其系数列出了一些需要读取的数据,但是看起来sympy并没有提供一种很好的方法。 collect函数似乎是正确的主意,但是当您将其与多个变量一起使用时,它实际上并没有为您提供单独的单项式,而是取决于列出变量顺序的奇怪的单项式分组。 有人知道这样做的方法吗? 回答1 多项式模块的文档列出了许多处理系数的方法。 例如: >>> import sympy >>> x,y,z = sympy.symbols('x,y,z') >>> p = sympy.poly((x+2*y-z)**3) >>> p.coeffs() [1, 6, -3, 12, -12, 3, 8, -12, 6, -1] 这些是按字典顺序的非零系数。 要按匹配顺序查看单项式,请使用 >>> p.monoms() [(3, 0, 0), (2, 1, 0), (2, 0, 1), (1, 2, 0), (1, 1, 1), (1, 0, 2), (0, 3, 0), (0, 2, 1), (0, 1, 2), (0, 0, 3)] 要获取特定单项式的系数,请使用 >>> p.coeff_monomial(x**2*y) 6 回答2 列出多项式的单项式,以便生成器出现(并且该顺序在用户的控制下): >>> from sympy import Poly >>>
  • 用 Python 做数学建模
    本文由 CDFMLR 原创,收录于个人主页 https://clownote.github.io,并同时发布到 CSDN。本人不保证 CSDN 排版正确,敬请访问 clownote 以获得良好的阅读体验。 用 Python 做数学建模 ⚠️【注意】这是一篇没有完成也不会被完成的文章,这里我只写了几个简单问题的 Python 解法,我发布它只是希望说明 Python 做数学建模是有可行性的。 线性规划 第三方依赖库:scipy。 用 scipy.optimize.linprog 可以解线性规划问题: linprog(c, A_ub=None, b_ub=None, A_eq=None, b_eq=None, bounds=None, method='simplex', callback=None, options=None) 其规定的问题标准型式为: Minimize: c^T * x Subject to: A_ub * x <= b_ub A_eq * x == b_eq e.g. 求接下列线性规划问题: max z = 2 x 1 + 3 x 2 − 5 x 3 , s.t. { x 1 + x 2 + x 3 = 7 2 x 1 − 5 x 2 + x 3 ≥ 10 x 1 + 3 x 2 + x 3 ≤ 12 x 1 , x 2 , x 3 ≥ 0 \textrm{max
  • Best way to isolate one coefficient of a multivariate polynomial in sympy
    I have a multivariate polynomial (which in the general case many many variables) whose coefficients list some data that I need to read off, but it doesn't seem like sympy gives a good way to do this. The collect function seemed like the right idea, but when you use it with several variables, it doesn't actually give you the individual monomials, but rather strange groupings of monomials that depend on the order you listed the variables. Does anyone know of a way to do this?
  • 如何使用Numpy计算导数?(How do I compute derivative using Numpy?)
    问题 例如,如何计算函数的导数 y = x 2 +1 使用numpy吗? 假设我想要x = 5的导数的值... 回答1 您有四个选择 有限差异自动衍生工具象征差异手动计算导数。 有限的差异不需要外部工具,但容易出现数值误差,如果您处于多变量情况,则可能需要一段时间。 如果您的问题足够简单,则使用符号区分是理想的选择。 如今,符号方法变得越来越强大。 为此,SymPy是一个出色的项目,可与NumPy很好地集成。 查看autowrap或lambdify函数,或查看Jensen的博客文章,探讨类似问题。 自动导数非常酷,不易出现数字错误,但确实需要一些其他库(为此,google,有一些不错的选择)。 这是设置选项中最可靠但也最复杂/最困难的。 如果可以将自己限制为numpy语法,那么Theano可能是一个不错的选择。 这是使用SymPy的示例 In [1]: from sympy import * In [2]: import numpy as np In [3]: x = Symbol('x') In [4]: y = x**2 + 1 In [5]: yprime = y.diff(x) In [6]: yprime Out[6]: 2⋅x In [7]: f = lambdify(x, yprime, 'numpy') In [8]: f(np.ones(5)) Out[8]: [
  • C ++中最快的正弦,余弦和平方根实现(不需要非常准确)(Fastest implementation of sine, cosine and square root in C++ (doesn't need to be much accurate))
    问题 我过去一个小时一直在搜索这个问题,但是泰勒级数或一些示例代码要么太慢,要么根本没有编译。 好吧,我在Google上找到的大多数答案是“ Google it,已经被问到了”,但可悲的是,事实并非如此…… 我在低端奔腾4上对游戏进行了性能分析,发现大约85%的执行时间被浪费在计算窦,余弦和平方根上(来自Visual Studio中的标准C ++库),并且这似乎很大程度上取决于CPU(在我的I7同样功能只得到了5%的执行时间,而游戏是waaaaaaaaaay更快)。 我无法优化这三个函数,也无法一次计算正弦和余弦(相互依赖),但是我的模拟并不需要太精确的结果,因此我可以使用更快的近似值。 那么,问题来了:在C ++中计算浮点数的最快的正弦,余弦和平方根的方法是什么? EDIT查找表更加麻烦,因为在现代CPU上导致的Cache Miss比Taylor系列要昂贵得多。 这些天的CPU太快了,而缓存却没有。 我犯了一个错误,尽管我需要为泰勒级数计算几个阶乘,但现在我可以将它们实现为常量。 所以更新了一个问题:平方根是否也有快速优化? 编辑2 我正在使用平方根来计算距离,而不是归一化-无法使用快速反平方根算法(如注释中所指出:http://en.wikipedia.org/wiki/Fast_inverse_square_root 编辑3 我也无法在平方距离上进行运算
  • python求解各种复杂的线性/非线性方程组
    如何用Python求解各种复杂的线性/非线性方程组 Python求解各种复杂的线性/非线性方程组一、线性方程组。二、非线性方程组。1.scipy求解2.sympy求解 三、scipy和sympy的优缺点分析。四、总结 Python求解各种复杂的线性/非线性方程组 本文将要介绍几种方法去求解各种复杂的方程组,包括实数域和复数域的线性、非线性方程组,并对比这几种方法的优缺点。本文用到了numpy、scipy、sympy这三个科学计算包。 一、线性方程组。 线性方程组可以用numpy去求解。 1.实数域。 import numpy as np a=np.mat('1,2,3;2,4,8;9,6,3') b=np.mat('1;1;3') c=np.linalg.solve(a,b) 输出如下: 2.复数域。 import numpy as np a=np.mat('1,-1j;1j,-1') b=np.mat('1;1') c=np.linalg.solve(a,b) 输出如下: 二、非线性方程组。 scipy和sympy不但可以解线性方程(组),还可以求解非线性方程(组),但是也有各自的优缺点。 1.scipy求解 scipy.optimize里面有两个函数可以数值求解方程组,分别是root和solve,这两个函数会找到方程组的一个近似解。下面通过例子介绍这两个函数的使用。 (1)
  • 快速评估大量输入值的数学表达式(函数)(Evaluating a mathematical expression (function) for a large number of input values fast)
    问题 以下问题 评估字符串中的数学表达式 Python中的方程式解析在Python中解析用户提供的数学公式的安全方法从Python中不安全的用户输入评估数学方程式 和它们各自的答案使我想到如何有效地解析(或多或少受信任的)用户给出的单个数学表达式(按照该答案的大致术语https://stackoverflow.com/a/594294/1672565)来自数据库的20k到30k的输入值。 我实施了一个快速而肮脏的基准测试,因此可以比较不同的解决方案。 # Runs with Python 3(.4) import pprint import time # This is what I have userinput_function = '5*(1-(x*0.1))' # String - numbers should be handled as floats demo_len = 20000 # Parameter for benchmark (20k to 30k in real life) print_results = False # Some database, represented by an array of dicts (simplified for this example) database_xy = [] for a in range(1, demo_len
  • 是否有Python库列出素数?(Is there a Python library to list primes?)
    问题 是否有一个库函数可以枚举Python中的质数(按顺序)? 我发现了这个问题,是列出N以下所有素数的最快方法,但是我宁愿使用别人可靠的库也不愿自己动手。 我很乐意做import math; for n in math.primes: import math; for n in math.primes: 回答1 SymPy是另一种选择。 这是一个用于符号数学的Python库。 它提供了一些主要功能。 isprime(n) # Test if n is a prime number (True) or not (False). primerange(a, b) # Generate a list of all prime numbers in the range [a, b). randprime(a, b) # Return a random prime number in the range [a, b). primepi(n) # Return the number of prime numbers less than or equal to n. prime(nth) # Return the nth prime, with the primes indexed as prime(1) = 2. The nth prime is approximately n*log(n)
  • 如何使用Python求解一对非线性方程?(How to solve a pair of nonlinear equations using Python?)
    问题 使用Python解决一对非线性方程式的(最佳)方法是什么? (Numpy,Scipy或Sympy) 例如: x + y ^ 2 = 4 e ^ x + xy = 3 解决以上问题的代码段会很棒 回答1 对于数值解,可以使用fsolve: http://docs.scipy.org/doc/scipy/reference/generation/scipy.optimize.fsolve.html#scipy.optimize.fsolve from scipy.optimize import fsolve import math def equations(p): x, y = p return (x+y**2-4, math.exp(x) + x*y - 3) x, y = fsolve(equations, (1, 1)) print equations((x, y)) 回答2 如果您喜欢sympy,则可以使用nsolve。 >>> nsolve([x+y**2-4, exp(x)+x*y-3], [x, y], [1, 1]) [0.620344523485226] [1.83838393066159] 第一个参数是方程式列表,第二个参数是变量列表,第三个参数是初始猜测。 回答3 简短答案:使用fsolve 正如其他答案中提到的那样
  • 指数如何计算?(How are exponents calculated?)
    问题 我正在尝试确定使用指数的算法之一的渐近运行时间,但是我不确定如何以编程方式计算指数。 我专门在寻找用于双精度浮点数的pow()算法。 回答1 我有机会了解fdlibm的实现。 注释描述了所使用的算法: * n * Method: Let x = 2 * (1+f) * 1. Compute and return log2(x) in two pieces: * log2(x) = w1 + w2, * where w1 has 53-24 = 29 bit trailing zeros. * 2. Perform y*log2(x) = n+y' by simulating muti-precision * arithmetic, where |y'|<=0.5. * 3. Return x**y = 2**n*exp(y'*log2) 然后列出所有已处理的特殊情况(0、1,inf,nan)。 在进行所有特殊情况处理之后,代码中最紧张的部分涉及log2和2**计算。 在这两个循环中都没有循环。 因此,尽管浮点图元很复杂,但它看起来像一个渐近恒定时间算法。 欢迎浮点专家(我不是其中的一员)发表评论。 :-) 回答2 除非他们发现了更好的方法,否则我相信三角函数,对数函数和指数函数的近似值(例如,对于指数增长和衰减)通常使用算术规则和泰勒级数展开来计算
  • 如何获得sympy表达式中的符号列表?(How can I get a list of the symbols in a sympy expression?)
    问题 例如,如果我跑步 import sympy x, y, z = sympy.symbols('x:z') f = sympy.exp(x + y) - sympy.sqrt(z) 我可以使用f任何方法来获取表达式包含的sympy.Symbol对象的列表或元组吗? 我宁愿不必解析srepr(f)或通过f.args向下解析。 在这种情况下, g.args[0].args[1].args[0]给我Symbol("z") ,而g.args[1].args[0].args给我元组(Symbol("x"), Symbol("y")) ,但显然这些是特定于表达式的。 回答1 您可以使用: f.free_symbols 这将返回一组所有免费符号。 例子: >>> import sympy >>> x, y, z = sympy.symbols('x:z') >>> f = sympy.exp(x + y) - sympy.sqrt(z) >>> f.free_symbols set([x, z, y]) 回答2 请注意,JuniorCompressors答案仅列出自由变量。 如果您有“总和”,“产品”,“积分”或类似的东西,则可能会或可能不想使用.variables属性来另外了解积分/求和变量: In [216]: (x, n) = sympy.symbols("x n") In [217]
  • python数学方程计算_用Python解方程
    一元一次方程 例题1: 这是北师大版小学六年级上册课本95页的一道解方程练习题: 大家可以先口算一下,这道题里面的x的值为200 接下来我们用python来实现,代码如下,每一句代码后面都写有解释语: #一元一次方程 x = sy.symbols("x") #申明未知数"x" a = sy.solve((x+(1/5)*x-240),[x]) #写入需要解的方程体 print(a) 大家应该注意到了,在写入方程体的时候,(上面的第三行代码)我们并没有原封不动的将原方程写进去,而是换了一种写法,将等号右边的数移到了等号左边(当然,移动的过程中注意要变号哦!)然后将等号丢弃,最后变成了一个式子。这个是我们的一个固定写法,大家记住就可以了。 注意:注意!!在数学里面数字和未知数相乘时中间可以不加任何符号,比如2x就代表2乘以x,但在计算机里,乘法必须写成*乘的形式。比如2*x,而不能直接写出2x,此处一定要注意! 这是运行后的结果: 大家可以看到,结果被一对大括号包裹着,冒号前是要求的未知数,冒号后即是程序运行后得出的结果。 我们的计算机还是很聪明的,是吧! 例题2: 接下来,我们再来尝试一下分式方程: 以下为2018成都市的中考数学真题A卷第8题: 用同样的程序逻辑,填好我们要求的方程,代码如下: x = sy.symbols("x") a = sy.solve([(x+1)/x+1/
  • python解方程问题例子简单_用Python解方程
    一元一次方程 例题1: 这是北师大版小学六年级上册课本95页的一道解方程练习题: 大家可以先口算一下,这道题里面的x的值为200 接下来我们用python来实现,代码如下,每一句代码后面都写有解释语: #一元一次方程 x = sy.symbols("x") #申明未知数"x" a = sy.solve((x+(1/5)*x-240),[x]) #写入需要解的方程体 print(a) 大家应该注意到了,在写入方程体的时候,(上面的第三行代码)我们并没有原封不动的将原方程写进去,而是换了一种写法,将等号右边的数移到了等号左边(当然,移动的过程中注意要变号哦!)然后将等号丢弃,最后变成了一个式子。这个是我们的一个固定写法,大家记住就可以了。 注意:注意!!在数学里面数字和未知数相乘时中间可以不加任何符号,比如2x就代表2乘以x,但在计算机里,乘法必须写成*乘的形式。比如2*x,而不能直接写出2x,此处一定要注意! 这是运行后的结果: 大家可以看到,结果被一对大括号包裹着,冒号前是要求的未知数,冒号后即是程序运行后得出的结果。 我们的计算机还是很聪明的,是吧! 例题2: 接下来,我们再来尝试一下分式方程: 以下为2018成都市的中考数学真题A卷第8题: 用同样的程序逻辑,填好我们要求的方程,代码如下: x = sy.symbols("x") a = sy.solve([(x+1)/x+1/
  • 如何用sympy替换表达式中的多个符号?(How to substitute multiple symbols in an expression in sympy?)
    问题 直接分配变量不会修改追溯使用该变量的表达式。 >>> from sympy import Symbol >>> x = Symbol('x') >>> y = Symbol('y') >>> f = x + y >>> x = 0 >>> f x + y 回答1 要替换几个值: >>> from sympy import Symbol >>> x, y = Symbol('x y') >>> f = x + y >>> f.subs({x:10, y: 20}) >>> f 30 回答2 命令x = Symbol('x')将Sympy的Symbol('x')到Python的变量x 。 之后创建的Sympy表达式f确实包含Symbol('x') ,而不是Python变量x 。 重新分配x = 0 ,Python变量x设置为零,并且不再与Symbol('x') 。 这对仍然包含Symbol('x')的Sympy表达式没有影响。 最好在Sympy文档的以下页面中对此进行说明:http://docs.sympy.org/latest/gotchas.html#variables 如其他答案中所述,您要执行的操作是f.subs(x,0) 。 回答3 实际上,sympy的设计宗旨是在您真正希望用subs替换它们之前,不要替换它们(请参阅http://docs.sympy.org
  • 立方根是整数吗?(Is cube root integer?)
    问题 这似乎很简单,但我找不到解决方法。 我需要显示整数的立方根是否为整数。 我在Python 3.4中使用了is_integer() float方法,但没有成功。 作为 x = (3**3)**(1/3.0) is_integer(x) True 但 x = (4**3)**(1/3.0) is_integer(x) False 我尝试x%1 == 0 , x == int(x)和isinstance(x,int)没有成功。 我将不胜感激。 回答1 对于较小的数字(<〜10 13左右),可以使用以下方法: def is_perfect_cube(n): c = int(n**(1/3.)) return (c**3 == n) or ((c+1)**3 == n) 这将截断浮点立方根,然后测试两个最接近的整数。 对于较大的数字,一种方法是仅使用整数来保留精度来对真正的立方根进行二进制搜索: def find_cube_root(n): lo = 0 hi = 1 << ((n.bit_length() + 2) // 3) while lo < hi: mid = (lo+hi)//2 if mid**3 < n: lo = mid+1 else: hi = mid return lo def is_perfect_cube(n): return find_cube_root(n
  • 三角函数如何工作? [关闭](How do Trigonometric functions work? [closed])
    问题 关门了。 这个问题需要更加集中。 它当前不接受答案。 想要改善这个问题吗? 更新问题,使其仅通过编辑此帖子即可解决一个问题。 上个月关闭。 改善这个问题 因此,在高中数学(可能还有大学)中,我们学会了如何使用三角函数,它们的作用以及所解决的问题的类型。 但是它们始终以黑匣子的形式呈现给我。 如果您需要某些东西的正弦或余弦,请按一下计算器上的sin或cos按钮,然后进行设置。 没关系 我想知道的是通常如何实现三角函数。 回答1 首先,您必须进行某种范围的缩小。 触发函数是周期性的,因此您需要将参数减少到标准间隔。 对于初学者,您可以将角度减小到0到360度之间。 但是,通过使用一些身份,您意识到可以少花钱。 如果您为0到45度之间的角度计算正弦和余弦,则可以引导您的方法来计算所有角度的所有触发函数。 减少论点后,大多数芯片都会使用CORDIC算法来计算正弦和余弦。 您可能会听到人们说计算机使用泰勒级数。 这听起来很合理,但事实并非如此。 CORDIC算法更适合高效的硬件实现。 (例如,软件库可能在不支持触发功能的硬件上使用泰勒级数。)可能会有一些额外的处理,使用CORDIC算法可以获得相当好的答案,但随后可以做一些其他事情以提高准确性。 上面有一些改进。 例如,对于非常小的角度theta(以弧度为单位),sin(theta)= theta等于您拥有的所有精度,因此
  • Alink漫谈(十一) :线性回归 之 L-BFGS优化
    Alink 是阿里巴巴基于实时计算引擎 Flink 研发的新一代机器学习算法平台,是业界首个同时支持批式算法、流式算法的机器学习平台。本文介绍了线性回归的L-BFGS优化在Alink是如何实现的,希望可以作为大家看线性回归代码的Roadmap。Alink漫谈(十一) :线性回归 之 L-BFGS优化目录Alink漫谈(十一) :线性回归 之 L-BFGS优化3.1 如何分布式实施3.2 CalcGradient3.3 AllReduce3.4 CalDirection3.5 CalcLosses3.6 UpdateModel3.7 OutputModel3.4.1 预先分配3.4.2 计算方向2.1 泰勒展开2.2 牛顿法2.3 拟牛顿法2.4 L-BFGS算法如何通俗推理?2.2.1 泰勒一阶展开2.2.2 泰勒二阶展开2.2.3 高维空间2.2.4 牛顿法基本流程2.2.5 问题点及解决1.1 优化基本思路1.2 各类优化方法0x00 摘要0x01 回顾0x02 基本概念0x03 优化模型 -- L-BFGS算法0x04 准备模型元数据0x05 建立模型0x06 使用模型预测0x07 本系列其他文章0xFF 参考0x00 摘要Alink 是阿里巴巴基于实时计算引擎 Flink 研发的新一代机器学习算法平台,是业界首个同时支持批式算法、流式算法的机器学习平台
  • 澄清Python中的小数类型(Clarification on the Decimal type in Python)
    问题 每个人都知道,或者至少每个程序员都应该知道,使用float类型可能会导致精度错误。 但是,在某些情况下,精确的解决方案将是不错的选择,并且在某些情况下,使用epsilon值进行比较是不够的。 无论如何,这不是重点。 我知道Python中的Decimal类型,但从未尝试使用它。 它指出“十进制数可以精确表示”,我认为这意味着可以实现任何实数的巧妙实现。 我的第一次尝试是: >>> from decimal import Decimal >>> d = Decimal(1) / Decimal(3) >>> d3 = d * Decimal(3) >>> d3 < Decimal(1) True 非常令人失望,我回到文档中并继续阅读: 算术上下文是一个指定精度的环境[...] 好的,所以实际上有一个精度。 可以复制经典问题: >>> dd = d * 10**20 >>> dd Decimal('33333333333333333333.33333333') >>> for i in range(10000): ... dd += 1 / Decimal(10**10) >>> dd Decimal('33333333333333333333.33333333') 所以,我的问题是:有没有办法让精度无限的小数类型? 如果不是,比较2个十进制数字的更优雅的方法是什么(例如