# Module `Gg.V3`

3D vectors.

`type t = v3`

The type for 3D vectors.

`val dim : int`

`dim` is the dimension of vectors of type `v3`.

`type m = m3`

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

## Constructors, accessors and constants

`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 zero : v3`

`zero` is the neutral element for `add`.

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

`val of_spherical : v3 -> 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 : v3 -> 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 : v2 -> z:float -> v3`

`of_v2 u z` is `v (V2.x u) (V2.y u) z`.

`val of_v4 : v4 -> v3`

`of_v4 u z` is `v (V4.x u) (V4.y u) (V4.z u)`.

## Functions

`val neg : v3 -> v3`

`neg v` is the inverse vector `-v`.

`val add : v3 -> v3 -> v3`

`add u v` is the vector addition `u + v`.

`val sub : v3 -> v3 -> v3`

`sub u v` is the vector subtraction `u - v`.

`val mul : v3 -> v3 -> v3`

`mul u v` is the component wise multiplication `u * v`.

`val div : v3 -> v3 -> v3`

`div u v` is the component wise division `u / v`.

`val smul : float -> v3 -> v3`

`smul s v` is the scalar multiplication `sv`.

`val half : v3 -> v3`

`half v` is the half vector `smul 0.5 v`.

`val cross : v3 -> v3 -> v3`

`cross u v` is the cross product `u x v`.

`val dot : v3 -> v3 -> float`

`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 unit : v3 -> v3`

`unit v` is the unit vector `v/|v|`.

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

`val homogene : v3 -> v3`

`homogene v` is the vector `v/v`z if `v`z` <> 0` and `v` otherwise.

`val mix : v3 -> v3 -> float -> v3`

`mix u v t` is the linear interpolation `u + t(v - u)`.

`val ltr : m3 -> v3 -> v3`

`ltr m v` is the linear transform `mv`.

`val tr : m4 -> v3 -> 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 `P3.tr` to transform finite points.

## Overridden `Stdlib` operators

`val (+) : v3 -> v3 -> v3`

`u + v` is `add u v`.

`val (-) : v3 -> v3 -> v3`

`u - v` is `sub u v`.

`val (*) : float -> v3 -> v3`

`t * v` is `smul t v`.

`val (/) : v3 -> float -> v3`

`v / t` is `smul (1. /. t) v`.

## Traversal

`val map : ( float -> float ) -> v3 -> v3`

`map f v` is the component wise application of `f` to `v`.

`val mapi : ( int -> float -> float ) -> v3 -> v3`

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

## Predicates and comparisons

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

`val equal : v3 -> v3 -> bool`

`equal u v` is `u = v`.

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

`equal_f eq u v` tests `u` and `v` like `equal` but uses `eq` to test floating point values.

`val compare : v3 -> v3 -> int`

`compare u v` is `Stdlib.compare u v`.

`val compare_f : ( float -> float -> int ) -> v3 -> v3 -> int`

`compare_f cmp u v` compares `u` and `v` like `compare` but uses `cmp` to compare floating point values.

## Formatters

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

`pp ppf v` prints a textual representation of `v` on `ppf`.

```val pp_f : ( Stdlib.Format.formatter -> float -> unit ) -> Stdlib.Format.formatter -> v3 -> unit```

`pp_f pp_comp ppf v` prints `v` like `pp` but uses `pp_comp` to print floating point values.