ó ~9­\c@ sŠddlmZmZddlmZmZddlmZddlm Z m Z ddl m Z d„Z d„Zd„Zd „Zd S( iÿÿÿÿ(tprint_functiontdivision(tStsympify(trange(t Piecewisetpiecewise_fold(tIntervalcC s®|tjks|tjkr1t||ƒ}ns|tjksO|tjkrbt||ƒ}nBg}t|jƒ}|t|jƒkrÏt||ƒ}t||ƒ}t|jd ƒ} xê|jd D]Û} | j} | j} | jdj} xt | ƒD]\}}|j}|j}|jdj}|jdj}|| kra| |7} | |=Pq|| kr|| kr|j |ƒ| |=PqqW|j | | fƒqÍW|j | ƒ|j dt fƒnÉ|j ||jdj|jdjfƒx\t d|dƒD]G}|j ||j|j||j|dj|j|jfƒqW|j ||jdj|jdjfƒ|j |jdƒt|Œ}|jƒS(sConstruct c*b1 + d*b2.iÿÿÿÿiiiþÿÿÿ(RtZeroRtlentargstlisttexprtcondtrhst enumeratetappendtextendtTrueRRtexpand(tctb1tdtb2trvtnew_argst n_intervalstp1tp2tp2argstargR R tlowertitarg2texpr2tcond2tlower_2tupper_2((s?lib/python2.7/site-packages/sympy/functions/special/bsplines.pyt _add_splines sN        +'+ c C sÇg|D]}t|ƒ^q}t|ƒ}t|ƒ}t|ƒ}|d}||d|krptdƒ‚n|dkr»ttjt||||dƒj|ƒfdt fƒ}n|dkr³|||d||d}|tj kr.|||d||} t |d||d|ƒ} n tj } } |||||}|tj krŽ||||} t |d|||ƒ} n tj } } t | | | | ƒ}ntd|ƒ‚|S(sThe `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((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-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] https://en.wikipedia.org/wiki/B-spline is(n + d + 1 must not exceed len(knots) - 1isdegree must be non-negative: %r( RtintR t ValueErrorRRtOneRtcontainsRRt bspline_basisR&( Rtknotstntxtktn_knotsRtresulttdenomtBRtAR((s?lib/python2.7/site-packages/sympy/functions/special/bsplines.pyR+Us2=     *    cC s@t|ƒ|d}gt|ƒD]}t||||ƒ^q!S(sÀReturn 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 i(R RR+(RR,R.t n_splinesR ((s?lib/python2.7/site-packages/sympy/functions/special/bsplines.pytbspline_basis_set³s cC s®ddlm}m}m}m}ddlm}ddlm} t |ƒ}|j o]|j sst d|ƒ‚nt |ƒt |ƒkršt dƒ‚nt |ƒ|dkr¿t dƒ‚ntd „t||dƒDƒƒsñt d ƒ‚n|jr|dd } || | !} nW|d } gt|| | d!|| d| !ƒD]\} } || | d ƒ^qK} |d g|dt| ƒ|dg|d}t|||ƒ}g|D]+}g|D]} | j||ƒ^qÈ^q»}|| |ƒ| |ƒf|d jt |ƒƒd|ƒƒ}t|ƒd }tg|D].} | jD]\}}|tkrO|^qOqBƒ}g|D]}|j|ƒ^q€}g|D]}tt|ƒƒd ^q¢}t||ƒ}t|dd„ƒ}g|D]\}}|^qï}g|D]} td„| jDƒƒ^q}g}xh|D]`}tgt||ƒD]%\}}||j|tjƒ^qYtjƒ}|j||fƒq@Wt |ŒS(s¡Return 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)), (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((-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 iÿÿÿÿ(tsymbolstNumbertDummytRational(tlinsolve(tMatrixs1Spline degree must be a positive integer, not %s.s/Number of X and Y coordinates must be the same.is6Degree must be less than the number of control points.cs s!|]\}}||kVqdS(N((t.0tatb((s?lib/python2.7/site-packages/sympy/functions/special/bsplines.pys ss.The x-coordinates must be strictly increasing.iisc0:{}tclstkeycS s|dS(Ni((R.((s?lib/python2.7/site-packages/sympy/functions/special/bsplines.pyttcs s!|]\}}||fVqdS(N((R=teR((s?lib/python2.7/site-packages/sympy/functions/special/bsplines.pys "s(!tsympyR7R8R9R:tsympy.solvers.solvesetR;tsympy.matrices.denseR<Rt is_Integert is_positiveR(R talltziptis_oddR R6tsubstformattsetR RtatomstsortedtdicttsumtgetRRRR(RR.tXtYR7R8R9R:R;R<tjtinterior_knotsR>R?R,tbasistvR4tcoeffRDRt intervalstivaltcomtyt basis_dictstsplineR tpiece((s?lib/python2.7/site-packages/sympy/functions/special/bsplines.pytinterpolating_spline×sT"   #   J28!#"), AN(t __future__RRt sympy.coreRRtsympy.core.compatibilityRtsympy.functionsRRtsympy.sets.setsRR&R+R6Rc(((s?lib/python2.7/site-packages/sympy/functions/special/bsplines.pyts L ^ $