B [&@slddlmZmZddlmZmZddlmZddlm Z m Z ddl m Z ddZ dd Zd d Zd d ZdS))print_functiondivision)Ssympify)range) Piecewisepiecewise_fold)IntervalcCs|tjks|tjkr$t||}n|tjks8|tjkrHt||}ng}t|j}|t|jkr\t||}t||}t|jdd} x|jddD]} | j} | j} | jdj} xvt | D]j\}}|j}|j}|jdj}|jdj}|| kr| |7} | |=Pq|| kr|| kr| || |=PqW| | | fqW| | | dn| ||jdj|jdjfxNt d|dD]<}| ||j|j||j|dj|j|jfqW| ||jdj|jdjf| |jdt |}|S)zConstruct c*b1 + d*b2.Nr)rT)rZerorlenargslistexprcondZrhs enumerateappendextendrrexpand)cb1db2rvZnew_args n_intervalsZp1Zp2Zp2argsargrrloweriZarg2Zexpr2Zcond2Zlower_2Zupper_2r ?lib/python3.7/site-packages/sympy/functions/special/bsplines.py _add_splines sN          """r"c CsPdd|D}t|}t|}t|}|d}||d|krFtd|dkrxttjt||||d|fd}n|dkr@|||d||d}|tjkr|||d||}t |d||d|} n tj} }|||||}|tjkr&||||} t |d|||} n tj} } t | | || }n td||S)aThe `n`-th B-spline at `x` of degree `d` with knots. B-Splines are piecewise polynomials of degree `d` [1]_. They are defined on a set of knots, which is a sequence of integers or floats. The 0th degree splines have a value of one on a single interval: >>> from sympy import bspline_basis >>> from sympy.abc import x >>> d = 0 >>> knots = 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, 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((-x/2 + 1, (x >= 0) & (x <= 2)), (0, True)) It is quite time consuming to construct and evaluate B-splines. If you need to evaluate a B-splines many times, it is best to lambdify them first: >>> from sympy import lambdify >>> d = 3 >>> knots = range(10) >>> b0 = bspline_basis(d, knots, 0, x) >>> f = lambdify(x, b0) >>> y = f(0.5) See Also ======== bsplines_basis_set References ========== .. [1] http://en.wikipedia.org/wiki/B-spline cSsg|] }t|qSr )r).0kr r r! sz!bspline_basis..r z(n + d + 1 must not exceed len(knots) - 1r)rTzdegree must be non-negative: %r) intr ValueErrorrrZOner containsr bspline_basisr") rknotsnxZn_knotsrresultZdenomBrArr r r!r)Us2=       r)cs*td}fddt|DS)aReturn the ``len(knots)-d-1`` B-splines at ``x`` of degree ``d`` with ``knots``. 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))] See Also ======== bsplines_basis r csg|]}t|qSr )r))r#r)rr*r,r r!r%sz%bspline_basis_set..)rr)rr*r,Z n_splinesr )rr*r,r!bspline_basis_sets r0cs8ddlm}mm}mddlm}ddlm}t |}|j rD|j sPt d|t |t |krht dt ||dkrt dtd d t||dd Dst d |jr|dd }||| } n<|d }fddt||| d||d| D} |dg|dt| |dg|d} t|| fdd|D} ||| ||f|dt ||d} t| d} tddD} fdd| D}dd|D}t|| }t|ddd}dd|D} ddD}g}x<| D]4tfddt| |Dtj}||fqWt|S)aReturn spline of degree ``d``, passing through the given ``X`` and ``Y`` values. This function returns a piecewise function such that each part is a polynomial of degree not greater than ``d``. The value of ``d`` must be 1 or greater and the values of ``X`` must be strictly increasing. Examples ======== >>> 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)), (-x/2 + 7, (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((-x**3/36 - x**2/36 - 17*x/18 + 2, (x >= -2) & (x <= 1)), (5*x**3/36 - 13*x**2/36 - 11*x/18 + 7/3, (x >= 1) & (x <= 4))) See Also ======== bsplines_basis_set, sympy.polys.specialpolys.interpolating_poly r)symbolsNumberDummyRational)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|]\}}||kVqdS)Nr )r#abr r r! sz'interpolating_spline..Nz.The x-coordinates must be strictly increasing.csg|]\}}||dqS)r:r )r#r7r8)r4r r!r% sz(interpolating_spline..r cs g|]fddDqS)csg|]}|qSr )Zsubs)r#r8)vr,r r!r%sz3interpolating_spline...r )r#)basisr,)r;r!r%szc0:{})clscSs(g|] }|jD]\}}|dkr|qqS)T)r)r#r8err r r!r%scsg|]}|qSr )Zatoms)r#r>)r2r r!r%scSsg|]}tt|dqS)r)rsorted)r#r>r r r!r%scSs|dS)Nrr )r,r r r!sz&interpolating_spline..)keycSsg|] \}}|qSr r )r#r,yr r r!r% scSs g|]}tdd|jDqS)css|]\}}||fVqdS)Nr )r#r>rr r r!r9"sz2interpolating_spline...)dictr)r#r8r r r!r%"scs"g|]\}}||tjqSr )getrr )r#rr)rr r!r%%s)Zsympyr1r2r3r4Zsympy.solvers.solvesetr5Zsympy.matrices.denser6rZ is_IntegerZ is_positiver'rallzipZis_oddrr0formatsetr?sumrr rr)rr,XYr1r3r5r6jZinterior_knotsr*r/ZcoeffZ intervalsZivalZcomZ basis_dictsZsplineZpiecer )r2r4r<rr,r!interpolating_splinesR       *,     rMN)Z __future__rrZ sympy.corerrZsympy.core.compatibilityrZsympy.functionsrrZsympy.sets.setsr r"r)r0rMr r r r!s  L^$