phantom-algebra 1.0 · OCaml Package

type (+'dim, +'rank) t

Tensor core type:

rank is either 2 (for matrix), 1 (for vector) or zero for scalars
dim belongs to {1,2,3,4}.

val pp : Format.formatter -> ('dim, 'rank) t -> unit

Printer function

type +'x scalar = ('a Type_functions.one, 'b Type_functions.z) t constraint 'x = 'a * 'b

Type abreviations

type +'x vec2 = ('a Type_functions.two, 'b Type_functions.one) t constraint 'x = 'a * 'b

type +'x vec3 = ('a Type_functions.three, 'b Type_functions.one) t constraint 'x = 'a * 'b

type +'x vec4 = ('a Type_functions.four, 'b Type_functions.one) t constraint 'x = 'a * 'b

type +'x mat2 = ('a Type_functions.two, 'b Type_functions.two) t constraint 'x = 'a * 'b

type +'x mat3 = ('a Type_functions.three, 'b Type_functions.two) t constraint 'x = 'a * 'b

type +'x mat4 = ('a Type_functions.four, 'b Type_functions.two) t constraint 'x = 'a * 'b

val scalar : k -> _ scalar

Constructors

val (~+) : k -> _ scalar

scalar f build a scalar from the naked scalar type. It can be abbreviated to (+s).

val vec2 : k -> k -> _ vec2

val vec3 : k -> k -> k -> _ vec3

val vec4 : k -> k -> k -> k -> _ vec4

val mat2 : _ vec2 -> _ vec2 -> _ mat2

val mat3 : _ vec3 -> _ vec3 -> _ vec3 -> _ mat3

val mat4 : _ vec4 -> _ vec4 -> _ vec4 -> _ vec4 -> _ mat4

Vector stretching and concatenation

val vec2' : 
  ([< _ Type_functions.one | _ Type_functions.two ],
    [< _ Type_functions.one | _ Type_functions.z ])
    t ->
  _ vec2

vec$n' v extends a vector of dimension d <= n to a vector of dimension n by repeating the last value of the vector

val vec3' : 
  ([< _ Type_functions.one | _ Type_functions.two | _ Type_functions.three ],
    [< _ Type_functions.one | _ Type_functions.z ])
    t ->
  _ vec3

val vec4' : 
  ([< _ Type_functions.one
   | _ Type_functions.two
   | _ Type_functions.three
   | _ Type_functions.four ],
    [< _ Type_functions.one | _ Type_functions.z ])
    t ->
  _ vec4

val (|+|) : 
  (('dim1, 'dim2, 'dim3, _) Type_functions.nat_sum,
    [< _ Type_functions.one | _ Type_functions.z ])
    t ->
  ('dim2, [< _ Type_functions.one | _ Type_functions.z ]) t ->
  ('dim3, _ Type_functions.one) t

Vector concatenation : v |+| w is (v_0, v_1, … , v_{dim-1}, w_0, …, w_{dim-1})

Map functions

val map : (k -> k) -> ('dim, 'rank) t -> ('dim, 'rank) t

val map2 : 
  (k -> k -> k) ->
  ('dim, 'rank) t ->
  ('dim, 'rank) t ->
  ('dim, 'rank) t

Core linear algebra functions

val (+) : 
  ('dim1, ('rank1, 'rank2, 'rank3, 'dim1, 'dim2, 'dim3, _) Type_functions.sum)
    t ->
  ('dim2, 'rank2) t ->
  ('dim3, 'rank3) t

x + y is the standard vector sum, except for scalar argument which are broadcasted to a constant tensor

val (<+>) : ('dim, 'rank) t -> ('dim, 'rank) t -> ('dim, 'rank) t

x <+> y is the standard vector sum, without broadcasting

val (~-) : ('dim, 'rank) t -> ('dim, 'rank) t

~-x is the standard addition inverse

val (-) : 
  ('a, ('rank1, 'rank2, 'rank3, 'dim1, 'dim2, 'dim3, _) Type_functions.sum) t ->
  ('a, 'rank2) t ->
  ('a, 'rank3) t

x - y is the standard vector difference, except for scalar argument which are broadcasted to a constant tensor

val (<->) : ('dim, 'rank) t -> ('dim, 'rank) t -> ('dim, 'rank) t

x <-> y is the standard vector difference, without broadcasting

val (*) : 
  ('dim1,
    ('rank1, 'rank2, 'rank3, 'dim1, 'dim2, 'dim3, _) Type_functions.product)
    t ->
  ('dim2, 'rank2) t ->
  ('dim3, 'rank3) t

x * y is:

the external product if x or y is a scalar
the matrix product if x or y is a matrix
the element-wise (hadamard) product otherwise

val (/) : 
  ('dim1, ('rank1, 'rank2, 'rank3, 'dim1, 'dim2, 'dim3, _) Type_functions.div)
    t ->
  ('dim2, 'rank2) t ->
  ('dim3, 'rank3) t

x / y is:

the external product division if x or y is a scalar
the right matrix division if y is a matrix and x is either a matrix or a vector
the element-wise division if both x and y are vectors

Exponentiation functions

val (**) : ('dim, 'rank) t -> int -> ('dim, 'rank) t

t ** k is t * … * t k-times

val exp : ('dim, 'rank) t -> ('dim, 'rank) t

exp is the algebraic exponential: exp m = 1 + m + m ** 2 / 2 + m **3 / 3! + …

Scalar products and norms

val (|*|) : ('dim, 'rank) t -> ('dim, 'rank) t -> k

(x|*|y) is the canonical scalar product

val norm : ('dim, 'rank) t -> k

norm x is the canonical 2-norm of x

val normalize : ('dim, 'rank) t -> ('dim, 'rank) t

normalize x is x / scalar (norm x)

val orthonormalize : 
  ('dim, _ Type_functions.one) t list ->
  ('dim, _ Type_functions.one) t list

orthonomalize [v_0;...;v_n] returns a list of orthonormal vectors [w_0;...;w_k] that spans the same vector subspace as v_0;...;v_n. If the family [v_0;...;v_n] was free then k = n, otherwise k<n.

val distance : ('dim, 'rank) t -> ('dim, 'rank) t -> k

distance x y is norm (x - y)

val norm_1 : ('dim, 'rank) t -> k

norm_1 x is ∑ |x_i|

val norm_q : float -> ('dim, 'rank) t -> k

norm_q q x is (∑ |x_i|^q) ^ 1/q

Cross and external product

val cross : 
  (('dim, 'dim2 * 'rank2, _) Type_functions.cross, _ Type_functions.one) t ->
  ('dim, _ Type_functions.one) t ->
  ('dim2, 'rank2) t

cross v w is the cross product, it maps either two 3d vectors to a 3d pseudo-vector, or two 2d vectors to a scalar

val (^) : 
  ('dim, _ Type_functions.one) t ->
  ('dim, _ Type_functions.one) t ->
  ('dim, _ Type_functions.two) t

See cross for the 2d and 3d cross-product for vectors v ^ w is the infinitesimal rotation matrix in the plane generated by v and w with an amplitude |v||w| sin θ . In other words the matrix representation of the 2-form dv ^ dw in the corresponding graded algebra.

More linear algebra functions

val commutator : 
  ('dim, _ Type_functions.two) t ->
  ('dim, _ Type_functions.two) t ->
  ('dim, _ Type_functions.two) t

commutator m n is m * n - n * m

val anticommutator : 
  ('dim, _ Type_functions.two) t ->
  ('dim, _ Type_functions.two) t ->
  ('dim, _ Type_functions.two) t

anticommutator m n is m * n + n * m

val trace : ('dim, _ Type_functions.two) t -> k

trace m is ∑_i m_ii

val det : ('dim, _ Type_functions.two) t -> k

det m is the signed volume of the convex hull of of the matrix rows

val transpose : 
  ('dim, _ Type_functions.two) t ->
  ('dim, _ Type_functions.two) t

transpose m is the matrix with row and column reversed

package phantom-algebra