diff --git a/include/world_builder/point.h b/include/world_builder/point.h
index b2faebb89..02ad6a2ca 100644
--- a/include/world_builder/point.h
+++ b/include/world_builder/point.h
@@ -42,24 +42,44 @@ namespace WorldBuilder
        * Constructor. Constructs a Point at (0,0) in 2d or (0,0,0) in 3d
        * with a Cartesian coordinate system.
        */
-      Point(CoordinateSystem coordinate_system);
+      inline
+      Point(CoordinateSystem coordinate_system_)
+        :
+        point(std::array<double,dim>()),
+        coordinate_system(coordinate_system_)
+      {}
 
       /**
        * Constructor. Constructs a Point from a std::array<double,dim> and
        * a coordinate system.
        */
-      Point(const std::array<double,dim> &location, CoordinateSystem coordinate_system);
+      inline
+      Point(const std::array<double,dim> &location, CoordinateSystem coordinate_system_)
+        :
+        point(location),
+        coordinate_system(coordinate_system_)
+      {}
 
       /**
        * Constructor. Constructs a Point from an other Point and
        * a coordinate system.
        */
-      Point(const Point<dim> &point, CoordinateSystem coordinate_system);
+      inline
+      Point(const Point<dim> &location, CoordinateSystem coordinate_system_)
+        :
+        point(location.get_array()),
+        coordinate_system(coordinate_system_)
+      {}
 
       /**
        * Constructor. Constructs a Point from an other Point.
        */
-      Point(const Point<dim> &point);
+      inline
+      Point(const Point<dim> &location)
+        :
+        point(location.get_array()),
+        coordinate_system(location.get_coordinate_system())
+      {}
 
       /**
        * Constructor. Constructs a 2d Point from two doubles and
@@ -76,59 +96,133 @@ namespace WorldBuilder
       /**
        * Destructor
        */
-      ~Point();
+      inline
+      ~Point() = default;
 
-      Point<dim> &operator=(const Point<dim> &point);
+      inline
+      Point<dim> &operator=(const Point<dim> &point_right)
+      {
+        point = point_right.point;
+        coordinate_system = point_right.coordinate_system;
+        return *this;
+      }
 
       /**
        * dot product
        */
-      double operator*(const Point<dim> &point) const;
+      inline
+      double operator*(const Point<dim> &point_right) const
+      {
+        const std::array<double,dim> &array = point_right.get_array();
+        double dot_product = 0;
+        for (unsigned int i = 0; i < dim; ++i)
+          dot_product += point[i] * array[i];
+        return dot_product;
+      }
 
 
       /**
        * Multiply the vector with a scalar
        */
-      Point<dim> operator*(const double scalar) const;
+      inline
+      Point<dim> operator*(const double scalar) const
+      {
+        // initialize the array to zero.
+        std::array<double,dim> array;
+        for (unsigned int i = 0; i < dim; ++i)
+          array[i] = point[i] * scalar;
+        return Point<dim>(array,coordinate_system);
+      }
 
       /**
        * Divide the vector through a scalar
        */
-      Point<dim> operator/(const double scalar) const;
+      inline
+      Point<dim> operator/(const double scalar) const
+      {
+        // initialize the array to zero.
+        std::array<double,dim> array;
+        const double one_over_scalar = 1/scalar;
+        for (unsigned int i = 0; i < dim; ++i)
+          array[i] = point[i] * one_over_scalar;
+        return Point<dim>(array,coordinate_system);
+      }
 
       /**
        * add two points
        */
-      Point<dim> operator+(const Point<dim> &point) const;
+      inline
+      Point<dim> operator+(const Point<dim> &point_right) const
+      {
+        WBAssert(coordinate_system == point_right.get_coordinate_system(),
+                 "Cannot add two points which represent different coordinate systems.");
+        Point<dim> point_tmp(point,coordinate_system);
+        for (unsigned int i = 0; i < dim; ++i)
+          point_tmp[i] += point_right[i];
+
+        return point_tmp;
+      }
 
 
       /**
        * Substract two points
        */
-      Point<dim> operator-(const Point<dim> &point) const;
-
+      inline
+      Point<dim> operator-(const Point<dim> &point_right) const
+      {
+        WBAssert(coordinate_system == point_right.get_coordinate_system(),
+                 "Cannot substract two points which represent different coordinate systems. Internal has type " << static_cast<int>(coordinate_system)
+                 << ", other point has type " << static_cast<int>(point_right.get_coordinate_system()));
+        Point<dim> point_tmp(point,coordinate_system);
+        for (unsigned int i = 0; i < dim; ++i)
+          point_tmp[i] -= point_right[i];
+
+        return point_tmp;
+      }
 
 
       /**
        * Multiply the vector with a scalar
        */
-      Point<dim> &operator*=(const double scalar);
-
+      inline
+      Point<dim> &operator*=(const double scalar)
+      {
+        for (unsigned int i = 0; i < dim; ++i)
+          point[i] *= scalar;
+        return *this;
+      }
       /**
        * Divide the vector through a scalar
        */
-      Point<dim> &operator/=(const double scalar);
+      inline
+      Point<dim> &operator/=(const double scalar)
+      {
+        for (unsigned int i = 0; i < dim; ++i)
+          point[i] /= scalar;
+        return *this;
+      }
 
       /**
        * add two points
        */
-      Point<dim> &operator+=(const Point<dim> &point);
-
+      inline
+      Point<dim> &operator+=(const Point<dim> &point_right)
+      {
+        for (unsigned int i = 0; i < dim; ++i)
+          point[i] += point_right[i];
+        return *this;
+      }
 
       /**
        * substract two points
        */
-      Point<dim> &operator-=(const Point<dim> &point);
+      inline
+      Point<dim> &operator-=(const Point<dim> &point_left)
+      {
+        for (unsigned int i = 0; i < dim; ++i)
+          point[i] -= point_left[i];
+        return *this;
+      }
 
       /**
        * access index (const)
@@ -171,26 +265,43 @@ namespace WorldBuilder
       /**
        * return the internal array which stores the point data.
        */
-      const std::array<double,dim> &get_array() const;
+      inline
+      const std::array<double,dim> &get_array() const
+      {
+        return point;
+      }
 
 
       /**
        * returns the coordinate system associated with the data.
        */
-      CoordinateSystem get_coordinate_system() const;
+      inline
+      CoordinateSystem get_coordinate_system() const
+      {
+        return coordinate_system;
+      }
 
 
       /**
       * Computes the L2 norm: sqrt(x_i * x_i + y_i * y_i + z_i * z_i) in 3d.
       */
-      double norm() const;
+      inline
+      double norm() const
+      {
+        return std::sqrt(this->norm_square());
+      }
 
 
       /**
       * Computes the square of the norm, which is the sum of the absolute squares
       * x_i * x_i + y_i * y_i + z_i * z_i in 3d.
       */
-      double norm_square() const;
+      inline
+      double norm_square() const
+      {
+        WBAssertThrow(false,"This function is only available in 2d or 3d.");
+        return 0;
+      }
 
       /**
        * Outputs the values of the point to std cout separated by spaces. This does not
@@ -214,6 +325,20 @@ namespace WorldBuilder
 
   };
 
+  template <>
+  inline
+  double Point<2>::norm_square() const
+  {
+    return (point[0] * point[0]) + (point[1] * point[1]);
+  }
+
+  template <>
+  inline
+  double Point<3>::norm_square() const
+  {
+    return (point[0] * point[0]) + (point[1] * point[1]) + (point[2] * point[2]);
+  }
+
   /**
    * This namespace contains some faster but less accurate version of the
    * trigonomic functions and a faster version of the fmod function.
@@ -281,9 +406,22 @@ namespace WorldBuilder
 
 
   template<int dim>
-  Point<dim> operator*(const double scalar, const Point<dim> &point);
+  inline
+  Point<dim> operator*(const double scalar, const Point<dim> &point)
+  {
+    return point*scalar;
+  }
 
   template<int dim>
-  Point<dim> operator/(const double scalar, const Point<dim> &point);
+  inline
+  Point<dim> operator/(const double scalar, const Point<dim> &point)
+  {
+    // initialize the array to zero.
+    std::array<double,dim> array = Point<dim>(point.coordinate_system).get_array();
+    for (unsigned int i = 0; i < dim; ++i)
+      array[i] = scalar / point[i];
+    return Point<dim>(array,point.coordinate_system);
+  }
+
 } // namespace WorldBuilder
 #endif
diff --git a/source/point.cc b/source/point.cc
index 90326b9af..bd8692904 100644
--- a/source/point.cc
+++ b/source/point.cc
@@ -23,41 +23,6 @@
 
 namespace WorldBuilder
 {
-  template<>
-  Point<3>::Point(const CoordinateSystem coordinate_system_)
-    :
-    point({{0,0,0}}),
-  coordinate_system(coordinate_system_)
-  {}
-
-  template<>
-  Point<2>::Point(const CoordinateSystem coordinate_system_)
-    :
-    point({{0,0}}),
-  coordinate_system(coordinate_system_)
-  {}
-
-  template<int dim>
-  Point<dim>::Point(const std::array<double,dim> &location, const CoordinateSystem coordinate_system_)
-    :
-    point(location),
-    coordinate_system(coordinate_system_)
-  {}
-
-  template<int dim>
-  Point<dim>::Point(const Point<dim> &point_, const CoordinateSystem coordinate_system_)
-    :
-    point(point_.get_array()),
-    coordinate_system(coordinate_system_)
-  {}
-
-  template<int dim>
-  Point<dim>::Point(const Point<dim> &point_)
-    :
-    point(point_.get_array()),
-    coordinate_system(point_.get_coordinate_system())
-  {}
-
 
   template<>
   Point<2>::Point(const double x, const double y, const CoordinateSystem coordinate_system_)
@@ -94,152 +59,9 @@ namespace WorldBuilder
   {}
 
 
-  template<int dim>
-  Point<dim>::~Point()
-    = default;
-
-  template<int dim>
-  Point<dim> &Point<dim>::operator=(const Point<dim> &point_)
-  {
-    point = point_.point;
-    coordinate_system = point_.coordinate_system;
-    return *this;
-  }
-
-  template<int dim>
-  double Point<dim>::operator*(const Point<dim> &point_) const
-  {
-    const std::array<double,dim> array = point_.get_array();
-    double dot_product = 0;
-    for (unsigned int i = 0; i < dim; ++i)
-      dot_product += point[i] * array[i];
-    return dot_product;
-  }
-
-  template<int dim>
-  Point<dim> Point<dim>::operator*(const double scalar) const
-  {
-    // initialize the array to zero.
-    std::array<double,dim> array = Point<dim>(coordinate_system).get_array();
-    for (unsigned int i = 0; i < dim; ++i)
-      array[i] += point[i] * scalar;
-    return Point<dim>(array,coordinate_system);
-  }
 
-  template<int dim>
-  Point<dim> Point<dim>::operator/(const double scalar) const
-  {
-    // initialize the array to zero.
-    std::array<double,dim> array = Point<dim>(coordinate_system).get_array();
-    const double one_over_scalar = 1/scalar;
-    for (unsigned int i = 0; i < dim; ++i)
-      array[i] += point[i] * one_over_scalar;
-    return Point<dim>(array,coordinate_system);
-  }
 
-  template<int dim>
-  Point<dim>
-  Point<dim>::operator+(const Point<dim> &point_) const
-  {
-    WBAssert(coordinate_system == point_.get_coordinate_system(),
-             "Cannot add two points which represent different coordinate systems.");
-    Point<dim> point_tmp(point,coordinate_system);
-    point_tmp += point_;
 
-    return point_tmp;
-  }
-
-  template<int dim>
-  Point<dim>
-  Point<dim>::operator-(const Point<dim> &point_) const
-  {
-    WBAssert(coordinate_system == point_.get_coordinate_system(),
-             "Cannot substract two points which represent different coordinate systems. Internal has type " << static_cast<int>(coordinate_system)
-             << ", other point has type " << static_cast<int>(point_.get_coordinate_system()));
-    Point<dim> point_tmp(point,coordinate_system);
-    point_tmp -= point_;
-
-    return point_tmp;
-  }
-
-
-  template<int dim>
-  Point<dim> &
-  Point<dim>::operator*=(const double scalar)
-  {
-    for (unsigned int i = 0; i < dim; ++i)
-      point[i] *= scalar;
-    return *this;
-  }
-
-
-  template<int dim>
-  Point<dim> &
-  Point<dim>::operator/=(const double scalar)
-  {
-    for (unsigned int i = 0; i < dim; ++i)
-      point[i] /= scalar;
-    return *this;
-  }
-
-
-  template<int dim>
-  Point<dim> &
-  Point<dim>::operator+=(const Point<dim> &point_)
-  {
-    for (unsigned int i = 0; i < dim; ++i)
-      point[i] += point_[i];
-    return *this;
-  }
-
-
-  template<int dim>
-  Point<dim> &
-  Point<dim>::operator-=(const Point<dim> &point_)
-  {
-    for (unsigned int i = 0; i < dim; ++i)
-      point[i] -= point_[i];
-    return *this;
-  }
-
-
-  template<int dim>
-  const std::array<double,dim> &
-  Point<dim>::get_array() const
-  {
-    return point;
-  }
-
-
-  template<int dim>
-  CoordinateSystem
-  Point<dim>::get_coordinate_system() const
-  {
-    return coordinate_system;
-  }
-
-
-  template<int dim>
-  double
-  Point<dim>::norm() const
-  {
-    return std::sqrt(this->norm_square());
-  }
-
-
-  template<>
-  double
-  Point<2>::norm_square() const
-  {
-    return (point[0] * point[0]) + (point[1] * point[1]);
-  }
-
-  template<>
-  double
-  Point<3>::norm_square() const
-  {
-    return (point[0] * point[0]) + (point[1] * point[1]) + (point[2] * point[2]);
-  }
 
 
   template<int dim>
@@ -263,8 +85,6 @@ namespace WorldBuilder
 
   }
 
-
-
   template<int dim>
   double
   Point<dim>::cheap_relative_distance(const Point<dim> &two) const
@@ -286,30 +106,6 @@ namespace WorldBuilder
 
   }
 
-  /**
-   * Multiplies a point with a scalar.
-   */
-  template<int dim>
-  Point<dim>
-  operator*(const double scalar, const Point<dim> &point)
-  {
-    return point*scalar;
-  }
-
-  /**
-   * Divides a scalar by a point: output_vector[i] = scalar / point[i].
-   */
-  template<int dim>
-  Point<dim>
-  operator/(const double scalar, const Point<dim> &point)
-  {
-    // initialize the array to zero.
-    std::array<double,dim> array = Point<dim>(point.coordinate_system).get_array();
-    for (unsigned int i = 0; i < dim; ++i)
-      array[i] = scalar / point[i];
-    return Point<dim>(array,point.coordinate_system);
-  }
-
   /**
    * The 2d version of the point class.
    */