`ip:&ddlZddlZddlmZddlmZddlmZddl m Z m Z ddl Z ddlmZeZn#e$rdZYnwxYwdZd d gZd d gZd ZejedddgZdZejeddeDdeDzdeDzdeDzZdZejeddeDZdZdZdZdZdZdZ d(dZ!Gd d!Z"Gd"d#e"Z#Gd$d%e"Z$Gd&d'Z%dS))N)internal) get_typename)special)BSpline _get_dtype)combctj|tj||z tj|zzSN)math factorial)nks x/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/scipy/interpolate/_interpolate.py_combrs4~a  T^AE%:%:T^A=N=N%NOO@doublezthrust::complexintz long longa2 #include #define le_or_ge(x, y, r) ((r) ? ((x) < (y)) : ((x) > (y))) #define ge_or_le(x, y, r) ((r) ? ((x) > (y)) : ((x) < (y))) #define geq_or_leq(x, y, r) ((r) ? ((x) >= (y)) : ((x) <= (y))) __device__ long long find_breakpoint_position( const double* breakpoints, const double xp, bool extrapolate, const int total_breakpoints, const bool* pasc) { double a = *&breakpoints[0]; double b = *&breakpoints[total_breakpoints - 1]; bool asc = pasc[0]; if(isnan(xp)) { return -1; } if(le_or_ge(xp, a, asc) || ge_or_le(xp, b, asc)) { if(!extrapolate) { return -1; } else if(le_or_ge(xp, a, asc)) { return 0; } else { // ge_or_le(xp, b, asc) return total_breakpoints - 2; } } else if (xp == b) { return total_breakpoints - 2; } int left = 0; int right = total_breakpoints - 2; int mid; if(le_or_ge(xp, *&breakpoints[left + 1], asc)) { right = left; } bool found = false; while(left < right && !found) { mid = ((right + left) / 2); if(le_or_ge(xp, *&breakpoints[mid], asc)) { right = mid; } else if (geq_or_leq(xp, *&breakpoints[mid + 1], asc)) { left = mid + 1; } else { found = true; left = mid; } } return left; } __global__ void find_breakpoint_position_1d( const double* breakpoints, const double* x, long long* out, bool extrapolate, int total_x, int total_breakpoints, const bool* pasc) { int idx = blockDim.x * blockIdx.x + threadIdx.x; if(idx >= total_x) { return; } const double xp = *&x[idx]; out[idx] = find_breakpoint_position( breakpoints, xp, extrapolate, total_breakpoints, pasc); } __global__ void find_breakpoint_position_nd( const double* breakpoints, const double* x, long long* out, bool extrapolate, int total_x, const long long* x_dims, const long long* breakpoints_sizes, const long long* breakpoints_strides) { int idx = blockDim.x * blockIdx.x + threadIdx.x; if(idx >= total_x) { return; } const long long x_dim = *&x_dims[idx]; const long long stride = breakpoints_strides[x_dim]; const double* dim_breakpoints = breakpoints + stride; const int num_breakpoints = *&breakpoints_sizes[x_dim]; const bool asc = true; const double xp = *&x[idx]; out[idx] = find_breakpoint_position( dim_breakpoints, xp, extrapolate, num_breakpoints, &asc); } )z -std=c++11find_breakpoint_position_1dfind_breakpoint_position_nd)codeoptionsname_expressionsa #include #include template __device__ T eval_poly_1( const double s, const T* coef, long long ci, int cj, int dx, const long long* c_dims, const long long stride_0, const long long stride_1) { int kp, k; T res, z; double prefactor; res = 0.0; z = 1.0; if(dx < 0) { for(int i = 0; i < -dx; i++) { z *= s; } } int c_dim_0 = (int) *&c_dims[0]; for(kp = 0; kp < c_dim_0; kp++) { if(dx == 0) { prefactor = 1.0; } else if(dx > 0) { if(kp < dx) { continue; } else { prefactor = 1.0; for(k = kp; k > kp - dx; k--) { prefactor *= k; } } } else { prefactor = 1.0; for(k = kp; k < kp - dx; k++) { prefactor /= k + 1; } } int off = stride_0 * (c_dim_0 - kp - 1) + stride_1 * ci + cj; T cur_coef = *&coef[off]; res += cur_coef * z * ((T) prefactor); if((kp < c_dim_0 - 1) && kp >= dx) { z *= s; } } return res; } template __global__ void eval_ppoly( const T* coef, const double* breakpoints, const double* x, const long long* intervals, int dx, const long long* c_dims, const long long* c_strides, int num_x, T* out) { int idx = blockDim.x * blockIdx.x + threadIdx.x; if(idx >= num_x) { return; } double xp = *&x[idx]; long long interval = *&intervals[idx]; double breakpoint = *&breakpoints[interval]; const int num_c = *&c_dims[2]; const long long stride_0 = *&c_strides[0]; const long long stride_1 = *&c_strides[1]; if(interval < 0) { for(int j = 0; j < num_c; j++) { out[num_c * idx + j] = CUDART_NAN; } return; } for(int j = 0; j < num_c; j++) { T res = eval_poly_1( xp - breakpoint, coef, interval, ((long long) (j)), dx, c_dims, stride_0, stride_1); out[num_c * idx + j] = res; } } template __global__ void eval_ppoly_nd( const T* coef, const double* xs, const double* xp, const long long* intervals, const long long* dx, const long long* ks, T* c2_all, const long long* c_dims, const long long* c_strides, const long long* xs_strides, const long long* xs_offsets, const long long* ks_strides, const int num_x, const int ndims, const int num_ks, T* out) { int idx = blockDim.x * blockIdx.x + threadIdx.x; if(idx >= num_x) { return; } const long long c_dim0 = c_dims[0]; const int num_c = *&c_dims[2]; const long long c_stride0 = c_strides[0]; const long long c_stride1 = c_strides[1]; const double* xp_dims = xp + ndims * idx; const long long* xp_intervals = intervals + ndims * idx; T* c2 = c2_all + c_dim0 * idx; bool invalid = false; for(int i = 0; i < ndims && !invalid; i++) { invalid = xp_intervals[i] < 0; } if(invalid) { for(int j = 0; j < num_c; j++) { out[num_c * idx + j] = CUDART_NAN; } return; } long long pos = 0; for(int k = 0; k < ndims; k++) { pos += xp_intervals[k] * xs_strides[k]; } for(int jp = 0; jp < num_c; jp++) { for(int i = 0; i < c_dim0; i++) { c2[i] = coef[c_stride0 * i + c_stride1 * pos + jp]; } for(int k = ndims - 1; k >= 0; k--) { const long long interval = xp_intervals[k]; const long long xs_offset = xs_offsets[k]; const double* dim_breakpoints = xs + xs_offset; const double xval = xp_dims[k] - dim_breakpoints[interval]; const long long k_off = ks_strides[k]; const long long dim_ks = ks[k]; int kpos = 0; for(int ko = 0; ko < k_off; ko++) { const T* c2_off = c2 + kpos; const int k_dx = dx[k]; T res = eval_poly_1( xval, c2_off, ((long long) 0), 0, k_dx, &dim_ks, ((long long) 1), ((long long) 1)); c2[ko] = res; kpos += dim_ks; } } out[num_c * idx + jp] = c2[0]; } } template __global__ void fix_continuity( T* coef, const double* breakpoints, const int order, const long long* c_dims, const long long* c_strides, int num_breakpoints) { const long long c_size0 = *&c_dims[0]; const long long c_size2 = *&c_dims[2]; const long long stride_0 = *&c_strides[0]; const long long stride_1 = *&c_strides[1]; const long long stride_2 = *&c_strides[2]; for(int idx = 1; idx < num_breakpoints - 1; idx++) { const double breakpoint = *&breakpoints[idx]; const long long interval = idx - 1; const double breakpoint_interval = *&breakpoints[interval]; for(int jp = 0; jp < c_size2; jp++) { for(int dx = order; dx > -1; dx--) { T res = eval_poly_1( breakpoint - breakpoint_interval, coef, interval, jp, dx, c_dims, stride_0, stride_1); for(int kp = 0; kp < dx; kp++) { res /= kp + 1; } const long long c_idx = ( stride_0 * (c_size0 - dx - 1) + stride_1 * idx + stride_2 * jp); coef[c_idx] = res; } } } } template __global__ void integrate( const T* coef, const double* breakpoints, const double* a_val, const double* b_val, const long long* start, const long long* end, const long long* c_dims, const long long* c_strides, const bool* pasc, T* out) { int idx = blockDim.x * blockIdx.x + threadIdx.x; const long long c_dim2 = *&c_dims[2]; if(idx >= c_dim2) { return; } const bool asc = pasc[0]; const long long start_interval = asc ? *&start[0] : *&end[0]; const long long end_interval = asc ? *&end[0] : *&start[0]; const double a = asc ? *&a_val[0] : *&b_val[0]; const double b = asc ? *&b_val[0] : *&a_val[0]; const long long stride_0 = *&c_strides[0]; const long long stride_1 = *&c_strides[1]; if(start_interval < 0 || end_interval < 0) { out[idx] = CUDART_NAN; return; } T vtot = 0; T vb; T va; for(int interval = start_interval; interval <= end_interval; interval++) { const double breakpoint = *&breakpoints[interval]; if(interval == end_interval) { vb = eval_poly_1( b - breakpoint, coef, interval, idx, -1, c_dims, stride_0, stride_1); } else { const double next_breakpoint = *&breakpoints[interval + 1]; vb = eval_poly_1( next_breakpoint - breakpoint, coef, interval, idx, -1, c_dims, stride_0, stride_1); } if(interval == start_interval) { va = eval_poly_1( a - breakpoint, coef, interval, idx, -1, c_dims, stride_0, stride_1); } else { va = eval_poly_1( 0, coef, interval, idx, -1, c_dims, stride_0, stride_1); } vtot += (vb - va); } if(!asc) { vtot = -vtot; } out[idx] = vtot; } cg|]}d|d S)z eval_ppoly<>.0 type_names r r $;;; #y # # #;;;rcg|]}d|d S)zeval_ppoly_nd>>9 &) & & &>>>rcg|]}d|d S)zfix_continuity #include template __device__ T eval_bpoly1( const double s, const T* coef, const long long ci, const long long cj, const long long c_dims_0, const long long c_strides_0, const long long c_strides_1) { const long long k = c_dims_0 - 1; const double s1 = 1 - s; T res; const long long i0 = 0 * c_strides_0 + ci * c_strides_1 + cj; const long long i1 = 1 * c_strides_0 + ci * c_strides_1 + cj; const long long i2 = 2 * c_strides_0 + ci * c_strides_1 + cj; const long long i3 = 3 * c_strides_0 + ci * c_strides_1 + cj; if(k == 0) { res = coef[i0]; } else if(k == 1) { res = coef[i0] * s1 + coef[i1] * s; } else if(k == 2) { res = coef[i0] * s1 * s1 + coef[i1] * 2.0 * s1 * s + coef[i2] * s * s; } else if(k == 3) { res = (coef[i0] * s1 * s1 * s1 + coef[i1] * 3.0 * s1 * s1 * s + coef[i2] * 3.0 * s1 * s * s + coef[i3] * s * s * s); } else { T comb = 1; res = 0; for(int j = 0; j < k + 1; j++) { const long long idx = j * c_strides_0 + ci * c_strides_1 + cj; res += (comb * pow(s, ((double) j)) * pow(s1, ((double) k) - j) * coef[idx]); comb *= 1.0 * (k - j) / (j + 1.0); } } return res; } template __device__ T eval_bpoly1_deriv( const double s, const T* coef, const long long ci, const long long cj, int dx, T* wrk, const long long c_dims_0, const long long c_strides_0, const long long c_strides_1, const long long wrk_dims_0, const long long wrk_strides_0, const long long wrk_strides_1) { T res, term; double comb, poch; const long long k = c_dims_0 - 1; if(dx == 0) { res = eval_bpoly1(s, coef, ci, cj, c_dims_0, c_strides_0, c_strides_1); } else { poch = 1.0; for(int a = 0; a < dx; a++) { poch *= k - a; } term = 0; for(int a = 0; a < k - dx + 1; a++) { term = 0; comb = 1; for(int j = 0; j < dx + 1; j++) { const long long idx = (c_strides_0 * (j + a) + c_strides_1 * ci + cj); term += coef[idx] * pow(-1.0, ((double) (j + dx))) * comb; comb *= 1.0 * (dx - j) / (j + 1); } wrk[a] = term * poch; } res = eval_bpoly1(s, wrk, 0, 0, wrk_dims_0, wrk_strides_0, wrk_strides_1); } return res; } template __global__ void eval_bpoly( const T* coef, const double* breakpoints, const double* x, const long long* intervals, int dx, T* wrk, const long long* c_dims, const long long* c_strides, const long long* wrk_dims, const long long* wrk_strides, int num_x, T* out) { int idx = blockDim.x * blockIdx.x + threadIdx.x; if(idx >= num_x) { return; } double xp = *&x[idx]; long long interval = *&intervals[idx]; const int num_c = *&c_dims[2]; const long long c_dims_0 = *&c_dims[0]; const long long c_strides_0 = *&c_strides[0]; const long long c_strides_1 = *&c_strides[1]; const long long wrk_dims_0 = *&wrk_dims[0]; const long long wrk_strides_0 = *&wrk_strides[0]; const long long wrk_strides_1 = *&wrk_strides[1]; if(interval < 0) { for(int j = 0; j < num_c; j++) { out[num_c * idx + j] = CUDART_NAN; } return; } const double ds = breakpoints[interval + 1] - breakpoints[interval]; const double ds_dx = pow(ds, ((double) dx)); T* off_wrk = wrk + idx * (c_dims_0 - dx); for(int j = 0; j < num_c; j++) { T res; const double s = (xp - breakpoints[interval]) / ds; if(dx == 0) { res = eval_bpoly1( s, coef, interval, ((long long) (j)), c_dims_0, c_strides_0, c_strides_1); } else { res = eval_bpoly1_deriv( s, coef, interval, ((long long) (j)), dx, off_wrk, c_dims_0, c_strides_0, c_strides_1, wrk_dims_0, wrk_strides_0, wrk_strides_1) / ds_dx; } out[num_c * idx + j] = res; } } cg|]}d|d S)z eval_bpoly.s"DDDs< **DDDrz, .ss000QV000rr7Nr6r9rr8r: eval_ppoly_nd)r>rUlenr<rAr?cumsumr_cumprodr=arange broadcast_to expand_dimscopyr@r,rBrCzerosrr4rD)rExsksrGrHrIrJ num_samplestotal_xpndimsnum_ksxs_sizes xs_offsets xs_complete xs_sizes_m1 xs_stridesrLdim_seqxp_dimsrMrNrOc2 ks_stridesrPs r_ndppoly_evaluaterpQs{8(1+KwH GGE WF|00R000 CCCHX&&JJssO+,J'"+KQ,Kk%1R%011JDDbD)1,-J 284:666Ik%tz222G !$${E&:<r?rBrCr4rD)rErForderrNrOcontinuity_kernels r_fix_continuityrvs$l17$*555G QYdj999QZGI(7GKKdD!UGY CEEEEErc|d|dk}tj|gtj}tj|gtj}tj|jtj}tj|jtj}t d} | |jddzdz dzfd|||||jd|jd|f| |jddzdz dzfd|||||jd|jd|ftj|jtj} tj|jtj|j z} ttd|} | |jd dzdz dzfd||||||| | ||f d S) a Compute integral over a piecewise polynomial. Parameters ---------- c : ndarray, shape (k, m, n) Coefficients local polynomials of order `k-1` in `m` intervals. x : ndarray, shape (m+1,) Breakpoints of polynomials a : double Start point of integration. b : double End point of integration. extrapolate : bool, optional Whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. out : ndarray, shape (n,) Integral of the piecewise polynomial, assuming the polynomial is zero outside the range (x[0], x[-1]). This argument is modified in-place. r6rr7rr8r9r: integrateN) r<rAfloat64r=r>r?r@r,rBrCr4rD) rErFabrIrJrKstart_interval end_intervalrMrNrO int_kernels r _integraters."1 I aS ---A aS ---AZtz:::N:agTZ888L%22%''OOagaj3&*s24f>; AGAJ !!!Oagaj3&*s24f<agaj!'!* !!! l17$*555G QYdj999QZGI!, Q??JJc!A%#-/1aNL'93 !!!!!rc|d|dk}tj|jtj}td}||jddzdz dzfd|||||jd|jd|ftj|jtj} tj|jtj|jz} tj|jd|jd|z zddft|} tj|jd|z ddgtj} tj| jtj| jz} ttd|}||jddzdz dzfd|||||| | | | | |jd|f d S) aM Evaluate a Bernstein polynomial. Parameters ---------- c : ndarray, shape (k, m, n) Coefficients local polynomials of order `k-1` in `m` intervals. There are `n` polynomials in each interval. Coefficient of highest order-term comes first. x : ndarray, shape (m+1,) Breakpoints of polynomials. xp : ndarray, shape (r,) Points to evaluate the piecewise polynomial at. dx : int Order of derivative to evaluate. The derivative is evaluated piecewise and may have discontinuities. extrapolate : bool Whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. out : ndarray, shape (r, n) Value of each polynomial at each of the input points. This argument is modified in-place. r6rr7rr8r9r: eval_bpolyN) r<r=r>r?r@r,rArBrCrr4 BPOLY_MODULE)rErFrGrHrIrJrKrLrMrNrOwrk wrk_shape wrk_strides bpoly_kernels r_bpoly_evaluaters2"1 I 284:666I%22%''OObhqkC'!+35vI{BHQK !!! l17$*555G QYdj999QZGI *bhqkQWQZ"_5q!<%a== * * *C agaj2oq!4DJGGGI,s{$*===MK#L,BBLL28A;$q(S02FQIr3Irx{C122222rct|tr-t|dkrtj|d}t|tr;tjd|D}d|D}tj|d}nNtj|}|jdkr/||dd}n|d|}|S)zM Convert a tuple of coordinate arrays to a (..., ndim)-shaped array. r9rc6g|]}tj|Sr)r<rArVs rr z,_ndim_coords_from_arrays.. s #D#D#DDLOO#D#D#Drc8g|]}tj|dS)r6)r<r^rVs rr z,_ndim_coords_from_arrays..!s% 0 0 0T a $ $ 0 0 0rr6axis) isinstancetuplerXr<rAbroadcast_arrays concatenatendimreshape)pointsrps r_ndim_coords_from_arraysrs &%  )S[[A%5%5fQi((&%  2  !#D#DV#D#D#D E 0 0a 0 0 0!!"---f%% ;!  |A..D11 MrcPeZdZdZdZd dZdZed dZdZ d Z d d Z dS) _PPolyBasez%Base class for piecewise polynomials.)rErFrIrNrctj||_tj|tj|_|d}n|dkrt |}||_|jjdkrtdd|cxkr|jjdz ks$ntd|d |jjdz ||_ |dkrFtj |j|dzd|_tj |j|dzd|_|jjdkrtd |jj dkrtd |jjdkrtd |jj ddkrtd |jj d|jj dz krtdtj|j}tj|dks'tj|dkstd||jj}tj|j||_dS)Nr7Tperiodicryz2Coefficients array must be at least 2-dimensional.rr9zaxis=z must be between 0 and zx must be 1-dimensionalz!at least 2 breakpoints are neededz!c must have at least 2 dimensionsz&polynomial must be at least of order 0z"number of coefficients != len(x)-1z.`x` must be strictly increasing or decreasing.)r<rArEascontiguousarrayrzrFboolrIr ValueErrorrmoveaxisrUr>diffallrr()selfrErFrIrrHr(s r__init__z_PPolyBase.__init__1s;a'>>>  KK J & &{++K& 6;??.// /T++++DFK!O++++*"ddDFKMM344 4 199]4646155DF]4646155DF 6;!  677 7 6;??@AA A 6;??@AA A 6<?a  EFF F 6<?dfk!m + +ABB B Ytv  q!! OTXbAg%6%6 OMNN N --'e<<<rctj|tjs)tj|jjtjr tjStjSr r< issubdtypecomplexfloatingrEr( complex128rzrr(s rrz_PPolyBase._get_dtype_D OE4#7 8 8 ?46<1EFF ? "< rczt|}||_||_||_|d}||_|S)aG Construct the piecewise polynomial without making checks. Takes the same parameters as the constructor. Input arguments ``c`` and ``x`` must be arrays of the correct shape and type. The ``c`` array can only be of dtypes float and complex, and ``x`` array must have dtype float. NT)object__new__rErFrrI)clsrErFrIrrs rconstruct_fastz_PPolyBase.construct_fastfsB~~c""  K& rc|jjjs|j|_|jjjs |j|_dSdS)zr c and x may be modified by the user. The Cython code expects that they are C contiguous. N)rFflags c_contiguousr_rErs r_ensure_c_contiguousz_PPolyBase._ensure_c_contiguousxsR v|( #V[[]]DFv|( #V[[]]DFFF # #rctj|}tj|}|jdkrtd|jdkrtd|jd|jdkr-td|j|j|jdd|jjddks|j|jjkr2td|j|jj|jdkrdStj|}tj |dks'tj |dkstd |j d |j dkrd|d |dkstd |d|j d krd }n|d |j dkrd }nstd|d |dkstd |d|j d krd }n)|d |j dkrd }ntd| |j }t|jd|jjd}tj||jjd|jdzf|jjddz|}|d kr{|j|||jjdz dd|jjdf<||||jdz d|jjddf<tj|j |f|_ nv|d krp||||jjdz dd|jdf<|j|||jdz d|jddf<tj||j f|_ ||_dS)a# Add additional breakpoints and coefficients to the polynomial. Parameters ---------- c : ndarray, size (k, m, ...) Additional coefficients for polynomials in intervals. Note that the first additional interval will be formed using one of the ``self.x`` end points. x : ndarray, size (m,) Additional breakpoints. Must be sorted in the same order as ``self.x`` and either to the right or to the left of the current breakpoints. ryzinvalid dimensions for cr9zinvalid dimensions for xrz(Shapes of x {} and c {} are incompatibleNz-Shapes of c {} and self.c {} are incompatiblez`x` is not sorted.r6z,`x` is in the different order than `self.x`.appendprependz9`x` is neither on the left or on the right from `self.x`.r7)r<rArrr>formatrErUrrrFrr(maxr`rZ)rrErFrHactionr(k2rns rextendz_PPolyBase.extends LOO LOO 6A::788 8 6Q;;788 8 71: # #G$fQWag6688 8 7122;$&,qrr* * *af .C.CL$fQWdfl;;== = 6Q;; F Yq\\q!! 3TXbAg%6%6 3122 2 6": " "R5AaD== "2333ttvbz!!!2$&)##" "2333R5AaD== "2333ttvbz!!!2$&)##" "2333(( TV\!_ - - Z a171:- .abb1A A X  :>&BrDFLO#$$&6tv|A&66 756BrAGAJa!1!11 2WTVQY'DFF y 56BrDFLO#$$kqwqzk1 204BrAGAJ, -WQY'DFrc ||j}tj|}|j|j}}tj|tj}|dkr<|jd||jdz |jd|jdz zz}d}tj t|ttj |jjddf|jj}|||||||||jjddz}|jdkrft)t+|j}||||jz|d|z|||jzdz}||}|S)aX Evaluate the piecewise polynomial or its derivative. Parameters ---------- x : array_like Points to evaluate the interpolant at. nu : int, optional Order of derivative to evaluate. Must be non-negative. extrapolate : {bool, 'periodic', None}, optional If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. If None (default), use `self.extrapolate`. Returns ------- y : array_like Interpolated values. Shape is determined by replacing the interpolation axis in the original array with the shape of x. Notes ----- Derivatives are evaluated piecewise for each polynomial segment, even if the polynomial is not differentiable at the breakpoints. The polynomial intervals are considered half-open, ``[a, b)``, except for the last interval which is closed ``[a, b]``. Nr7rrr6Fry)rIr<rAr>rrravelrzrFr=rXrnpprodrEr(r _evaluaterrlistrange transpose)rrFnurIx_shapex_ndimrJdimss r__call__z_PPolyBase.__call__s<  *K LOO'16  "17799DL A A A * $ $q Q]tvbzDF1I/EFFAKj#a&&#bgdfl122.>&?&?"@"@A#v|--- !!### q"k3///kk'DFL$4455 9>>ch((D 223d7F7mC$)+,,-.D--%%C rNrrN) __name__ __module__ __qualname____doc__ __slots__rr classmethodrrrrrrrrr-s//1I,=,=,=,=\   ["###NNN`555555rrcpeZdZdZdZddZddZddZdd Zdd Z e dd Z e dd Z dS)PPolya Piecewise polynomial in terms of coefficients and breakpoints The polynomial between ``x[i]`` and ``x[i + 1]`` is written in the local power basis:: S = sum(c[m, i] * (xp - x[i]) ** (k - m) for m in range(k + 1)) where ``k`` is the degree of the polynomial. Parameters ---------- c : ndarray, shape (k, m, ...) Polynomial coefficients, order `k` and `m` intervals. x : ndarray, shape (m+1,) Polynomial breakpoints. Must be sorted in either increasing or decreasing order. extrapolate : bool or 'periodic', optional If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. Default is True. axis : int, optional Interpolation axis. Default is zero. Attributes ---------- x : ndarray Breakpoints. c : ndarray Coefficients of the polynomials. They are reshaped to a 3-D array with the last dimension representing the trailing dimensions of the original coefficient array. axis : int Interpolation axis. See also -------- BPoly : piecewise polynomials in the Bernstein basis Notes ----- High-order polynomials in the power basis can be numerically unstable. Precision problems can start to appear for orders larger than 20-30. .. seealso:: :class:`scipy.interpolate.BSpline` c t|j|jjd|jjdd|j||t ||dS)Nrr9r6)rQrErr>rFrrrFrrIrJs rrzPPoly._evaluate:sWtv|A QLL2tK'8'8# ? ? ? ? ?rr9cB|dkr|| S|dkr|j}n&|jd| ddf}|jddkr+t jd|jddz|j}tjt j |jddd|}||tdfd|j dz zzz}| ||j |j|jS)a Construct a new piecewise polynomial representing the derivative. Parameters ---------- nu : int, optional Order of derivative to evaluate. Default is 1, i.e., compute the first derivative. If negative, the antiderivative is returned. Returns ------- pp : PPoly Piecewise polynomial of order k2 = k - n representing the derivative of this polynomial. Notes ----- Derivatives are evaluated piecewise for each polynomial segment, even if the polynomial is not differentiable at the breakpoints. The polynomial intervals are considered half-open, ``[a, b)``, except for the last interval which is closed ``[a, b]``. rNrsr9r7r6r )antiderivativerEr_r>r<r`r(specpochr\slicerrrFrIr)rrrnfactors r derivativezPPoly.derivative>s 0 66&&s++ + 77BB"aaa%%''B 8A;!  D28ABB</rx@@@B4;rx{Ar::B?? feDkk^grwqy&99::""2tvt/?KKKrc|dkr|| Stj|jjd|z|jjdf|jjddz|jj}|j|d| <t jtj|jjddd|}|d| xx|tdfd|j dz zzzcc<| t| |jd|jdd|j|dz |jdkrd }n|j}|||j||jS) a< Construct a new piecewise polynomial representing the antiderivative. Antiderivative is also the indefinite integral of the function, and derivative is its inverse operation. Parameters ---------- nu : int, optional Order of antiderivative to evaluate. Default is 1, i.e., compute the first integral. If negative, the derivative is returned. Returns ------- pp : PPoly Piecewise polynomial of order k2 = k + n representing the antiderivative of this polynomial. Notes ----- The antiderivative returned by this function is continuous and continuously differentiable to order n-1, up to floating point rounding error. If antiderivative is computed and ``self.extrapolate='periodic'``, it will be set to False for the returned instance. This is done because the antiderivative is no longer periodic and its correct evaluation outside of the initially given x interval is difficult. rr9ryNr7r6r rF)rr<r`rEr>r(rrr\rrrrvrrFrIrr)rrrErrIs rrzPPoly.antiderivativejsp: 77??B3'' ' J V\!_r !46<? 3dfl1226F F&,   &$B3$4;tv|A2>>CC $B3$65;;.7afQh+??@@ !!### !'!*agaj"==Q ( ( (  z ) )KK*K""1dfk49EEErNc ||j}d}||kr||}}d}tjtt j|jjddf|jj}| |dkr|j d|j d}}||z }||z } t| |\} } | dkrZt|j |jjd|jjdd|j ||d| || z}n|d|||z |zz}|| z}tj|} ||kr[t|j |jjd|jjdd|j ||d| || z }nt|j |jjd|jjdd|j ||d| || z }t|j |jjd|jjdd|j ||| z|z|z d| || z }nat|j |jjd|jjdd|j ||t!|| ||z}| |jjddS) a Compute a definite integral over a piecewise polynomial. Parameters ---------- a : float Lower integration bound b : float Upper integration bound extrapolate : {bool, 'periodic', None}, optional If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. If None (default), use `self.extrapolate`. Returns ------- ig : array_like Definite integral of the piecewise polynomial over [a, b] Nr9r6ryr7rrF)rJ)rIr<r=rrrrEr>r(rrFdivmodrrfill empty_liker) rr{r|rIsign range_intraxeperiodinterval n_periodsleft remainder_ints rrxzPPoly.integrates*  *K q55aqADJ abb)** + + -TV\CCC  !!### * $ $VAYr B"WF1uH$Xv66OIt1}}FNN46<?DFLORHHFBEy::::Y& q!!!a"f&&ADA!OI66MBwwFNN46<?DFLORHHFAq%]<<<<]* FNN46<?DFLORHHFAr5m====]* FNN46<?DFLORHHFBT A  2E}NNNN]* tv|A QDD1d;//Y @ @ @ @ T   abb!1222rTc td)a Find real solutions of the equation ``pp(x) == y``. Parameters ---------- y : float, optional Right-hand side. Default is zero. discontinuity : bool, optional Whether to report sign changes across discontinuities at breakpoints as roots. extrapolate : {bool, 'periodic', None}, optional If bool, determines whether to return roots from the polynomial extrapolated based on first and last intervals, 'periodic' works the same as False. If None (default), use `self.extrapolate`. Returns ------- roots : ndarray Roots of the polynomial(s). If the PPoly object describes multiple polynomials, the return value is an object array whose each element is an ndarray containing the roots. Notes ----- This routine works only on real-valued polynomials. If the piecewise polynomial contains sections that are identically zero, the root list will contain the start point of the corresponding interval, followed by a ``nan`` value. If the polynomial is discontinuous across a breakpoint, and there is a sign change across the breakpoint, this is reported if the `discont` parameter is True. At the moment, there is not an actual implementation. z9At the moment there is not a GPU implementation for solve)NotImplementedError)ry discontinuityrIs rsolvez PPoly.solvesH" GII Irc0|d||S)aZ Find real roots of the piecewise polynomial. Parameters ---------- discontinuity : bool, optional Whether to report sign changes across discontinuities at breakpoints as roots. extrapolate : {bool, 'periodic', None}, optional If bool, determines whether to return roots from the polynomial extrapolated based on first and last intervals, 'periodic' works the same as False. If None (default), use `self.extrapolate`. Returns ------- roots : ndarray Roots of the polynomial(s). If the PPoly object describes multiple polynomials, the return value is an object array whose each element is an ndarray containing the roots. See Also -------- PPoly.solve r)r)rrrIs rrootsz PPoly.rootss4zz!]K888rct|tr|j\}}}||j}n|\}}}t||||}t j|dzt |dz f|j}t|ddD];}||dd|} | tj |dzz |||z ddf<<| |||S)a Construct a piecewise polynomial from a spline Parameters ---------- tck A spline, as a (knots, coefficients, degree) tuple or a BSpline object. extrapolate : bool or 'periodic', optional If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. Default is True. NrIr9r7r6)r) rrtckrIr<r=rXr(rrgammar) rrrItrErsplcvalsmrs r from_splinezPPoly.from_spline6s c7 # # gGAq!"!o GAq!aA;777 AE3q66A:.ag>>>q"b!! 4 4AAcrcFq!!!A$*QU"3"33E!a%(OO!!%K888rc t|tstdt|zt j|j}|jjddz }d|jj dz z}t j |j}t|dzD]}d|zt||z|j|z}t||dzD]Q} t||z | |z d| zz} ||| z xx|| z|tdf|z| zz z cc<R||j}|||j||jS)a Construct a piecewise polynomial in the power basis from a polynomial in Bernstein basis. Parameters ---------- bp : BPoly A Bernstein basis polynomial, as created by BPoly extrapolate : bool or 'periodic', optional If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. Default is True. zC.from_bernstein_basis only accepts BPoly instances. Got %s instead.rr9r ryr6N)rBPoly TypeErrortyper<rrFrEr>r zeros_likerrrrIrr) rbprIrHrrestrEr{rsvals rfrom_bernstein_basiszPPoly.from_bernstein_basisTsl"e$$ E9;?88DEE EYrt__ DJqMA  ! $ OBD ! !qs D DA1WuQ{{*RT!W4F1ac]] D DAaC1ooa/!A#&3,U4[[N4,?)@!)CCC D  .K!!!RT;@@@rrsr )rTN)TN) rrrrrrrrxrrrrrrrrrr s--^???*L*L*L*LX4F4F4F4FlQ3Q3Q3Q3f%I%I%I%IN99998999[9:!A!A!A[!A!A!ArrceZdZdZdZd dZd dZddZdZe jje_e d Z e dd Z e dd Ze d ZdS)ra Piecewise polynomial in terms of coefficients and breakpoints. The polynomial between ``x[i]`` and ``x[i + 1]`` is written in the Bernstein polynomial basis:: S = sum(c[a, i] * b(a, k; x) for a in range(k+1)), where ``k`` is the degree of the polynomial, and:: b(a, k; x) = binom(k, a) * t**a * (1 - t)**(k - a), with ``t = (x - x[i]) / (x[i+1] - x[i])`` and ``binom`` is the binomial coefficient. Parameters ---------- c : ndarray, shape (k, m, ...) Polynomial coefficients, order `k` and `m` intervals x : ndarray, shape (m+1,) Polynomial breakpoints. Must be sorted in either increasing or decreasing order. extrapolate : bool, optional If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. Default is True. axis : int, optional Interpolation axis. Default is zero. Attributes ---------- x : ndarray Breakpoints. c : ndarray Coefficients of the polynomials. They are reshaped to a 3-D array with the last dimension representing the trailing dimensions of the original coefficient array. axis : int Interpolation axis. See also -------- PPoly : piecewise polynomials in the power basis Notes ----- Properties of Bernstein polynomials are well documented in the literature, see for example [1]_ [2]_ [3]_. References ---------- .. [1] https://en.wikipedia.org/wiki/Bernstein_polynomial .. [2] Kenneth I. Joy, Bernstein polynomials, http://www.idav.ucdavis.edu/education/CAGDNotes/Bernstein-Polynomials.pdf .. [3] E. H. Doha, A. H. Bhrawy, and M. A. Saker, Boundary Value Problems, vol 2011, article ID 829546, `10.1155/2011/829543 `_. Examples -------- >>> from cupyx.scipy.interpolate import BPoly >>> x = [0, 1] >>> c = [[1], [2], [3]] >>> bp = BPoly(c, x) This creates a 2nd order polynomial .. math:: B(x) = 1 \times b_{0, 2}(x) + 2 \times b_{1, 2}(x) + 3 \times b_{2, 2}(x) \\ = 1 \times (1-x)^2 + 2 \times 2 x (1 - x) + 3 \times x^2 c |dkrtdt|j|jjd|jjdd|j||t ||dS)Nrz-Cannot do antiderivatives in the B-basis yet.r9r6)rrrErr>rFrrs rrzBPoly._evaluates{ 66%?AA A  FNN46<?DFLOR @ @ FAr4 ,,c 3 3 3 3 3rr9c|dkr|| S|dkr*|}t|D]}|}|S|dkr|j}nyd|jjdz z}|jjddz }tj|j dtdf|z}|tj|jdz|z }|jddkr+tj d|jddz|j }| ||j |j|jS) a Construct a new piecewise polynomial representing the derivative. Parameters ---------- nu : int, optional Order of derivative to evaluate. Default is 1, i.e., compute the first derivative. If negative, the antiderivative is returned. Returns ------- bp : BPoly Piecewise polynomial of order k - nu representing the derivative of this polynomial. rr9r ryNrrsr7)rrrrEr_rr>r<rrFrr`r(rrIr)rrrrrnrrHs rrzBPoly.derivatives; 66&&s++ + 66B2YY % %]]__I 77BBdfk!m,D Q!#A46""D%++#6t#;r<r`r(rYrrrIrr) rrrrrErFrndeltarIs rrzBPoly.antiderivatives. 77??B3'' ' 66B2YY ) )&&((Ivtv1 GAJ Z1,AG < < <k!!,,,q0122s7 !""#2# eT5;;''16!8*<<== 111abb5 T[AqqqD2223B377  z ) )KK*K""2q+DI"FFFrNc2|}||j}|dkr||_|dkr||krd}n||}}d}|jd|jd}}||z }||z } t| |\} } | ||||z z} |||z |zz}|| z}||kr| ||||z z } n;| ||||z ||| z|z|z z||z z } || zS||||z S)as Compute a definite integral over a piecewise polynomial. Parameters ---------- a : float Lower integration bound b : float Upper integration bound extrapolate : {bool, 'periodic', None}, optional Whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. If None (default), use `self.extrapolate`. Returns ------- array_like Definite integral of the piecewise polynomial over [a, b] Nrr9r6r)rrIrFr) rr{r|rIibrrarrrrrress rrxzBPoly.integrate=sn, " "  *K * $ $(BN * $ $ Avv!1VAYr B"WF1uH$Xv66OItrr"vv2/Ca"f&&ADABwwrr!uurr!uu}$rr"vv1~29q=2+=(>(>>BGG#: 2a5522a55= rc>t|jjd|jd}||j||jjdz |_||||jdz }t|||Sr)rrEr> _raise_degreerr)rrErFrs rrz BPoly.extend|s|  Q , ,##DFA Q,?@@   q!agaj. 1 1  q!,,,rc |dkr|S|jddz }tj|jd|zf|jddz|j}t |jdD]k}||t ||z}t |dzD]=}|||zxx|t ||zt ||z||zz z cc<>l|S)a Raise a degree of a polynomial in the Bernstein basis. Given the coefficients of a polynomial degree `k`, return (the coefficients of) the equivalent polynomial of degree `k+d`. Parameters ---------- c : array_like coefficient array, 1-D d : integer Returns ------- array coefficient array, 1-D array of length `c.shape[0] + d` Notes ----- This uses the fact that a Bernstein polynomial `b_{a, k}` can be identically represented as a linear combination of polynomials of a higher degree `k+d`: .. math:: b_{a, k} = comb(k, a) \sum_{j=0}^{d} b_{a+j, k+d} \ comb(d, j) / comb(k+d, a+j) rr9Nr7)r>r<r`r(rr)rEdrrJr{fjs rr zBPoly._raise_degrees8 66H GAJNj!'!*q.*QWQRR[8HHHqwqz"" D DA!uQ{{"A1q5\\ D DAE a%1++oa!eQU0C0CCC  D rc t|tstdt|zt j|j}|jjddz }d|jj dz z}t j |j}t|dzD]}|j|t|||z z |tdf|z||z zz}t||z |dzD]&} || xx|t| ||z zz cc<'||j}|||j||jS)a Construct a piecewise polynomial in Bernstein basis from a power basis polynomial. Parameters ---------- pp : PPoly A piecewise polynomial in the power basis extrapolate : bool or 'periodic', optional If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. Default is True. z?.from_power_basis only accepts PPoly instances. Got %s instead.rr9r ryN)rrrrr<rrFrEr>rrrrrrIrr) rpprIrHrrrEr{rrs rfrom_power_basiszBPoly.from_power_basissP"e$$ :.04R9:: :Yrt__ DJqMA  ! $ OBD ! !qs / /AT!WuQ!}},r5;;.2E/F1/MMF1Q3!__ / /!q!A#.. /  .K!!!RT;@@@rc tj|}t|tkrtdtj|dd|ddz dkrtdt|dz } t fdt |D}n"#t$r}td|d}~wwxYw|dg|z}nlt|ttj fr|g|z}t |t |}t d|Drtd g}t |D]} | | dz} } || t| t| } } n|| dz}t|d zt| } t|| z t| } t|| z t| } | | z|krHd || t| || dzt| || fz}t|| t| kr| t| kstd t || || dz| d| | d| }t||kr+t||t|z }||tj|}||dd||S) aB Construct a piecewise polynomial in the Bernstein basis, compatible with the specified values and derivatives at breakpoints. Parameters ---------- xi : array_like sorted 1-D array of x-coordinates yi : array_like or list of array_likes ``yi[i][j]`` is the ``j`` th derivative known at ``xi[i]`` orders : None or int or array_like of ints. Default: None. Specifies the degree of local polynomials. If not None, some derivatives are ignored. extrapolate : bool or 'periodic', optional If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. Default is True. Notes ----- If ``k`` derivatives are specified at a breakpoint ``x``, the constructed polynomial is exactly ``k`` times continuously differentiable at ``x``, unless the ``order`` is provided explicitly. In the latter case, the smoothness of the polynomial at the breakpoint is controlled by the ``order``. Deduces the number of derivatives to match at each end from ``order`` and the number of derivatives available. If possible it uses the same number of derivatives from each end; if the number is odd it tries to take the extra one from y2. In any case if not enough derivatives are available at one end or another it draws enough to make up the total from the other end. If the order is too high and not enough derivatives are available, an exception is raised. Examples -------- >>> from cupyx.scipy.interpolate import BPoly >>> BPoly.from_derivatives([0, 1], [[1, 2], [3, 4]]) Creates a polynomial `f(x)` of degree 3, defined on `[0, 1]` such that `f(0) = 1, df/dx(0) = 2, f(1) = 3, df/dx(1) = 4` >>> BPoly.from_derivatives([0, 1, 2], [[0, 1], [0], [2]]) Creates a piecewise polynomial `f(x)`, such that `f(0) = f(1) = 0`, `f(2) = 2`, and `df/dx(0) = 1`. Based on the number of derivatives provided, the order of the local polynomials is 2 on `[0, 1]` and 1 on `[1, 2]`. Notice that no restriction is imposed on the derivatives at ``x = 1`` and ``x = 2``. Indeed, the explicit form of the polynomial is:: f(x) = | x * (1 - x), 0 <= x < 1 | 2 * (x - 1), 1 <= x <= 2 So that f'(1-0) = -1 and f'(1+0) = 2 z&xi and yi need to have the same lengthr9Nrz)x coordinates are not in increasing orderc3tK|]2}t|t|dzzV3dSr9N)rX)riyis r z)BPoly.from_derivatives..s@@@!C1JJR!W-@@@@@@rz0Using a 1-D array for y? Please .reshape(-1, 1).c3"K|] }|dkV dSrr)ros rrz)BPoly.from_derivatives..%s&**a16******rzOrders must be positive.ryzPPoint %g has %d derivatives, point %g has %d derivatives, but order %d requestedz0`order` input incompatible with length y1 or y2.)r<rArXranyrrrrrintegerminr_construct_from_derivativesr rswapaxes)rxirordersrIrrerEry1y2n1n2r mesgr|s ` rfrom_derivativeszBPoly.from_derivativessI~\"   r77c"gg  EFF F 8BqrrFRVOq( ) ) JHII I GGaK @@@@uQxx@@@@@AA   B   >VaZFF&3 "566 & AAs6{{##A**6***** = !;<<< q  AUBqsGBay R#b''B1IaKAs2ww''RR))RR))b5A::J "1s2ww1Q3R&)MMMD%T***c"gg "B--$&9:::11"Q%AaC24SbS'2crc7DDA1vvzz''1s1vv:66 HHQKKKK LOOs1::a##R555s(B;; CCCc tj|tj|}}|jdd|jddkr-td|j|j|j|j}}tj|tjstj|tjr tj}n tj }t|t|}}||z} tj ||zf|jddz|} td|D]r} || tj| | z | z ||z | zz| | <td| D]2} | | xxd| | zzt| | z| | zzcc<3std|D]} || tj| | z | z d| zz||z | zz| | dz <td| D]=} | | dz xxd| dzzt| | dzz| | | zzzcc<>| S)aR Compute the coefficients of a polynomial in the Bernstein basis given the values and derivatives at the edges. Return the coefficients of a polynomial in the Bernstein basis defined on ``[xa, xb]`` and having the values and derivatives at the endpoints `xa` and `xb` as specified by `ya`` and `yb`. The polynomial constructed is of the minimal possible degree, i.e., if the lengths of `ya` and `yb` are `na` and `nb`, the degree of the polynomial is ``na + nb - 1``. Parameters ---------- xa : float Left-hand end point of the interval xb : float Right-hand end point of the interval ya : array_like Derivatives at `xa`. `ya[0]` is the value of the function, and `ya[i]` for ``i > 0`` is the value of the ``i``th derivative. yb : array_like Derivatives at `xb`. Returns ------- array coefficient array of a polynomial having specified derivatives Notes ----- This uses several facts from life of Bernstein basis functions. First of all, .. math:: b'_{a, n} = n (b_{a-1, n-1} - b_{a, n-1}) If B(x) is a linear combination of the form .. math:: B(x) = \sum_{a=0}^{n} c_a b_{a, n}, then :math: B'(x) = n \sum_{a=0}^{n-1} (c_{a+1} - c_{a}) b_{a, n-1}. Iterating the latter one, one finds for the q-th derivative .. math:: B^{q}(x) = n!/(n-q)! \sum_{a=0}^{n-q} Q_a b_{a, n-q}, with .. math:: Q_a = \sum_{j=0}^{q} (-)^{j+q} comb(q, j) c_{j+a} This way, only `a=0` contributes to :math: `B^{q}(x = xa)`, and `c_q` are found one by one by iterating `q = 0, ..., na`. At ``x = xb`` it's the same with ``a = n - q``. r9Nz*Shapes of ya {} and yb {} are incompatibler7rr6)r<rAr>rrr(rrrrzrXr=rrrr) xaxbyaybdtadtbdtnanbr rEqrs rr z!BPoly._construct_from_derivativesEs\pb!!4<#3#3B 8ABB<28ABB< ' 'I$fRXrx88:: :8RXS OC!5 6 6 T%9:: BBBR#b''B G J2x"(122,.b 9 9 9q" 9 9Aa549QUA..."r'A=AaD1a[[ 9 9!qs eAqkk1AaD88 9q" A AAediAq111R!G;rBwlJAqbdG1a[[ A A1"Q$B!A#;q!A#6A2a4@@ Arrsr NN)rrrrrrrrxrr staticmethodr rrr*r rrrrrysIIV3332L2L2L2Lh8G8G8G8Gt=!=!=!=!~---  &.FN%%\%N A A A[ ADt6t6t6[t6lUU\UUUrrcneZdZdZddZeddZdZdZddZ dZ d Z d Z d Z dd Zdd ZdS)NdPPolya Piecewise tensor product polynomial The value at point ``xp = (x', y', z', ...)`` is evaluated by first computing the interval indices `i` such that:: x[0][i[0]] <= x' < x[0][i[0]+1] x[1][i[1]] <= y' < x[1][i[1]+1] ... and then computing:: S = sum(c[k0-m0-1,...,kn-mn-1,i[0],...,i[n]] * (xp[0] - x[0][i[0]])**m0 * ... * (xp[n] - x[n][i[n]])**mn for m0 in range(k[0]+1) ... for mn in range(k[n]+1)) where ``k[j]`` is the degree of the polynomial in dimension j. This representation is the piecewise multivariate power basis. Parameters ---------- c : ndarray, shape (k0, ..., kn, m0, ..., mn, ...) Polynomial coefficients, with polynomial order `kj` and `mj+1` intervals for each dimension `j`. x : ndim-tuple of ndarrays, shapes (mj+1,) Polynomial breakpoints for each dimension. These must be sorted in increasing order. extrapolate : bool, optional Whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. Default: True. Attributes ---------- x : tuple of ndarrays Breakpoints. c : ndarray Coefficients of the polynomials. See also -------- PPoly : piecewise polynomials in 1D Notes ----- High-order polynomials in the power basis can be numerically unstable. Nc (td|D|_tj||_|d}t ||_t|j}td|jDrtdtd|jDrtd|j d|zkrtdtd |jDrtd td t|j |d|z|jDrtd | |jj}tj|j| |_dS)Nc3VK|]$}tj|tjV%dS)r7N)r<rrzrvs rrz#NdPPoly.__init__..sO//'(- T\###//////rTc3,K|]}|jdkVdSr)rr<s rrz#NdPPoly.__init__..s(++qqv{++++++rz"x arrays must all be 1-dimensionalc3,K|]}|jdkVdS)ryNrTr<s rrz#NdPPoly.__init__..s(**aqvz******rz+x arrays must all contain at least 2 pointsryz(c must have at least 2*len(x) dimensionsc3lK|]/}tj|dd|ddz dkV0dS)r9Nr6r)r<rr<s rrz#NdPPoly.__init__..sE<<tx!""#2#*++<<<<<.s0MM41aqAFQJMMMMMMrz/x and c do not agree on the number of intervalsr7)rrFr<rArErrIrXrrrzipr>rr(r)rrErFrIrr(s rrzNdPPoly.__init__s//,-/////a  K ,,46{{ ++DF+++ + + CABB B **46*** * * LJKK K 6AdF??GHH H <r<rrrzr`r?rArrrrrrEr=r(rrp) rrFrrIrrdim1dim2dim3rbrJs rrzNdPPoly.__call__ s8  *KK{++K46{{ $Q ' ''  "199R#=#=)- 7 7 7 :TG4:666BBb 333Bw!||rx{d22 !IJJJ2746<.//002746<QtV 455662746<$01122 \$&,uu-TZ @ @ @j!'!*d+46<@@@ !!### FNN4t , ,dfb!R   s $ $ ${{73B3<$&,qvww*??@@@rcp|dkr|| |St|j}||z}|dkrdStdg|z}td| d||<|jt |}|j|dkr4t|j}d||<tj ||j }tj tj |j|dd|}dg|jz}td||<||t |z}||_dS)zz Compute 1-D derivative along a selected dimension in-place May result to non-contiguous c array. rNr9r7r6)_antiderivative_inplacerXrFrrErr>rr<r`r(rrr\r)rrrrslrnshprs r_derivative_inplacezNdPPoly._derivative_inplaceFs' 66//T:: :46{{d{ 77 F++t#BTB3--BtHb "B 8D>Q  rx..CCICrx000B4;rx~q"==rBBVbg ;;4 fU2YYrcz|dkr|| |St|j}||z}tt |}|||dc|d<||<|tt ||jjz}|j|}tj |j d|zf|j ddz|j }||d| <tj tj|j ddd|}|d| xx|tdfd|jdz zzzcc<tt |j}|||z|dc|d<|||z<||}|}t#||j d|j dd|j||dz ||}||}||_dS)zu Compute 1-D antiderivative along a selected dimension May result to non-contiguous c array. rr9Nr7r6r )rNrXrFrrrErrr<r`r>r(rrr\rr_rvr) rrrrpermrErnrperm2s rrKzNdPPoly._antiderivative_inplacehs 77++RC66 646{{d{E$KK  "4j$q'Qdd5tv{33444 F  T " " Zb*QWQRR[8g'''4RC44;qwqz1b992>> 4RC4FE$KK>GQVAX,>>??U27^^$$%*49%5uQx"a%T " \\%  WWYY JJrx{BHQK 4 4dfTlBF L L L\\%  \\$  rc||j|j|j}t |D]\}}|||||S)a# Construct a new piecewise polynomial representing the derivative. Parameters ---------- nu : ndim-tuple of int Order of derivatives to evaluate for each dimension. If negative, the antiderivative is returned. Returns ------- pp : NdPPoly Piecewise polynomial of orders (k[0] - nu[0], ..., k[n] - nu[n]) representing the derivative of this polynomial. Notes ----- Derivatives are evaluated piecewise for each polynomial segment, even if the polynomial is not differentiable at the breakpoints. The polynomial intervals in each dimension are considered half-open, ``[a, b)``, except for the last interval which is closed ``[a, b]``. )rrEr_rFrI enumeraterNrrrrrr s rrzNdPPoly.derivativess0    tvt7G H H }} + +GD! ! !!T * * * *    rc||j|j|j}t |D]\}}|||||S)a Construct a new piecewise polynomial representing the antiderivative. Antiderivative is also the indefinite integral of the function, and derivative is its inverse operation. Parameters ---------- nu : ndim-tuple of int Order of derivatives to evaluate for each dimension. If negative, the derivative is returned. Returns ------- pp : PPoly Piecewise polynomial of order k2 = k + n representing the antiderivative of this polynomial. Notes ----- The antiderivative returned by this function is continuous and continuously differentiable to order n-1, up to floating point rounding error. )rrEr_rFrIrSrKrrTs rrzNdPPoly.antiderivativess0    tvt7G H H }} / /GD! % %a . . . .    rcl||j}nt|}t|j}t ||z}|j}t t|j}| d||||dz=| d|||z|||zdz=| |}t | |jd|jdd|j||}||||} |dkr"| |jddS| |jdd}|jd||j|dzdz} | || |S)a Compute NdPPoly representation for one dimensional definite integral The result is a piecewise polynomial representing the integral: .. math:: p(y, z, ...) = \int_a^b dx\, p(x, y, z, ...) where the dimension integrated over is specified with the `axis` parameter. Parameters ---------- a, b : float Lower and upper bound for integration. axis : int Dimension over which to compute the 1-D integrals extrapolate : bool, optional Whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. Returns ------- ig : NdPPoly or array-like Definite integral of the piecewise polynomial over [a, b]. If the polynomial was 1D, an array is returned, otherwise, an NdPPoly object. Nrr9r6rry)rIrrXrFrrErrrinsertrrrrr>rx) rr{r|rrIrrEswaprrJrFs r integrate_1dzNdPPoly.integrate_1ds8  *KK{++K46{{4yy4 FE!&MM"" AtDz""" N AtD4K())) q ! KK    171:qwqz2!F!F!%-8 ! : :kk!QKk88 199;;qwqrr{++ + AGABBK((Auu tAvww/A&&q!&EE Erct|j}||j}nt|}t |drt||krt d||j}t|D]\}\}}tt|j }| d|||z |||z dz=| |}t||j||} | |||} | |jdd}|S)ap Compute a definite integral over a piecewise polynomial. Parameters ---------- ranges : ndim-tuple of 2-tuples float Sequence of lower and upper bounds for each dimension, ``[(a[0], b[0]), ..., (a[ndim-1], b[ndim-1])]`` extrapolate : bool, optional Whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. Returns ------- ig : array_like Definite integral of the piecewise polynomial over [a[0], b[0]] x ... x [a[ndim-1], b[ndim-1]] N__len__z&Range not a sequence of correct lengthr9rry)rXrFrIrhasattrrrrErSrrrrWrrrrxrr>) rrangesrIrrEr r{r|rXrrJs rrxzNdPPoly.integrate sE(46{{  *KK{++Kvy)) GS[[D-@-@EFF F !!### F"6** ) )IAv1af &&D KK4q> * * *TAX\" D!!A$$Qq {$KKA++a +<rks* ++++++''''''@@@@@@@@P EEPPPPPPPPP  ,- K ]~!$. /%'DFGGG H Tt~ ;;U;;;>>>>> ?????? @ ;:E::: ;=== G Rt~ ;;U;;;>>> )%)%)%XF'F'F'REEE4/!/!/!d.2.2.2b,ZZZZZZZZzlAlAlAlAlAJlAlAlA^ bbbbbJbbbJYYYYYYYYYYs 1<<