out = dot(x,y)

Same as NumPy dot but in UTP arithmetic

Apply a global push forward of the computational procedure defined by the computational graph saved in this CGraph instance.

generic implementation of numpy.zeros

this method is equivalent to `clone`. It's there to allow generic programming because ndarrays do not have the clone method.

Extract a diagonal or construct diagonal UTPM instance

initializes this UTPM instance to compute the Jacobian, it is possible to force the dtype to a certain dtype, if no dtype is provide

computes y = exp(x) in UTP arithmetic

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

Apply the pullback of the cotangent element, e.g. for:: y = y(x) compute:: ybar dy(x) = xbar dx

Returns a new UTPM instance with the same data. `clone` is opposed to `copy` or `deepcopy` by calling the __init__ function.

generic sum function calls either numpy.sum or Function.sum resp. UTPM.sum depending on the input

computes y = log(x) in UTP arithmetic

computes the gradient of a function f: R^N --> R g = gradient(self, x_list) Parameters ---------- x: array_like or

computes the Jacobian of a function F:R^N --> R^M in the reverse mode J = self.jacobian(x) If x is a UTPM instance, the Taylor seri

z = dot(x,y)

Permute the dimensions of UTPM data

z += x*y

solves for y in: A y = x

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

accepted filenames, e.g.: filename = 'myfolder/mypic.png' 'mypic.svg' etc. accepted methods

computes y = sign(x) in UTP arithmetic

extracts the Hessian of shape (N,N) from the UTPM instance y

computes the Jacobian-vector product J*v of a function F:R^N --> R^M in the forward mode Jv = self.jac_vec(x, v) Parameters

Sample an ndarray of random normal variables. @param utpm_shape: an array shape @return: a random UTPM object

Constants are only added to the d=0 slice of the data array. A function like this is not so useful for multiplication by a constant, beca

computes the eigenvalue decomposition A = Q^T L Q of a symmetrical matrix A with distinct eigenvalues (l,Q) = UTPM.eigh(A, o

initializes this UTPM instance to compute the Hessian

out = outer(x,y)

computes the inverse of A by STEP 1: QR decomposition STEP 2: Solution of the extended linear system:: (Q R | I) =

rhs of the ODE

accepted filenames, e.g.: filename = 'myfolder/mypic.png' 'mypic.svg' etc. accepted methods

peform the operation fun(x,y) where fun = operator.iadd, operator.imul, operator.setitem, etc. workaround for the bug

UTPM equivalent of numpy.broadcast_arrays

z = x*x This can theoretically be twice as efficient as mul(x, x).

this is the UTPM equivalent to numpy.broadcast_arrays

computes y = sign(x) in UTP arithmetic

QR decomposition of A Q,R = qr(A)

Extract a diagonal or construct diagonal UTPM data

computes y = square(x) in UTP arithmetic

generic sum function calls either numpy.sum or Function.sum resp. UTPM.sum depending on the input

computes y = reciprocal(x) in UTP arithmetic

tries to convert x to an object of the class

human readable representation of the UTPS object for printing >>print UTPS([1,2,3])

z = 1/y

computes y = cosh(x) in UTP arithmetic