`Gg.V3`

3D vectors.

`type t = v3`

The type for 3D vectors.

`dim`

is the dimension of vectors of type `v3`

.

`type m = m3`

The type for matrices representing linear transformations of 3D space.

`val v : float -> float -> float -> v3`

`v x y z`

is the vector `(x y z)`

.

`val comp : int -> v3 -> float`

`comp i v`

is `v`

_{i}, the `i`

th component of `v`

.

Raises `Invalid_argument`

if `i`

is not in [`0;`

`dim`

[.

`val x : v3 -> float`

`x v`

is the x component of `v`

.

`val y : v3 -> float`

`y v`

is the y component of `v`

.

`val z : v3 -> float`

`z v`

is the z component of `v`

.

`val ox : v3`

`ox`

is the unit vector `(1. 0. 0.)`

.

`val oy : v3`

`oy`

is the unit vector `(0. 1. 0.)`

.

`val oz : v3`

`oz`

is the unit vector `(0. 0. 1.)`

.

`val infinity : v3`

`infinity`

is the vector whose components are `infinity`

.

`val neg_infinity : v3`

`neg_infinity`

is the vector whose components are `neg_infinity`

.

`val basis : int -> v3`

`basis i`

is the `i`

th 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 * float) -> v3`

`of_tuple (x, y, z)`

is `v x y z`

.

`val to_tuple : v3 -> float * float * float`

`to_tuple v`

is `(x v, y v, z v)`

.

`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)`

.

`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`

].

`cross u v`

is the cross product `u x v`

.

`dot u v`

is the dot product `u.v`

.

`val norm : v3 -> float`

`norm v`

is the norm `|v| = sqrt v.v`

.

`val norm2 : v3 -> float`

`norm2 v`

is the squared norm `|v|`

^{2} .

`val spherical : float -> float -> float -> v3`

`spherical r theta phi`

is `of_spherical (V3.v r theta phi)`

.

`val azimuth : v3 -> float`

`azimuth v`

is the azimuth angle spherical coordinates of `v`

. The result is in [`-pi;pi`

].

`val zenith : v3 -> float`

`zenith v`

is the zenith angle spherical coordinates of `v`

. The result is in [`0;pi`

].

`ltr m v`

is the linear transform `mv`

.

`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 `P3.tr`

to transform finite points.

`Stdlib`

operators`mapi f v`

is like `map`

but the component index is also given.

`val fold : ( 'a -> float -> 'a ) -> 'a -> v3 -> 'a`

`fold f acc v`

is `f (`

...`(f (f acc v`

_{0}`) v`

_{1}`)`

...`)`

.

`val foldi : ( 'a -> int -> float -> 'a ) -> 'a -> v3 -> 'a`

`foldi f acc v`

is `f (`

...`(f (f acc 0 v`

_{0}`) 1 v`

_{1}`)`

...`)`

.

`val iter : ( float -> unit ) -> v3 -> unit`

`iter f v`

is `f v`

_{0}`; f v`

_{1}`;`

...

`val iteri : ( int -> float -> unit ) -> v3 -> unit`

`iteri f v`

is `f 0 v`

_{0}`; f 1 v`

_{1}`;`

...

`val for_all : ( float -> bool ) -> v3 -> bool`

`for_all p v`

is `p v`

_{0}` && p v`

_{1}` &&`

...

`val exists : ( float -> bool ) -> v3 -> bool`

`exists p v`

is `p v`

_{0}` || p v`

_{1}` ||`

...

`equal_f eq u v`

tests `u`

and `v`

like `equal`

but uses `eq`

to test floating point values.

`compare_f cmp u v`

compares `u`

and `v`

like `compare`

but uses `cmp`

to compare floating point values.

`val pp : Stdlib.Format.formatter -> v3 -> unit`

`pp ppf v`

prints a textual representation of `v`

on `ppf`

.