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