Multivariable Series Expansion

[KwentiN-ui]

Native support for multivariable series

As Taylor approximations are a very common problem in engineering I would love to see the expr.series method expanded to natively support more than one variable. This would work intuitively with already existing syntax.
I'd imagine something like this:

x,y = symbols("x y")
z = 4*x/y+x**2+y

Taylor = z.series([x,y],[0,-2],2)

which would result in the equation for the tangential plane at $P(0;2)$.

I'd love to hear you guys opinion though, maybe there's already a perfect function for this.

[oscarbenjamin]

The example is not great because it is already basically in a series format:

In [4]: z.series(x).series(y)
Out[4]: 
 2   4⋅x    
x  + ─── + y
      y 

A more interesting example could be (if it worked):

In [5]: z = exp(x + y)

In [6]: z.series(x).series(y)
---------------------------------------------------------------------------
NotImplementedError                       Traceback (most recent call last)
Cell In[6], line 1
----> 1 z.series(x).series(y)

File ~/current/active/sympy/sympy/core/expr.py:3026, in Expr.series(self, x, x0, n, dir, logx, cdir)
   3023 if x.is_positive is x.is_negative is None or x.is_Symbol is not True:
   3024     # replace x with an x that has a positive assumption
   3025     xpos = Dummy('x', positive=True)
-> 3026     rv = self.subs(x, xpos).series(xpos, x0, n, dir, logx=logx, cdir=cdir)
   3027     if n is None:
   3028         return (s.subs(xpos, x) for s in rv)

File ~/current/active/sympy/sympy/core/expr.py:3038, in Expr.series(self, x, x0, n, dir, logx, cdir)
   3035 o = s1.getO() or S.Zero
   3036 if o:
   3037     # make sure the requested order is returned
-> 3038     ngot = o.getn()
   3039     if ngot > n:
   3040         # leave o in its current form (e.g. with x*log(x)) so
   3041         # it eats terms properly, then replace it below
   3042         if n != 0:

File ~/current/active/sympy/sympy/core/expr.py:1273, in Expr.getn(self)
   1270                     if oi.base.is_Symbol and oi.exp.is_Rational:
   1271                         return abs(oi.exp)
-> 1273 raise NotImplementedError('not sure of order of %s' % o)

NotImplementedError: not sure of order of O(x**6) + O(_x**6)

[KwentiN-ui]

Correct me if I'm wrong but simply chaining the series command does not generally result in the correct Taylor approximation.
Doing the first order of my example manually would look something like this:

x0,y0 = 0,-2
AP = {x:x0,y:y0}
dx = z.diff(x)
dy = z.diff(y)

Z_tan = z.subs(AP) + dx.subs(AP)*(x-x0) + dy.subs(AP)*(y-y0)
Z_tan

---

$-2x+y$

For now I'll have to do with my own unoptimized functions, but this would be some very handy functionality of the series method.

[oscarbenjamin]

simply chaining the series command does not generally result in the correct Taylor approximation

That is correct. I was just saying that a function like the one that you showed is not that interesting as an example because it does not get any O terms (at least around 0,0).

this would be some very handy functionality

Yes, but it is not a simple thing to do. For starters the whole approach of representing series as just a sum with a O term added does not really even allow for the possibility of representing a multivariate series (e.g. the error I showed).

[KwentiN-ui]

Ah I get what you're saying now. That would explain why it hasn't been implemented yet. What about a completely seperate function that computes only finite series, so you can scrap the residual term. Something like sympy.fseries? Then again you wouldn't want to clutter the main module with somewhat redundant functions. Just wishful thinking on my part.