Internal API Reference

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_domaintype(T, m)

Convert the given map to a map such that its domaintype is T.

See also: domaintype.

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)

convert_numtype(T, x)

Convert x such that its numtype equals T.

convert_prectype(T, x)

Convert x such that its prectype equals T.

The inverse function of convert_fromcartesian.

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

functionmap(m)

Return a map associated with the object m.

The result need not have type Map, but its MapStyle is IsMap.

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?

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

AbstractAffineMap{T} <: Map{T}

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.

See also: affinematrix, affinevector.

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.

ComposedMap{T,MAPS}

The composition of several maps.

The components of a ComposedMap are the maps in the order that they are applied to the input.

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.

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.

The identity map for variables of type T.

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.

Any instance of 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}.