computes y = dawsn(x) in UTP arithmetic

generic implementation of numpy.ones

computes y = polygamma(n, x) in UTP arithmetic

shifting coefficients [x0,x1,x2,x3] s positions e.g. shift([x0,x1,x2,x3], -1) = [x1,x2,x3,0] shift([x0,x1,x2,x3], +1) =

computes the singular value decomposition A = U S V.T of matrices A with full rank (i.e. nonzero singular values) by reformul

z = x*y

z = x/y

B = expm(A) Compute the matrix exponential using a Pade approximation of order 7. Warning ------- A Pade approximation order 7

computes y = expm1(x) in UTP arithmetic

computes y = gammaln(x) in UTP arithmetic

This function harshly glues together f and g at the origin. @param x: independent variable @param f: dominant function when x < 0 @pa

computes y = log1p(x) in UTP arithmetic

computes a binomial coefficient binomial(i,j) where i and j multi-indices Parameters ---------- i: numpy.ndarray array with

computes y = psi(x) in UTP arithmetic

This is a general O(D^2) algorithm for functions that are ODE solutions. It is an attempt to implement Proposition 13.1 of "Evaluating De

computes y = hyperu(a, b, x) in UTP arithmetic

UTPM equivalent to numpy.real

Sample an ndarray of random normal variables then make them positive. @param utpm_shape: an array shape @param eps: push the random numbe

computes y = sinh(x) in UTP arithmetic

The function evaluation is a black box, but the derivative is compound. @param f: computes the scalar function directly @param fprime_dat

This is related to summations associated with the name 'Faa di Bruno.' @param f: f(X, out=None, n=0) computes nth derivative of f at X @p

solves the linear system of equations for y:: A y = x

computes y = arctan(x) in UTP arithmetic

==========================================================================*/

==========================================================================*/

computes y = expit(x) in UTP arithmetic

UTPM equivalent to numpy.fft.fft(a, n=None, axis=-1)

UTPM equivalent to numpy.fft.ifft(a, n=None, axis=-1)

Most numpy functions support an 'out' argument but np.real does not.

computes y = tanh(x) in UTP arithmetic

computes y = absolute(x) in UTP arithmetic

computes y = arccos(x) in UTP arithmetic

computes y = arcsin(x) in UTP arithmetic

computes y = botched_clip(a_min, a_max, x) in UTP arithmetic

some reformulations to make eval_f_orig compatible with algopy missing: support for scipy.linalg.expm i.e., this function c

using algopy.expm

generic implementation of y = expit(x) x: either a * float * numpy.ndarray * algopy.UTPM

This function is a smooth blend between functions f and g. Well it is not so smooth when k is huge; at huge k it approximates the Heavisi

UTPM equivalent to numpy.imag

computes y = logit(x) in UTP arithmetic

This is soft in the sense that nans or infs may leak through. It is softer than hard_piecewise but not as soft as expit_blend. This shoul

maps a symmetric matrix to a vector containing the distinct elements

returns a full symmetric matrix filled the distinct elements of v, filled row-wise

Add documentation to a function.

Takes an x and a seed matrix S and returns an array of adoubles with D Taylor elements S is a NxP matrix, P the number of directions

computes y = hyp1f1(a, b, x) in UTP arithmetic

computes the relaxed eigenvalue decompositin of level 1 of a symmetrical matrix A with distinct eigenvalues (L,Q,b) = UTPM.e

computes y = erfi(x) in UTP arithmetic

some reformulations to make eval_f_orig compatible with algopy replaced scipy.linalg.expm by a symmetric eigenvalue decomposition

reformulation of eval_f(Y) to use eigh instead of expm

computes y = hyp1f1(a, b, x) in UTP arithmetic

univariate Taylor arithmetic of scipy.linalg.lu_factor but returns piv, L, U = lu2(A)

computes y = negative(x) in UTP arithmetic

tries to convert x to an object of the class works for : scalar x, numpy.ndarray x Remark: at t