9j8SSKJr SSKrSrSrSSjrSSjrg)) annotationsNc[RRRUS5nUS:a [ S5eUR S:XaUR 5nURRS;a[RO URnU[R"US-US9RSSUR --5-n[R"USS 5$) zComputes the Vandermonde matrix of given degree. Args: x (cupy.ndarray): array of points deg (int): degree of the resulting matrix. Returns: cupy.ndarray: The Vandermonde matrix .. seealso:: :func:`numpy.polynomial.polynomial.polyvander` degrzdegree must be non-negativebiu)dtype)rr ) cupy polynomial polyutils_as_int ValueErrorndimravelrkindfloat64arangereshapemoveaxis)xrrouts T/home/wildlama/miniconda3/lib/python3.13/site-packages/cupy/polynomial/polynomial.py polyvanderrs // # # + +C 7C Qw677vv{ GGIGGLLE1DLLqwwE t{{37%0889NO OC ==a $$c[RRRU/5unURS- nUS:Xa [ S5e[R "USURS9nUSS2S4==USSUS- -ss'U$)aComputes the companion matrix of c. Args: c (cupy.ndarray): 1-D array of polynomial coefficients ordered from low to high degree. Returns: cupy.ndarray: Companion matrix of dimensions (deg, deg). .. seealso:: :func:`numpy.polynomial.polynomial.polycompanion` rrz.Series must have maximum degree of at least 1.r )krN)r r r as_seriessizereyer)crmatrixs r polycompanionr#s} // # # - -qc 2CQ &&1*C axIJJ XXcRqww /F 1b5MQsVae^#M Mrc[R"USSS9nURRS;aUS-n[ U[ [ 45(a[R"U5n[ U[R5(a2U(a+URURSUR--5nUSUS--n[S [U5S-5H nX*X0--nM U$) aG Evaluate a polynomial at points x. If `c` is of length `n + 1`, this function returns the value .. math:: p(x) = c_0 + c_1 * x + ... + c_n * x^n The parameter `x` is converted to an array only if it is a tuple or a list, otherwise it is treated as a scalar. In either case, either `x` or its elements must support multiplication and addition both with themselves and with the elements of `c`. If `c` is a 1-D array, then `p(x)` will have the same shape as `x`. If `c` is multidimensional, then the shape of the result depends on the value of `tensor`. If `tensor` is true the shape will be c.shape[1:] + x.shape. If `tensor` is false the shape will be c.shape[1:]. Note that scalars have shape (,). Trailing zeros in the coefficients will be used in the evaluation, so they should be avoided if efficiency is a concern. Parameters ---------- x : array_like, compatible object If `x` is a list or tuple, it is converted to an ndarray, otherwise it is left unchanged and treated as a scalar. In either case, `x` or its elements must support addition and multiplication with with themselves and with the elements of `c`. c : array_like Array of coefficients ordered so that the coefficients for terms of degree n are contained in c[n]. If `c` is multidimensional the remaining indices enumerate multiple polynomials. In the two dimensional case the coefficients may be thought of as stored in the columns of `c`. tensor : boolean, optional If True, the shape of the coefficient array is extended with ones on the right, one for each dimension of `x`. Scalars have dimension 0 for this action. The result is that every column of coefficients in `c` is evaluated for every element of `x`. If False, `x` is broadcast over the columns of `c` for the evaluation. This keyword is useful when `c` is multidimensional. The default value is True. Returns ------- values : ndarray, compatible object The shape of the returned array is described above. See Also -------- numpy.polynomial.polynomial.polyval Notes ----- The evaluation uses Horner's method. rFndmincopy ?bBhHiIlLqQpPgr r r)r arrayrchar isinstancetuplelistasarrayndarrayrshaperrangelen)rr!tensorc0is rpolyvalr73sr 1AE*Aww||& G!eT]## LLO!T\\""v IIaggQVV + , 21B 1c!fqj ! rURT\" Irc[R"USSS9nURRS;aUR [R 5n[ U[[45(a[R"U5n[ U[R5(aXU(a,URURSUR--5nO%URUR:a [S5e[R"X- SS9$) a5 Evaluate a polynomial specified by its roots at points x. If `r` is of length `N`, this function returns the value .. math:: p(x) = \prod_{n=1}^{N} (x - r_n) The parameter `x` is converted to an array only if it is a tuple or a list, otherwise it is treated as a scalar. In either case, either `x` or its elements must support multiplication and addition both with themselves and with the elements of `r`. If `r` is a 1-D array, then `p(x)` will have the same shape as `x`. If `r` is multidimensional, then the shape of the result depends on the value of `tensor`. If `tensor` is ``True`` the shape will be r.shape[1:] + x.shape; that is, each polynomial is evaluated at every value of `x`. If `tensor` is ``False``, the shape will be r.shape[1:]; that is, each polynomial is evaluated only for the corresponding broadcast value of `x`. Note that scalars have shape (,). Parameters ---------- x : array_like, compatible object If `x` is a list or tuple, it is converted to an ndarray, otherwise it is left unchanged and treated as a scalar. In either case, `x` or its elements must support addition and multiplication with with themselves and with the elements of `r`. r : array_like Array of roots. If `r` is multidimensional the first index is the root index, while the remaining indices enumerate multiple polynomials. For instance, in the two dimensional case the roots of each polynomial may be thought of as stored in the columns of `r`. tensor : boolean, optional If True, the shape of the roots array is extended with ones on the right, one for each dimension of `x`. Scalars have dimension 0 for this action. The result is that every column of coefficients in `r` is evaluated for every element of `x`. If False, `x` is broadcast over the columns of `r` for the evaluation. This keyword is useful when `r` is multidimensional. The default value is True. Returns ------- values : ndarray, compatible object The shape of the returned array is described above. See Also -------- numpy.polynomial.polynomial.polyvalfroomroots rFr%r(r z,x.ndim must be < r.ndim when tensor == Falser)axis)r r*rr+astypedoubler,r-r.r/r0rr1rrprod)rrr4s rpolyvalfromrootsr>{sd 1AE*Aww||& HHT[[ !!eT]## LLO!T\\""  !''DK/0A VVqvv KL L 99QU ##r)T) __future__rr rr#r7r>rrrAs!" %.,EP<$r