Index: LinearAlgebra/src/LinearAlgebra/MatrixContent.cpp
===================================================================
--- LinearAlgebra/src/LinearAlgebra/MatrixContent.cpp	(revision 7a03405921dca3b136f7e49c7e1b3797e598c4fc)
+++ LinearAlgebra/src/LinearAlgebra/MatrixContent.cpp	(revision 59e06352565152e740ef911af808bb55268fba36)
@@ -86,9 +86,11 @@
 }
 
-/** Constructor that parses square matrix from a stream.
+/** Constructor that parses matrix from a stream.
  *
  * \note Matrix dimensions can be preparsed via
  * MatrixContent::preparseMatrixDimensions() without harming the stream.
  *
+ * \param _row number of rows
+ * \param _column number of columns
  * \param &inputstream stream to parse from
  */
@@ -509,4 +511,88 @@
     }
   return *this;
+}
+
+/** Performs a SVD on the contained matrix.
+ *
+ * A SVD is the factorization of a MxN matrix A into the product form \f$U S V^t\f$, where
+ *  -# U is a MxN orthogonal matrix
+ *  -# S is a NxN diagonal matrix (here just a vector)
+ *  -# V is a NxN orthogonal, square matrix.
+ *
+ * The SVD is only done if MatrixContent::rows is larger equal to MatrixContent::columns, i.e.
+ * N >= M.
+ *
+ * \note The matrix content of this matrix, \a V and \a S are overwritten in the process.
+ *
+ * \param V orthogonal square matrix on return
+ * \param S diagonal matrix on return
+ */
+void MatrixContent::performSingularValueDecomposition(MatrixContent &V, VectorContent &S)
+{
+  ASSERT(rows >= columns,
+      "MatrixContent::performSingularValueDecomposition() - row count "
+      +toString(rows)+" must be larger than or equal to column count "+toString(columns)+".");
+  ASSERT(V.getRows() == V.getColumns(),
+      "MatrixContent::performSingularValueDecomposition() - Matrix V must be square!");
+  ASSERT(V.getRows() == columns,
+      "MatrixContent::performSingularValueDecomposition() - Given matrix V does not have the right dimension "
+      +toString(V.getRows())+"!="+toString(rows)+".");
+  ASSERT(S.getDimension() == columns,
+      "MatrixContent::performSingularValueDecomposition() - Vector S does not haver the right dimension "
+      +toString(S.getDimension())+"!="+toString(columns)+".");
+  gsl_matrix *A = content;
+  gsl_vector *work = gsl_vector_alloc(columns);
+  gsl_linalg_SV_decomp(A,V.content,S.content,work);
+  gsl_vector_free(work);
+}
+
+/** Performs a SVD on the contained matrix and solves the linear system \f$Ax=b\f$ with given \a b.
+ *
+ * The SVD is only done if MatrixContent::rows is larger equal to MatrixContent::columns.
+ *
+ * \note The matrix content is overwritten in the process.
+ *
+ * \param V NxN orthogonal, diagonal matrix from SVD decomposition
+ * \param S N vector representing the diagonal elements from SVD decomposition
+ * \param *b right-hand side of linear equation \f$Ax=b\f$ to solve
+ * \return *x solution, if rows>columns this will be the solution in the least squares sense \f$||Ax-b||^2\f$
+ */
+VectorContent MatrixContent::solveOverdeterminedLinearEquation(MatrixContent &V, VectorContent &S, const VectorContent &b)
+{
+  ASSERT(b.getDimension() == rows,
+      "MatrixContent::performSingularValueDecomposition() - Given vector b does not have the right dimension "
+      +toString(b.getDimension())+"!="+toString(rows)+".");
+  ASSERT(V.getRows() == V.getColumns(),
+      "MatrixContent::performSingularValueDecomposition() - Matrix V must be square!");
+  ASSERT(V.getRows() == columns,
+      "MatrixContent::performSingularValueDecomposition() - Given matrix V does not have the right dimension "
+      +toString(V.getRows())+"!="+toString(rows)+".");
+  ASSERT(S.getDimension() == columns,
+      "MatrixContent::performSingularValueDecomposition() - Vector S does not haver the right dimension "
+      +toString(S.getDimension())+"!="+toString(columns)+".");
+
+  gsl_vector *x = gsl_vector_alloc(columns);
+  gsl_linalg_SV_solve(content,V.content,S.content,b.content,x);
+  return VectorContent(x, true);
+}
+
+/** Performs a SVD on the contained matrix and solves the linear system \f$Ax=b\f$ with given \a b.
+ *
+ * The SVD is only done if MatrixContent::rows is larger equal to MatrixContent::columns.
+ *
+ * \note The matrix content is overwritten in the process.
+ *
+ * \param *b right-hand side of linear equation \f$Ax=b\f$ to solve.
+ * \return *x solution, if rows>columns this will be the solution in the least squares sense \f$||Ax-b||^2\f$
+ */
+VectorContent MatrixContent::solveOverdeterminedLinearEquation(const VectorContent &b)
+{
+  ASSERT(b.getDimension() == rows,
+      "MatrixContent::performSingularValueDecomposition() - Given vector b does not have the right dimension "
+      +toString(b.getDimension())+"!="+toString(rows)+".");
+  MatrixContent V(columns, columns);
+  VectorContent S(columns);
+  performSingularValueDecomposition(V,S);
+  return solveOverdeterminedLinearEquation(V,S,b);
 }
 
Index: LinearAlgebra/src/LinearAlgebra/MatrixContent.hpp
===================================================================
--- LinearAlgebra/src/LinearAlgebra/MatrixContent.hpp	(revision 7a03405921dca3b136f7e49c7e1b3797e598c4fc)
+++ LinearAlgebra/src/LinearAlgebra/MatrixContent.hpp	(revision 59e06352565152e740ef911af808bb55268fba36)
@@ -98,4 +98,7 @@
   gsl_vector* transformToEigenbasis();
   void sortEigenbasis(gsl_vector *eigenvalues);
+  void performSingularValueDecomposition(MatrixContent &V, VectorContent &S);
+  VectorContent solveOverdeterminedLinearEquation(const VectorContent &b);
+  VectorContent solveOverdeterminedLinearEquation(MatrixContent &V, VectorContent &S, const VectorContent &b);
 
   // Properties
Index: LinearAlgebra/src/unittests/MatrixContentUnitTest.cpp
===================================================================
--- LinearAlgebra/src/unittests/MatrixContentUnitTest.cpp	(revision 7a03405921dca3b136f7e49c7e1b3797e598c4fc)
+++ LinearAlgebra/src/unittests/MatrixContentUnitTest.cpp	(revision 59e06352565152e740ef911af808bb55268fba36)
@@ -24,7 +24,11 @@
 #include <cppunit/ui/text/TestRunner.h>
 
+#include <cmath>
+#include <limits>
+
 #include "MatrixContentUnitTest.hpp"
 
 #include "MatrixContent.hpp"
+#include "VectorContent.hpp"
 
 #ifdef HAVE_TESTRUNNER
@@ -33,4 +37,10 @@
 
 /********************************************** Test classes **************************************/
+
+const std::string matrixA = "   9.962848439806617e-01   5.950413028139907e-01   3.172650036465889e-01\n\
+   2.070939109924951e-01   8.365712117773689e-01   3.980567886073226e-01\n\
+   1.021600573071414e-01   8.061359922326598e-02   8.493537275043391e-01\n\
+   6.955361514014282e-01   6.873206387346102e-02   2.649165458481005e-01";
+const std::string vectorS = "1.630290761001098e+00                    7.624807744374841e-01                    6.374093742147465e-01";
 
 // Registers the fixture into the 'registry'
@@ -293,2 +303,47 @@
   delete n;
 }
+
+/** Unit test for MatrixContent::performSingularValueDecomposition().
+ *
+ */
+void MatrixContentTest::SVDTest()
+{
+  // setup "A", U,S,V
+  std::stringstream Astream(matrixA);
+  std::stringstream Sstream(vectorS);
+  MatrixContent A(m->getRows(), m->getColumns(), Astream);
+  VectorContent S_expected(m->getColumns(), Sstream);
+  *m = A;
+
+  // check SVD
+  VectorContent S(m->getColumns());
+  MatrixContent V(m->getColumns(), m->getColumns());
+  A.performSingularValueDecomposition(V,S);
+  MatrixContent S_diag(m->getColumns(), m->getColumns());
+  for (size_t index = 0; index < m->getColumns(); ++index)
+    S_diag.set(index, index, S[index]);
+  CPPUNIT_ASSERT_EQUAL(*m,A*S_diag*(V.transpose()));
+  for (size_t index = 0; index < m->getColumns(); ++index) {
+    //CPPUNIT_ASSERT_EQUAL(S_expected[index], S[index]);
+    CPPUNIT_ASSERT(fabs(S_expected[index] - S[index]) < numeric_limits<double>::epsilon()*10.);
+  }
+
+  // set up right-hand side
+  VectorContent b(4);
+  b[0] = 1.;
+  b[1] = 0.;
+  b[2] = 0.;
+  b[3] = 0.;
+
+  // SVD
+  VectorContent x_expected(3);
+  x_expected[0] = -0.00209169;
+  x_expected[1] = -0.325399;
+  x_expected[2] = 0.628004;
+  const VectorContent x_result(A.solveOverdeterminedLinearEquation(V,S,b));
+
+  // check result
+  for (size_t index = 0; index < m->getColumns(); ++index) {
+    CPPUNIT_ASSERT(fabs(x_expected[index] - x_result[index]) < 1.e-6);
+  }
+}
Index: LinearAlgebra/src/unittests/MatrixContentUnitTest.hpp
===================================================================
--- LinearAlgebra/src/unittests/MatrixContentUnitTest.hpp	(revision 7a03405921dca3b136f7e49c7e1b3797e598c4fc)
+++ LinearAlgebra/src/unittests/MatrixContentUnitTest.hpp	(revision 59e06352565152e740ef911af808bb55268fba36)
@@ -30,4 +30,5 @@
     CPPUNIT_TEST (PropertiesTest );
     CPPUNIT_TEST (ReadWriteTest );
+    CPPUNIT_TEST (SVDTest );
     CPPUNIT_TEST_SUITE_END();
 
@@ -42,4 +43,5 @@
     void PropertiesTest();
     void ReadWriteTest();
+    void SVDTest();
 
 private:
