o 8Va'@snddlmZmZddlmZmZddlmZddlm Z ddZ ddZ e d d d d Z d dZ ddZdS))Ssympify) Piecewisepiecewise_fold)Interval) lru_cachecCsZddlm}t||r't|jdkr'|j\}}|j|kr!||}}|j|jfStd|)zreturn the interval corresponding to the condition Conditions in spline's Piecewise give the range over which an expression is valid like (lo <= x) & (x <= hi). This function returns (lo, hi). r)Andzunexpected cond type: %s)Zsympy.logic.boolalgr isinstancelenargsZltsZgts TypeError)condxrabrB/usr/lib/python3/dist-packages/sympy/functions/special/bsplines.py_ivls      rcCsN|tjks |tjkrt||}| S|tjks|tjkr(t||}| Sg}t||}t||}t|jdd} |jddD]K} | j} | j} t| |d} t| D]0\}}|j}|j}t||\}}|| krw| |7} | |=n|| kr|| kr| || |=nqY| | | fqF| | | dt |ddi}| S)zConstruct c*b1 + d*b2.NrrTZevaluateF) rZerorlistr exprrr enumerateappendextendrexpand)cb1db2rZrvnew_argsZp1Zp2Zp2argsargrrloweriZarg2Zexpr2Zcond2Zlower_2Zupper_2rrr _add_spliness@ 4 2     r&)maxsizecCsrddlm}|}|}tdd|D}t|}t|}t|}|d}||d|kr0td|dkrIttjt ||||d |fd}ni|dkr|||d||d} | tj krx|||d|| } t |d||d|} ntj } } |||||} | tj kr|||| } t |d|||} ntj } } t | | | | |}ntd||||iS) a0 The $n$-th B-spline at $x$ of degree $d$ with knots. Explanation =========== B-Splines are piecewise polynomials of degree $d$. They are defined on a set of knots, which is a sequence of integers or floats. Examples ======== The 0th degree splines have a value of 1 on a single interval: >>> from sympy import bspline_basis >>> from sympy.abc import x >>> d = 0 >>> knots = tuple(range(5)) >>> bspline_basis(d, knots, 0, x) Piecewise((1, (x >= 0) & (x <= 1)), (0, True)) For a given ``(d, knots)`` there are ``len(knots)-d-1`` B-splines defined, that are indexed by ``n`` (starting at 0). Here is an example of a cubic B-spline: >>> bspline_basis(3, tuple(range(5)), 0, x) Piecewise((x**3/6, (x >= 0) & (x <= 1)), (-x**3/2 + 2*x**2 - 2*x + 2/3, (x >= 1) & (x <= 2)), (x**3/2 - 4*x**2 + 10*x - 22/3, (x >= 2) & (x <= 3)), (-x**3/6 + 2*x**2 - 8*x + 32/3, (x >= 3) & (x <= 4)), (0, True)) By repeating knot points, you can introduce discontinuities in the B-splines and their derivatives: >>> d = 1 >>> knots = (0, 0, 2, 3, 4) >>> bspline_basis(d, knots, 0, x) Piecewise((1 - x/2, (x >= 0) & (x <= 2)), (0, True)) It is quite time consuming to construct and evaluate B-splines. If you need to evaluate a B-spline many times, it is best to lambdify them first: >>> from sympy import lambdify >>> d = 3 >>> knots = tuple(range(10)) >>> b0 = bspline_basis(d, knots, 0, x) >>> f = lambdify(x, b0) >>> y = f(0.5) Parameters ========== d : integer degree of bspline knots : list of integer values list of knots points of bspline n : integer $n$-th B-spline x : symbol See Also ======== bspline_basis_set References ========== .. [1] https://en.wikipedia.org/wiki/B-spline r)Dummycss|]}t|VqdSNr).0krrr sz bspline_basis..z(n + d + 1 must not exceed len(knots) - 1rzdegree must be non-negative: %r)Zsympy.core.symbolr)tupleintr ValueErrorrrZOnercontainsr bspline_basisr&Zxreplace)r knotsnrr)ZxvarZn_knotsZ n_intervalsresultZdenomBr!Arrrrr4Ss8 R"     r4cs*td}fddt|DS)a| Return the ``len(knots)-d-1`` B-splines at *x* of degree *d* with *knots*. Explanation =========== This function returns a list of piecewise polynomials that are the ``len(knots)-d-1`` B-splines of degree *d* for the given knots. This function calls ``bspline_basis(d, knots, n, x)`` for different values of *n*. Examples ======== >>> from sympy import bspline_basis_set >>> from sympy.abc import x >>> d = 2 >>> knots = range(5) >>> splines = bspline_basis_set(d, knots, x) >>> splines [Piecewise((x**2/2, (x >= 0) & (x <= 1)), (-x**2 + 3*x - 3/2, (x >= 1) & (x <= 2)), (x**2/2 - 3*x + 9/2, (x >= 2) & (x <= 3)), (0, True)), Piecewise((x**2/2 - x + 1/2, (x >= 1) & (x <= 2)), (-x**2 + 5*x - 11/2, (x >= 2) & (x <= 3)), (x**2/2 - 4*x + 8, (x >= 3) & (x <= 4)), (0, True))] Parameters ========== d : integer degree of bspline knots : list of integers list of knots points of bspline x : symbol See Also ======== bspline_basis r/csg|] }tt|qSr)r4r0r,r%r r5rrr sz%bspline_basis_set..)r range)r r5rZ n_splinesrr;rbspline_basis_sets0r>cs"ddlm}m}ddlm}ddlm}t|}|jr|j s$t d|t |t |kr0t dt ||dkr>> from sympy import interpolating_spline >>> from sympy.abc import x >>> interpolating_spline(1, x, [1, 2, 4, 7], [3, 6, 5, 7]) Piecewise((3*x, (x >= 1) & (x <= 2)), (7 - x/2, (x >= 2) & (x <= 4)), (2*x/3 + 7/3, (x >= 4) & (x <= 7))) >>> interpolating_spline(3, x, [-2, 0, 1, 3, 4], [4, 2, 1, 1, 3]) Piecewise((7*x**3/117 + 7*x**2/117 - 131*x/117 + 2, (x >= -2) & (x <= 1)), (10*x**3/117 - 2*x**2/117 - 122*x/117 + 77/39, (x >= 1) & (x <= 4))) Parameters ========== d : integer Degree of Bspline strictly greater than equal to one x : symbol X : list of strictly increasing integer values list of X coordinates through which the spline passes Y : list of strictly increasing integer values list of Y coordinates through which the spline passes See Also ======== bspline_basis_set, interpolating_poly r)symbolsr))linsolve)Matrixz1Spline degree must be a positive integer, not %s.z/Number of X and Y coordinates must be the same.r/z6Degree must be less than the number of control points.css|] \}}||kVqdSr*rr,rrrrrr.:sz'interpolating_spline..Nz.The x-coordinates must be strictly increasing.cSsg|]}t|qSrr+r:rrrr<<z(interpolating_spline..r cSsg|] \}}||dqS)r rrBrrrr<Dsrcs g|] fddDqS)csg|]}|qSr)Zsubsr,r)vrrrr<Lsz3interpolating_spline...r)r,)basisr)rErr<Ls zc0:{})clscSs(h|]}|jD] \}}|dkr|qqS)Tr )r,rerrrr Ps(z'interpolating_spline..csg|]}t|qSr)r)r,rrrrr<TcSs|dS)NrrrKrrrVsz&interpolating_spline..)keycSsg|]\}}|qSrr)r,ryrrrr<WrCcSsg|] }dd|jDqS)cSsi|]\}}||qSrr)r,rIrrrr YrLz3interpolating_spline...rHrDrrrr<Yscs"g|] \}}||tjqSr)getrr)r,rr )r%rrr<]s")Zsympyr?r)Zsympy.solvers.solvesetr@Zsympy.matrices.denserArZ is_IntegerZ is_positiver2r allzipZis_oddrr>formatsortedsumrrrr)r rXYr?r)r@rAjZinterior_knotsr5r9ZcoeffZ intervalsZivalZcomZ basis_dictsZsplineZpiecer)rFr%rrinterpolating_splinesL.      $, (  rZN)Z sympy.corerrZsympy.functionsrrZsympy.sets.setsrZsympy.core.cacherrr&r4r>rZrrrrs  ; x 4