diff --git a/.gitignore b/.gitignore
index 0eee755..10891cc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 exercise1/build/
 exercise2/build/
 exercise3/build/
+exercise4/build/
 
 .vscode/ipch
\ No newline at end of file
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index 219d479..8f14c13 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -77,6 +77,27 @@
       "options": {
         "cwd": "/usr/bin"
       }
-    }
+    },
+    {
+      "label": "Run Exercise 4",
+      "type": "shell",
+      "command": "cd exercise4/build/cmake/ && ./exercise4",
+      "dependsOn": "Build Exercise 4",
+      "problemMatcher": []
+    },
+    {
+      "label": "Build Exercise 4",
+      "type": "shell",
+      "command": "cd exercise4/build/cmake && cmake . && make -j16",
+      "problemMatcher": [],
+      "presentation": {
+        "echo": true,
+        "reveal": "always",
+        "focus": false,
+        "panel": "shared",
+        "showReuseMessage": true,
+        "clear": true
+      }
+    },
   ]
 }
\ No newline at end of file
diff --git a/exercise4/include/tiny_vec.h b/exercise4/include/tiny_vec.h
index 940a061..9f34372 100644
--- a/exercise4/include/tiny_vec.h
+++ b/exercise4/include/tiny_vec.h
@@ -1,93 +1,90 @@
 //
-// This source code is property of the Computer Graphics and Visualization 
-// chair of the TU Dresden. Do not distribute in modified or unmodified form! 
+// This source code is property of the Computer Graphics and Visualization
+// chair of the TU Dresden. Do not distribute in modified or unmodified form!
 // Copyright (C) 2016 CGV TU Dresden - All Rights Reserved
 //
 /*************************************************************************
 Template class for vectors.
 This template class defines small vectors of a defined dimension with
 an arbitrary data type. Basic operations such as addition of vectors and
-multiplication of a vector and a scalar are supported via operator 
-overloading. Also more advanced functions such as normalization and 
+multiplication of a vector and a scalar are supported via operator
+overloading. Also more advanced functions such as normalization and
 iterating through the elements are implemented.
-At the end of this file the data types "point2d", "point3d" and 
+At the end of this file the data types "point2d", "point3d" and
 "point4d" are specified as a tinyvec of doubles with the according dimension.
 *************************************************************************/
 
 #pragma once
 
-
-
-
 #include <iostream>
 #include <algorithm>
 #include <cassert>
 #include <math.h>
+#include <numeric>
 
-#ifdef _MSC_VER 
-#pragma warning( push )
-#pragma warning( disable : 4996 )
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996)
 #endif
-template <typename T,int N>
+template <typename T, int N>
 class tiny_vec
 {
 
-	T  _data[N];
+	T _data[N];
 
 public:
-	typedef T              value_type;
-	typedef T&             reference;
-	typedef const T&       const_reference;
-	typedef std::size_t    size_type;
+	typedef T value_type;
+	typedef T &reference;
+	typedef const T &const_reference;
+	typedef std::size_t size_type;
 	typedef std::ptrdiff_t difference_type;
-	typedef T*             pointer;
-	typedef const T*       const_pointer;
-	typedef T* iterator;
-	typedef const T* const_iterator;
+	typedef T *pointer;
+	typedef const T *const_pointer;
+	typedef T *iterator;
+	typedef const T *const_iterator;
 	typedef std::reverse_iterator<iterator> reverse_iterator;
 	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
 	tiny_vec();
 
 	template <typename InputIterator>
-	tiny_vec(InputIterator first,InputIterator last)
+	tiny_vec(InputIterator first, InputIterator last)
 	{
-		std::copy(first,last,begin());
+		std::copy(first, last, begin());
 	}
 
-
-	tiny_vec(size_t n, const T* marray);
+	tiny_vec(size_t n, const T *marray);
 
 	~tiny_vec();
 
-	tiny_vec(const T&x,const T&y);
+	tiny_vec(const T &x, const T &y);
 
-	tiny_vec(const T&x,const T&y, const T&z);
+	tiny_vec(const T &x, const T &y, const T &z);
 
-	tiny_vec(const T&x, const T&y, const T&z,const T& w);	
+	tiny_vec(const T &x, const T &y, const T &z, const T &w);
 
 	int size() const;
 
-	operator T*();
+	operator T *();
 
-	operator const T*() const;
+	operator const T *() const;
 
-	void set(const T& x);
+	void set(const T &x);
 
-	void set(const T& x, const T& y);
+	void set(const T &x, const T &y);
 
-	void set(const T& x, const T& y,const T& z);
+	void set(const T &x, const T &y, const T &z);
 
-	void set(const T& x, const T& y,const T& z, const T& w);
+	void set(const T &x, const T &y, const T &z, const T &w);
 
-	tiny_vec& operator=(const T &s);
+	tiny_vec &operator=(const T &s);
 
-	tiny_vec& operator=(int s);
+	tiny_vec &operator=(int s);
 
-	tiny_vec& operator=(const tiny_vec & v);
+	tiny_vec &operator=(const tiny_vec &v);
+
+	void fill(const T &s);
 
-	void fill(const T& s);
-	
 	void zeros();
 
 	void ones();
@@ -106,124 +103,107 @@ public:
 
 	const_reverse_iterator rbegin() const;
 
-	const_reverse_iterator rend() const;	
+	const_reverse_iterator rend() const;
 
-	bool operator==(const tiny_vec& v) const;
+	bool operator==(const tiny_vec &v) const;
 
-	bool operator!=(const tiny_vec& v) const;
+	bool operator!=(const tiny_vec &v) const;
 
 	tiny_vec operator-() const;
-	
 
+	tiny_vec &operator+=(int s);
 
-	tiny_vec& operator+=(int s);
+	tiny_vec &operator+=(float s);
 
-	tiny_vec& operator+=(float s);
+	tiny_vec &operator+=(double s);
 
-	tiny_vec& operator+=(double s);
-
-
-	
 	tiny_vec operator+(int s) const;
 
 	tiny_vec operator+(float s) const;
 
 	tiny_vec operator+(double s) const;
-	
-	
-	
-	tiny_vec& operator-=(int s);
 
-	tiny_vec& operator-=(float s);
-		
-	tiny_vec& operator-=(double s);
-	
+	tiny_vec &operator-=(int s);
+
+	tiny_vec &operator-=(float s);
+
+	tiny_vec &operator-=(double s);
 
-	
 	tiny_vec operator-(int s) const;
 
 	tiny_vec operator-(float s) const;
 
 	tiny_vec operator-(double s) const;
-	
-	
-	
-	tiny_vec& operator*=(int s);
 
-	tiny_vec& operator*=(float s);
+	tiny_vec &operator*=(int s);
 
-	tiny_vec& operator*=(double s);
-	
+	tiny_vec &operator*=(float s);
+
+	tiny_vec &operator*=(double s);
 
-		
 	tiny_vec operator*(int s) const;
 
 	tiny_vec operator*(float s) const;
 
 	tiny_vec operator*(double s) const;
-	
 
+	tiny_vec &operator/=(int s);
 
-	tiny_vec& operator/=(int s);
+	tiny_vec &operator/=(float s);
 
-	tiny_vec& operator/=(float s);
+	tiny_vec &operator/=(double s);
 
-	tiny_vec& operator/=(double s);
-
-
-	
 	tiny_vec operator/(int s) const;
 
 	tiny_vec operator/(float s) const;
-	
+
 	tiny_vec operator/(double s) const;
 
-	tiny_vec& operator+=(const tiny_vec& v);
+	tiny_vec &operator+=(const tiny_vec &v);
 
-	tiny_vec operator+(const tiny_vec& v) const;
+	tiny_vec operator+(const tiny_vec &v) const;
 
-	tiny_vec& operator-=(const tiny_vec& v);
+	tiny_vec &operator-=(const tiny_vec &v);
 
-	tiny_vec operator-(const tiny_vec& v) const;
+	tiny_vec operator-(const tiny_vec &v) const;
 
-	tiny_vec& operator*=(const tiny_vec& v);
+	tiny_vec &operator*=(const tiny_vec &v);
 
-	tiny_vec operator*(const tiny_vec& v) const;
+	tiny_vec operator*(const tiny_vec &v) const;
 
-	tiny_vec& operator/=(const tiny_vec& v);
+	tiny_vec &operator/=(const tiny_vec &v);
 
-	tiny_vec operator/(const tiny_vec& v) const;
+	tiny_vec operator/(const tiny_vec &v) const;
 
-	T& operator()(size_t i);
+	T &operator()(size_t i);
 
 	T operator()(size_t i) const;
 
-	T& x() {return _data[0];};
-	T& y() {return _data[1];};
-	T& z() {return _data[2];};
-
-	T x() const {return _data[0];};
-	T y() const {return _data[1];};
-	T z() const {return _data[2];};
+	T &x() { return _data[0]; };
+	T &y() { return _data[1]; };
+	T &z() { return _data[2]; };
 
+	T x() const { return _data[0]; };
+	T y() const { return _data[1]; };
+	T z() const { return _data[2]; };
 
 	void sort();
 
 	void random_shuffle();
 
-	T& min_elem();
+	T &min_elem();
 
 	T min_elem() const;
 
 	size_t min_index() const;
 
-	T& max_elem();
+	T &max_elem();
 
 	T max_elem() const;
 
 	size_t max_index() const;
 
-	T& median_elem();
+	T &median_elem();
 
 	size_t median_index() const;
 
@@ -232,262 +212,243 @@ public:
 	T length() const;
 
 	void normalize();
-
 };
 
-
+template <typename T, int N>
+tiny_vec<T, N>::tiny_vec() {}
 
 template <typename T, int N>
-tiny_vec<T,N>::tiny_vec(){}
-
-
-template <typename T, int N>
-tiny_vec<T,N>::tiny_vec(size_t n,const T* marray)
-{			
-	std::copy(marray,marray+N,begin());		
-}
-
-template <typename T, int N>
-tiny_vec<T,N>::~tiny_vec(){}
-
-template <typename T, int N>
-tiny_vec<T,N>::tiny_vec(const T&x,const T&y)
+tiny_vec<T, N>::tiny_vec(size_t n, const T *marray)
 {
-	_data[0]=x;
-	_data[1]=y;
+	std::copy(marray, marray + N, begin());
 }
 
 template <typename T, int N>
-tiny_vec<T,N>::tiny_vec(const T&x,const T&y, const T&z)
+tiny_vec<T, N>::~tiny_vec() {}
+
+template <typename T, int N>
+tiny_vec<T, N>::tiny_vec(const T &x, const T &y)
 {
-	_data[0]=x;
-	_data[1]=y;
-	_data[2]=z;
+	_data[0] = x;
+	_data[1] = y;
 }
 
 template <typename T, int N>
-tiny_vec<T,N>::tiny_vec(const T&x, const T&y, const T&z,const T& w)
+tiny_vec<T, N>::tiny_vec(const T &x, const T &y, const T &z)
 {
-	_data[0]=x;
-	_data[1]=y;
-	_data[2]=z;
-	_data[3]=w;
+	_data[0] = x;
+	_data[1] = y;
+	_data[2] = z;
 }
 
 template <typename T, int N>
-void tiny_vec<T,N>::set(const T& x)
+tiny_vec<T, N>::tiny_vec(const T &x, const T &y, const T &z, const T &w)
 {
-	_data[0]=x;
+	_data[0] = x;
+	_data[1] = y;
+	_data[2] = z;
+	_data[3] = w;
 }
 
 template <typename T, int N>
-void tiny_vec<T,N>::set(const T& x, const T& y)
+void tiny_vec<T, N>::set(const T &x)
 {
-	_data[0]=x;
-	_data[1]=y;
-
+	_data[0] = x;
 }
+
 template <typename T, int N>
-void tiny_vec<T,N>::set(const T& x, const T& y,const T& z)
+void tiny_vec<T, N>::set(const T &x, const T &y)
 {
-	_data[0]=x;
-	_data[1]=y;
-	_data[2]=z;
-
+	_data[0] = x;
+	_data[1] = y;
 }
 template <typename T, int N>
-void tiny_vec<T,N>::set(const T& x, const T& y,const T& z, const T& w)
+void tiny_vec<T, N>::set(const T &x, const T &y, const T &z)
 {
-	_data[0]=x;
-	_data[1]=y;
-	_data[2]=z;
-	_data[3]=w;
+	_data[0] = x;
+	_data[1] = y;
+	_data[2] = z;
+}
+template <typename T, int N>
+void tiny_vec<T, N>::set(const T &x, const T &y, const T &z, const T &w)
+{
+	_data[0] = x;
+	_data[1] = y;
+	_data[2] = z;
+	_data[3] = w;
 }
 
 template <typename T, int N>
-int tiny_vec<T,N>::size() const
+int tiny_vec<T, N>::size() const
 {
 	return N;
 }
 
 template <typename T, int N>
-tiny_vec<T,N>::operator T*()
-{
-	return _data;
-}
-
-
-template <typename T, int N>
-tiny_vec<T,N>::operator const T*() const
+tiny_vec<T, N>::operator T *()
 {
 	return _data;
 }
 
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator=(const T &s)
+tiny_vec<T, N>::operator const T *() const
 {
-	for(int i=0;i < N;i++)
-		_data[i]=s;
+	return _data;
+}
+
+template <typename T, int N>
+tiny_vec<T, N> &tiny_vec<T, N>::operator=(const T &s)
+{
+	for (int i = 0; i < N; i++)
+		_data[i] = s;
 
 	return *this;
 }
 
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator=(int s)
+tiny_vec<T, N> &tiny_vec<T, N>::operator=(int s)
 {
-	for(int i=0;i<N;i++)
-		_data[i]=(T)s;
+	for (int i = 0; i < N; i++)
+		_data[i] = (T)s;
 
 	return *this;
 }
 
-
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator=(const tiny_vec & v)
+tiny_vec<T, N> &tiny_vec<T, N>::operator=(const tiny_vec &v)
 {
-	if(&v== this) return *this;
+	if (&v == this)
+		return *this;
 
-	std::copy(v.begin(),v.end(),begin());
+	std::copy(v.begin(), v.end(), begin());
 	return *this;
 }
 
-
-
 template <typename T, int N>
-void tiny_vec<T,N>::fill(const T& s)
+void tiny_vec<T, N>::fill(const T &s)
 {
-	std::fill(begin(),end(),s);
+	std::fill(begin(), end(), s);
 }
 
-
-
 template <typename T, int N>
-void tiny_vec<T,N>::zeros()
-{	
+void tiny_vec<T, N>::zeros()
+{
 	T zero;
-	zero=0;
+	zero = 0;
 	std::fill(begin(), end(), zero);
 }
 
 template <typename T, int N>
-void tiny_vec<T,N>::ones()
+void tiny_vec<T, N>::ones()
 {
 	T one;
 	one = 1;
 	std::fill(begin(), end(), one);
 }
 
-
-
 template <typename T, int N>
-typename tiny_vec<T,N>::iterator tiny_vec<T,N>::begin()
+typename tiny_vec<T, N>::iterator tiny_vec<T, N>::begin()
 {
 	return _data;
 }
 
 template <typename T, int N>
-typename tiny_vec<T,N>::const_iterator tiny_vec<T,N>::begin() const
+typename tiny_vec<T, N>::const_iterator tiny_vec<T, N>::begin() const
 {
 	return _data;
 }
 
 template <typename T, int N>
-typename tiny_vec<T,N>::iterator tiny_vec<T,N>::end()
+typename tiny_vec<T, N>::iterator tiny_vec<T, N>::end()
 {
 	return _data + N;
 }
 
 template <typename T, int N>
-typename tiny_vec<T,N>::const_iterator tiny_vec<T,N>::end() const
+typename tiny_vec<T, N>::const_iterator tiny_vec<T, N>::end() const
 {
-	return _data +N;
+	return _data + N;
 }
 
 template <typename T, int N>
-typename tiny_vec<T,N>::reverse_iterator tiny_vec<T,N>::rbegin()
+typename tiny_vec<T, N>::reverse_iterator tiny_vec<T, N>::rbegin()
 {
 	return reverse_iterator(end());
 }
 
 template <typename T, int N>
-typename tiny_vec<T,N>::reverse_iterator tiny_vec<T,N>::rend()
+typename tiny_vec<T, N>::reverse_iterator tiny_vec<T, N>::rend()
 {
 	return reverse_iterator(begin());
 }
 
 template <typename T, int N>
-typename tiny_vec<T,N>::const_reverse_iterator tiny_vec<T,N>::rbegin() const
+typename tiny_vec<T, N>::const_reverse_iterator tiny_vec<T, N>::rbegin() const
 {
 	return const_reverse_iterator(end());
 }
 
 template <typename T, int N>
-typename tiny_vec<T,N>::const_reverse_iterator tiny_vec<T,N>:: rend() const
+typename tiny_vec<T, N>::const_reverse_iterator tiny_vec<T, N>::rend() const
 {
 	return const_reverse_iterator(begin());
 }
 
 template <typename T, int N>
-bool tiny_vec<T,N>::operator==(const tiny_vec<T,N>& v) const
+bool tiny_vec<T, N>::operator==(const tiny_vec<T, N> &v) const
 {
-	return std::equal(begin(),end(),v.begin());
+	return std::equal(begin(), end(), v.begin());
 }
 
-
 template <typename T, int N>
-bool tiny_vec<T,N>::operator!=(const tiny_vec<T,N>& v) const
+bool tiny_vec<T, N>::operator!=(const tiny_vec<T, N> &v) const
 {
 	return !(*this == v);
 }
 
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator-() const
+tiny_vec<T, N> tiny_vec<T, N>::operator-() const
 {
-	return  (T)-1* *this;
+	return (T)-1 * *this;
 }
 
-
-
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator+=(int s)
+tiny_vec<T, N> &tiny_vec<T, N>::operator+=(int s)
 {
 
-	for(int i=0;i<size();i++)
-		_data[i]+=s;
+	for (int i = 0; i < size(); i++)
+		_data[i] += s;
 	return *this;
 }
 
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator+=(float s)
+tiny_vec<T, N> &tiny_vec<T, N>::operator+=(float s)
 {
 
-	for(int i=0;i<size();i++)
-		_data[i]+=(T)s;
+	for (int i = 0; i < size(); i++)
+		_data[i] += (T)s;
 	return *this;
 }
 
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator+=(double s)
+tiny_vec<T, N> &tiny_vec<T, N>::operator+=(double s)
 {
 
-	for(int i=0;i<size();i++)
-		_data[i]+=(T)s;
+	for (int i = 0; i < size(); i++)
+		_data[i] += (T)s;
 	return *this;
 }
 
-
-
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator+(int s) const
+tiny_vec<T, N> tiny_vec<T, N>::operator+(int s) const
 {
 	tiny_vec r = *this;
 	r += s;
 	return r;
 }
 
-
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator+(float s) const
+tiny_vec<T, N> tiny_vec<T, N>::operator+(float s) const
 {
 	tiny_vec r = *this;
 	r += (T)s;
@@ -495,476 +456,435 @@ tiny_vec<T,N> tiny_vec<T,N>::operator+(float s) const
 }
 
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator+(double s) const
+tiny_vec<T, N> tiny_vec<T, N>::operator+(double s) const
 {
 	tiny_vec r = *this;
 	r += (T)s;
 	return r;
 }
 
-
-
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator-=(int s)
+tiny_vec<T, N> &tiny_vec<T, N>::operator-=(int s)
 {
 
-	for(int i=0;i<N;i++)
-		_data[i]-=(T)s;
+	for (int i = 0; i < N; i++)
+		_data[i] -= (T)s;
 
 	return *this;
 }
 
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator-=(float s)
+tiny_vec<T, N> &tiny_vec<T, N>::operator-=(float s)
 {
 
-	for(int i=0;i<N;i++)
-		_data[i]-=(T)s;
+	for (int i = 0; i < N; i++)
+		_data[i] -= (T)s;
 
 	return *this;
 }
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator-=(double s)
+tiny_vec<T, N> &tiny_vec<T, N>::operator-=(double s)
 {
 
-	for(int i=0;i<N;i++)
-		_data[i]-=(T)s;
+	for (int i = 0; i < N; i++)
+		_data[i] -= (T)s;
 
 	return *this;
 }
 
-
-
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator-(int s) const
+tiny_vec<T, N> tiny_vec<T, N>::operator-(int s) const
 {
 	tiny_vec r = *this;
 	r -= (T)s;
 	return r;
 }
 
-
-
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator-(float s) const
+tiny_vec<T, N> tiny_vec<T, N>::operator-(float s) const
 {
 	tiny_vec r = *this;
 	r -= (T)s;
 	return r;
 }
 
-
-
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator-(double s) const
+tiny_vec<T, N> tiny_vec<T, N>::operator-(double s) const
 {
 	tiny_vec r = *this;
 	r -= (T)s;
 	return r;
 }
 
-
-
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator*=(int s)
+tiny_vec<T, N> &tiny_vec<T, N>::operator*=(int s)
 {
-	for(int i=0; i <N; i++)
-		_data[i]*=(T)s;
+	for (int i = 0; i < N; i++)
+		_data[i] *= (T)s;
 
 	return *this;
 }
 
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator*=(float s)
+tiny_vec<T, N> &tiny_vec<T, N>::operator*=(float s)
 {
-	for(int i=0; i <N; i++)
-		_data[i]*=(T)s;
+	for (int i = 0; i < N; i++)
+		_data[i] *= (T)s;
 
 	return *this;
 }
 
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator*=(double s)
+tiny_vec<T, N> &tiny_vec<T, N>::operator*=(double s)
 {
-	for(int i=0; i <N; i++)
-		_data[i]*=(T)s;
+	for (int i = 0; i < N; i++)
+		_data[i] *= (T)s;
 
 	return *this;
 }
 
-
-
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator*(int s) const
+tiny_vec<T, N> tiny_vec<T, N>::operator*(int s) const
 {
-	tiny_vec<T,N> r = *this;
+	tiny_vec<T, N> r = *this;
 	r *= (T)s;
 	return r;
 }
 
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator*(float s) const
+tiny_vec<T, N> tiny_vec<T, N>::operator*(float s) const
 {
-	tiny_vec<T,N> r = *this;
+	tiny_vec<T, N> r = *this;
 	r *= (T)s;
 	return r;
 }
 
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator*(double s) const
+tiny_vec<T, N> tiny_vec<T, N>::operator*(double s) const
 {
-	tiny_vec<T,N> r = *this;
+	tiny_vec<T, N> r = *this;
 	r *= (T)s;
 	return r;
 }
 
-
-
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator/=(int s)
+tiny_vec<T, N> &tiny_vec<T, N>::operator/=(int s)
 {
 
-	for(int i=0;i <N; i++)
-		_data[i]/=(T)s;
+	for (int i = 0; i < N; i++)
+		_data[i] /= (T)s;
 	return *this;
 }
 
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator/=(float s)
+tiny_vec<T, N> &tiny_vec<T, N>::operator/=(float s)
 {
 
-	for(int i=0;i <N; i++)
-		_data[i]/=(T)s;
+	for (int i = 0; i < N; i++)
+		_data[i] /= (T)s;
 	return *this;
 }
 
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator/=(double s)
+tiny_vec<T, N> &tiny_vec<T, N>::operator/=(double s)
 {
 
-	for(int i=0;i <N; i++)
-		_data[i]/=(T)s;
+	for (int i = 0; i < N; i++)
+		_data[i] /= (T)s;
 	return *this;
 }
 
-
-
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator/(int s) const
+tiny_vec<T, N> tiny_vec<T, N>::operator/(int s) const
 {
-	tiny_vec<T,N> r = *this;
+	tiny_vec<T, N> r = *this;
 	r /= (T)s;
 	return r;
 }
 
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator/(float s) const
+tiny_vec<T, N> tiny_vec<T, N>::operator/(float s) const
 {
-	tiny_vec<T,N> r = *this;
+	tiny_vec<T, N> r = *this;
 	r /= (T)s;
 	return r;
 }
 
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator/(double s) const
+tiny_vec<T, N> tiny_vec<T, N>::operator/(double s) const
 {
-	tiny_vec<T,N> r = *this;
+	tiny_vec<T, N> r = *this;
 	r /= (T)s;
 	return r;
 }
 
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator+=(const tiny_vec& v)
+tiny_vec<T, N> &tiny_vec<T, N>::operator+=(const tiny_vec &v)
 {
 
-	for(int i=0; i <N;i++)
+	for (int i = 0; i < N; i++)
 		_data[i] += v[i];
 
 	return *this;
 }
 
-
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator+(const tiny_vec& v) const
+tiny_vec<T, N> tiny_vec<T, N>::operator+(const tiny_vec &v) const
 {
 	tiny_vec r = *this;
 	r += v;
 	return r;
 }
 
-
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator-=(const tiny_vec& v)
+tiny_vec<T, N> &tiny_vec<T, N>::operator-=(const tiny_vec &v)
 {
-	for(int i =0; i < N; i++)
-		_data[i]-= v[i];
+	for (int i = 0; i < N; i++)
+		_data[i] -= v[i];
 
 	return *this;
 }
 
-
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator-(const tiny_vec& v) const
+tiny_vec<T, N> tiny_vec<T, N>::operator-(const tiny_vec &v) const
 {
 	tiny_vec r = *this;
 	r -= v;
 	return r;
 }
 
-
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator*=(const tiny_vec& v)
+tiny_vec<T, N> &tiny_vec<T, N>::operator*=(const tiny_vec &v)
 {
-	for(int i=0; i < N; i++)
-		_data[i]*= v[i];
+	for (int i = 0; i < N; i++)
+		_data[i] *= v[i];
 	return *this;
 }
 
-
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator*(const tiny_vec& v) const
+tiny_vec<T, N> tiny_vec<T, N>::operator*(const tiny_vec &v) const
 {
-	tiny_vec<T,N> r = *this;
+	tiny_vec<T, N> r = *this;
 	r *= v;
 	return r;
 }
 
-
 template <typename T, int N>
-tiny_vec<T,N>& tiny_vec<T,N>::operator/=(const tiny_vec& v)
+tiny_vec<T, N> &tiny_vec<T, N>::operator/=(const tiny_vec &v)
 {
-	for(int i = 0; i < N; i++)
+	for (int i = 0; i < N; i++)
 		_data[i] /= v[i];
 
 	return *this;
 }
 
-
 template <typename T, int N>
-tiny_vec<T,N> tiny_vec<T,N>::operator/(const tiny_vec<T,N>& v) const
+tiny_vec<T, N> tiny_vec<T, N>::operator/(const tiny_vec<T, N> &v) const
 {
 	tiny_vec r = *this;
 	r /= v;
 	return r;
 }
 
-
 template <typename T, int N>
-T& tiny_vec<T,N>::operator()(size_t i)
+T &tiny_vec<T, N>::operator()(size_t i)
 {
 	assert(i >= 0 && i < N);
 	return _data[i];
 }
 
 template <typename T, int N>
-T tiny_vec<T,N>::operator()(size_t i) const
+T tiny_vec<T, N>::operator()(size_t i) const
 {
 	assert(i >= 0 && i < N);
 	return _data[i];
 }
 
 template <typename T, int N>
-void tiny_vec<T,N>::sort()
+void tiny_vec<T, N>::sort()
 {
-	std::sort(begin(),end());
+	std::sort(begin(), end());
 }
 
 template <typename T, int N>
-void tiny_vec<T,N>::random_shuffle()
+void tiny_vec<T, N>::random_shuffle()
 {
-	std::random_shuffle(begin(),end());
+	std::random_shuffle(begin(), end());
 }
 
 template <typename T, int N>
-T& tiny_vec<T,N>::min_elem()
+T &tiny_vec<T, N>::min_elem()
 {
-	return *std::min_element(begin(),end());
+	return *std::min_element(begin(), end());
 }
 
 template <typename T, int N>
-T tiny_vec<T,N>::min_elem() const
+T tiny_vec<T, N>::min_elem() const
 {
-	return *std::min_element(begin(),end());
+	return *std::min_element(begin(), end());
 }
 
 template <typename T, int N>
-size_t tiny_vec<T,N>::min_index() const
+size_t tiny_vec<T, N>::min_index() const
 {
-	return std::distance(begin(),std::min_element(begin(),end()));
+	return std::distance(begin(), std::min_element(begin(), end()));
 }
 
 template <typename T, int N>
-T& tiny_vec<T,N>::max_elem() 
+T &tiny_vec<T, N>::max_elem()
 {
-	return *std::max_element(begin(),end());
+	return *std::max_element(begin(), end());
 }
 
 template <typename T, int N>
-T tiny_vec<T,N>::max_elem() const
+T tiny_vec<T, N>::max_elem() const
 {
-	return *std::max_element(begin(),end());
+	return *std::max_element(begin(), end());
 }
 
 template <typename T, int N>
-size_t tiny_vec<T,N>::max_index() const
+size_t tiny_vec<T, N>::max_index() const
 {
-	return std::distance(begin(),std::max_element(begin(),end()));
+	return std::distance(begin(), std::max_element(begin(), end()));
 }
 
-
 template <typename T, int N>
-T tiny_vec<T,N>::sqr_length() const
+T tiny_vec<T, N>::sqr_length() const
 {
-	iterator it= (double*)begin();
+	iterator it = (double *)begin();
 	T l = 0;
-	while(it != end())
-		l += (*it)*(*it++);
+	while (it != end())
+		l += (*it) * (*it++);
 
 	return l;
 }
 
 template <typename T, int N>
-T tiny_vec<T,N>::length() const
+T tiny_vec<T, N>::length() const
 {
 	T l = sqr_length();
 	return sqrt(l);
 }
 
-
 template <typename T, int N>
-tiny_vec<T,N> operator+(const T& s, const tiny_vec<T,N>& v)
+tiny_vec<T, N> operator+(const T &s, const tiny_vec<T, N> &v)
 {
-	return v+s;
-}
-
-
-template <typename T, int N>
-tiny_vec<T,N> operator+(int s, const tiny_vec<T,N>& v)
-{
-	return v+(T)s;
+	return v + s;
 }
 
 template <typename T, int N>
-tiny_vec<T,N> operator-(const T& s, const tiny_vec<T,N>& v)
+tiny_vec<T, N> operator+(int s, const tiny_vec<T, N> &v)
 {
-	return -v+s;
-}
-
-
-template <typename T, int N>
-tiny_vec<T,N> operator-(int s, const tiny_vec<T,N>& v)
-{
-	return -v+(T)s;
-}
-
-
-template <typename T, int N>
-tiny_vec<T,N> operator*(const T& s, const tiny_vec<T,N>& v)
-{
-	return v*s;
-}
-
-
-template <typename T, int N>
-tiny_vec<T,N> operator*(int s, const tiny_vec<T,N>& v)
-{
-	return v*(T)s;
+	return v + (T)s;
 }
 
 template <typename T, int N>
-tiny_vec<T,N> operator/(const T& s, const tiny_vec<T,N>& v)
+tiny_vec<T, N> operator-(const T &s, const tiny_vec<T, N> &v)
 {
-	return v*(T)(1.0/s);
+	return -v + s;
 }
 
 template <typename T, int N>
-tiny_vec<T,N> operator/(int s, const tiny_vec<T,N>& v)
+tiny_vec<T, N> operator-(int s, const tiny_vec<T, N> &v)
 {
-	return v*(T)(1.0/s);
+	return -v + (T)s;
 }
 
 template <typename T, int N>
-T dot(const tiny_vec<T,N>& v1, const tiny_vec<T,N>& v2)
+tiny_vec<T, N> operator*(const T &s, const tiny_vec<T, N> &v)
 {
-	return std::inner_product(v1.begin(),v1.end(),v2.begin(),(T)0);
+	return v * s;
 }
 
+template <typename T, int N>
+tiny_vec<T, N> operator*(int s, const tiny_vec<T, N> &v)
+{
+	return v * (T)s;
+}
 
+template <typename T, int N>
+tiny_vec<T, N> operator/(const T &s, const tiny_vec<T, N> &v)
+{
+	return v * (T)(1.0 / s);
+}
+
+template <typename T, int N>
+tiny_vec<T, N> operator/(int s, const tiny_vec<T, N> &v)
+{
+	return v * (T)(1.0 / s);
+}
+
+template <typename T, int N>
+T dot(const tiny_vec<T, N> &v1, const tiny_vec<T, N> &v2)
+{
+	return std::inner_product(v1.begin(), v1.end(), v2.begin(), (T)0);
+}
 
 template <typename T>
-tiny_vec<T,3> cross(const tiny_vec<T,3>& b, const tiny_vec<T,3>& c)
+tiny_vec<T, 3> cross(const tiny_vec<T, 3> &b, const tiny_vec<T, 3> &c)
 {
-	tiny_vec<T,3> a;
-	a[0] = b(1)*c(2) - b(2)*c(1);
-	a[1] = b(2)*c(0) - b(0)*c(2);
-	a[2] = b(0)*c(1) - b(1)*c(0);
+	tiny_vec<T, 3> a;
+	a[0] = b(1) * c(2) - b(2) * c(1);
+	a[1] = b(2) * c(0) - b(0) * c(2);
+	a[2] = b(0) * c(1) - b(1) * c(0);
 	return a;
 }
 
-
 template <typename T, int N>
-tiny_vec<T,N+1> homog(const tiny_vec<T,N>& v)
+tiny_vec<T, N + 1> homog(const tiny_vec<T, N> &v)
 {
-	tiny_vec<T,N+1> vh;
-	std::copy(v.begin(),v.end(),vh.begin());
+	tiny_vec<T, N + 1> vh;
+	std::copy(v.begin(), v.end(), vh.begin());
 	vh(v.size()) = (T)1;
 	return vh;
 }
 
 template <typename T, int N>
-tiny_vec<T,N-1> unhomog(const tiny_vec<T,N>& v)
+tiny_vec<T, N - 1> unhomog(const tiny_vec<T, N> &v)
 {
-	tiny_vec<T,N-1> vh;
-	T w = *(v.end()-1);
+	tiny_vec<T, N - 1> vh;
+	T w = *(v.end() - 1);
 
-	for(int i = 0; i < N-1; i++)
-		vh[i] = v[i]/w;
+	for (int i = 0; i < N - 1; i++)
+		vh[i] = v[i] / w;
 
 	return vh;
 }
 
-
-
-
 template <typename T, int N>
-std::ostream& operator<<(std::ostream& out, const tiny_vec<T,N>& v)
+std::ostream &operator<<(std::ostream &out, const tiny_vec<T, N> &v)
 {
-	if(v.size() > 0)
+	if (v.size() > 0)
 		out << v[0];
-	for(int i = 1; i < v.size(); i++)
-		out <<" " <<v[i];
+	for (int i = 1; i < v.size(); i++)
+		out << " " << v[i];
 	return out;
 }
 
-
-template <typename T,int N>
-std::istream& operator>>(std::istream& in, tiny_vec<T,N>& v)
+template <typename T, int N>
+std::istream &operator>>(std::istream &in, tiny_vec<T, N> &v)
 {
-	for(int i = 0; i < v.size(); i++)
+	for (int i = 0; i < v.size(); i++)
 		in >> v[i];
 
 	return in;
 }
 
 template <typename T, int N>
-void tiny_vec<T,N>::normalize()
+void tiny_vec<T, N>::normalize()
 {
 	T l = length();
-	if(l != 0)
+	if (l != 0)
 		operator/=(l);
 }
 
-
-
 typedef tiny_vec<double, 2> point2d;
 typedef tiny_vec<double, 3> point3d;
 typedef tiny_vec<double, 4> point4d;
 #ifdef _MSC_VER
-#pragma warning( pop )
+#pragma warning(pop)
 #endif
 
-
-
 typedef tiny_vec<double, 2> vec2d;
 typedef tiny_vec<double, 3> vec3d;
 typedef tiny_vec<double, 4> vec4d;