- Refactored code. Approximants now have a dedicated class which

inherits from Approximant. The available approximants are:
BSplineApproximant, PSplineApproximant, PolynomialApproximant, and
RBFApproximant. Related files have been renamed.
- Constant term in test function f_2_5 was increased to -1e5
- Jacobians are now tested by checking the inf-norm (more strict than
previously)
- operator_overloads.* renamed to operatoroverloads.*
- Added some comparison operators for BSplineBasis and BSplineBasis1D

CMakeLists.txt

@@ -135,7 +135,7 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/Catch)
 # These are the sources we need for compilation of the library
 set(SRC_LIST
     include/approximant.h
-    include/bsplineregression.h
+    include/bsplineapproximant.h
     include/bspline.h
     include/bsplinebasis.h
     include/bsplinebasis1d.h
@@ -145,44 +145,44 @@ set(SRC_LIST
     include/definitions.h
     include/linearsolvers.h
     include/mykroneckerproduct.h
-    include/polynomialregression.h
-    include/pspline.h
-    include/radialbasisfunction.h
-    include/radialbasisfunctionterm.h
+    include/polynomialapproximant.h
+    include/psplineapproximant.h
+    include/rbfapproximant.h
+    include/rbfterm.h
     include/serializer.h
     include/utilities.h
-    src/bsplineregression.cpp
+    src/bsplineapproximant.cpp
     src/bspline.cpp
     src/bsplinebasis.cpp
     src/bsplinebasis1d.cpp
     src/datasample.cpp
     src/datatable.cpp
     src/function.cpp
     src/mykroneckerproduct.cpp
-    src/polynomialregression.cpp
-    src/pspline.cpp
-    src/radialbasisfunction.cpp
+    src/polynomialapproximant.cpp
+    src/psplineapproximant.cpp
+    src/rbfapproximant.cpp
     src/serializer.cpp
     src/utilities.cpp
 )
 set(MATLAB_SRC_LIST ${SRC_LIST} include/matlab.h src/matlab.cpp)
 set(TEST_SRC_LIST
     ${SRC_LIST}
     test/main.cpp
-    test/approximation/bspline.cpp
-    test/approximation/pspline.cpp
-    test/approximation/radialbasisfunction.cpp
-    test/approximation/polynomialregression.cpp
+    test/approximation/bsplineapproximant.cpp
+    test/approximation/psplineapproximant.cpp
+    test/approximation/rbfapproximant.cpp
+    test/approximation/polynomialapproximant.cpp
     test/general/datatable.cpp
     test/general/utilities.cpp
     test/serialization/datatable.cpp
-    test/serialization/bspline.cpp
-    test/serialization/pspline.cpp
-    test/serialization/radialbasisfunction.cpp
-    test/serialization/polynomialregression.cpp
+    test/serialization/bsplineapproximant.cpp
+    test/serialization/psplineapproximant.cpp
+    test/serialization/rbfapproximant.cpp
+    test/serialization/polynomialapproximant.cpp
 
-    test/operator_overloads.h
-    test/operator_overloads.cpp
+    test/operatoroverloads.h
+    test/operatoroverloads.cpp
     test/testfunction.h
     test/testfunction.cpp
     test/testfunctions.h

include/approximant.h

@@ -23,12 +23,15 @@ namespace SPLINTER
  */
 class SPLINTER_API Approximant : public Function
 {
-public:
+protected:
     Approximant(unsigned int numVariables)
         : Function(numVariables) {}
 
+public:
     virtual ~Approximant() {}
 
+    //virtual DenseVector computeCoefficients(DataTable data);
+
     /**
      * Serialize and save approximant to fileName
      * Throws if file could not be opened
@@ -58,6 +61,9 @@ class SPLINTER_API Approximant : public Function
      * Will typically include name of the class and degree
      */
     virtual const std::string getDescription() const = 0;
+
+private:
+    Approximant();
 };
 
 } // namespace SPLINTER

include/bsplineapproximant.h

@@ -0,0 +1,98 @@
+/*
+ * This file is part of the SPLINTER library.
+ * Copyright (C) 2012 Bjarne Grimstad (bjarne.grimstad@gmail.com).
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+
+#ifndef SPLINTER_BSPLINEAPPROXIMANT_H
+#define SPLINTER_BSPLINEAPPROXIMANT_H
+
+#include "datatable.h"
+#include "bspline.h"
+
+namespace SPLINTER
+{
+
+// Enum for different B-spline types
+enum class BSplineType
+{
+    LINEAR,     // Linear basis functions in each variable
+    QUADRATIC,  // Quadratic basis functions in each variable
+    CUBIC,      // Cubic basis functions in each variable
+    QUARTIC     // Quartic basis functions in each variable
+};
+
+inline std::vector<unsigned int> getBSplineDegrees(unsigned int numVariables, BSplineType type)
+{
+    switch (type) {
+    case BSplineType::LINEAR:
+            return std::vector<unsigned int>(numVariables, 1);
+        break;
+    case BSplineType::QUADRATIC:
+            return std::vector<unsigned int>(numVariables, 2);
+        break;
+    case BSplineType::CUBIC:
+            return std::vector<unsigned int>(numVariables, 3);
+        break;
+    case BSplineType::QUARTIC:
+            return std::vector<unsigned int>(numVariables, 4);
+        break;
+    default:
+        // Default is CUBIC
+        return std::vector<unsigned int>(numVariables, 3);
+        break;
+    }
+}
+
+class SPLINTER_API BSplineApproximant : public Approximant
+{
+public:
+    BSplineApproximant(const char *fileName);
+    BSplineApproximant(const std::string fileName);
+    BSplineApproximant(const DataTable &samples, std::vector<unsigned int> basisDegrees);
+    BSplineApproximant(const DataTable &samples, BSplineType type);
+
+    virtual BSplineApproximant * clone() const { return new BSplineApproximant(*this); }
+
+    // Build B-spline
+    BSpline buildBSpline(const DataTable &samples, std::vector<unsigned int> basisDegrees) const;
+
+    // Evaluation
+    double eval(DenseVector x) const override;
+    DenseMatrix evalJacobian(DenseVector x) const override;
+    DenseMatrix evalHessian(DenseVector x) const override;
+
+    void save(const std::string fileName) const override;
+
+    const std::string getDescription() const override;
+
+protected:
+    BSplineApproximant();
+    BSplineApproximant(unsigned int numVariables);
+
+    BSpline bspline;
+
+    // Control point computations
+    virtual DenseMatrix computeCoefficients(const DataTable &samples) const;
+    SparseMatrix computeBasisFunctionMatrix(const DataTable &samples) const;
+    DenseMatrix controlPointEquationRHS(const DataTable &samples) const;
+
+    // Computing knots
+    std::vector<std::vector<double> > computeKnotVectorsFromSamples(const DataTable &samples, std::vector<unsigned int> degrees) const;
+    virtual std::vector<double> computeKnotVector(const std::vector<double> &values, unsigned int degree) const;
+    std::vector<double> knotVectorMovingAverage(const std::vector<double> &values, unsigned int degree) const;
+    std::vector<double> knotVectorBuckets(const std::vector<double> &values, unsigned int degree) const;
+
+    void load(const std::string fileName) override;
+
+    friend class Serializer;
+    friend bool operator==(const BSplineApproximant &lhs, const BSplineApproximant &rhs);
+};
+
+
+} // namespace SPLINTER
+
+#endif // SPLINTER_BSPLINEAPPROXIMANT_H

include/bsplinebasis.h

@@ -64,6 +64,7 @@ class BSplineBasis
     unsigned int numVariables;
 
     friend class Serializer;
+    friend bool operator==(const BSplineBasis &lhs, const BSplineBasis &rhs);
 };
 
 } // namespace SPLINTER

include/bsplinebasis1d.h

@@ -83,6 +83,8 @@ class BSplineBasis1D
     unsigned int targetNumBasisfunctions;
 
     friend class Serializer;
+    friend bool operator==(const BSplineBasis1D &lhs, const BSplineBasis1D &rhs);
+    friend bool operator!=(const BSplineBasis1D &lhs, const BSplineBasis1D &rhs);
 };
 
 } // namespace SPLINTER

include/polynomialregression.h → include/polynomialapproximant.h

@@ -7,24 +7,24 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
-#ifndef SPLINTER_POLYNOMIALREGRESSION_H
-#define SPLINTER_POLYNOMIALREGRESSION_H
+#ifndef SPLINTER_POLYNOMIALAPPROXIMANT_H
+#define SPLINTER_POLYNOMIALAPPROXIMANT_H
 
 #include "approximant.h"
 #include "datatable.h"
 
 namespace SPLINTER
 {
 
-class SPLINTER_API PolynomialRegression : public Approximant
+class SPLINTER_API PolynomialApproximant : public Approximant
 {
 public:
-    PolynomialRegression(const char *fileName);
-    PolynomialRegression(const std::string fileName);
-    PolynomialRegression(const DataTable &samples, unsigned int degree);
-    PolynomialRegression(const DataTable &samples, std::vector<unsigned int> degrees);
+    PolynomialApproximant(const char *fileName);
+    PolynomialApproximant(const std::string fileName);
+    PolynomialApproximant(const DataTable &samples, unsigned int degree);
+    PolynomialApproximant(const DataTable &samples, std::vector<unsigned int> degrees);
 
-    virtual PolynomialRegression * clone() const { return new PolynomialRegression(*this); }
+    virtual PolynomialApproximant * clone() const { return new PolynomialApproximant(*this); }
 
     // Evaluation
     double eval(DenseVector x) const override;
@@ -39,7 +39,7 @@ class SPLINTER_API PolynomialRegression : public Approximant
     const std::string getDescription() const override;
 
 private:
-    PolynomialRegression();
+    PolynomialApproximant();
 
     unsigned int numCoefficients;
     std::vector<unsigned int> degrees;
@@ -58,4 +58,4 @@ class SPLINTER_API PolynomialRegression : public Approximant
 
 } // namespace SPLINTER
 
-#endif // SPLINTER_POLYNOMIALREGRESSION_H
+#endif // SPLINTER_POLYNOMIALAPPROXIMANT_H

include/psplineapproximant.h

@@ -0,0 +1,54 @@
+/*
+ * This file is part of the SPLINTER library.
+ * Copyright (C) 2012 Bjarne Grimstad (bjarne.grimstad@gmail.com).
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+
+#ifndef SPLINTER_PSPLINEAPPROXIMANT_H
+#define SPLINTER_PSPLINEAPPROXIMANT_H
+
+#include "bsplineapproximant.h"
+
+namespace SPLINTER
+{
+
+/*
+ * The P-Spline is a smooting spline which relaxes the interpolation constraints on the control points to allow smoother spline curves.
+ * It minimizes objective which penalizes both deviation (for interpolation) and second derivative (for smoothing).
+ * It inherits all properties of the B-spline - the only difference lies in the calculation of the control points.
+ */
+class SPLINTER_API PSplineApproximant : public BSplineApproximant
+{
+public:
+    PSplineApproximant(const char *fileName);
+    PSplineApproximant(const std::string fileName);
+    PSplineApproximant(const DataTable &samples, std::vector<unsigned int> basisDegrees, double lambda);
+    PSplineApproximant(const DataTable &samples, BSplineType type, double lambda);
+    PSplineApproximant(const DataTable &samples, double lambda);
+    PSplineApproximant(const DataTable &samples) : PSplineApproximant(samples, 0.03) {}
+
+    void save(const std::string fileName) const override;
+
+    const std::string getDescription() const override;
+
+private:
+    PSplineApproximant();
+
+    double lambda; // Smoothing parameter. Requirement: lambda >= 0
+
+    // P-spline control point calculation
+    DenseMatrix computeCoefficients(const DataTable &samples) const override;
+    SparseMatrix getSecondOrderFiniteDifferenceMatrix() const;
+
+    void load(const std::string fileName) override;
+
+    friend class Serializer;
+    friend bool operator==(const PSplineApproximant &lhs, const PSplineApproximant &rhs);
+};
+
+} // namespace SPLINTER
+
+#endif // SPLINTER_PSPLINEAPPROXIMANT_H