diff --git a/vectors.hpp b/vectors.hpp
new file mode 100644
index 0000000..2ce0c24
--- /dev/null
+++ b/vectors.hpp
@@ -0,0 +1,333 @@
+/** Vector type and functionality
+ *
+ * This file defines the Vector type which defines some
+ * basic operations on a vector
+ *
+ * @file vectors.cpp
+ * @author Valentin Gehrke
+ * @version 0.1
+ * @date Friday, 11. December 2015 16:09
+ */
+
+#pragma once
+
+#include <cassert>
+#include <cmath>
+
+/** Vector type for N dimensions
+ *
+ * This class defines the Vector type
+ * with basic operations for vectors
+ *
+ * TElem must have add, subtract and multiplication defined.
+ *
+ * @tparam NDim dimension of the Vector
+ * @tparam TElem type of the coordinates
+ */
+template<
+    unsigned int NDim,
+    typename TElem
+>
+class Vector
+{
+    static_assert( NDim > 0 , "The Vector must atleast have one dimension." );
+private:
+    TElem coord[ NDim ];
+public:
+    /** Empty constructor
+     *
+     * This constructor just creates a Vector
+     * that doesn't have to be initialized
+     *
+     */
+    Vector() {}
+
+    /** Constructor for one value
+     *
+     * This constructor takes one value and
+     * initializes all coordinates with it
+     *
+     * @param initialElement Value for initialization
+     */
+    Vector(const TElem initialElement)
+    {
+        for( unsigned int i = 0; i < NDim; i++ )
+        {
+            this->coord[ i ] = initialElement;
+        }
+    }
+
+    /** constructor for initialization with array
+     *
+     * This constructor initializes the coordinates with the
+     * contents of an array
+     *
+     * @tparam template parameter
+     * @param parameter
+     * @return return value
+     */
+    Vector( const TElem initialData[ NDim ] )
+    {
+        for( unsigned int i = 0; i < NDim; i++ )
+        {
+            this->coord[ i ] = initialData[ i ];
+        }
+    }
+
+    /** constructor for brace enclosed initializer list
+     *
+     * this constructor initializes the coordinates with a
+     * brace enclosed initializer list which enables the object
+     * to be initialized like the following code example
+     *
+     * @code
+     * Vector<3,int> v{1,2,3};
+     * @end-code
+     *
+     * @tparam template parameter
+     * @param parameter
+     * @return return value
+     */
+    Vector( std::initializer_list<TElem> initialData )
+    {
+        assert( initialData.size() == NDim );
+        std::copy( initialData.begin(), initialData.end(), this->coord );
+    }
+
+    /** return the length of the vector
+     *
+     * This method calculates the length of the vector using
+     * the Pythagorean Theorem
+     *
+     * @return length of the vector
+     */
+    auto
+    length( ) const
+    -> decltype( sqrt( coord[0] ) )
+    {
+        TElem len = 0;
+        for( unsigned int index = 0; index < NDim; index++ )
+        {
+            len += this->coord[ index ] * this->coord[ index ];
+        }
+        return sqrt( len );
+    }
+
+    /** vector normalization
+     *
+     * This method normalizes the vector by dividing its
+     * coordinates by the length of the vector
+     *
+     * @return normalized vector
+     */
+    auto
+    normalize( ) const
+    -> Vector<NDim, decltype( coord[ 0 ] / sqrt( coord[ 0 ] ) ) >
+    {
+        return (*this) / this->length();
+    }
+
+    template<
+        typename TElemOther
+    >
+    auto
+    operator=( Vector<NDim,TElemOther> const & other )
+    -> Vector< NDim, TElem >&
+    {
+        for(unsigned int index = 0; index < NDim; index++) {
+            this->coord[ index ] = (TElem) other[ index ];
+        }
+        return *this;
+    }
+
+    /** division by scalar
+     *
+     * This method divides the coordinates of the vector
+     * by a scalar elementwise
+     *
+     * @param other divisor
+     * @return vector divided by divisor
+     */
+    template<
+        typename TFactor
+    >
+    auto
+    operator/( const TFactor other ) const
+    -> Vector<NDim, decltype( coord[0]/other ) >
+    {
+        Vector< NDim, decltype( coord[0]/other ) > result;
+        for( unsigned int index = 0; index < NDim; index++ )
+        {
+            result[ index ] = this->coord[ index ] / other;
+        }
+        return result;
+    }
+
+    /** + operator for Vector
+     *
+     * This operator adds 2 vectors together
+     * by adding their coordinates elementwise
+     *
+     * @param other Vector which is added to this vector
+     * @return A new Vector containing the result
+     */
+    template<
+        typename TElemOther
+    >
+    auto
+    operator+ ( const Vector<NDim, TElemOther> other ) const
+    -> Vector<NDim, decltype( coord[0] + other[0] ) >
+    {
+        Vector< NDim, decltype( coord[0] + other[0] ) > result;
+        for( unsigned int i = 0 ; i < NDim ; i++ ) {
+            result[ i ] = this->coord[ i ] + other[ i ];
+        }
+        return result;
+    }
+
+    /** += operator for Vector
+     *
+     * This operator adds another vector to the current
+     * vector without creating a new vector
+     *
+     * @param other The vector to be added
+     * @return The current vector after the addition
+     */
+    template<
+        typename TElemOther
+    >
+    auto
+    operator+= ( const Vector< NDim, TElemOther >& other )
+    -> Vector<NDim, TElem>&
+    {
+        for( unsigned int i = 0; i < NDim; i++ ) {
+            this->coord[ i ] = ( TElem )( this->coord[ i ] + other[ i ] );
+        }
+        return *this;
+    }
+
+    /** - operator for Vector
+     *
+     * This operator subtract another vector from the
+     * current vector resulting in a new Vector object
+     *
+     * @param other The vector to subtract
+     * @return A new vector containing the result
+     */
+    template<
+        typename TElemOther
+    >
+    auto
+    operator- ( const Vector<NDim,TElemOther> other ) const
+    -> Vector<
+        NDim,
+        decltype( coord[0] - other[0] )
+    >
+    {
+        Vector< NDim, decltype( coord[0] - other[0] ) > result;
+        for(unsigned int i = 0; i < NDim; i++)
+        {
+            result[ i ] = this->coord[ i ] - other[ i ];
+        }
+        return result;
+    }
+
+    /** negation operator for Vector
+     *
+     * This operator negates the current vector and
+     * returns the result as a new Vector
+     *
+     * @return A new vector containing the result
+     */
+    auto
+    operator- ( ) const
+    -> Vector<
+        NDim,
+        TElem
+    >
+    {
+        Vector< NDim , TElem > result;
+        for( unsigned int i = 0; i < NDim; i++ )
+        {
+            result[i] = - this->coord[ i ];
+        }
+        return result;
+    }
+
+    /** multiplication operator for multiplication with a scalar
+     *
+     * This operator multiplys every coordinate with a factor
+     *
+     * @param factor factor used for the multiplication
+     * @return A new vector containing the result
+     */
+    template<
+        typename TFactor
+    >
+    auto
+    operator*( TFactor factor ) const
+    -> Vector<
+        NDim,
+        decltype( factor * coord[0] )
+    >
+    {
+        Vector< NDim , decltype( factor * coord[0] ) > result;
+        for( unsigned int i = 0; i < NDim; i++ ) {
+            result[i] = this->coord[ i ] * factor;
+        }
+        return result;
+    }
+
+    /** subscript operator
+     *
+     * This operator is used to read or write single coordinates
+     * of the vector
+     *
+     * @param index The index of the coordinate to be read or written
+     * @return A reference to the coordinate specified by index
+     */
+    TElem&
+    operator[]( const unsigned int index )
+    {
+        assert( index >= 0 && index <= NDim );
+        return this->coord[ index ];
+    }
+
+    /** subscript operator for constant use
+     *
+     * This operator is used to read a single coordinate as a constant value
+     *
+     * @param index The index of the coordinate to be read
+     * @return The value of the coordinate specified by index
+     */
+    const TElem
+    operator[]( const unsigned int index ) const
+    {
+        assert( index >= 0 && index <= NDim );
+        return this->coord[ index ];
+    }
+};
+
+/** reverse definition for multiplikation with a scalar
+ *
+ * This function defines the multiplication operator
+ * for TElem * Vector<NDim, TElem> as the same as
+ * Vector<NDim, TElem> * TElem
+ *
+ * @tparam template parameter
+ * @param parameter
+ * @return return value
+ */
+template<
+    unsigned int NDim,
+    typename TElem,
+    typename TFactor
+>
+Vector<
+    NDim,
+    TElem
+>
+operator*( const TFactor factor, const Vector<NDim, TElem> vector )
+{
+    return vector.operator*( factor );
+}