FunctionMaps.jl

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 codomain type of the function map m, given that T is its domain type?

convert_numtype(T, x)

Convert x such that its numtype equals T.

convert_prectype(T, x)

Convert x such that its prectype equals 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?

inverse(m[, x])

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

isequalmap(map1, map2)

Are the two given maps equal?

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.

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.

The supertype of all affine maps that store A and b. Concrete subtypes differ in how A and b are represented.

The supertype of constant maps from T to U.

Supertype of identity maps.

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)).

The identity map for variables of type T.

A Translation represents the map y = x + b.

The unity map f(x) = 1.

The zero map f(x) = 0.

AnyMap is the union of Map and MapRef.

In both cases map(m::AnyMap) returns the map itself.

Compute the affine map that represents map2 after map1, that is: y = a2*(a1*x+b1)+b2 = a2*a1*x + a2*b1 + b2.

Like interval_map, but guaranteed to return a scalar affine map.

Return the extension type associated with the given object.

checkmap(m)

Checks that m is a map or refers to a map and if so returns that map, throws an error otherwise.

convert_eltype(T, x)

Convert x such that its eltype equals T.

Convert a vector from a cartesian format to a nested tuple according to the given dimensions.

For example: convert_fromcartesian([1,2,3,4,5], Val{(2,2,1)}()) -> ([1,2],[3,4],5)

The inverse function of convert_fromcartesian.

What is the euclidean dimension of the given type (if applicable)?

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

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

functionmap(m)

Return a map associated with the object m.

What is the suggested domaintype for a generic linear map A*x with the given argument 'A'?

Does the map have a canonical map?

Apply the hash function recursively to the given arguments.

Return an identity matrix with the same size as the map.

Map the interval [a,b] to the interval [c,d].

This function deals with infinite intervals, and the type of the map returned may depend on the value (finiteness) of the given endpoints.

Is the given map a square map?

Is the map a vector-valued function, i.e., a function from Rn to Rm?

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

Are the given element types promotable to a concrete supertype?

Can the maps be promoted to a common domain type without throwing an error?

Promote map and point to compatible types.

Promote the given maps to have a common domain type.

promote_numtype(a, b[, ...])

Promote the numeric types of the arguments to a joined supertype.

promote_prectype(a, b[, ...])

Promote the precision types of the arguments to a joined supertype.

simplifies(m)

Does the map simplify?

simplify(m)

Simplify the given map to an equal map.

to_matrix(::Type{T}, A[, b])

Convert the A in the affine map A*x or A*x+b with domaintype T to a matrix.

to_numtype(U, T)

Return the type to which T can be converted, such that the numtype becomes U.

to_prectype(U, T)

Return the type to which T can be converted, such that the prectype becomes U.

to_vector(::Type{T}, A[, b])

Convert the b in the affine map A*x or A*x+b with domaintype T to a vector.

Convert the given map to a map defined in FunctionMaps.jl.

Return a zero matrix of the same size as the map.

Return a zero vector of the same size as the codomain of the map.

An AbsMap returns the absolute value of the result of a given map.

An affine map has the general form y = A*x + b.

We use affinematrix(m) and affinevector(m) to denote A and b respectively. Concrete subtypes include linear maps of the form y = A*x and translations of the form y = x + b.

An AbstractMap represents a function y=f(x) of a single variable.

AngleMap is a left inverse of UnitCircleMap. A 2D vector x is projected onto the intersection point with the unit circle of the line connecting x to the origin. The angle of this point, scaled to the interval [0,1), is the result.

CanonicalExtensionType <: CanonicalType

Canonical types used to translate between packages.

Supertype of different kinds of canonical objects.

A Cartesion to Polar map. First dimension is interpreted as radial distance, second as an angle. The unit circle is mapped to the square [-1,1]x[-1,1].

ComplexToVector()
ComplexToVector{T}()

Map a complex number $a+bi$ to the length 2 vector $[a; b]$.

See also: VectorToComplex.

The composition of several maps.

A composite lazy map is defined in terms of several other maps.

A DerivedMap inherits all of its properties from another map, but has its own type.

A DeterminantMap returns the determinant of the result of a given map.

Identity map with dynamic size determined by a dimension field.

Equal <: CanonicalType

A canonical object that is equal but simpler.

Equivalent <: CanonicalType

A canonical object that is equivalent but may have different type.

The constant map f(x) = c.

Map a flattened vector to a nested one.

An affine map for any combination of types of A and b.

A GenericLinearMap is a linear map y = A*x for any type of A.

Translation by a generic vectorlike object.

IsMap()

indicates an object implements the map interface.

Isomorphism{T,U} <: TypedMap{T,U}

An isomorphism is a bijection between types that preserves norms.

A lazy volume element evaluates to diffvolume(m, x) on the fly.

A lazy inverse stores a map m and returns inverse(m, x).

A lazy Jacobian J stores a map m and returns J(x) = jacobian(m, x).

A lazy map has an action that is defined in terms of other maps. Those maps are stored internally, and the action of the lazy map is computed on-the-fly and only when invoked.

MapStyle(m)

Trait to indicate whether or not m implements the map interface.

The lazy multiplication of one or more maps.

Map a nested vector or tuple to a flat vector.

NotMap()

indicates an object does not implement the Map interface.

NumberToVector()
NumberToVector{T}()

Map a number x to the length 1 vector [x].

See also: VectorToNumber.

A Polar to Cartesian map. The angle is mapped to the second dimension, radius to the first. The square [-1,1]x[-1,1] is mapped to the unit circle.

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).

An affine map with scalar representation.

A ScalarLinearMap is a linear map y = A*x for scalars.

Translation by a scalar value.

A simple lazy map derives from a single other map.

An affine map with representation using static arrays.

A StaticLinearMap is a linear map y = A*x using static arrays.

Translation by a static vector.

The lazy sum of one or more maps.

A TupleProductMap is a product map with all components collected in a tuple. There is no vector-valued function associated with this map.

Map a tuple to a static vector.

A TypedMap{T,U} maps a variable of type T to a variable of type U.

The map [cos(2πt), sin(2πt)] from [0,1] to the unit circle in ℝ^2.

The map r*[cos(2πt), sin(2πt)] from [0,1]^2 to the unit disk in ℝ^2.

A VcatMap is a product map with domain and codomain vectors concatenated (vcat) into a single vector.

An affine map with array and vector representation.

A VectorLinearMap is a linear map y = A*x using vectors and matrices.

A VectorProductMap is a product map where all components are univariate maps, with inputs and outputs collected into a Vector.

VectorToComplex()
VectorToComplex{T}()

Map a length 2 vector $[a;b]$ to the complex number $a+bi$.

See also: ComplexToVector.

VectorToNumber()
VectorToNumber{T}()

Map a length 1 vector x to the number x[1].

See also: NumberToVector.

Map a static vector to a tuple.

Translation by a vector.

A WrappedMap{T} takes any object and turns it into a Map{T}.