Module `Gg.V2`

type t = v2: The type for 2D vectors.

val dim : int: dim is the dimension of vectors of type v2.

type m = m2: The type for matrices representing linear transformations of 2D space.

Constructors, accessors and constants

val v : float -> float -> v2: v x y is the vector (x y).

val comp : int -> v2 -> float

comp i v is v_i, the ith component of v.

raises Invalid_argument: if i is not in [0;dim[.

val x : v2 -> float: x v is the x component of v.

val y : v2 -> float: y v is the y component of v.

val ox : v2: ox is the unit vector (1. 0.).

val oy : v2: oy is the unit vector (0. 1.).

val zero : v2: zero is the neutral element for add.

val infinity : v2: infinity is the vector whose components are infinity.

val neg_infinity : v2: neg_infinity is the vector whose components are neg_infinity.

val basis : int -> v2

basis i is the ith vector of an orthonormal basis of the vector space t with inner product dot.

raises Invalid_argument: if i is not in [0;dim[.

val of_tuple : (float * float) -> v2: of_tuple (x, y) is V2.v x y.

val to_tuple : v2 -> float * float: of_tuple v is (V2.x v, V2.y v).

val of_polar : v2 -> v2: of_polar pv is a vector whose cartesian coordinates (x, y) correspond to the radial and angular polar coordinates (r, theta) given by (V2.x pv, V2.y pv).

val to_polar : v2 -> v2: to_polar v is a vector whose coordinates (r, theta) are the radial and angular polar coordinates of v. theta is in [-pi;pi].

val of_v3 : v3 -> v2: of_v3 u is v (V3.x u) (V3.y u).

val of_v4 : v4 -> v2: of_v4 u is v (V4.x u) (V4.y u).

Functions

val neg : v2 -> v2: neg v is the inverse vector -v.

val add : v2 -> v2 -> v2: add u v is the vector addition u + v.

val sub : v2 -> v2 -> v2: sub u v is the vector subtraction u - v.

val mul : v2 -> v2 -> v2: mul u v is the component wise multiplication u * v.

val div : v2 -> v2 -> v2: div u v is the component wise division u / v.

val smul : float -> v2 -> v2: smul s v is the scalar multiplication sv.

val half : v2 -> v2: half v is the half vector smul 0.5 v.

val dot : v2 -> v2 -> float: dot u v is the dot product u.v.

val norm : v2 -> float: norm v is the norm |v| = sqrt v.v.

val norm2 : v2 -> float: norm2 v is the squared norm |v|² .

val unit : v2 -> v2: unit v is the unit vector v/|v|.

val polar : float -> float -> v2: polar r theta is V2.of_polar (V2.v r theta).

val angle : v2 -> float: angle v is the angular polar coordinates of v. The result is in [-pi;pi].

val ortho : v2 -> v2: ortho v is v rotated by pi / 2.

val homogene : v2 -> v2: homogene v is the vector v/v_y if v_y <> 0 and v otherwise.

val mix : v2 -> v2 -> float -> v2: mix u v t is the linear interpolation u + t(v - u).

val ltr : m2 -> v2 -> v2: ltr m v is the linear transform mv.

val tr : m3 -> v2 -> v2

tr m v is the affine transform in homogenous 2D space of the vector v by m.

Note. Since m is supposed to be affine the function ignores the last row of m. v is treated as a vector (infinite point, its last coordinate in homogenous space is 0) and is thus translationally invariant. Use P2.tr to transform finite points.

Overridden `Pervasives` operators

val (+) : v2 -> v2 -> v2: u + v is add u v.

val (-) : v2 -> v2 -> v2: u - v is sub u v.

val (*) : float -> v2 -> v2: t * v is smul t v.

val (/) : v2 -> float -> v2: v / t is smul (1. /. t) v.

Traversal

val map : (float -> float) -> v2 -> v2: map f v is the component wise application of f to v.

val mapi : (int -> float -> float) -> v2 -> v2: mapi f v is like map but the component index is also given.

val fold : ('a -> float -> 'a) -> 'a -> v2 -> 'a: fold f acc v is f (...(f (f acc v₀) v₁)...).

val foldi : ('a -> int -> float -> 'a) -> 'a -> v2 -> 'a: foldi f acc v is f (...(f (f acc 0 v₀) 1 v₁)...).

val iter : (float -> unit) -> v2 -> unit: iter f v is f v₀; f v₁; ...

val iteri : (int -> float -> unit) -> v2 -> unit: iteri f v is f 0 v₀; f 1 v₁; ...

Predicates and comparisons

val for_all : (float -> bool) -> v2 -> bool: for_all p v is p v₀ && p v₁ && ...

val exists : (float -> bool) -> v2 -> bool: exists p v is p v₀ || p v₁ || ...

val equal : v2 -> v2 -> bool: equal u v is u = v.

val equal_f : (float -> float -> bool) -> v2 -> v2 -> bool: equal_f eq u v tests u and v like equal but uses eq to test floating point values.

val compare : v2 -> v2 -> int: compare u v is Pervasives.compare u v.

val compare_f : (float -> float -> int) -> v2 -> v2 -> int: compare_f cmp u v compares u and v like compare but uses cmp to compare floating point values.

Printers

val pp : Stdlib.Format.formatter -> v2 -> unit: pp ppf v prints a textual representation of v on ppf.

val pp_f : (Stdlib.Format.formatter -> float -> unit) -> Stdlib.Format.formatter -> v2 -> unit: pp_f pp_comp ppf v prints v like pp but uses pp_comp to print floating point values.