Function

The function module defines the Evaluable class and derived objects, commonly referred to as nutils functions. They represent mappings from a nutils.topology onto Python space. The notabe class of ArrayFunc objects map onto the space of Numpy arrays of predefined dimension and shape. Most functions used in nutils applicatons are of this latter type, including the geometry and function bases for analysis.

Nutils functions are essentially postponed python functions, stored in a tree structure of input/output dependencies. Many ArrayFunc objects have directly recognizable numpy equivalents, such as Sin or Inverse. By not evaluating directly but merely stacking operations, coplex operations can be defined prior to entering a quadrature loop, allowing for a higher lever style programming. It also allows for automatic differentiation and code optimization.

It is important to realize that nutils functions do not map for a physical xy-domain but from a topology, where a point is characterized by the combination of an element and its local coordinate. This is a natural fit for typical finite element operations such as quadrature. Evaluation from physical coordinates is possible only via inverting of the geometry function, which is a fundamentally expensive and currently unsupported operation.

class nutils.function.Evaluable(args, evalf)

Base class

recurse_index(data, operations, cbuild)

compile

compile()

graphviz(title='graphviz')

create function graph

stackstr(values=None)

print stack

asciitree()

string representation

exception nutils.function.EvaluationError(etype, evalue, evaluable, values)

evaluation error

class nutils.function.Tuple(items)

combine

static vartuple(*f)

evaluate

class nutils.function.PointShape

shape of integration points

static pointshape(points)

evaluate

class nutils.function.Cascade(ndims, side=0)

point cascade: list of (elem,points) tuples

static cascade(elem, points, ndims, side)

evaluate

class nutils.function.ArrayFunc(evalf, args, shape, dtype=<type 'float'>)

array function

vector(ndims)

vectorize

dot(weights, axis=0)

array contraction

find(elem, C)

iteratively find x for f(x) = target, starting at x=start

normalized()

normalize last axis

normal(ndims=-1)

curvature(ndims=-1)

swapaxes(n1, n2)

swap axes

transpose(trans=None)

grad(coords, ndims=0)

gradient

laplace(coords, ndims=0)

laplacian

add_T(axes=(-2, -1))

add transposed

symgrad(coords, ndims=0)

gradient

div(coords, ndims=0)

gradient

dotnorm(coords, ndims=0)

normal component

ngrad(coords, ndims=0)

normal gradient

nsymgrad(coords, ndims=0)

normal gradient

T

transpose

class nutils.function.ElemArea(weights)

element area

static elemarea(weights)

evaluate

class nutils.function.ElemInt(func, weights)

elementwise integration

static elemint(w, f, ndim)

evaluate

class nutils.function.Align(func, axes, ndim)

align axes

static align(arr, trans, ndim)

class nutils.function.Get(func, axis, item)

get

class nutils.function.Product(func, axis)

product

class nutils.function.IWeights

integration weights

static iweights(elem, weights)

evaluate

class nutils.function.OrientationHack(side=0)

orientation hack for 1d elements; VERY dirty

static orientation(elem, side)

evaluate

class nutils.function.Transform(fromcascade, tocascade, side=0)

transform

static transform(fromcascade, tocascade, side)

class nutils.function.Function(cascade, stdmap, igrad, axis)

function

static function(cascade, stdmap, igrad)

evaluate

class nutils.function.Choose(level, choices)

piecewise function

static choose(level, *choices)

class nutils.function.Choose2D(coords, contour, fin, fout)

piecewise function

static choose2d(xy, contour, fin, fout)

evaluate

class nutils.function.Inverse(func)

inverse

class nutils.function.DofMap(cascade, dofmap, axis)

dof axis

static evalmap(cascade, dofmap)

evaluate

class nutils.function.Concatenate(funcs, axis=0)

concatenate

static concatenate(iax, *arrays)

evaluate

class nutils.function.Interpolate(x, xp, fp, left=None, right=None)

interpolate uniformly spaced data; stepwise for now

class nutils.function.Cross(func1, func2, axis)

cross product

class nutils.function.Determinant(func)

normal

class nutils.function.DofIndex(array, iax, index)

element-based indexing

static dofindex(arr, *item)

evaluate

class nutils.function.Multiply(func1, func2)

multiply

cdef()

generate C code

class nutils.function.Negative(func)

negate

class nutils.function.Add(func1, func2)

add

cdef()

generate C code

class nutils.function.BlockAdd(func1, func2)

block addition (used for DG)

class nutils.function.Dot(func1, func2, naxes)

dot

cdef()

generate C code

class nutils.function.Sum(func, axis)

sum

class nutils.function.Debug(func)

debug

static debug(arr)

class nutils.function.TakeDiag(func)

extract diagonal

class nutils.function.Take(func, indices, axis)

generalization of numpy.take(), to accept lists, slices, arrays

class nutils.function.Power(func, power)

power

class nutils.function.ElemFunc(domainelem, side=0)

trivial func

static elemfunc(cascade, domainelem)

evaluate

find(elem, C)

find coordinates

class nutils.function.Pointwise(args, evalf, deriv)

pointwise transformation

class nutils.function.Sign(func)

sign

class nutils.function.Eig(func, symmetric=False, sort=False)

Eig

class nutils.function.Zeros(shape)

zero

static zeros(points, shape)

prepend point axes

class nutils.function.Inflate(func, dofmap, length, axis)

inflate

static inflate(array, indices, length, axis)

class nutils.function.Diagonalize(func)

diagonal matrix

class nutils.function.Repeat(func, length, axis)

repeat singleton axis

class nutils.function.Const(func)

pointwise transformation

static const(points, arr)

prepend point axes

nutils.function.asarray(arg)

convert to ArrayFunc or numpy.ndarray

nutils.function.insert(arg, n)

insert axis

nutils.function.stack(args, axis=0)

stack functions along new axis

nutils.function.chain(funcs)

nutils.function.merge(funcs)

Combines unchained funcs into one function object.

nutils.function.vectorize(args)

nutils.function.expand(arg, shape)

nutils.function.repeat(arg, length, axis)

nutils.function.get(arg, iax, item)

get item

nutils.function.align(arg, axes, ndim)

nutils.function.bringforward(arg, axis)

bring axis forward

nutils.function.elemint(arg, weights)

elementwise integration

nutils.function.grad(arg, coords, ndims=0)

local derivative

nutils.function.symgrad(arg, coords, ndims=0)

symmetric gradient

nutils.function.div(arg, coords, ndims=0)

gradient

nutils.function.sum(arg, axes=-1)

sum over multiply axes

nutils.function.dot(arg1, arg2, axes)

dot product

nutils.function.determinant(arg, axes=(-2, -1))

nutils.function.inverse(arg, axes=(-2, -1))

nutils.function.takediag(arg, ax1=-2, ax2=-1)

nutils.function.localgradient(arg, ndims)

local derivative

nutils.function.dotnorm(arg, coords, ndims=0)

normal component

nutils.function.kronecker(arg, axis, length, pos)

nutils.function.diagonalize(arg)

nutils.function.concatenate(args, axis=0)

nutils.function.transpose(arg, trans=None)

nutils.function.product(arg, axis)

nutils.function.choose(level, choices)

nutils.function.cross(arg1, arg2, axis)

cross product

nutils.function.outer(arg1, arg2=None, axis=0)

outer product

nutils.function.pointwise(args, evalf, deriv)

general pointwise operation

nutils.function.multiply(arg1, arg2)

nutils.function.add(arg1, arg2)

nutils.function.negative(arg)

make negative

nutils.function.power(arg, n)

nutils.function.sign(arg)

nutils.function.eig( arg, axes [ symmetric ] )

Compute the eigenvalues and vectors of a matrix. The eigenvalues and vectors are positioned on the last axes.

• tuple axes The axis on which the eigenvalues and vectors are calculated
• bool symmetric Is the matrix symmetric
• int sort Sort the eigenvalues and vectors (-1=descending, 0=unsorted, 1=ascending)

nutils.function.swapaxes(arg, axes=(-2, -1))

swap axes

nutils.function.opposite(arg)

evaluate jump over interface

nutils.function.function(fmap, nmap, ndofs, ndims)

create function on ndims-element

nutils.function.take(arg, index, axis)

take index

nutils.function.inflate(arg, dofmap, length, axis)

nutils.function.pointdata(topo, ischeme, func=None, shape=None, value=None)

point data

nutils.function.fdapprox(func, w, dofs, delta=1e-05)

Finite difference approximation of the variation of func in directions w around dofs. Input arguments: * func, the functional to differentiate * dofs, DOF vector of linearization point * w, the function space or a tuple of chained spaces * delta, finite difference step scaling of ||dofs||_inf

nutils.function.iwscale(coords, ndims)

integration weights scale

nutils.function.supp(funcsp, indices)

find support of selection of basis functions

class nutils.function.CBuilder(cachedir='/tmp/nutils')

cbuilder