implicit function to solve: 0 = F(x_new, x, t_new, t_old)

Combines several directional derivatives and combines them to a transposed Jacobian JT, i.e. x.data.shape = (D,P,shp) y = x.F

z = |x|

computes dyadic product and adds it to out out += x y^T

z = -x

computes sin and cos in Taylor arithmetic

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

computes y = hyp2f0(a1, a2, x) in UTP arithmetic

computes the eigenvalue decomposition Q^-1 A Q = L of a diagonalizable matrix A with distinct eigenvalues (l,Q) = UTPM.eig(A

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

computes y = erf(x) in UTP arithmetic

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

@param theta: length six unconstrained vector of free variables

compute the gradient of f in the forward mode of AD

compute the hessian of f in the forward mode of AD

Compute expm(t*S) using AlgoPy default expm. t: truncated univariate Taylor polynomial S: symmetric numpy matrix

Compute expm(t*S) using AlgoPy eigendecomposition and an identity. t: truncated univariate Taylor polynomial S: symmetric numpy matrix

Compute expm(t*S) using LAPACK eigendecomposition and an identity. t: truncated univariate Taylor polynomial S: symmetric numpy matrix

extracts the Jacobian vector product from a UTPM instance if x.ndim == 1 it is equivalent to the gradient

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

generate_multi_indices(N,deg) Create a 2D array of all possible multi-indices i with |i| = deg and :math:`i in N_0^N`. Parameters -

computes the Hessian vector product dot(H,v) Hv = self.hess_vec(x, v) Parameters ---------- x: array_like

initializes this UTPM instance to compute the Jacobian vector product J v, it is possible to force the dtype to a certain dtype, if

compute logdet using algopy.lu2 as described in http://www.mathworks.com/matlabcentral/fileexchange/22026-safe-computation-of-logarit

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

This is changed because scipy.special.polygamma does not have 'out'.

Extract a diagonal or construct diagonal UTPM instance

generic implementation of y = polygamma(n, x) x: either a * float * numpy.ndarray * algopy.UT

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

Arbitrary-dimensional Rosenbrock function for testing.

Sample an ndarray of random normal variables then push them away from zero. @param utpm_shape: an array shape @param eps: push the random

Sample an ndarray between -1 and 1. @param utpm_shape: an array shape @param eps: push the random numbers this far away from 0 and 1

computes d^D/dt^D ( [X]_D [Y]_D [Z]_D) with t set to zero after differentiation X,Y,Z are (DT,P,N,M) arrays s.t. the dimensions match to com

computes the hessian of dot(w, F(x)), where F:R^N ---> R^M wH = self.vec_hess(w, x) Parameters ---------- w: array

inverse operation of FtoJT x.data.shape = (D,1, P,shp) y = x.JTtoF() y.data.shape = (D+1, P, shp)

computes the Jacobian of F_fcn all inputs are double arrays

prototypical OED objective function

absolute value of polynomials FIXME: theory tells us to check first coefficient if the zero'th coefficient is zero

computes the solution of the relaxed problem of order 1 L,Q = eig(A) for symmetric matrix A with possibly repeated eigenval

computes y = inv(x)

y = x**r, where r is scalar

computation of qr(A) where A.shape(M,N) with M >= N this function is called by the more general function _qr

assumes that A.shape = M,N with M >= N

computes tan and sec in Taylor arithmetic

tries to convert a container (e.g. list or numpy.array) with UTPM elements as instances to a UTPM instance

Creates a new function node. INPUTS: x anything current value args

Use numerical integration. This is not so compatible with algopy because it goes through fortran. Note that d = 2*h - 1 following Kimura

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

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

some function

Note that Y is last for compatibility with functools.partial. It is convenient for usage with numdifftools, although this parameter order

some vector-valued function

compute the gradient of f in the forward mode of AD

compute the gradient of f in the forward mode of AD