# Module `Gg.V2`

2D vectors.

`type t = v2`

The type for 2D vectors.

`val dim : int`

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

`type m = m2`

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

## Constructors, accessors and constants

`val v : float -> float -> v2`

`v x y` is the vector `(x y)`.

`val comp : int -> v2 -> 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 : v2 -> float`

`x v` is the x component of `v`.

`val y : v2 -> float`

`y v` is the y component of `v`.

`val ox : v2`

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

`val oy : v2`

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

`val zero : v2`

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

`val infinity : v2`

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

`val neg_infinity : v2`

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

`val basis : int -> v2`

`basis i` is the `i`th vector of an orthonormal basis of the vector space `t` with inner product `dot`.

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

`val of_tuple : (float * float) -> v2`

`of_tuple (x, y)` is `V2.v x y`.

`val to_tuple : v2 -> float * float`

`of_tuple v` is `(V2.x v, V2.y v`).

`val of_polar : v2 -> 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 : v2 -> 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 : v3 -> v2`

`of_v3 u` is `v (V3.x u) (V3.y u)`.

`val of_v4 : v4 -> v2`

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

## Functions

`val neg : v2 -> v2`

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

`val add : v2 -> v2 -> v2`

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

`val sub : v2 -> v2 -> v2`

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

`val mul : v2 -> v2 -> v2`

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

`val div : v2 -> v2 -> v2`

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

`val smul : float -> v2 -> v2`

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

`val half : v2 -> v2`

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

`val dot : v2 -> v2 -> float`

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

`val norm : v2 -> float`

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

`val norm2 : v2 -> float`

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

`val unit : v2 -> v2`

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

`val polar : float -> float -> v2`

`polar r theta` is `V2.of_polar (V2.v r theta)`.

`val angle : v2 -> float`

`angle v` is the angular polar coordinates of `v`. The result is in [`-pi;pi`].

`val ortho : v2 -> v2`

`ortho v` is `v` rotated by `pi` / 2.

`val homogene : v2 -> v2`

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

`val mix : v2 -> v2 -> float -> v2`

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

`val ltr : m2 -> v2 -> v2`

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

`val tr : m3 -> v2 -> 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 `P2.tr` to transform finite points.

## Overridden `Stdlib` operators

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

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

`val (-) : v2 -> v2 -> v2`

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

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

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

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

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

## Traversal

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

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

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

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

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

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

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

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

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

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

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

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

## Predicates and comparisons

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

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

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

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

`val equal : v2 -> v2 -> bool`

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

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

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

`val compare : v2 -> v2 -> int`

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

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

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

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

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