VpfdlnddlmZddlmZddlZddlZddlmZddlm Z ddl m Z ddl m Z ddl mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZdd l m!Z!m"Z"m#Z#dd l$m%Z%dd l&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,dd l-m.Z.m/Z/edBdZ0edCdZ1dddDdZ2eed dEdFd)Z3edGd+Z4eed,gd-d.dHd/Z5edId2Z6eed3dJdKd8Z7eed3dLdMd9Z8dd:dNd<Z9dd:dOd@Z:edIdAZ;dS)P) annotations)partialN)jit)lax)dtypes)core)arangeargminarrayasarray atleast_1d concatenateconvolvediagdotfinfofullonesouterroll trim_zerostrim_zeros_tolvanderzeros)maximum true_dividesqrt)alllinalg)check_arraylikepromote_dtypespromote_dtypes_inexact_where)Array ArrayLikepr%returncT|jdkr(tgtj|jSt t |jdz f|jd}|jdddf|dd |dz }tj |S)Ndtyper) sizer rto_complex_dtyper,rratsetr eigvals)r'As Y/var/www/html/nettyfy-visnx/env/lib/python3.11/site-packages/jax/_src/numpy/polynomial.py_roots_no_zerosr6&sVaZZ 6217;; < < << 4! qw ' ',,!d1aaa4jnnaeVad]##!   num_leading_zeros Array | intcbtt||kd|}tt|| }t j|dk|d}tt |j|j|z k|ttj tj S)N?rr.) r$lenr6rr sort_key_valr r/complexnpnan)r'r8rootss r5_roots_with_zerosrB0s SVV( (#q11! $q#4"455 6 6% 5A:u - -a 0% uz""UZ2C%CCUGTVTZ\^\bLcLc d ddr7T) strip_zerosr&rCboolc td|tt|d}~|jdkrt d|jdkr(t gtj|j Stt|dkt|t|dk}|r2tjt |d}t#||dSt%||S) aReturns the roots of a polynomial given the coefficients ``p``. JAX implementations of :func:`numpy.roots`. Args: p: Array of polynomial coefficients having rank-1. strip_zeros : bool, default=True. If True, then leading zeros in the coefficients will be stripped, similar to :func:`numpy.roots`. If set to False, leading zeros will not be stripped, and undefined roots will be represented by NaN values in the function output. ``strip_zeros`` must be set to ``False`` for the function to be compatible with :func:`jax.jit` and other JAX transformations. Returns: An array containing the roots of the polynomial. Note: Unlike ``np.roots`` of this function, the ``jnp.roots`` returns the roots in a complex array regardless of the values of the roots. See Also: - :func:`jax.numpy.poly`: Finds the polynomial coefficients of the given sequence of roots. - :func:`jax.numpy.polyfit`: Least squares polynomial fit to data. - :func:`jax.numpy.polyval`: Evaluate a polynomial at specific values. Examples: >>> coeffs = jnp.array([0, 1, 2]) The default behavior matches numpy and strips leading zeros: >>> jnp.roots(coeffs) Array([-2.+0.j], dtype=complex64) With ``strip_zeros=False``, extra roots are set to NaN: >>> jnp.roots(coeffs, strip_zeros=False) Array([-2. +0.j, nan+nanj], dtype=complex64) rArr.zInput must be a rank-1 array.r*r+zThe error occurred in the jnp.roots() function. To use this within a JIT-compiled context, pass strip_zeros=False, but be aware that leading zeros will result in some returned roots being set to NaN.N)r!r r#ndim ValueErrorr/r rr0r,r$rr<r rconcrete_or_errorintr6rB)r'rCp_arrr8s r5rArA<sP'1 +A..q1 2 2% Z1__ 4 5 55 Z!^^ 625;?? @ @ @@S!__c%jj&!:L:LMM7.s4E=>> 5!2!3!34 5 55 U$5 6 66r7)degrcondrcov)static_argnamesFxyrKrIrL float | NonerwArrayLike | NonerMArray | tuple[Array, ...]cn|td||ntd|||tjt|d}|dz}t |t |} }~~|dkrt d|jdkrtd|jdkrtd| jdks | jd krtd |j d| j dkrtd |)t|t|j j z}tjt|d }t||} | } |t!|\}t |} | jdkrtd | j d| j dkrtd| | ddt"jfz} | jd kr| | ddt"jfz} n| | z} t'| | zd} | | t"jddfz} t+j| | |\}}}}|j| z j}|r||||t |fS|rt+jt3| j| }|t5| | z}|dkrd}n?t||krt d|t||z z }|d}| jdkr|||zfS||ddddt"jf|zfS|S)aLeast squares polynomial fit to data. Jax implementation of :func:`numpy.polyfit`. Given a set of data points ``(x, y)`` and degree of polynomial ``deg``, the function finds a polynomial equation of the form: .. math:: y = p(x) = p[0] x^{deg} + p[1] x^{deg - 1} + ... + p[deg] Args: x: Array of data points of shape ``(M,)``. y: Array of data points of shape ``(M,)`` or ``(M, K)``. deg: Degree of the polynomials. It must be specified statically. rcond: Relative condition number of the fit. Default value is ``len(x) * eps``. It must be specified statically. full: Switch that controls the return value. Default is ``False`` which restricts the return value to the array of polynomail coefficients ``p``. If ``True``, the function returns a tuple ``(p, resids, rank, s, rcond)``. It must be specified statically. w: Array of weights of shape ``(M,)``. If None, all data points are considered to have equal weight. If not None, the weight :math:`w_i` is applied to the unsquared residual of :math:`y_i - \widehat{y}_i` at :math:`x_i`, where :math:`\widehat{y}_i` is the fitted value of :math:`y_i`. Default is None. cov: Boolean or string. If ``True``, returns the covariance matrix scaled by ``resids/(M-deg-1)`` along with ploynomial coefficients. If ``cov='unscaled'``, returns the unscaaled version of covariance matrix. Default is ``False``. ``cov`` is ignored if ``full=True``. It must be specified statically. Returns: - An array polynomial coefficients ``p`` if ``full=False`` and ``cov=False``. - A tuple of arrays ``(p, resids, rank, s, rcond)`` if ``full=True``. Where - ``p`` is an array of shape ``(M,)`` or ``(M, K)`` containing the polynomial coefficients. - ``resids`` is the sum of squared residual of shape () or (K,). - ``rank`` is the rank of the matrix ``x``. - ``s`` is the singular values of the matrix ``x``. - ``rcond`` as the array. - A tuple of arrays ``(p, C)`` if ``full=False`` and ``cov=True``. Where - ``p`` is an array of shape ``(M,)`` or ``(M, K)`` containing the polynomial coefficients. - ``C`` is the covariance matrix of polynomial coefficients of shape ``(deg + 1, deg + 1)`` or ``(deg + 1, deg + 1, 1)``. Note: Unlike :func:`numpy.polyfit` implementation of polyfit, :func:`jax.numpy.polyfit` will not warn on rank reduction, which indicates an ill conditioned matrix. See Also: - :func:`jax.numpy.poly`: Finds the polynomial coefficients of the given sequence of roots. - :func:`jax.numpy.polyval`: Evaluate a polynomial at specific values. - :func:`jax.numpy.roots`: Computes the roots of a polynomial for given coefficients. Examples: >>> x = jnp.array([3., 6., 9., 4.]) >>> y = jnp.array([[0, 1, 2], ... [2, 5, 7], ... [8, 4, 9], ... [1, 6, 3]]) >>> p = jnp.polyfit(x, y, 2) >>> with jnp.printoptions(precision=2, suppress=True): ... print(p) [[ 0.2 -0.35 -0.14] [-1.17 4.47 2.96] [ 1.95 -8.21 -5.93]] If ``full=True``, returns a tuple of arrays as follows: >>> p, resids, rank, s, rcond = jnp.polyfit(x, y, 2, full=True) >>> with jnp.printoptions(precision=2, suppress=True): ... print("Polynomial Coefficients:", "\n", p, "\n", ... "Residuals:", resids, "\n", ... "Rank:", rank, "\n", ... "s:", s, "\n", ... "rcond:", rcond) Polynomial Coefficients: [[ 0.2 -0.35 -0.14] [-1.17 4.47 2.96] [ 1.95 -8.21 -5.93]] Residuals: [0.37 5.94 0.61] Rank: 3 s: [1.67 0.47 0.04] rcond: 4.7683716e-07 If ``cov=True`` and ``full=False``, returns a tuple of arrays having polynomial coefficients and covariance matrix. >>> p, C = jnp.polyfit(x, y, 2, cov=True) >>> p.shape, C.shape ((3, 3), (3, 3, 1)) Npolyfitzdeg must be intr.rzexpected deg >= 0zexpected 1D vector for xzexpected non-empty vector for xr*zexpected 1D or 2D array for yz$expected x and y to have same lengthzrcond must be floatz expected a 1-d array for weightsz(expected w and y to have the same length)axisunscaledzJthe number of data points must exceed order to scale the covariance matrix)r!rrHrIr rGrF TypeErrorr/shaper<rr,epsfloatrr#r?newaxisrsumr lstsqTinvrr)rOrPrKrLrrRrMorderx_arry_arrlhsrhsw_arrscalecresidsranksVbasefacs r5rVrVwsJLYIq!$$$$Iq!Q''' sC):;;# '%WQZZ%1WW ( ) )) Z1__ . / // Z1__ 5 6 66 Z!^^uzA~~ 3 4 44 [^u{1~%% : ; ;; ] JJu{++/ /E  /D E E%ue# #]  " "BA AJJE zQ 8 9 99 {1~Q'' @ A AA5BJ C x1}} U111bj= !!cc Ulc C}}!}$$ % %%rz!!!| #|Ce44!VT1s5ym!  fdAwu~~ --  Js35# ' 'E U5%  E j cc Uu  =>> > c%jj5( )c Fc zQ  ^ aaaBJ&'#- -- Hr7 seq_of_zerosc Btd|t|\}t|}~|j}t |dkr4|d|dkr"|ddkrddlm}|j|}|jdkrtd|j }t |dkrtd|Std |}tt |D],}t|td|| g|d }-|S) aReturns the coefficients of a polynomial for the given sequence of roots. JAX implementation of :func:`numpy.poly`. Args: seq_of_zeros: A scalar or an array of roots of the polynomial of shape ``(M,)`` or ``(M, M)``. Returns: An array containing the coefficients of the polynomial. The dtype of the output is always promoted to inexact. Note: :func:`jax.numpy.poly` differs from :func:`numpy.poly`: - When the input is a scalar, ``np.poly`` raises a ``TypeError``, whereas ``jnp.poly`` treats scalars the same as length-1 arrays. - For complex-valued or square-shaped inputs, ``jnp.poly`` always returns complex coefficients, whereas ``np.poly`` may return real or complex depending on their values. See also: - :func:`jax.numpy.polyfit`: Least squares polynomial fit. - :func:`jax.numpy.polyval`: Evaluate a polynomial at specific values. - :func:`jax.numpy.roots`: Computes the roots of a polynomial for given coefficients. Example: Scalar inputs: >>> jnp.poly(1) Array([ 1., -1.], dtype=float32) Input array with integer values: >>> x = jnp.array([1, 2, 3]) >>> jnp.poly(x) Array([ 1., -6., 11., -6.], dtype=float32) Input array with complex conjugates: >>> x = jnp.array([2, 1+2j, 1-2j]) >>> jnp.poly(x) Array([ 1.+0.j, -4.+0.j, 9.+0.j, -10.+0.j], dtype=complex64) Input array as square matrix with real valued inputs: >>> x = jnp.array([[2, 1, 5], ... [3, 4, 7], ... [1, 3, 5]]) >>> jnp.round(jnp.poly(x)) Array([ 1.+0.j, -11.-0.j, 9.+0.j, -15.+0.j], dtype=complex64) polyr*rr.rz.input must be 1d or non-empty square 2d array.r+r.rmode)r!r#r rZr<jax._src.numpyr r3rFrGr,rrangerr )roseq_of_zeros_arrshr dtaks r5rqrq"sCr&,'''(66-, --"WW\\ber!unnA!%%%%%%%v~&677a E F FF" a "    4r! %&& ' 'MMaE1/2232>>>VLLLAA (r7unrollr}ctd||t||\}~~tj|jddj}tjd|j}tjfd|||\}}|S)aEvaluates the polynomial at specific values. JAX implementations of :func:`numpy.polyval`. For the 1D-polynomial coefficients ``p`` of length ``M``, the function returns the value: .. math:: p_0 x^{M - 1} + p_1 x^{M - 2} + ... + p_{M - 1} Args: p: An array of polynomial coefficients of shape ``(M,)``. x: A number or an array of numbers. unroll: A number used to control the number of unrolled steps with ``lax.scan``. It must be specified statically. Returns: An array of same shape as ``x``. Note: The ``unroll`` parameter is JAX specific. It does not affect correctness but can have a major impact on performance for evaluating high-order polynomials. The parameter controls the number of unrolled steps with ``lax.scan`` inside the ``jnp.polyval`` implementation. Consider setting ``unroll=128`` (or even higher) to improve runtime performance on accelerators, at the cost of increased compilation time. See also: - :func:`jax.numpy.polyfit`: Least squares polynomial fit. - :func:`jax.numpy.poly`: Finds the coefficients of a polynomial with given roots. - :func:`jax.numpy.roots`: Computes the roots of a polynomial for given coefficients. Example: >>> p = jnp.array([2, 5, 1]) >>> jnp.polyval(p, 3) Array(34., dtype=float32) If ``x`` is a 2D array, ``polyval`` returns 2D-array with same shape as that of ``x``: >>> x = jnp.array([[2, 1, 5], ... [3, 4, 7], ... [1, 3, 5]]) >>> jnp.polyval(p, x) Array([[ 19., 8., 76.], [ 34., 53., 134.], [ 8., 34., 76.]], dtype=float32) polyvalr.Nr)rZr,c|z|zdfS)Nrr)rPr'rcs r5zpolyval..sE A t4r7r)r!r#rbroadcast_shapesrZ full_liker,scan)r'rOr}rJrZrP_rcs @r5rrtsl)Q"""'1--,% u{122 < <% mE1E===! 4444av N N N$!Q (r7a1a2c>td||t||\}}~~|jd|jdkr.|j|jd d|S|j|jd d|S)aReturns the sum of the two polynomials. JAX implementation of :func:`numpy.polyadd`. Args: a1: Array of polynomial coefficients. a2: Array of polynomial coefficients. Returns: An array containing the coefficients of the sum of input polynomials. Note: :func:`jax.numpy.polyadd` only accepts arrays as input unlike :func:`numpy.polyadd` which accepts scalar inputs as well. See also: - :func:`jax.numpy.polysub`: Computes the difference of two polynomials. - :func:`jax.numpy.polymul`: Computes the product of two polynomials. - :func:`jax.numpy.polydiv`: Computes the quotient and remainder of polynomial division. Example: >>> x1 = jnp.array([2, 3]) >>> x2 = jnp.array([5, 4, 1]) >>> jnp.polyadd(x1, x2) Array([5, 6, 4], dtype=int32) >>> x3 = jnp.array([[2, 3, 1]]) >>> x4 = jnp.array([[5, 7, 3], ... [8, 2, 6]]) >>> jnp.polyadd(x3, x4) Array([[ 5, 7, 3], [10, 5, 7]], dtype=int32) >>> x5 = jnp.array([1, 3, 5]) >>> x6 = jnp.array([[5, 7, 9], ... [8, 6, 4]]) >>> jnp.polyadd(x5, x6) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ValueError: Cannot broadcast to shape with fewer dimensions: arr_shape=(2, 3) shape=(2,) >>> x7 = jnp.array([2]) >>> jnp.polyadd(x6, x7) Array([[ 5, 7, 9], [10, 8, 6]], dtype=int32) polyaddrN)r!r"rZr1add)rra1_arra2_arrs r5rrs`)R$$$!"b)).&&" \!_ Q'' 9fl1o%&& ' + +F 3 33 9fl1o%&& ' + +F 3 33r7)mr.rr|int | ArrayLike | Nonectjtj|d}|dn|}t d||t ||\}}~~|dkrt dt|}t|dkrt|f|d}|j |fkrt d|dkr|Stt||z|j tjt||j ddtjfz }td|dddd }t#t%||f|S) aReturns the coefficients of the integration of specified order of a polynomial. JAX implementation of :func:`numpy.polyint`. Args: p: An array of polynomial coefficients. m: Order of integration. Default is 1. It must be specified statically. k: Scalar or array of ``m`` integration constant (s). Returns: An array of coefficients of integrated polynomial. See also: - :func:`jax.numpy.polyder`: Computes the coefficients of the derivative of a polynomial. - :func:`jax.numpy.polyval`: Evaluates a polynomial at specific values. Examples: The first order integration of the polynomial :math:`12 x^2 + 12 x + 6` is :math:`4 x^3 + 6 x^2 + 6 x`. >>> p = jnp.array([12, 12, 6]) >>> jnp.polyint(p) Array([4., 6., 6., 0.], dtype=float32) Since the constant ``k`` is not provided, the result included ``0`` at the end. If the constant ``k`` is provided: >>> jnp.polyint(p, k=4) Array([4., 6., 6., 4.], dtype=float32) and the second order integration is :math:`x^4 + 2 x^3 + 3 x`: >>> jnp.polyint(p, m=2) Array([1., 2., 3., 0., 0.], dtype=float32) When ``m>=2``, the constants ``k`` should be provided as an array having ``m`` elements. The second order integration of the polynomial :math:`12 x^2 + 12 x + 6` with the constants ``k=[4, 5]`` is :math:`x^4 + 2 x^3 + 3 x^2 + 4 x + 5`: >>> jnp.polyint(p, m=2, k=jnp.array([4, 5])) Array([1., 2., 3., 4., 5.], dtype=float32) z'm' argument of jnp.polyintNrpolyintz0Order of integral must be positive (see polyder)r.z6k must be a scalar or a rank-1 array of length 1 or m.r+r-)rrHoperatorindexr!r#rGr r<rrZr r,r?r]rprodrr)r'rr|rJk_arrgridcoeffs r5rrsW^ X^Q0MNN! 9aa!!)Q"""'1--,%UU G H HH U  %ZZ1__ !uQx E [QD M N NN!VV L 3u::> 5 5 5bj AQek***111bj=9 :D At   ! !! $ $TTrT *E {E5>22E : ::r7ctd|tjtj|d}t |\}~|dkrt d|dkr|St|t||j tj t||j ddtj fz d}|d| |dddzS)aIReturns the coefficients of the derivative of specified order of a polynomial. JAX implementation of :func:`numpy.polyder`. Args: p: Array of polynomials coefficients. m: Order of differentiation (positive integer). Default is 1. It must be specified statically. Returns: An array of polynomial coefficients representing the derivative. Note: :func:`jax.numpy.polyder` differs from :func:`numpy.polyder` when an integer array is given. NumPy returns the result with dtype ``int`` whereas JAX returns the result with dtype ``float``. See also: - :func:`jax.numpy.polyint`: Computes the integral of polynomial. - :func:`jax.numpy.polyval`: Evaluates a polynomial at specific values. Examples: The first order derivative of the polynomial :math:`2 x^3 - 5 x^2 + 3 x - 1` is :math:`6 x^2 - 10 x +3`: >>> p = jnp.array([2, -5, 3, -1]) >>> jnp.polyder(p) Array([ 6., -10., 3.], dtype=float32) and its second order derivative is :math:`12 x - 10`: >>> jnp.polyder(p, m=2) Array([ 12., -10.], dtype=float32) polyderz'm' argument of jnp.polyderrz$Order of derivative must be positiver+Nr-) r!rrHrrr#rGr r<r,r?r]r)r'rrJrs r5rr0sJ)Q X^Q0MNN! !! $ $&%UU ; < <<!VV L !SZZu{ 3 3 3BJ ? 1EK ( ( (BJ 7 89=a sseDDbDk !!r7)trim_leading_zerosrctd||t||\}}~~|rHt|dkst|dkr"t|dt|d}}t|dkrt dg|j}t|dkrt dg|j}t ||dS) a]Returns the product of two polynomials. JAX implementation of :func:`numpy.polymul`. Args: a1: 1D array of polynomial coefficients. a2: 1D array of polynomial coefficients. trim_leading_zeros: Default is ``False``. If ``True`` removes the leading zeros in the return value to match the result of numpy. But prevents the function from being able to be used in compiled code. Due to differences in accumulation of floating point arithmetic errors, the cutoff for values to be considered zero may lead to inconsistent results between NumPy and JAX, and even between different JAX backends. The result may lead to inconsistent output shapes when ``trim_leading_zeros=True``. Returns: An array of the coefficients of the product of the two polynomials. The dtype of the output is always promoted to inexact. Note: :func:`jax.numpy.polymul` only accepts arrays as input unlike :func:`numpy.polymul` which accepts scalar inputs as well. See also: - :func:`jax.numpy.polyadd`: Computes the sum of two polynomials. - :func:`jax.numpy.polysub`: Computes the difference of two polynomials. - :func:`jax.numpy.polydiv`: Computes the quotient and remainder of polynomial division. Example: >>> x1 = np.array([2, 1, 0]) >>> x2 = np.array([0, 5, 0, 3]) >>> np.polymul(x1, x2) array([10, 5, 6, 3, 0]) >>> jnp.polymul(x1, x2) Array([ 0., 10., 5., 6., 3., 0.], dtype=float32) If ``trim_leading_zeros=True``, the result matches with ``np.polymul``'s. >>> jnp.polymul(x1, x2, trim_leading_zeros=True) Array([10., 5., 6., 3., 0.], dtype=float32) For input arrays of dtype ``complex``: >>> x3 = np.array([2., 1+2j, 1-2j]) >>> x4 = np.array([0, 5, 0, 3]) >>> np.polymul(x3, x4) array([10. +0.j, 5.+10.j, 11.-10.j, 3. +6.j, 3. -6.j]) >>> jnp.polymul(x3, x4) Array([ 0. +0.j, 10. +0.j, 5.+10.j, 11.-10.j, 3. +6.j, 3. -6.j], dtype=complex64) >>> jnp.polymul(x3, x4, trim_leading_zeros=True) Array([10. +0.j, 5.+10.j, 11.-10.j, 3. +6.j, 3. -6.j], dtype=complex64) polymulr.f)trimrr+rrt)r!r#r<rr r,r)rrrrrs r5rrbsl)R$$$)"b11.&&"PS[[1__F aS111:f33O3O3OFF[[A aS - - -F[[A aS - - -F &&v . . ..r7uvtuple[Array, Array]cXtd||t||\}}~~t|dz }t|dz }d|dz }tt ||z dzd|j}t d||z dzD]Y} ||| z} |j| | }|j| | |zdz | |z}Z|r6t|tt|jj d}||fS)aReturns the quotient and remainder of polynomial division. JAX implementation of :func:`numpy.polydiv`. Args: u: Array of dividend polynomial coefficients. v: Array of divisor polynomial coefficients. trim_leading_zeros: Default is ``False``. If ``True`` removes the leading zeros in the return value to match the result of numpy. But prevents the function from being able to be used in compiled code. Due to differences in accumulation of floating point arithmetic errors, the cutoff for values to be considered zero may lead to inconsistent results between NumPy and JAX, and even between different JAX backends. The result may lead to inconsistent output shapes when ``trim_leading_zeros=True``. Returns: A tuple of quotient and remainder arrays. The dtype of the output is always promoted to inexact. Note: :func:`jax.numpy.polydiv` only accepts arrays as input unlike :func:`numpy.polydiv` which accepts scalar inputs as well. See also: - :func:`jax.numpy.polyadd`: Computes the sum of two polynomials. - :func:`jax.numpy.polysub`: Computes the difference of two polynomials. - :func:`jax.numpy.polymul`: Computes the product of two polynomials. Example: >>> x1 = jnp.array([5, 7, 9]) >>> x2 = jnp.array([4, 1]) >>> np.polydiv(x1, x2) (array([1.25 , 1.4375]), array([7.5625])) >>> jnp.polydiv(x1, x2) (Array([1.25 , 1.4375], dtype=float32), Array([0. , 0. , 7.5625], dtype=float32)) If ``trim_leading_zeros=True``, the result matches with ``np.polydiv``'s. >>> jnp.polydiv(x1, x2, trim_leading_zeros=True) (Array([1.25 , 1.4375], dtype=float32), Array([7.5625], dtype=float32)) polydivr.r;rr+r)tolr)r!r#r<rmaxr,rwr1r2rrrrr[) rrru_arrv_arrrnrhqr|ds r5rrs+T)Q"""'1--,% %jj1n! %jj1n! uQx-% 3q1uqy!$$ek : : :! AaCE??,,a aA Q AA HQqs1uW  ! !1"U( + +EEN 5d5+=+=+A&B&B M M ME E/r7cltd||t||\}}t|| S)aReturns the difference of two polynomials. JAX implementation of :func:`numpy.polysub`. Args: a1: Array of minuend polynomial coefficients. a2: Array of subtrahend polynomial coefficients. Returns: An array containing the coefficients of the difference of two polynomials. Note: :func:`jax.numpy.polysub` only accepts arrays as input unlike :func:`numpy.polysub` which accepts scalar inputs as well. See also: - :func:`jax.numpy.polyadd`: Computes the sum of two polynomials. - :func:`jax.numpy.polymul`: Computes the product of two polynomials. - :func:`jax.numpy.polydiv`: Computes the quotient and remainder of polynomial division. Example: >>> x1 = jnp.array([2, 3]) >>> x2 = jnp.array([5, 4, 1]) >>> jnp.polysub(x1, x2) Array([-5, -2, 2], dtype=int32) >>> x3 = jnp.array([[2, 3, 1]]) >>> x4 = jnp.array([[5, 7, 3], ... [8, 2, 6]]) >>> jnp.polysub(x3, x4) Array([[-5, -7, -3], [-6, 1, -5]], dtype=int32) >>> x5 = jnp.array([1, 3, 5]) >>> x6 = jnp.array([[5, 7, 9], ... [8, 6, 4]]) >>> jnp.polysub(x5, x6) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ValueError: Cannot broadcast to shape with fewer dimensions: arr_shape=(2, 3) shape=(2,) >>> x7 = jnp.array([2]) >>> jnp.polysub(x6, x7) Array([[5, 7, 9], [6, 4, 2]], dtype=int32) polysub)r!r"r)rrs r5rrs<`)R$$$ "b ! !&"b bS  r7)r'r%r(r%)r'r%r8r9r(r%)r'r&rCrDr(r%)NFNF)rOr&rPr&rKrIrLrQrrDrRrSrMrDr(rT)ror&r(r%)r'r&rOr&r}rIr(r%)rr&rr&r(r%)r.N)r'r&rrIr|rr(r%rs)r'r&rrIr(r%)rr&rr&rrDr(r%)rr&rr&rrDr(r)< __future__r functoolsrrnumpyr?jaxrrjax._srcrrjax._src.numpy.lax_numpyr r r r r rrrrrrrrrrrrrjax._src.numpy.ufuncsrrrjax._src.numpy.reductionsrrvr jax._src.numpy.utilr!r"r#r$jax._src.typingr%r&r6rBrArVrqrrrrrrrrrr7r5rs #"""""########################################=<<<<<<<<<))))))!!!!!!EEEEEEEEEEEE,,,,,,,,eeee04878787878787v =>>>HLHMg g g g ?>g TN N N N b xj)))9;; ; ; ; ; *); |54545454p f%%%@;@;@;@;&%@;F f%%%."."."."&%."bIN?/?/?/?/?/?/DGL888888v111111r7