# Module type `Gg.V`

Implemented by all vector types.

`type t`

The type for vectors.

`val dim : int`

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

`type m`

The type for matrices representing linear transformations of `dim` space.

## Constructors, accessors and constants

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

`comp i v` is `v``i`, the `i`th component of `v`.

Raises `Invalid_argument` if `i` is not in [`0;``dim`[.

`val zero : t`

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

`val infinity : t`

`infinity` is the vector whose components are `infinity`.

`val neg_infinity : t`

`neg_infinity` is the vector whose components are `neg_infinity`.

`val basis : int -> t`

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

## Functions

`val neg : t -> t`

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

`val add : t -> t -> t`

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

`val sub : t -> t -> t`

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

`val mul : t -> t -> t`

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

`val div : t -> t -> t`

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

`val smul : float -> t -> t`

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

`val half : t -> t`

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

`val dot : t -> t -> float`

`dot u v` is the dot product `u.v`.

`val norm : t -> float`

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

`val norm2 : t -> float`

`norm2 v` is the squared norm `|v|`2 .

`val unit : t -> t`

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

`val homogene : t -> t`

`homogene v` is the vector `v/(comp (dim - 1) v)` if `comp (dim - 1) v <> 0` and `v` otherwise.

`val mix : t -> t -> float -> t`

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

`val ltr : m -> t -> t`

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

## Overridden `Stdlib` operators

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

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

`val (-) : t -> t -> t`

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

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

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

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

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

## Traversal

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

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

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

`mapi f v` is like `map` but the component index is also given.

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

`fold f acc v` is `f (`...`(f (f acc v`0`) v`1`)`...`)`.

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

`foldi f acc v` is `f (`...`(f (f acc 0 v`0`) 1 v`1`)`...`)`.

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

`iter f v` is `f v`0`; f v`1`;` ...

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

`iteri f v` is `f 0 v`0`; f 1 v`1`;` ...

## Predicates and comparisons

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

`for_all p v` is `p v`0` && p v`1` &&` ...

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

`exists p v` is `p v`0` || p v`1` ||` ...

`val equal : t -> t -> bool`

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

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

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

`val compare : t -> t -> int`

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

`val compare_f : ( float -> float -> int ) -> t -> t -> 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 -> t -> unit`

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

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

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