Public API Reference

Return the matrix A in the affine map Ax+b.

Return the vector b in the affine map Ax+b.

canonicalmap([ctype::CanonicalType, ]map)

Return an associated canonical map, if any, of the given map.

Optionally, a canonical type argument may specify an alternative canonical map. Canonical maps help with converting between equal maps of different types.

codomaintype(m[, T])

What is the type of a point in the codomain of the function map m?

The second argument optionally specifies a domain type T.

diffvolume(m[, x])

Compute the differential volume (at a point x). If J is the Jacobian matrix, possibly rectangular, then the differential volume is sqrt(det(J'*J)).

If the map is square, then the differential volume is the absolute value of the Jacobian determinant.

domaintype(m)

What is the expected type of a point in the domain of the function map m?

Factor I... of a product-like composite object.

Factors of a product-like composite object (equivalent to components(d)).

inverse(m[, x])

Return the inverse of m. The two-argument function evaluates the inverse at the point x.

isaffinemap(m)

Is m an affine map?

If m is affine, then it has the form m(x) = A*x+b.

See also: affinematrix, affinevector.

isequalmap(map1, map2)

Are the two given maps equal?

islinearmap(m)

Is m a linear map?

isrealmap(m)

Is the map real-valued?

A map is real-valued if both its domain and codomain types are real.

jacdet(m[, x])

Return the determinant of the jacobian as a map. The two-argument version evaluates the jacobian determinant at a point x.

jacobian(m[, x])

Return the jacobian map. The two-argument version evaluates the jacobian at a point x.

leftinverse(m[, x])

Return a left inverse of the given map. This left inverse mli is not unique, but in any case it is such that (mli ∘ m) * x = x for each x in the domain of m.

The two-argument function applies the left inverse to the point x.

mapsize(m[, i])

The size of a vectorvalued map is the size of its jacobian matrix.

A map with size (3,5) maps vectors of length 5 to vectors of length 3. Its jacobian matrix is a 3-by-5 matrix.

Optionally, similar to the size function, a second argument i can be provided. Choose i to be 1 or 2 to return only the corresponding element of the size. The dimension of the domain type is mapsize(m, 2), while that of the codomain type is mapsize(m, 1).

If a map is scalar valued, its mapsize equals (). This reflects the convention in Julia that the size of a number is an empty tuple: size(5) == (). If a map is scalar-to-vector, its mapsize is the tuple (m,) of length one. In this case the jacobian is a vector with size (m,). If a map is vector-to-scalar, its mapsize is (1,n).

Thus, in all cases of scalarvalued and vectorvalued maps, the mapsize of a map agrees with the size of the Jacobian matrix.

The number of factors of a product-like composite object.

The numeric element type of x in a Euclidean space.

prectype(x[, ...])

The floating point precision type associated with the argument(s).

rightinverse(m[, x])

Return a right inverse of the given map. This right inverse mri is not unique, but in any case it is such that (m ∘ mri) * y = y for each y in the range of m.

The two-argument function applies the right inverse to the point x.

AffineMap{T} <: AbstractAffineMap{T}

The supertype of all affine maps that store `A` and `b`.

Concrete subtypes differ in how A and b are represented.

AffineMap(A, b)

Return an affine map with an appropriate concrete type depending on the arguments A and b.

Examples

julia> AffineMap(2, 3)
x -> 2 * x + 3

The supertype of constant maps from T to U.

Supertype of identity maps.

LinearMap{T} <: AbstractAffineMap{T}

The supertype of all linear maps y = A*x.

Concrete subtypes may differ in how A is represented.

A Map{T} is a map of a single variable of type T.

MapRef(m)

A reference to a map.

In a function call, MapRef(x) can be used to indicate that x should be treated as a map, e.g., foo(x, MapRef(m)).

A product map is diagonal and acts on each of the components of x separately: y = f(x) becomes y_i = f_i(x_i).

A Translation represents the map y = x + b.

The unity map f(x) = 1.

The zero map f(x) = 0.