module V2:sig
..end
typet =
Gg.v2
val dim : int
typem =
Gg.m2
val v : float -> float -> Gg.v2
v x y
is the vector (x y)
.val comp : int -> Gg.v2 -> float
val x : Gg.v2 -> float
x v
is the x component of v
.val y : Gg.v2 -> float
y v
is the y component of v
.val ox : Gg.v2
ox
is the unit vector (1. 0.)
.val oy : Gg.v2
oy
is the unit vector (0. 1.)
.val zero : Gg.v2
val infinity : Gg.v2
infinity
is the vector whose components are infinity
.val neg_infinity : Gg.v2
neg_infinity
is the vector whose components are neg_infinity
.val basis : int -> Gg.v2
basis i
is the i
th vector of an
orthonormal basis
of the vector space Gg.V2.t
with inner product Gg.V2.dot
.Invalid_argument
if i
is not in [0;
Gg.V2.dim
[.val of_tuple : float * float -> Gg.v2
of_tuple (x, y)
is V2.v x y
.val to_tuple : Gg.v2 -> float * float
of_tuple v
is (V2.x v, V2.y v
).val of_polar : Gg.v2 -> Gg.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 : Gg.v2 -> Gg.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 : Gg.v3 -> Gg.v2
of_v3 u
is v (V3.x u) (V3.y u)
.val of_v4 : Gg.v4 -> Gg.v2
of_v4 u
is v (V4.x u) (V4.y u)
.val neg : Gg.v2 -> Gg.v2
neg v
is the inverse vector -v
.val add : Gg.v2 -> Gg.v2 -> Gg.v2
add u v
is the vector addition u + v
.val sub : Gg.v2 -> Gg.v2 -> Gg.v2
sub u v
is the vector subtraction u - v
.val mul : Gg.v2 -> Gg.v2 -> Gg.v2
mul u v
is the component wise multiplication u * v
.val div : Gg.v2 -> Gg.v2 -> Gg.v2
div u v
is the component wise division u / v
.val smul : float -> Gg.v2 -> Gg.v2
smul s v
is the scalar multiplication sv
.val half : Gg.v2 -> Gg.v2
half v
is the half vector smul 0.5 v
.val dot : Gg.v2 -> Gg.v2 -> float
val norm : Gg.v2 -> float
norm v
is the norm |v| = sqrt v.v
.val norm2 : Gg.v2 -> float
norm2 v
is the squared norm |v|
2 .val unit : Gg.v2 -> Gg.v2
unit v
is the unit vector v/|v|
.val polar : float -> float -> Gg.v2
polar r theta
is V2.of_polar (V2.v r theta)
.val angle : Gg.v2 -> float
val ortho : Gg.v2 -> Gg.v2
ortho v
is v
rotated by pi
/ 2.val homogene : Gg.v2 -> Gg.v2
homogene v
is the vector v/v
y if v
y <> 0
and v
otherwise.val mix : Gg.v2 -> Gg.v2 -> float -> Gg.v2
mix u v t
is the linear interpolation u + t(v - u)
.val ltr : Gg.m2 -> Gg.v2 -> Gg.v2
val tr : Gg.m3 -> Gg.v2 -> Gg.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 Gg.P2.tr
to
transform finite points.
Pervasives
operatorsval (+) : Gg.v2 -> Gg.v2 -> Gg.v2
u + v
is add u v
.val (-) : Gg.v2 -> Gg.v2 -> Gg.v2
u - v
is sub u v
.val ( * ) : float -> Gg.v2 -> Gg.v2
t * v
is smul t v
.val (/) : Gg.v2 -> float -> Gg.v2
v / t
is smul (1. /. t) v
.val map : (float -> float) -> Gg.v2 -> Gg.v2
map f v
is the component wise application of f
to v
.val mapi : (int -> float -> float) -> Gg.v2 -> Gg.v2
val fold : ('a -> float -> 'a) -> 'a -> Gg.v2 -> 'a
fold f acc v
is f (
...(f (f acc v
0) v
1)
...)
.val foldi : ('a -> int -> float -> 'a) -> 'a -> Gg.v2 -> 'a
foldi f acc v
is f (
...(f (f acc 0 v
0) 1 v
1)
...)
.val iter : (float -> unit) -> Gg.v2 -> unit
iter f v
is f v
0; f v
1;
...val iteri : (int -> float -> unit) -> Gg.v2 -> unit
iteri f v
is f 0 v
0; f 1 v
1;
...val for_all : (float -> bool) -> Gg.v2 -> bool
for_all p v
is p v
0 && p v
1 &&
...val exists : (float -> bool) -> Gg.v2 -> bool
exists p v
is p v
0 || p v
1 ||
...val equal : Gg.v2 -> Gg.v2 -> bool
equal u v
is u = v
.val equal_f : (float -> float -> bool) -> Gg.v2 -> Gg.v2 -> bool
val compare : Gg.v2 -> Gg.v2 -> int
compare u v
is Pervasives.compare u v
.val compare_f : (float -> float -> int) -> Gg.v2 -> Gg.v2 -> int
compare_f cmp u v
compares u
and v
like Gg.V2.compare
but uses cmp
to compare floating point values.val to_string : Gg.v2 -> string
to_string v
is a textual representation of v
.val pp : Format.formatter -> Gg.v2 -> unit
pp ppf v
prints a textual representation of v
on ppf
.val pp_f : (Format.formatter -> float -> unit) -> Format.formatter -> Gg.v2 -> unit