From c212d3d95b6831394c39ee73e732a9db3fd6aa1e Mon Sep 17 00:00:00 2001
From: guzba <guzba8@gmail.com>
Date: Thu, 5 Mar 2020 19:44:26 -0600
Subject: [PATCH] Improve docs and use unix line endings (#2)

* use unix line endings
* improving some docs
* add mddoc dep
---
 .github/workflows/build.yml |  73 +++---
 .gitignore                  |  16 +-
 README.md                   | 386 +++++++++++++++----------------
 src/vmath.nim               |  40 ++--
 tests/vmathtest.nim         | 444 ++++++++++++++++++------------------
 tests/vmathtest.nims        |   2 +-
 vmath.nimble                |   1 +
 7 files changed, 481 insertions(+), 481 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 38dcb2c..fc339c4 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,37 +1,36 @@
-name: Build
-on: [push]
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v1
-
-    - name: Cache choosenim
-      id: cache-choosenim
-      uses: actions/cache@v1
-      with:
-        path: ~/.choosenim
-        key: ${{ runner.os }}-choosenim-1.0.2
-
-    - name: Cache nimble
-      id: cache-nimble
-      uses: actions/cache@v1
-      with:
-        path: ~/.nimble
-        key: ${{ runner.os }}-nimble-1.0.2
-
-    - name: Install Nim
-      if: steps.cache-choosenim.outputs.cache-hit != 'true' || steps.cache-nimble.outputs.cache-hit != 'true'
-      run: |
-        export CHOOSENIM_CHOOSE_VERSION="1.0.2"
-        curl https://nim-lang.org/choosenim/init.sh -sSf > init.sh
-        sh init.sh -y
-
-    - name: Build project
-      run: |
-        export PATH=$HOME/.nimble/bin:$PATH
-        echo $PATH
-        nimble install -y
-        nim c src/vmath.nim
-
+name: Build
+on: [push]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+
+    - name: Cache choosenim
+      id: cache-choosenim
+      uses: actions/cache@v1
+      with:
+        path: ~/.choosenim
+        key: ${{ runner.os }}-choosenim-1.0.2
+
+    - name: Cache nimble
+      id: cache-nimble
+      uses: actions/cache@v1
+      with:
+        path: ~/.nimble
+        key: ${{ runner.os }}-nimble-1.0.2
+
+    - name: Install Nim
+      if: steps.cache-choosenim.outputs.cache-hit != 'true' || steps.cache-nimble.outputs.cache-hit != 'true'
+      run: |
+        export CHOOSENIM_CHOOSE_VERSION="1.0.2"
+        curl https://nim-lang.org/choosenim/init.sh -sSf > init.sh
+        sh init.sh -y
+
+    - name: Build project
+      run: |
+        export PATH=$HOME/.nimble/bin:$PATH
+        echo $PATH
+        nimble install -y
+        nim c src/vmath.nim
diff --git a/.gitignore b/.gitignore
index c1eb6d1..1b48119 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,8 +1,8 @@
-# ignore files with no extention:
-*
-!*/
-!*.*
-
-# normal ignores:
-*.exe
-nimcache
+# ignore files with no extention:
+*
+!*/
+!*.*
+
+# normal ignores:
+*.exe
+nimcache
diff --git a/README.md b/README.md
index 4650a8b..1cd5d8f 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,9 @@
-# VMath
-
-Collection of math rutines that for 2d and 3d graphics.
-
-Has functinos for Vec2, Vec3, Vec4, Mat3, Mat4 and Quat.
+# VMath
+
+Collection of math routines for 2d and 3d graphics.
+
+Has functions for Vec2, Vec3, Vec4, Mat3, Mat4 and Quat.
+
 # API: vmath
 
 ```nim
@@ -11,10 +12,10 @@ import vmath
 
 ## **proc** clamp
 
-Clamps n to min or max if its over.
+Clamps n to min, else returns max if n is higher.
 
 ```nim
-proc clamp(n, min, max: float32): float32 
+proc clamp(n, min, max: float32): float32
 ```
 
 ## **proc** sign
@@ -22,15 +23,15 @@ proc clamp(n, min, max: float32): float32
 Returns the sign of a number, -1 or 1.
 
 ```nim
-proc sign(v: float32): float32 
+proc sign(v: float32): float32
 ```
 
 ## **proc** quantize
 
-Makes v be multipe of n. Rounding to intger quantize by 1.0.
+Makes v be multipe of n. Rounding to integer quantize by 1.0.
 
 ```nim
-proc quantize(v: float32; n: float32): float32 
+proc quantize(v: float32; n: float32): float32
 ```
 
 ## **proc** lerp
@@ -43,7 +44,7 @@ Interpolates value between a and b.
 
 
 ```nim
-proc lerp(a: float32; b: float32; v: float32): float32 
+proc lerp(a: float32; b: float32; v: float32): float32
 ```
 
 ## **type** Vec2
@@ -61,168 +62,168 @@ Vec2 = object
 
 
 ```nim
-proc vec2(x, y: float32): Vec2 
+proc vec2(x, y: float32): Vec2
 ```
 
 ## **proc** vec2
 
 
 ```nim
-proc vec2(a: Vec2): Vec2 
+proc vec2(a: Vec2): Vec2
 ```
 
 ## **proc** `+`
 
 
 ```nim
-proc `+`(a: Vec2; b: Vec2): Vec2 
+proc `+`(a: Vec2; b: Vec2): Vec2
 ```
 
 ## **proc** `-`
 
 
 ```nim
-proc `-`(a: Vec2; b: Vec2): Vec2 
+proc `-`(a: Vec2; b: Vec2): Vec2
 ```
 
 ## **proc** `*`
 
 
 ```nim
-proc `*`(a: Vec2; b: float32): Vec2 
+proc `*`(a: Vec2; b: float32): Vec2
 ```
 
 ## **proc** `*`
 
 
 ```nim
-proc `*`(a: float32; b: Vec2): Vec2 
+proc `*`(a: float32; b: Vec2): Vec2
 ```
 
 ## **proc** `/`
 
 
 ```nim
-proc `/`(a: Vec2; b: float32): Vec2 
+proc `/`(a: Vec2; b: float32): Vec2
 ```
 
 ## **proc** `+=`
 
 
 ```nim
-proc `+=`(a: var Vec2; b: Vec2) 
+proc `+=`(a: var Vec2; b: Vec2)
 ```
 
 ## **proc** `-=`
 
 
 ```nim
-proc `-=`(a: var Vec2; b: Vec2) 
+proc `-=`(a: var Vec2; b: Vec2)
 ```
 
 ## **proc** `*=`
 
 
 ```nim
-proc `*=`(a: var Vec2; b: float32) 
+proc `*=`(a: var Vec2; b: float32)
 ```
 
 ## **proc** `/=`
 
 
 ```nim
-proc `/=`(a: var Vec2; b: float32) 
+proc `/=`(a: var Vec2; b: float32)
 ```
 
 ## **proc** zero
 
 
 ```nim
-proc zero(a: var Vec2) 
+proc zero(a: var Vec2)
 ```
 
 ## **proc** `-`
 
 
 ```nim
-proc `-`(a: Vec2): Vec2 
+proc `-`(a: Vec2): Vec2
 ```
 
 ## **proc** lengthSq
 
 
 ```nim
-proc lengthSq(a: Vec2): float32 
+proc lengthSq(a: Vec2): float32
 ```
 
 ## **proc** length
 
 
 ```nim
-proc length(a: Vec2): float32 
+proc length(a: Vec2): float32
 ```
 
 ## **proc** length=
 
 
 ```nim
-proc length=(a: var Vec2; b: float32) 
+proc length=(a: var Vec2; b: float32)
 ```
 
 ## **proc** normalize
 
 
 ```nim
-proc normalize(a: Vec2): Vec2 
+proc normalize(a: Vec2): Vec2
 ```
 
 ## **proc** dot
 
 
 ```nim
-proc dot(a: Vec2; b: Vec2): float32 
+proc dot(a: Vec2; b: Vec2): float32
 ```
 
 ## **proc** dir
 
 
 ```nim
-proc dir(at: Vec2; to: Vec2): Vec2 
+proc dir(at: Vec2; to: Vec2): Vec2
 ```
 
 ## **proc** dir
 
 
 ```nim
-proc dir(th: float32): Vec2 
+proc dir(th: float32): Vec2
 ```
 
 ## **proc** dist
 
 
 ```nim
-proc dist(at: Vec2; to: Vec2): float32 
+proc dist(at: Vec2; to: Vec2): float32
 ```
 
 ## **proc** distSq
 
 
 ```nim
-proc distSq(at: Vec2; to: Vec2): float32 
+proc distSq(at: Vec2; to: Vec2): float32
 ```
 
 ## **proc** lerp
 
 
 ```nim
-proc lerp(a: Vec2; b: Vec2; v: float32): Vec2 
+proc lerp(a: Vec2; b: Vec2; v: float32): Vec2
 ```
 
 ## **proc** quantize
 
 
 ```nim
-proc quantize(v: Vec2; n: float32): Vec2 
+proc quantize(v: Vec2; n: float32): Vec2
 ```
 
 ## **proc** inRect
@@ -230,35 +231,35 @@ proc quantize(v: Vec2; n: float32): Vec2
 Check to see if v is inside a rectange formed by a and b. It does not matter how a and b are arranged.
 
 ```nim
-proc inRect(v: Vec2; a: Vec2; b: Vec2): bool 
+proc inRect(v: Vec2; a: Vec2; b: Vec2): bool
 ```
 
 ## **proc** `[]`
 
 
 ```nim
-proc `[]`(a: Vec2; i: int): float32 
+proc `[]`(a: Vec2; i: int): float32
 ```
 
 ## **proc** `[]=`
 
 
 ```nim
-proc `[]=`(a: var Vec2; i: int; b: float32) 
+proc `[]=`(a: var Vec2; i: int; b: float32)
 ```
 
 ## **proc** randVec2
 
 
 ```nim
-proc randVec2(): Vec2 
+proc randVec2(): Vec2
 ```
 
 ## **proc** `$`
 
 
 ```nim
-proc `$`(a: Vec2): string 
+proc `$`(a: Vec2): string
 ```
 
 ## **proc** fixAngle
@@ -266,39 +267,39 @@ proc `$`(a: Vec2): string
 Make angle be from -PI to PI radians.
 
 ```nim
-proc fixAngle(angle: float32): float32 
+proc fixAngle(angle: float32): float32
 ```
 
 ## **proc** angle
 
-Angle of a vec2.
+Angle of a Vec2.
 
 ```nim
-proc angle(a: Vec2): float32 
+proc angle(a: Vec2): float32
 ```
 
 ## **proc** angleBetween
 
-Angle between 2 vec
+Angle between 2 Vec2.
 
 ```nim
-proc angleBetween(a: Vec2; b: Vec2): float32 
+proc angleBetween(a: Vec2; b: Vec2): float32
 ```
 
 ## **proc** angleBetween
 
-Angle between angle a and angle b
+Angle between angle a and angle b.
 
 ```nim
-proc angleBetween(a, b: float32): float32 
+proc angleBetween(a, b: float32): float32
 ```
 
 ## **proc** turnAngle
 
-Move from angle a to angle b with step of v
+Move from angle a to angle b with step of v.
 
 ```nim
-proc turnAngle(a, b, speed: float32): float32 
+proc turnAngle(a, b, speed: float32): float32
 ```
 
 ## **type** Vec3
@@ -317,14 +318,14 @@ Vec3 = object
 
 
 ```nim
-proc vec3(x, y, z: float32): Vec3 
+proc vec3(x, y, z: float32): Vec3
 ```
 
 ## **proc** vec3
 
 
 ```nim
-proc vec3(a: Vec3): Vec3 
+proc vec3(a: Vec3): Vec3
 ```
 
 ## **const** X_DIR
@@ -352,253 +353,253 @@ Z_DIR = (x: 0.0, y: 0.0, z: 1.0)
 
 
 ```nim
-proc `+`(a: Vec3; b: Vec3): Vec3 
+proc `+`(a: Vec3; b: Vec3): Vec3
 ```
 
 ## **proc** `-`
 
 
 ```nim
-proc `-`(a: Vec3; b: Vec3): Vec3 
+proc `-`(a: Vec3; b: Vec3): Vec3
 ```
 
 ## **proc** `-`
 
 
 ```nim
-proc `-`(a: Vec3): Vec3 
+proc `-`(a: Vec3): Vec3
 ```
 
 ## **proc** `*`
 
 
 ```nim
-proc `*`(a: Vec3; b: float32): Vec3 
+proc `*`(a: Vec3; b: float32): Vec3
 ```
 
 ## **proc** `*`
 
 
 ```nim
-proc `*`(a: float32; b: Vec3): Vec3 
+proc `*`(a: float32; b: Vec3): Vec3
 ```
 
 ## **proc** `/`
 
 
 ```nim
-proc `/`(a: Vec3; b: float32): Vec3 
+proc `/`(a: Vec3; b: float32): Vec3
 ```
 
 ## **proc** `/`
 
 
 ```nim
-proc `/`(a: float32; b: Vec3): Vec3 
+proc `/`(a: float32; b: Vec3): Vec3
 ```
 
 ## **proc** `+=`
 
 
 ```nim
-proc `+=`(a: var Vec3; b: Vec3) 
+proc `+=`(a: var Vec3; b: Vec3)
 ```
 
 ## **proc** `-=`
 
 
 ```nim
-proc `-=`(a: var Vec3; b: Vec3) 
+proc `-=`(a: var Vec3; b: Vec3)
 ```
 
 ## **proc** `*=`
 
 
 ```nim
-proc `*=`(a: var Vec3; b: float32) 
+proc `*=`(a: var Vec3; b: float32)
 ```
 
 ## **proc** `/=`
 
 
 ```nim
-proc `/=`(a: var Vec3; b: float32) 
+proc `/=`(a: var Vec3; b: float32)
 ```
 
 ## **proc** zero
 
 
 ```nim
-proc zero(a: var Vec3) 
+proc zero(a: var Vec3)
 ```
 
 ## **proc** `-`
 
 
 ```nim
-proc `-`(a: var Vec3): Vec3 
+proc `-`(a: var Vec3): Vec3
 ```
 
 ## **proc** lengthSq
 
 
 ```nim
-proc lengthSq(a: Vec3): float32 
+proc lengthSq(a: Vec3): float32
 ```
 
 ## **proc** length
 
 
 ```nim
-proc length(a: Vec3): float32 
+proc length(a: Vec3): float32
 ```
 
 ## **proc** length=
 
 
 ```nim
-proc length=(a: var Vec3; b: float32) 
+proc length=(a: var Vec3; b: float32)
 ```
 
 ## **proc** normalize
 
 
 ```nim
-proc normalize(a: Vec3): Vec3 
+proc normalize(a: Vec3): Vec3
 ```
 
 ## **proc** cross
 
 
 ```nim
-proc cross(a: Vec3; b: Vec3): Vec3 
+proc cross(a: Vec3; b: Vec3): Vec3
 ```
 
 ## **proc** computeNormal
 
 
 ```nim
-proc computeNormal(a, b, c: Vec3): Vec3 
+proc computeNormal(a, b, c: Vec3): Vec3
 ```
 
 ## **proc** dot
 
 
 ```nim
-proc dot(a: Vec3; b: Vec3): float32 
+proc dot(a: Vec3; b: Vec3): float32
 ```
 
 ## **proc** dir
 
 
 ```nim
-proc dir(at: Vec3; to: Vec3): Vec3 
+proc dir(at: Vec3; to: Vec3): Vec3
 ```
 
 ## **proc** dist
 
 
 ```nim
-proc dist(at: Vec3; to: Vec3): float32 
+proc dist(at: Vec3; to: Vec3): float32
 ```
 
 ## **proc** distSq
 
 
 ```nim
-proc distSq(at: Vec3; to: Vec3): float32 
+proc distSq(at: Vec3; to: Vec3): float32
 ```
 
 ## **proc** lerp
 
 
 ```nim
-proc lerp(a: Vec3; b: Vec3; v: float32): Vec3 
+proc lerp(a: Vec3; b: Vec3; v: float32): Vec3
 ```
 
 ## **proc** angleBetween
 
 
 ```nim
-proc angleBetween(a, b: Vec3): float32 
+proc angleBetween(a, b: Vec3): float32
 ```
 
 ## **proc** `[]`
 
 
 ```nim
-proc `[]`(a: Vec3; i: int): float32 
+proc `[]`(a: Vec3; i: int): float32
 ```
 
 ## **proc** `[]=`
 
 
 ```nim
-proc `[]=`(a: var Vec3; i: int; b: float32) 
+proc `[]=`(a: var Vec3; i: int; b: float32)
 ```
 
 ## **proc** xy
 
 
 ```nim
-proc xy(a: Vec3): Vec2 
+proc xy(a: Vec3): Vec2
 ```
 
 ## **proc** xz
 
 
 ```nim
-proc xz(a: Vec3): Vec2 
+proc xz(a: Vec3): Vec2
 ```
 
 ## **proc** yx
 
 
 ```nim
-proc yx(a: Vec3): Vec2 
+proc yx(a: Vec3): Vec2
 ```
 
 ## **proc** yz
 
 
 ```nim
-proc yz(a: Vec3): Vec2 
+proc yz(a: Vec3): Vec2
 ```
 
 ## **proc** zx
 
 
 ```nim
-proc zx(a: Vec3): Vec2 
+proc zx(a: Vec3): Vec2
 ```
 
 ## **proc** zy
 
 
 ```nim
-proc zy(a: Vec3): Vec2 
+proc zy(a: Vec3): Vec2
 ```
 
 ## **proc** almostEquals
 
 
 ```nim
-proc almostEquals(a, b: Vec3; precision = 1e-006): bool 
+proc almostEquals(a, b: Vec3; precision = 1e-006): bool
 ```
 
 ## **proc** randVec3
 
-Generates a random vector based on: <a class="reference external" href="http://mathworld.wolfram.com/SpherePointPicking.html">http://mathworld.wolfram.com/SpherePointPicking.html</a> .
+Generates a random vector based on <a class="reference external" href="http://mathworld.wolfram.com/SpherePointPicking.html">http://mathworld.wolfram.com/SpherePointPicking.html</a>
 
 ```nim
-proc randVec3(): Vec3 
+proc randVec3(): Vec3
 ```
 
 ## **proc** `$`
 
 
 ```nim
-proc `$`(a: Vec3): string 
+proc `$`(a: Vec3): string
 ```
 
 ## **type** Vec4
@@ -618,126 +619,126 @@ Vec4 = object
 
 
 ```nim
-proc vec4(x, y, z, w: float32): Vec4 
+proc vec4(x, y, z, w: float32): Vec4
 ```
 
 ## **proc** `+`
 
 
 ```nim
-proc `+`(a: Vec4; b: Vec4): Vec4 
+proc `+`(a: Vec4; b: Vec4): Vec4
 ```
 
 ## **proc** `-`
 
 
 ```nim
-proc `-`(a: Vec4; b: Vec4): Vec4 
+proc `-`(a: Vec4; b: Vec4): Vec4
 ```
 
 ## **proc** `-`
 
 
 ```nim
-proc `-`(a: Vec4): Vec4 
+proc `-`(a: Vec4): Vec4
 ```
 
 ## **proc** `*`
 
 
 ```nim
-proc `*`(a: Vec4; b: float32): Vec4 
+proc `*`(a: Vec4; b: float32): Vec4
 ```
 
 ## **proc** `*`
 
 
 ```nim
-proc `*`(a: float32; b: Vec4): Vec4 
+proc `*`(a: float32; b: Vec4): Vec4
 ```
 
 ## **proc** `/`
 
 
 ```nim
-proc `/`(a: Vec4; b: float32): Vec4 
+proc `/`(a: Vec4; b: float32): Vec4
 ```
 
 ## **proc** `/`
 
 
 ```nim
-proc `/`(a: float32; b: Vec4): Vec4 
+proc `/`(a: float32; b: Vec4): Vec4
 ```
 
 ## **proc** `+=`
 
 
 ```nim
-proc `+=`(a: var Vec4; b: Vec4) 
+proc `+=`(a: var Vec4; b: Vec4)
 ```
 
 ## **proc** `-=`
 
 
 ```nim
-proc `-=`(a: var Vec4; b: Vec4) 
+proc `-=`(a: var Vec4; b: Vec4)
 ```
 
 ## **proc** `*=`
 
 
 ```nim
-proc `*=`(a: var Vec4; b: float32) 
+proc `*=`(a: var Vec4; b: float32)
 ```
 
 ## **proc** `/=`
 
 
 ```nim
-proc `/=`(a: var Vec4; b: float32) 
+proc `/=`(a: var Vec4; b: float32)
 ```
 
 ## **proc** zero
 
 
 ```nim
-proc zero(a: var Vec4) 
+proc zero(a: var Vec4)
 ```
 
 ## **proc** xyz
 
 
 ```nim
-proc xyz(a: Vec4): Vec3 
+proc xyz(a: Vec4): Vec3
 ```
 
 ## **proc** `$`
 
 
 ```nim
-proc `$`(a: Vec4): string 
+proc `$`(a: Vec4): string
 ```
 
 ## **proc** vec3
 
 
 ```nim
-proc vec3(a: Vec2; z = 0.0): Vec3 
+proc vec3(a: Vec2; z = 0.0): Vec3
 ```
 
 ## **proc** vec4
 
 
 ```nim
-proc vec4(a: Vec3; w = 0.0): Vec4 
+proc vec4(a: Vec3; w = 0.0): Vec4
 ```
 
 ## **proc** vec4
 
 
 ```nim
-proc vec4(a: Vec2; z = 0.0; w = 0.0): Vec4 
+proc vec4(a: Vec2; z = 0.0; w = 0.0): Vec4
 ```
 
 ## **type** Mat3
@@ -752,91 +753,91 @@ Mat3 = array[9, float32]
 
 
 ```nim
-proc mat3(a, b, c, d, e, f, g, h, i: float32): Mat3 
+proc mat3(a, b, c, d, e, f, g, h, i: float32): Mat3
 ```
 
 ## **proc** mat3
 
 
 ```nim
-proc mat3(a: Mat3): Mat3 
+proc mat3(a: Mat3): Mat3
 ```
 
 ## **proc** identity
 
 
 ```nim
-proc identity(a: var Mat3) 
+proc identity(a: var Mat3)
 ```
 
 ## **proc** mat3
 
 
 ```nim
-proc mat3(): Mat3 
+proc mat3(): Mat3
 ```
 
 ## **proc** transpose
 
 
 ```nim
-proc transpose(a: Mat3): Mat3 
+proc transpose(a: Mat3): Mat3
 ```
 
 ## **proc** `$`
 
 
 ```nim
-proc `$`(a: Mat3): string 
+proc `$`(a: Mat3): string
 ```
 
 ## **proc** `*`
 
 
 ```nim
-proc `*`(a: Mat3; b: Mat3): Mat3 
+proc `*`(a: Mat3; b: Mat3): Mat3
 ```
 
 ## **proc** `*`
 
 
 ```nim
-proc `*`(m: Mat3; v: Vec3): Vec3 
+proc `*`(m: Mat3; v: Vec3): Vec3
 ```
 
 ## **proc** scale
 
 
 ```nim
-proc scale(a: Mat3; v: Vec2): Mat3 
+proc scale(a: Mat3; v: Vec2): Mat3
 ```
 
 ## **proc** scale
 
 
 ```nim
-proc scale(a: Mat3; v: Vec3): Mat3 
+proc scale(a: Mat3; v: Vec3): Mat3
 ```
 
 ## **proc** rotationMat3
 
 
 ```nim
-proc rotationMat3(angle: float32): Mat3 
+proc rotationMat3(angle: float32): Mat3
 ```
 
 ## **proc** rotate
 
 
 ```nim
-proc rotate(a: Mat3; angle: float32): Mat3 
+proc rotate(a: Mat3; angle: float32): Mat3
 ```
 
 ## **proc** `*`
 
 
 ```nim
-proc `*`(a: Mat3; b: Vec2): Vec2 
+proc `*`(a: Mat3; b: Vec2): Vec2
 ```
 
 ## **type** Mat4
@@ -851,203 +852,203 @@ Mat4 = array[16, float32]
 
 
 ```nim
-proc mat4(v0, v1, Vec2, Vec3, Vec4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15: float32): Mat4 
+proc mat4(v0, v1, Vec2, Vec3, Vec4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15: float32): Mat4
 ```
 
 ## **proc** mat4
 
 
 ```nim
-proc mat4(a: Mat4): Mat4 
+proc mat4(a: Mat4): Mat4
 ```
 
 ## **proc** identity
 
 
 ```nim
-proc identity(): Mat4 
+proc identity(): Mat4
 ```
 
 ## **proc** mat4
 
 
 ```nim
-proc mat4(): Mat4 
+proc mat4(): Mat4
 ```
 
 ## **proc** transpose
 
 
 ```nim
-proc transpose(a: Mat4): Mat4 
+proc transpose(a: Mat4): Mat4
 ```
 
 ## **proc** determinant
 
 
 ```nim
-proc determinant(a: Mat4): float32 
+proc determinant(a: Mat4): float32
 ```
 
 ## **proc** inverse
 
 
 ```nim
-proc inverse(a: Mat4): Mat4 
+proc inverse(a: Mat4): Mat4
 ```
 
 ## **proc** `*`
 
 
 ```nim
-proc `*`(a, b: Mat4): Mat4 
+proc `*`(a, b: Mat4): Mat4
 ```
 
 ## **proc** `*`
 
 
 ```nim
-proc `*`(a: Mat4; b: Vec3): Vec3 
+proc `*`(a: Mat4; b: Vec3): Vec3
 ```
 
 ## **proc** right
 
 
 ```nim
-proc right(a: Mat4): Vec3 
+proc right(a: Mat4): Vec3
 ```
 
 ## **proc** right=
 
 
 ```nim
-proc right=(a: var Mat4; b: Vec3) 
+proc right=(a: var Mat4; b: Vec3)
 ```
 
 ## **proc** up
 
 
 ```nim
-proc up(a: Mat4): Vec3 
+proc up(a: Mat4): Vec3
 ```
 
 ## **proc** up=
 
 
 ```nim
-proc up=(a: var Mat4; b: Vec3) 
+proc up=(a: var Mat4; b: Vec3)
 ```
 
 ## **proc** fov
 
 
 ```nim
-proc fov(a: Mat4): Vec3 
+proc fov(a: Mat4): Vec3
 ```
 
 ## **proc** fov=
 
 
 ```nim
-proc fov=(a: var Mat4; b: Vec3) 
+proc fov=(a: var Mat4; b: Vec3)
 ```
 
 ## **proc** pos
 
 
 ```nim
-proc pos(a: Mat4): Vec3 
+proc pos(a: Mat4): Vec3
 ```
 
 ## **proc** pos=
 
 
 ```nim
-proc pos=(a: var Mat4; b: Vec3) 
+proc pos=(a: var Mat4; b: Vec3)
 ```
 
 ## **proc** rotationOnly
 
 
 ```nim
-proc rotationOnly(a: Mat4): Mat4 
+proc rotationOnly(a: Mat4): Mat4
 ```
 
 ## **proc** dist
 
 
 ```nim
-proc dist(a, b: Mat4): float32 
+proc dist(a, b: Mat4): float32
 ```
 
 ## **proc** translate
 
 
 ```nim
-proc translate(v: Vec3): Mat4 
+proc translate(v: Vec3): Mat4
 ```
 
 ## **proc** scale
 
 
 ```nim
-proc scale(v: Vec3): Mat4 
+proc scale(v: Vec3): Mat4
 ```
 
 ## **proc** close
 
 
 ```nim
-proc close(a: Mat4; b: Mat4): bool 
+proc close(a: Mat4; b: Mat4): bool
 ```
 
 ## **proc** hrp
 
 
 ```nim
-proc hrp(m: Mat4): Vec3 
+proc hrp(m: Mat4): Vec3
 ```
 
 ## **proc** frustum
 
 
 ```nim
-proc frustum(left, right, bottom, top, near, far: float32): Mat4 
+proc frustum(left, right, bottom, top, near, far: float32): Mat4
 ```
 
 ## **proc** perspective
 
 
 ```nim
-proc perspective(fovy, aspect, near, far: float32): Mat4 
+proc perspective(fovy, aspect, near, far: float32): Mat4
 ```
 
 ## **proc** ortho
 
 
 ```nim
-proc ortho(left, right, bottom, top, near, far: float32): Mat4 
+proc ortho(left, right, bottom, top, near, far: float32): Mat4
 ```
 
 ## **proc** lookAt
 
 
 ```nim
-proc lookAt(eye, center, up: Vec3): Mat4 
+proc lookAt(eye, center, up: Vec3): Mat4
 ```
 
 ## **proc** tofloat32
 
 
 ```nim
-proc tofloat32(m: Mat4): array[16, float32] 
+proc tofloat32(m: Mat4): array[16, float32]
 ```
 
 ## **proc** `$`
 
 
 ```nim
-proc `$`(a: Mat4): string 
+proc `$`(a: Mat4): string
 ```
 
 ## **type** Quat
@@ -1066,171 +1067,171 @@ Quat = object
 
 
 ```nim
-proc quat(x, y, z, w: float32): Quat 
+proc quat(x, y, z, w: float32): Quat
 ```
 
 ## **proc** conjugate
 
 
 ```nim
-proc conjugate(q: Quat): Quat 
+proc conjugate(q: Quat): Quat
 ```
 
 ## **proc** length
 
 
 ```nim
-proc length(q: Quat): float32 
+proc length(q: Quat): float32
 ```
 
 ## **proc** normalize
 
 
 ```nim
-proc normalize(q: Quat): Quat 
+proc normalize(q: Quat): Quat
 ```
 
 ## **proc** xyz
 
 
 ```nim
-proc xyz(q: Quat): Vec3 
+proc xyz(q: Quat): Vec3
 ```
 
 ## **proc** xyz=
 
 
 ```nim
-proc xyz=(q: var Quat; v: Vec3) 
+proc xyz=(q: var Quat; v: Vec3)
 ```
 
 ## **proc** `*`
 
-Multiply the quaternion by a quaternion
+Multiply the quaternion by a quaternion.
 
 ```nim
-proc `*`(a, b: Quat): Quat 
+proc `*`(a, b: Quat): Quat
 ```
 
 ## **proc** `*`
 
-Multiply the quaternion by a float32
+Multiply the quaternion by a float32.
 
 ```nim
-proc `*`(q: Quat; v: float32): Quat 
+proc `*`(q: Quat; v: float32): Quat
 ```
 
 ## **proc** `*`
 
-Multiply the quaternion by a vector
+Multiply the quaternion by a vector.
 
 ```nim
-proc `*`(q: Quat; v: Vec3): Vec3 
+proc `*`(q: Quat; v: Vec3): Vec3
 ```
 
 ## **proc** mat3
 
 
 ```nim
-proc mat3(q: Quat): Mat3 
+proc mat3(q: Quat): Mat3
 ```
 
 ## **proc** mat4
 
 
 ```nim
-proc mat4(q: Quat): Mat4 
+proc mat4(q: Quat): Mat4
 ```
 
 ## **proc** reciprocalSqrt
 
 
 ```nim
-proc reciprocalSqrt(x: float32): float32 
+proc reciprocalSqrt(x: float32): float32
 ```
 
 ## **proc** quat
 
 
 ```nim
-proc quat(m: Mat4): Quat 
+proc quat(m: Mat4): Quat
 ```
 
 ## **proc** fromAxisAngle
 
 
 ```nim
-proc fromAxisAngle(axis: Vec3; angle: float32): Quat 
+proc fromAxisAngle(axis: Vec3; angle: float32): Quat
 ```
 
 ## **proc** toAxisAngle
 
 
 ```nim
-proc toAxisAngle(q: Quat; axis: var Vec3; angle: var float32) 
+proc toAxisAngle(q: Quat; axis: var Vec3; angle: var float32)
 ```
 
 ## **proc** quat
 
 
 ```nim
-proc quat(heading, pitch, roll: float32): Quat 
+proc quat(heading, pitch, roll: float32): Quat
 ```
 
 ## **proc** hrp
 
 
 ```nim
-proc hrp(q: Quat): Vec3 
+proc hrp(q: Quat): Vec3
 ```
 
 ## **proc** `$`
 
 
 ```nim
-proc `$`(a: Quat): string 
+proc `$`(a: Quat): string
 ```
 
 ## **proc** rotate
 
 
 ```nim
-proc rotate(angle: float32; axis: Vec3): Mat4 
+proc rotate(angle: float32; axis: Vec3): Mat4
 ```
 
 ## **proc** rotateX
 
 
 ```nim
-proc rotateX(angle: float32): Mat4 
+proc rotateX(angle: float32): Mat4
 ```
 
 ## **proc** rotateY
 
 
 ```nim
-proc rotateY(angle: float32): Mat4 
+proc rotateY(angle: float32): Mat4
 ```
 
 ## **proc** rotateZ
 
 
 ```nim
-proc rotateZ(angle: float32): Mat4 
+proc rotateZ(angle: float32): Mat4
 ```
 
 ## **proc** scaleMat
 
 
 ```nim
-proc scaleMat(scale: Vec3): Mat4 
+proc scaleMat(scale: Vec3): Mat4
 ```
 
 ## **proc** scaleMat
 
 
 ```nim
-proc scaleMat(scale: float32): Mat4 
+proc scaleMat(scale: float32): Mat4
 ```
 
 ## **type** Rect
@@ -1249,79 +1250,78 @@ Rect = object
 
 
 ```nim
-proc rect(x, y, w, h: float32): Rect 
+proc rect(x, y, w, h: float32): Rect
 ```
 
 ## **proc** rect
 
 
 ```nim
-proc rect(pos, size: Vec2): Rect 
+proc rect(pos, size: Vec2): Rect
 ```
 
 ## **proc** xy
 
-Gets the xy as a vec2
+Gets the xy as a Vec2.
 
 ```nim
-proc xy(rect: Rect): Vec2 
+proc xy(rect: Rect): Vec2
 ```
 
 ## **proc** xy=
 
-Sets the xy from vec2
+Sets the xy from Vec2.
 
 ```nim
-proc xy=(rect: var Rect; v: Vec2) 
+proc xy=(rect: var Rect; v: Vec2)
 ```
 
 ## **proc** wh
 
-Gets the wh as a vec2
+Gets the wh as a Vec2.
 
 ```nim
-proc wh(rect: Rect): Vec2 
+proc wh(rect: Rect): Vec2
 ```
 
 ## **proc** wh=
 
-Sets the wh from vec2
+Sets the wh from Vec2.
 
 ```nim
-proc wh=(rect: var Rect; v: Vec2) 
+proc wh=(rect: var Rect; v: Vec2)
 ```
 
 ## **proc** `*`
 
 
- * all elements of a rect
+ * all elements of a Rect.
 
 
 
 ```nim
-proc `*`(r: Rect; v: float): Rect 
+proc `*`(r: Rect; v: float): Rect
 ```
 
 ## **proc** `/`
 
-/ all elements of a rect
+/ all elements of a Rect.
 
 ```nim
-proc `/`(r: Rect; v: float): Rect 
+proc `/`(r: Rect; v: float): Rect
 ```
 
 ## **proc** intersects
 
-Checks if point is inside the rectangle
+Checks if pos is inside rect.
 
 ```nim
-proc intersects(rect: Rect; pos: Vec2): bool 
+proc intersects(rect: Rect; pos: Vec2): bool
 ```
 
 ## **proc** `$`
 
 
 ```nim
-proc `$`(a: Rect): string 
+proc `$`(a: Rect): string
 ```
-
diff --git a/src/vmath.nim b/src/vmath.nim
index 5f7b61a..01c834a 100644
--- a/src/vmath.nim
+++ b/src/vmath.nim
@@ -5,7 +5,7 @@ export math
 
 
 proc clamp*(n, min, max: float32): float32 =
-  ## Clamps n to min or max if its over.
+  ## Clamps n to min, else returns max if n is higher.
   if n < min:
     return min
   if n > max:
@@ -19,7 +19,7 @@ proc sign*(v: float32): float32 =
   return -1.0
 
 proc quantize*(v: float32, n: float32): float32 =
-  ## Makes v be multipe of n. Rounding to intger quantize by 1.0.
+  ## Makes v be multipe of n. Rounding to integer quantize by 1.0.
   result = sign(v) * floor(abs(v) / n) * n
 
 proc lerp*(a: float32, b: float32, v: float32): float32 =
@@ -161,19 +161,19 @@ proc fixAngle*(angle: float32): float32 =
   return angle
 
 proc angle*(a: Vec2): float32 =
-  ## Angle of a vec2.
+  ## Angle of a Vec2.
   math.arctan2(a.y, a.x)
 
 proc angleBetween*(a: Vec2, b: Vec2): float32 =
-  ## Angle between 2 vec
+  ## Angle between 2 Vec2.
   fixAngle(math.arctan2(a.y - b.y, a.x - b.x))
 
 proc angleBetween*(a, b: float32): float32 =
-  ## Angle between angle a and angle b
+  ## Angle between angle a and angle b.
   (b - a).fixAngle
 
 proc turnAngle*(a, b, speed: float32): float32 =
-  ## Move from angle a to angle b with step of v
+  ## Move from angle a to angle b with step of v.
   var
     turn = fixAngle(b - a)
   if abs(turn) < speed:
@@ -349,7 +349,7 @@ proc almostEquals*(a, b: Vec3, precision = 1e-6): bool =
   return abs(c.x) < precision and abs(c.y) < precision and abs(c.z) < precision
 
 proc randVec3*(): Vec3 =
-  ## Generates a random vector based on: http://mathworld.wolfram.com/SpherePointPicking.html .
+  ## Generates a random vector based on http://mathworld.wolfram.com/SpherePointPicking.html
   let
     u = rand(0.0 .. 1.0)
     v = rand(0.0 .. 1.0)
@@ -596,7 +596,7 @@ proc scale*(a: Mat3, v: Vec3): Mat3 =
 
 
 proc rotationMat3*(angle: float32): Mat3 =
-  # create a matrix from an angle
+  # Create a matrix from an angle.
   let
     sin = sin(angle)
     cos = cos(angle)
@@ -614,7 +614,7 @@ proc rotationMat3*(angle: float32): Mat3 =
 
 
 proc rotate*(a: Mat3, angle: float32): Mat3 =
-  # rotates a matrix by an angle
+  # Rotates a matrix by an angle.
   a * rotationMat3(angle)
 
 
@@ -964,7 +964,7 @@ proc hrp*(m: Mat4): Vec3 =
     heading = arctan2(m[2], m[10])
     pitch = PI / 2
     roll = 0
-  elif m[1] < -0.998:  # singularity at sresulth pole
+  elif m[1] < -0.998:  # singularity at south pole
     heading = arctan2(m[2], m[10])
     pitch = -PI / 2
     roll = 0
@@ -1187,7 +1187,7 @@ proc `xyz=`*(q: var Quat, v: Vec3) =
 
 
 proc `*`*(a, b: Quat): Quat =
-  ## Multiply the quaternion by a quaternion
+  ## Multiply the quaternion by a quaternion.
   #[
   var q = quat(0,0,0,0)
   q.w = dot(a.xyz, b.xyz)
@@ -1205,7 +1205,7 @@ proc `*`*(a, b: Quat): Quat =
   result.w = a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
 
 proc `*`*(q: Quat, v: float32): Quat =
-  ## Multiply the quaternion by a float32
+  ## Multiply the quaternion by a float32.
   result.x = q.x * v
   result.y = q.y * v
   result.z = q.z * v
@@ -1213,7 +1213,7 @@ proc `*`*(q: Quat, v: float32): Quat =
 
 
 proc `*`*(q: Quat, v: Vec3): Vec3 =
-  ## Multiply the quaternion by a vector
+  ## Multiply the quaternion by a vector.
   var
     x = v.x
     y = v.y
@@ -1446,33 +1446,33 @@ proc rect*(pos, size: Vec2): Rect =
   result.h = size.y
 
 proc xy*(rect: Rect): Vec2 =
-  ## Gets the xy as a vec2
+  ## Gets the xy as a Vec2.
   vec2(rect.x, rect.y)
 
 proc `xy=`*(rect: var Rect, v: Vec2) =
-  ## Sets the xy from vec2
+  ## Sets the xy from Vec2.
   rect.x = v.x
   rect.y = v.y
 
 proc wh*(rect: Rect): Vec2 =
-  ## Gets the wh as a vec2
+  ## Gets the wh as a Vec2.
   vec2(rect.w, rect.h)
 
 proc `wh=`*(rect: var Rect, v: Vec2) =
-  ## Sets the wh from vec2
+  ## Sets the wh from Vec2.
   rect.w = v.x
   rect.h = v.y
 
 proc `*`*(r: Rect, v: float): Rect =
-  ## * all elements of a rect
+  ## * all elements of a Rect.
   rect(r.x * v, r.y * v, r.w * v, r.h * v)
 
 proc `/`*(r: Rect, v: float): Rect =
-  ## / all elements of a rect
+  ## / all elements of a Rect.
   rect(r.x / v, r.y / v, r.w / v, r.h / v)
 
 proc intersects*(rect: Rect, pos: Vec2): bool =
-  ## Checks if point is inside the rectangle
+  ## Checks if pos is inside rect.
   (rect.x <= pos.x and pos.x <= rect.x + rect.w) and (
    rect.y <= pos.y and pos.y <= rect.y + rect.h)
 
diff --git a/tests/vmathtest.nim b/tests/vmathtest.nim
index 9568385..843c2c0 100644
--- a/tests/vmathtest.nim
+++ b/tests/vmathtest.nim
@@ -1,222 +1,222 @@
-# nim c -r --verbosity:0 tests\vmathtest > tests\vmathtest.test.txt; dos2unix tests\vmathtest.test.txt; git diff tests\vmathtest.test.txt
-
-include ../src/vmath
-
-
-randomize(1234)
-
-
-block:
-  echo "# angle stuff"
-  echo angleBetween(0.1, 0.2), " should be: ", 0.1
-
-  echo angleBetween(0.1, 0.2 + PI*2), " should be: ", 0.1
-  echo angleBetween(0.1, 0.2 - PI*2), " should be: ", 0.1
-  echo angleBetween(0.1 + PI*2, 0.2), " should be: ", 0.1
-  echo angleBetween(0.1 - PI*2, 0.2), " should be: ", 0.1
-
-  echo angleBetween(0.2, 0.1), " should be: ", -0.1
-
-  echo angleBetween(0.2, 0.1 - PI*2), " should be: ", -0.1
-  echo angleBetween(0.2, 0.1 + PI*2), " should be: ", -0.1
-  echo angleBetween(0.2 + PI*2, 0.1), " should be: ", -0.1
-  echo angleBetween(0.2 - PI*2, 0.1), " should be: ", -0.1
-
-block:
-  echo "# basic vector vec2"
-  var a = vec2(1, 2)
-  var b = vec2(7, 6)
-  var n = 13.7
-  echo a + b
-  echo a - b
-  echo a * n
-  echo a / n
-  a += b
-  echo a
-  a -= b
-  echo a
-  a *= n
-  echo a
-  a /= n
-  echo a
-
-block:
-  echo "# basic vector vec3"
-  var a = vec3(1, 2, 3)
-  var b = vec3(7, 6, 5)
-  var n = 13.7
-  echo a + b
-  echo a - b
-  echo a * n
-  echo a / n
-  a += b
-  echo a
-  a -= b
-  echo a
-  a *= n
-  echo a
-  a /= n
-  echo a
-
-block:
-  echo "# basic vector vec4"
-  var a = vec4(1, 2, 3, 4)
-  var b = vec4(7, 6, 5, 4)
-  var n = 13.7
-  echo a + b
-  echo a - b
-  echo a * n
-  echo a / n
-  a += b
-  echo a
-  a -= b
-  echo a
-  a *= n
-  echo a
-  a /= n
-  echo a
-
-block:
-  echo "# basic vector mat4"
-  var m1 = mat4(
-    1, 0, 0, 0,
-    0, 1, 0, 0,
-    0, 0, 1, 0,
-    0, 0, 0, 1)
-  echo m1
-  var q1 = m1.quat()
-  echo q1
-  var m2 = q1.mat4()
-  echo m2
-  assert m1.close(m2)
-
-block:
-  echo "# basic vector mat4 -1"
-  var m1 = mat4(
-    1, 0, 0, 0,
-    0, 0, -1, 0,
-    0, 1, 0, 0,
-    0, 0, 0, 1)
-  echo m1
-  var q1 = m1.quat()
-  echo q1
-  var m2 = q1.mat4()
-  echo m2
-  assert m1.close(m2)
-
-block:
-  echo "# Y 90"
-  var m1 = rotate(PI/2, vec3(0, 1, 0))
-  echo m1
-  var q1 = m1.quat()
-  echo q1
-  var m2 = q1.mat4()
-  echo m2
-  assert m1.close(m2)
-
-block:
-  echo "# -Y 90"
-  var m1 = rotate(PI/2, vec3(0, -1, 0))
-  echo m1
-  var q1 = m1.quat()
-  echo q1
-  var m2 = q1.mat4()
-  echo m2
-  assert m1.close(m2)
-
-block:
-  echo "# X 90"
-  var m1 = rotate(PI/2, vec3(1, 0, 0))
-  echo m1
-  var q1 = m1.quat()
-  echo q1
-  var m2 = q1.mat4()
-  echo m2
-  echo m1.close(m2)
-
-block:
-  echo "# Y 90"
-  var m1 = rotate(PI/2, vec3(1, 0, 0))
-  echo m1
-  var q1 = m1.quat()
-  echo q1
-  var m2 = q1.mat4()
-  echo m2
-  echo m1.close(m2)
-
-block:
-  echo "# 1,1,1 1.11rad"
-  var m1 = rotate(PI*1.11, vec3(1, 1, 1).normalize())
-  echo m1
-  var q1 = m1.quat()
-  echo q1
-  var m2 = q1.mat4()
-  echo m2
-  assert m1.close(m2)
-
-block:
-  echo "# 1,1,1 1.11rad"
-  var m1 = rotate(PI*1.11, vec3(-1, 1, 1).normalize())
-  echo m1
-  var q1 = m1.quat()
-  echo q1
-  var m2 = q1.mat4()
-  echo m2
-  assert m1.close(m2)
-
-
-block:
-  echo "# 1,1,1 1.11rad"
-  var m1 = rotate(PI*1.11, vec3(-1, 0.34, 1.123).normalize())
-  echo m1
-  var q1 = m1.quat()
-  echo q1
-  var m2 = q1.mat4()
-  echo m2
-  assert m1.close(m2)
-
-block:
-  echo "# super random"
-  for i in 0..100:
-    var m1 = rotate(PI*rand(2.0), vec3(rand(2.0)-0.5, rand(2.0)-0.5, rand(2.0)-0.5).normalize())
-    echo m1
-    var q1 = m1.quat()
-    echo q1
-    var m2 = q1.mat4()
-    echo m2
-    assert m1.close(m2)
-
-block:
-  echo "# matrix to quat test"
-  # TODO: Fix this test
-  # var m1 = mat4(
-  #    -0.33089, -0.51266, -0.79227, 0.00000,
-  #           0,     -1.0,        0, 0.00000,
-  #           0,        0,      1.0, 0.00000,
-  #     0.00000,  0.00000,  0.00000, 1.00000)
-  # echo m1
-  # var q1 = m1.quat()
-  # echo q1
-  # var m2 = q1.mat4()
-  # echo m2
-  # assert m1.close(m2)
-
-block:
-  echo "# matrix to quat test"
-  # TODO: Fix this test
-  # var m1 = mat4(
-  #   -0.33089, -0.51266, -0.79227, 0.00000,
-  #   -0.44681,  0.82460, -0.34697, 0.00000,
-  #   -0.83119, -0.23918,  0.50191, 0.00000,
-  #     0.00000,  0.00000,  0.00000, 1.00000)
-
-  # echo vec3(  -0.33089, -0.51266, -0.79227).length
-  # echo vec3(  -0.44681,  0.82460, -0.34697).length
-  # echo vec3(  -0.83119, -0.23918,  0.50191).length
-
-  # echo m1
-  # var q1 = m1.quat().normalize()
-  # echo q1
-  # var m2 = q1.mat4()
-  # echo m2
-  # assert m1.close(m2)
+# nim c -r --verbosity:0 tests\vmathtest > tests\vmathtest.test.txt; dos2unix tests\vmathtest.test.txt; git diff tests\vmathtest.test.txt
+
+include ../src/vmath
+
+
+randomize(1234)
+
+
+block:
+  echo "# angle stuff"
+  echo angleBetween(0.1, 0.2), " should be: ", 0.1
+
+  echo angleBetween(0.1, 0.2 + PI*2), " should be: ", 0.1
+  echo angleBetween(0.1, 0.2 - PI*2), " should be: ", 0.1
+  echo angleBetween(0.1 + PI*2, 0.2), " should be: ", 0.1
+  echo angleBetween(0.1 - PI*2, 0.2), " should be: ", 0.1
+
+  echo angleBetween(0.2, 0.1), " should be: ", -0.1
+
+  echo angleBetween(0.2, 0.1 - PI*2), " should be: ", -0.1
+  echo angleBetween(0.2, 0.1 + PI*2), " should be: ", -0.1
+  echo angleBetween(0.2 + PI*2, 0.1), " should be: ", -0.1
+  echo angleBetween(0.2 - PI*2, 0.1), " should be: ", -0.1
+
+block:
+  echo "# basic vector vec2"
+  var a = vec2(1, 2)
+  var b = vec2(7, 6)
+  var n = 13.7
+  echo a + b
+  echo a - b
+  echo a * n
+  echo a / n
+  a += b
+  echo a
+  a -= b
+  echo a
+  a *= n
+  echo a
+  a /= n
+  echo a
+
+block:
+  echo "# basic vector vec3"
+  var a = vec3(1, 2, 3)
+  var b = vec3(7, 6, 5)
+  var n = 13.7
+  echo a + b
+  echo a - b
+  echo a * n
+  echo a / n
+  a += b
+  echo a
+  a -= b
+  echo a
+  a *= n
+  echo a
+  a /= n
+  echo a
+
+block:
+  echo "# basic vector vec4"
+  var a = vec4(1, 2, 3, 4)
+  var b = vec4(7, 6, 5, 4)
+  var n = 13.7
+  echo a + b
+  echo a - b
+  echo a * n
+  echo a / n
+  a += b
+  echo a
+  a -= b
+  echo a
+  a *= n
+  echo a
+  a /= n
+  echo a
+
+block:
+  echo "# basic vector mat4"
+  var m1 = mat4(
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1)
+  echo m1
+  var q1 = m1.quat()
+  echo q1
+  var m2 = q1.mat4()
+  echo m2
+  assert m1.close(m2)
+
+block:
+  echo "# basic vector mat4 -1"
+  var m1 = mat4(
+    1, 0, 0, 0,
+    0, 0, -1, 0,
+    0, 1, 0, 0,
+    0, 0, 0, 1)
+  echo m1
+  var q1 = m1.quat()
+  echo q1
+  var m2 = q1.mat4()
+  echo m2
+  assert m1.close(m2)
+
+block:
+  echo "# Y 90"
+  var m1 = rotate(PI/2, vec3(0, 1, 0))
+  echo m1
+  var q1 = m1.quat()
+  echo q1
+  var m2 = q1.mat4()
+  echo m2
+  assert m1.close(m2)
+
+block:
+  echo "# -Y 90"
+  var m1 = rotate(PI/2, vec3(0, -1, 0))
+  echo m1
+  var q1 = m1.quat()
+  echo q1
+  var m2 = q1.mat4()
+  echo m2
+  assert m1.close(m2)
+
+block:
+  echo "# X 90"
+  var m1 = rotate(PI/2, vec3(1, 0, 0))
+  echo m1
+  var q1 = m1.quat()
+  echo q1
+  var m2 = q1.mat4()
+  echo m2
+  echo m1.close(m2)
+
+block:
+  echo "# Y 90"
+  var m1 = rotate(PI/2, vec3(1, 0, 0))
+  echo m1
+  var q1 = m1.quat()
+  echo q1
+  var m2 = q1.mat4()
+  echo m2
+  echo m1.close(m2)
+
+block:
+  echo "# 1,1,1 1.11rad"
+  var m1 = rotate(PI*1.11, vec3(1, 1, 1).normalize())
+  echo m1
+  var q1 = m1.quat()
+  echo q1
+  var m2 = q1.mat4()
+  echo m2
+  assert m1.close(m2)
+
+block:
+  echo "# 1,1,1 1.11rad"
+  var m1 = rotate(PI*1.11, vec3(-1, 1, 1).normalize())
+  echo m1
+  var q1 = m1.quat()
+  echo q1
+  var m2 = q1.mat4()
+  echo m2
+  assert m1.close(m2)
+
+
+block:
+  echo "# 1,1,1 1.11rad"
+  var m1 = rotate(PI*1.11, vec3(-1, 0.34, 1.123).normalize())
+  echo m1
+  var q1 = m1.quat()
+  echo q1
+  var m2 = q1.mat4()
+  echo m2
+  assert m1.close(m2)
+
+block:
+  echo "# super random"
+  for i in 0..100:
+    var m1 = rotate(PI*rand(2.0), vec3(rand(2.0)-0.5, rand(2.0)-0.5, rand(2.0)-0.5).normalize())
+    echo m1
+    var q1 = m1.quat()
+    echo q1
+    var m2 = q1.mat4()
+    echo m2
+    assert m1.close(m2)
+
+block:
+  echo "# matrix to quat test"
+  # TODO: Fix this test
+  # var m1 = mat4(
+  #    -0.33089, -0.51266, -0.79227, 0.00000,
+  #           0,     -1.0,        0, 0.00000,
+  #           0,        0,      1.0, 0.00000,
+  #     0.00000,  0.00000,  0.00000, 1.00000)
+  # echo m1
+  # var q1 = m1.quat()
+  # echo q1
+  # var m2 = q1.mat4()
+  # echo m2
+  # assert m1.close(m2)
+
+block:
+  echo "# matrix to quat test"
+  # TODO: Fix this test
+  # var m1 = mat4(
+  #   -0.33089, -0.51266, -0.79227, 0.00000,
+  #   -0.44681,  0.82460, -0.34697, 0.00000,
+  #   -0.83119, -0.23918,  0.50191, 0.00000,
+  #     0.00000,  0.00000,  0.00000, 1.00000)
+
+  # echo vec3(  -0.33089, -0.51266, -0.79227).length
+  # echo vec3(  -0.44681,  0.82460, -0.34697).length
+  # echo vec3(  -0.83119, -0.23918,  0.50191).length
+
+  # echo m1
+  # var q1 = m1.quat().normalize()
+  # echo q1
+  # var m2 = q1.mat4()
+  # echo m2
+  # assert m1.close(m2)
diff --git a/tests/vmathtest.nims b/tests/vmathtest.nims
index 3bb69f8..80091ff 100644
--- a/tests/vmathtest.nims
+++ b/tests/vmathtest.nims
@@ -1 +1 @@
-switch("path", "$projectDir/../src")
\ No newline at end of file
+switch("path", "$projectDir/../src")
diff --git a/vmath.nimble b/vmath.nimble
index c5a6f5b..7e44656 100644
--- a/vmath.nimble
+++ b/vmath.nimble
@@ -9,3 +9,4 @@ srcDir        = "src"
 # Dependencies
 
 requires "nim >= 0.19.1"
+requires "mddoc >= 0.0.2"