In CubicSplines kommt er mit den letzten 2 Konstruktor Überladungen nicht klar... daran anknüpfen

include/ITABase/Math/LinearAlgebra.h

@@ -32,7 +32,7 @@ namespace ITABase
 		* with M is a Matrix with only the 3 main diagonals nonequal zero, e the known excitation vector and x the vector of unknown variables.
 		* Since the matrix dimension is n x n the excitatio, the middle and the returned vector are n elements big. Therefore the lower and the upper diagonale needs to have a length of n-1.
 		*/
-		ITA_BASE_API std::vector<float> BandmatrixSolver(const std::vector<float>& vdLower, const std::vector<float>& vdMiddle, const std::vector<float>& vdUpper, const std::vector<float>& vdExcitation);
+		ITA_BASE_API std::vector<double> BandmatrixSolver(const std::vector<double>& vdLower, const std::vector<double>& vdMiddle, const std::vector<double>& vdUpper, const std::vector<double>& vdExcitation);
 	}
 }
 

include/ITABase/Math/PiecewisePolynomial.h

@@ -41,7 +41,7 @@ namespace ITABase
 		class ITA_BASE_API CPiecewisePolynomial
 		{
 		public:
-			CPiecewisePolynomial(const std::vector<float>& vdBreakPoints, const std::vector<float>& vdCoeffs, const int iOrder);
+			CPiecewisePolynomial(const std::vector<double>& vdBreakPoints, const std::vector<double>& vdCoeffs, const int iOrder);
 
 			//! Returns the polynomial order
 			inline int Order() const { return iOrder; };
@@ -50,16 +50,26 @@ namespace ITABase
 			//! Returns the number of coefficients for a single polynomial
 			inline int NumCoefficients() const { return Order() + 1; };
 			//! Returns the break points defining the intervals for the polynomials
-			inline const std::vector<float>& BreakPoints() const { return vdBreakPoints; };
+			inline const std::vector<double>& BreakPoints() const { return vdBreakPoints; };
 			//! Returns the Coefficients of that Polynom. Sorted according to ascending intervals [a0, b0, c0, d0, a1, b1, c1, d1]
-			inline const std::vector<float>& Coefficients() const { return vdCoefficients; };
+			inline const std::vector<double>& Coefficients() const { return vdCoefficients; };
 
 			//! Evaluate the piecewise polynomial at a given x value. If desired, xValues from outsite the breakpoints can be extrapolated linearly.
-			float Value(const float& xValue, bool bExtrapolate = false) const;
+			double Value(const double& xValue, bool bExtrapolate = false) const;
+			//! Evaluate the piecewise polynomial at a given x value. If desired, xValues from outsite the breakpoints can be extrapolated linearly.
+			double Value(const float& xValue, bool bExtrapolate = false) const;
+			
+			//! Evaluates the piecewise polynomial at all given x values. If desired, xValues from outsite the breakpoints can be extrapolated linearly.
+			std::vector<double> Value(const std::vector<double>& vdXValues, bool bExtrapolate = false) const;
 			//! Evaluates the piecewise polynomial at all given x values. If desired, xValues from outsite the breakpoints can be extrapolated linearly.
-			std::vector<float> Value(const std::vector<float>& vdXValues, bool bExtrapolate = false) const;
+			std::vector<double> Value(const std::vector<float>& vdXValues, bool bExtrapolate = false) const;
+
+			
+			//! Finds the index of Interval at a given x value. If extrapolation is desired, it will return -1 for xValue outsite the breakpoints
+			int IntervalIndex(const double xValue, bool bExtrapolate = false) const;
 			//! Finds the index of Interval at a given x value. If extrapolation is desired, it will return -1 for xValue outsite the breakpoints
 			int IntervalIndex(const float xValue, bool bExtrapolate = false) const;
+
 			//! Return a piecewise polynomial containing the derivations of the polynomials of this one
 			CPiecewisePolynomial Derivation() const;
 
@@ -69,13 +79,13 @@ namespace ITABase
 			  * The iterator ending this set of coefficients is then:
 			  * std::vector<float>::const_iterator itEnd = itStart + NumCoefficients();
 			  */
-			std::vector<float>::const_iterator CoefficientsOfInterval(const int idxInterval) const;
+			std::vector<double>::const_iterator CoefficientsOfInterval(const int idxInterval) const;
 
 		private:
 			//! Order of polynomials
 			int iOrder;
 			//! Vector with break points. Defines the interval for each polynomial.
-			std::vector<float> vdBreakPoints;
+			std::vector<double> vdBreakPoints;
 			//! Vector with all coefficients. Represents a 2D matrix: First dimension = number of intervals (pieces), second dimension = number of coefficients (order+1).
 			/**
 			  * The Coefficients are arranged in groups for each interval (piece) starting the coefficient of highest order. Example:
@@ -83,7 +93,7 @@ namespace ITABase
 			  * The coefficients for interval 1 represent the following polynomial:
 			  * f(x) = a1(x−x1)^3 + b1(x−x1)^2 + c1(x−x1) + d1
 			  */
-			std::vector<float> vdCoefficients;
+			std::vector<double> vdCoefficients;
 		};
 	}
 }

include/ITABase/Math/Spline.h

@@ -28,14 +28,25 @@ namespace ITABase
     namespace Math
     {
         //! Uses cubic splines to create a piecewise polynomial (order 3) for the given data pairs vdSupportingPoints and vdDataPoints. vdSupportingPoints need to be sorted in ascending order
-        ITA_BASE_API CPiecewisePolynomial CubicSpline(const std::vector<float>& vdSupportingPoints, const std::vector<float>& vdDataPoints);
-
-        //! Uses cubic splines to interpolate the function defined by the given data pairs vdSupportingPoints and vdDataPoints to a vector of points
-        ITA_BASE_API std::vector<float> CubicSpline(const std::vector<float>& vdSupportingPoints, const std::vector<float>& vdDataPoints, const std::vector<float>& vdEvalPoints);
-
-        //! Uses cubic splines to interpolate the function defined by the given data pairs vdSupportingPoints and vdDataPoints to a single point
-        ITA_BASE_API float CubicSpline(const std::vector<float>& vdSupportingPoints, const std::vector<float>& vdDataPoints, float dEvalPoint);
-    }
+        ITA_BASE_API CPiecewisePolynomial CubicSpline(const std::vector<double>& vdSupportingPoints, const std::vector<double>& vdDataPoints);
+		//All other Permutations of data Types
+		
+		//! Uses cubic splines to create a piecewise polynomial (order 3) for the given data pairs vdSupportingPoints and vdDataPoints. vdSupportingPoints need to be sorted in ascending order
+		ITA_BASE_API CPiecewisePolynomial CubicSpline(const std::vector<float>& vdSupportingPoints, const std::vector<float>& vdDataPoints);
+		//! Uses cubic splines to create a piecewise polynomial (order 3) for the given data pairs vdSupportingPoints and vdDataPoints. vdSupportingPoints need to be sorted in ascending order
+		ITA_BASE_API CPiecewisePolynomial CubicSpline(const std::vector<float>& vdSupportingPoints, const std::vector<double>& vdDataPoints);
+		//! Uses cubic splines to create a piecewise polynomial (order 3) for the given data pairs vdSupportingPoints and vdDataPoints. vdSupportingPoints need to be sorted in ascending order
+		ITA_BASE_API CPiecewisePolynomial CubicSpline(const std::vector<double>& vdSupportingPoints, const std::vector<float>& vdDataPoints);
+        
+		//! Uses cubic splines to interpolate the function defined by the given data pairs vdSupportingPoints and vdDataPoints to a vector of points
+        ITA_BASE_API std::vector<double> CubicSpline(const std::vector<double>& vdSupportingPoints, const std::vector<double>& vdDataPoints, const std::vector<double>& vdEvalPoints);
+		//! Uses cubic splines to interpolate the function defined by the given data pairs vdSupportingPoints and vdDataPoints to a vector of points
+		 ITA_BASE_API std::vector<double> CubicSpline(const std::vector<float>& vdSupportingPoints, const std::vector<float>& vdDataPoints, const std::vector<float>& vdEvalPoints);
+		
+		//! Uses cubic splines to interpolate the function defined by the given data pairs vdSupportingPoints and vdDataPoints to a single point
+       // ITA_BASE_API float CubicSpline(const std::vector<double>& vdSupportingPoints, const std::vector<double>& vdDataPoints, double dEvalPoint);
+    
+	}
 }
 
 #endif // IW_ITA_BASE_SPLINE

src/ITABase/Math/LinearAlgebra.cpp

@@ -5,7 +5,7 @@
 
 using namespace ITABase;
 
- std::vector<float> Math::BandmatrixSolver(const std::vector<float>& vdLower, const std::vector<float>& vdMiddle, const std::vector<float>& vdUpper, const std::vector<float>& vdExcitation)
+ std::vector<double> Math::BandmatrixSolver(const std::vector<double>& vdLower, const std::vector<double>& vdMiddle, const std::vector<double>& vdUpper, const std::vector<double>& vdExcitation)
 {
 	//solving bandmatrix with Thomas Algorithm. Implementation according to "numerical recipees in C", William H. Press -2nd edition 1992, ISBN 0-521-43108-5, page 51
 
@@ -16,9 +16,9 @@ using namespace ITABase;
 
 	const int iNum = vdMiddle.size();
 
-	std::vector<float> vdGamma(iNum);
-	float fBeta = vdMiddle[0];
-	std::vector<float> vdSolution(iNum); //
+	std::vector<double> vdGamma(iNum);
+	double fBeta = vdMiddle[0];
+	std::vector<double> vdSolution(iNum); //
 
 	vdSolution[0] = vdExcitation[0] / vdMiddle[0];
 	for (int idx = 1; idx < iNum; idx++) {

src/ITABase/Math/PiecewisePolynomial.cpp

@@ -9,7 +9,7 @@
 using namespace ITABase;
 using namespace ITABase::Math;
 
-CPiecewisePolynomial::CPiecewisePolynomial(const std::vector<float>& vdBreakPoints, const std::vector<float>& vdCoeffs, const int iOrder)
+CPiecewisePolynomial::CPiecewisePolynomial(const std::vector<double>& vdBreakPoints, const std::vector<double>& vdCoeffs, const int iOrder)
 	: iOrder(iOrder)
 	, vdBreakPoints(vdBreakPoints)
 	, vdCoefficients(vdCoeffs)
@@ -26,8 +26,7 @@ CPiecewisePolynomial::CPiecewisePolynomial(const std::vector<float>& vdBreakPoin
 		ITA_EXCEPT_INVALID_PARAMETER("Invalid number of coefficients: Expected " + std::to_string(nCoeffs) + " but got " + std::to_string(vdCoeffs.size()) + ".");
 
 }
-
-float CPiecewisePolynomial::Value(const float & xValue, bool bExtrapolate) const
+double CPiecewisePolynomial::Value(const double & xValue, bool bExtrapolate) const
 {
 	//a(x-x0)^(n) + b(x-x0)^(n-1) + c(x-x0)^(n-2) +...
 	int iInterval = IntervalIndex(xValue, bExtrapolate);
@@ -38,28 +37,35 @@ float CPiecewisePolynomial::Value(const float & xValue, bool bExtrapolate) const
 		if (xValue < vdBreakPoints[0]) iInterval = 0;
 		else iInterval = NumIntervals();
 		
-		float fX0 = vdBreakPoints[iInterval];
+		double fX0 = vdBreakPoints[iInterval];
 		return ppDerivative.Value(fX0) * ( xValue - fX0) + this->Value(fX0); //y=m(x-x0)+d
 	}
 	//inside bounds
-	std::vector<float>::const_iterator itCoef = CoefficientsOfInterval(iInterval);
-	const float x0 = vdBreakPoints[iInterval];
-	float fResult = 0;
+	std::vector<double>::const_iterator itCoef = CoefficientsOfInterval(iInterval);
+	const double x0 = vdBreakPoints[iInterval];
+	double fResult = 0;
 	for (int idx = 0; idx <= iOrder;  idx++) { //adding up the parts of the polynomial
 		fResult += itCoef[idx] * pow(xValue - x0, iOrder - idx);
 	}
 	return fResult;
 }
-
-std::vector<float> CPiecewisePolynomial::Value(const std::vector<float>& vdXValues, bool bExtrapolate) const
+double CPiecewisePolynomial::Value(const float& xValue, bool bExtrapolate) const
+{
+	return Value(float(xValue), bExtrapolate);
+}
+std::vector<double> CPiecewisePolynomial::Value(const std::vector<double>& vdXValues, bool bExtrapolate) const
 {
-	std::vector<float> result(vdXValues.size());
+	std::vector<double> result(vdXValues.size());
 	for (int i = 0; i < vdXValues.size(); i++)
 		result[i] = Value(vdXValues[i], bExtrapolate);
 	return result;
 }
-
-int CPiecewisePolynomial::IntervalIndex(const float xValue, bool bExtrapolate) const
+std::vector<double>  CPiecewisePolynomial::Value(const std::vector<float>& vdXValues, bool bExtrapolate) const
+{
+	auto doubles_xValues = std::vector<double>(vdXValues.begin(), vdXValues.end());
+	return Value(doubles_xValues, bExtrapolate);
+}
+int CPiecewisePolynomial::IntervalIndex(const double xValue, bool bExtrapolate) const
 {
 	if (xValue < vdBreakPoints[0] || xValue > vdBreakPoints[NumIntervals()])
 		if (bExtrapolate) return -1;
@@ -71,12 +77,17 @@ int CPiecewisePolynomial::IntervalIndex(const float xValue, bool bExtrapolate) c
 	return NumIntervals()-1; //last possibility is xValue == last BreakPoint --> xValue in last interval
 }
 
+int CPiecewisePolynomial::IntervalIndex(const float xValue, bool bExtrapolate) const
+{
+	return IntervalIndex(double(xValue), bExtrapolate);
+}
+
 CPiecewisePolynomial CPiecewisePolynomial::Derivation() const
 {
 	const int iNewOrder = std::max(0, iOrder - 1);						// Minimum order is zero
 	const int iNewNumCoefficients = std::max(1, NumCoefficients() - 1);	// At least one coefficient
 
-	std::vector<float> vdNewCoeffs( NumIntervals() * iNewNumCoefficients, 0.0);
+	std::vector<double> vdNewCoeffs( NumIntervals() * iNewNumCoefficients, 0.0);
 	for (int idxPiece = 0; idxPiece < NumIntervals(); idxPiece++)
 	{
 		for (int idxCoeff = 0; idxCoeff < iOrder; idxCoeff++)
@@ -91,7 +102,7 @@ CPiecewisePolynomial CPiecewisePolynomial::Derivation() const
 	return CPiecewisePolynomial(vdBreakPoints, vdNewCoeffs, iNewOrder);
 }
 
-std::vector<float>::const_iterator CPiecewisePolynomial::CoefficientsOfInterval(const int idxInterval) const
+std::vector<double>::const_iterator CPiecewisePolynomial::CoefficientsOfInterval(const int idxInterval) const
 {
 	if (idxInterval < 0 || idxInterval >= NumIntervals())
 		ITA_EXCEPT_INVALID_PARAMETER("Index for interval is out of bounds.");

src/ITABase/Math/Spline.cpp

@@ -6,8 +6,29 @@
 
 using namespace ITABase;
 using namespace ITABase::Math;
+//basic Constructors
 
-CPiecewisePolynomial Math::CubicSpline(const std::vector<float>& vdSupportingPoints, const std::vector<float>& vdDataPoints)
+CPiecewisePolynomial CubicSpline(const std::vector<float>& vdSupportingPoints, const std::vector<float>& vdDataPoints)
+{
+	//Typecasting upwards to doubles
+	auto doubles_SupportingPoints = std::vector<double>(vdSupportingPoints.begin(), vdSupportingPoints.end());
+	auto doubles_DataPoints = std::vector<double>(vdDataPoints.begin(), vdDataPoints.end());
+	return CubicSpline(doubles_SupportingPoints, doubles_DataPoints);//Constructor working with doubles
+}
+CPiecewisePolynomial CubicSpline(const std::vector<float>& vdSupportingPoints, const std::vector<double>& vdDataPoints)
+{
+	//Typecasting upwards to doubles
+	auto doubles_SupportingPoints = std::vector<double>(vdSupportingPoints.begin(), vdSupportingPoints.end());
+	return CubicSpline(doubles_SupportingPoints, vdDataPoints);//Constructor working with doubles
+}
+CPiecewisePolynomial CubicSpline(const std::vector<double>& vdSupportingPoints, const std::vector<float>& vdDataPoints)
+{
+	//Typecasting upwards to doubles
+	auto doubles_DataPoints = std::vector<double>(vdDataPoints.begin(), vdDataPoints.end());
+	return CubicSpline(vdSupportingPoints, doubles_DataPoints);//Constructor working with doubles
+}
+
+CPiecewisePolynomial ITABase::Math::CubicSpline(const std::vector<double>& vdSupportingPoints, const std::vector<double>& vdDataPoints)
 {
 	/*setUp the bandmatrix M with the the h values. The vector with the coefficent b is called b.
 		The vector with the linear approximations on the right hand side is called r.
@@ -25,7 +46,7 @@ CPiecewisePolynomial Math::CubicSpline(const std::vector<float>& vdSupportingPoi
 	//Calculate h_i, formular 1.27b
 	const int iPolynomialOrder = 3;
 	const int iPoints = vdSupportingPoints.size();
-	std::vector<float> vdH(iPoints - 1);
+	std::vector<double> vdH(iPoints - 1);
 
 	for (int i = 0; i < iPoints - 1; i++) {
 		vdH[i] = vdSupportingPoints[i + 1] - vdSupportingPoints[i];
@@ -35,7 +56,7 @@ CPiecewisePolynomial Math::CubicSpline(const std::vector<float>& vdSupportingPoi
 	}
 
 	//SetUp the band matrix with lower, middle and upper diagonals. momentary only natural splines
-	std::vector<float> vdLower(iPoints - 3), vdMiddle(iPoints - 2), vdUpper(iPoints - 3);
+	std::vector<double> vdLower(iPoints - 3), vdMiddle(iPoints - 2), vdUpper(iPoints - 3);
 	for (int i = 0; i < iPoints - 3; i++) {
 		vdLower[i] = vdH[i + 1];
 	}
@@ -47,17 +68,17 @@ CPiecewisePolynomial Math::CubicSpline(const std::vector<float>& vdSupportingPoi
 
 	//excitation vector
 	//TODO only for natural splines with S0=S_iPoints = 0
-	std::vector<float> vdR(iPoints - 2);
+	std::vector<double> vdR(iPoints - 2);
 	for (int i = 0; i < iPoints - 2; i++)
 		vdR[i] = 3 * ((vdDataPoints[i + 2] - vdDataPoints[i + 1]) / vdH[i + 1] - (vdDataPoints[i + 1] - vdDataPoints[i]) / vdH[i]);
 
 	//solve bandmatrix and get the other coefficients
-	std::vector<float> vdB = BandmatrixSolver(vdLower, vdMiddle, vdUpper, vdR);
+	std::vector<double> vdB = BandmatrixSolver(vdLower, vdMiddle, vdUpper, vdR);
 	vdB.insert(vdB.begin(), 0.0);
 
-	std::vector<float> vdA(iPoints - 1);
-	std::vector<float> vdC(iPoints - 1);
-	std::vector<float> vdD(iPoints - 1);
+	std::vector<double> vdA(iPoints - 1);
+	std::vector<double> vdC(iPoints - 1);
+	std::vector<double> vdD(iPoints - 1);
 
 	vdB.push_back(0.0);//for ease of loop
 	for (int i = 0; i < iPoints - 1; i++) {
@@ -70,7 +91,7 @@ CPiecewisePolynomial Math::CubicSpline(const std::vector<float>& vdSupportingPoi
 
 	//sort for Constructor CPiecewisePolynomial
 	int iCoefficients = (iPoints - 1) * (iPolynomialOrder + 1);
-	std::vector<float> vdCoefficients(iCoefficients);
+	std::vector<double> vdCoefficients(iCoefficients);
 	int k = 0;
 	for (int k = 0; k < iPoints - 1; k++) {
 		vdCoefficients[4 * k] = vdA[k];
@@ -81,16 +102,25 @@ CPiecewisePolynomial Math::CubicSpline(const std::vector<float>& vdSupportingPoi
 
 	return CPiecewisePolynomial(vdSupportingPoints, vdCoefficients, iPolynomialOrder);
 }
+//Constructors with vectors
+
+std::vector<double> CubicSpline(const std::vector<double>& vdSupportingPoints, const std::vector<double>& vdDataPoints, const std::vector<double>& vdEvalPoints)
+{
 
-std::vector<float> Math::CubicSpline(const std::vector<float>& vdSupportingPoints, const std::vector<float>& vdDataPoints, const std::vector<float>& vdEvalPoints)
+	CPiecewisePolynomial myPoly = CubicSpline(vdSupportingPoints, vdDataPoints);
+	return myPoly.Value(vdEvalPoints);
+}
+/*
+std::vector<double> CubicSpline(const std::vector<float>& vdSupportingPoints, const std::vector<float>& vdDataPoints, const std::vector<float>& vdEvalPoints)
 {
 	CPiecewisePolynomial myPoly = CubicSpline(vdSupportingPoints, vdDataPoints);
 	return myPoly.Value(vdEvalPoints);
 }
 
-float Math::CubicSpline(const std::vector<float>& vdSupportingPoints, const std::vector<float>& vdDataPoints, float dEvalPoint)
+//Constructor for impatient users ;)
+float Math::CubicSpline(const std::vector<double>& vdSupportingPoints, const std::vector<double>& vdDataPoints, double dEvalPoint)
 {
 	CPiecewisePolynomial myPoly = CubicSpline(vdSupportingPoints, vdDataPoints);
 	return myPoly.Value(dEvalPoint);
 }
- 
\ No newline at end of file
+*/
\ No newline at end of file

tests/SplineTest.cpp

@@ -28,12 +28,13 @@
 using namespace ITABase::Math;
 
 bool SpeedTest() {
+	/*
 	//the following data is random.
-	std::vector<float> vdSupportingPoints{ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
-	std::vector<float> vdDataPoints2{ 77,    80,    19,    49,    45,    65,    71,    76,    28,    68,    66,    17,12,    50,    96,    35,    59,    23,    76,    26,    51 };
-	std::vector<float> vdX = { -10,  float(1.5),  float(-7.898),float(3.3), float(3.3), float(9.9),float(-2.5),float(8.9),float(0.01),float(-4.3) };
+	std::vector<double> vdSupportingPoints{ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+	std::vector<double> vdDataPoints2{ 77,    80,    19,    49,    45,    65,    71,    76,    28,    68,    66,    17,12,    50,    96,    35,    59,    23,    76,    26,    51 };
+	std::vector<double> vdX = { -10,  1.5,  -7.898,3.3, 3.3,9.9,-2.5,8.9,0.01,-4.3 };
 	CPiecewisePolynomial myPoly = CubicSpline(vdSupportingPoints, vdDataPoints2);
-	std::vector<float> result(10);
+	std::vector<double> result(10);
 	ITAStopWatch myWatch = ITAStopWatch();
 	std::cout << "Rueckgabe von piecwisePolynomial Objekten" << std::endl;
 
@@ -52,14 +53,18 @@ bool SpeedTest() {
 		myWatch.stop();
 	}
 	std::cout << myWatch << std::endl;
+	*/
 	return true;
-}
+	
+	}
+
 //!creates one .txt file with the Points a spline function shall be constructed for and one with the cooeficients, this programm has computes. A third contains the coefficenc of the derivate. All can be read by the SplineTest.m into MATLAB.
 void Compare2MATLAB(){
+	/* //ALLES mit FLOATS
 	//the following data is random.
 	std::vector<float> vdSupportingPoints{ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
 	std::vector<float> vdDataPoints{ 77,    80,    19,    49,    45,    65,    71,    76,    28,    68,    66,    17,12,    50,    96,    35,    59,    23,    76,    26,    51 };
-	std::vector<float> vdX = { -10,  float(1.5),  float(-7.898),float(3.3), float(3.3), float(9.9),float(-2.5),float(8.9),float(0.01),float(-4.3) };
+	std::vector<float> vdX = {-10,  1.5,  -7.898,3.3, 3.3,9.9,-2.5,8.9,0.01,-4.3 };
 	CPiecewisePolynomial myPoly =CubicSpline(vdSupportingPoints, vdDataPoints);
 	CPiecewisePolynomial myDerivate = myPoly.Derivation();
 
@@ -84,20 +89,52 @@ void Compare2MATLAB(){
 	}
 	myFile.close();
 	return;
+	
+	//the following data is random.
+	std::vector<double> vdSupportingPoints{ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+	std::vector<double> vdDataPoints{ 77,    80,    19,    49,    45,    65,    71,    76,    28,    68,    66,    17,12,    50,    96,    35,    59,    23,    76,    26,    51 };
+	std::vector<double> vdX = { -10,  1.5,  -7.898,3.3, 3.3,9.9,-2.5,8.9,0.01,-4.3 };
+	CPiecewisePolynomial myPoly = CubicSpline(vdSupportingPoints, vdDataPoints);
+	CPiecewisePolynomial myDerivate = myPoly.Derivation();
+
+	std::vector<double> vdCoeff = myPoly.Coefficients();
+	std::ofstream myFile;
+	myFile.open("points.txt");
+	for (int k = 0; k < vdDataPoints.size(); k++) {
+		myFile << vdSupportingPoints[k] << ", " << vdDataPoints[k] << std::endl;
+	}
+	myFile.close();
+
+	myFile.open("coeff.txt");
+	for (int k = 0; k < vdDataPoints.size() - 1; k++) {
+		myFile << vdCoeff[4 * k] << ", " << vdCoeff[4 * k + 1] << ", " << vdCoeff[4 * k + 2] << ", " << vdCoeff[4 * k + 3] << std::endl;
+	}
+	myFile.close();
+
+	vdCoeff = myDerivate.Coefficients();
+	myFile.open("derivate.txt");
+	for (int k = 0; k < vdDataPoints.size() - 1; k++) {
+		myFile << vdCoeff[3 * k] << ", " << vdCoeff[3 * k + 1] << ", " << vdCoeff[3 * k + 2] << std::endl;
+	}
+	myFile.close();
+	*/
+	return;
+
 }
 //!Checks the general behavior of the code
 bool GeneralTest(){
+	/*//ALLES mit FLOATS
 	//the following data is random.
-	std::vector<float> vdSupportingPoints{ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
-	std::vector<float> vdDataPoints{ 77,    80,    19,    49,    45,    65,    71,    76,    28,    68,    66,    17,12,    50,    96,    35,    59,    23,    76,    26,    51 };
-	std::vector<float> vdX = { -10,  float(1.5),  float(-7.898),float(3.3), float(3.3), float(9.9),float(-2.5),float(8.9),float(0.01),float(-4.3) };
+	const std::vector<float> vdSupportingPoints{ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+	const std::vector<float> vdDataPoints{ 77,    80,    19,    49,    45,    65,    71,    76,    28,    68,    66,    17,12,    50,    96,    35,    59,    23,    76,    26,    51 };
+	const std::vector<float> vdX = {-10,  1.5f,  -7.898f,3.3f, 3.3f,9.9f,-2.5f,8.9f,0.01f,-4.3f  };
 	CPiecewisePolynomial myPoly = CubicSpline(vdSupportingPoints, vdDataPoints);
-
+	std::cout << "-------Starting with FLOAT values-------" << std::endl << std::endl;
 	std::cout << "At supportion Point 0, the calculated value should be 66: " << myPoly.Value(0) << std::endl;
 	//should get specific Value
 	std::cout << "At random Point x=0.5 the spline should interpolate ~40.9: " << myPoly.Value(0.5) << std::endl;
 	
-	
+	/*
 	std::vector<float> vdBreakPoints = { 0, 1 };
 	std::vector<float> vdCoeff = { 1,1,1 };
 	int iOrder = 2;
@@ -146,10 +183,77 @@ bool GeneralTest(){
 		std::cout << err << std::endl;
 	}
 	return true;
+	*/
+	/*
+	//the following data is random.
+	std::vector<double> vdSupportingPoints{ -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+	std::vector<double> vdDataPoints{ 77,    80,    19,    49,    45,    65,    71,    76,    28,    68,    66,    17,12,    50,    96,    35,    59,    23,    76,    26,    51 };
+	std::vector<double> vdX = { -10,  1.5,  -7.898,3.3, 3.3,9.9,-2.5,8.9,0.01,-4.3 };
+	CPiecewisePolynomial myPoly = CubicSpline(vdSupportingPoints, vdDataPoints);
+
+	std::cout<<std::endl << "-------continuing with DOUBLE values-------" << std::endl << std::endl;
+
+	std::cout << "At supportion Point 0, the calculated value should be 66: " << myPoly.Value(0) << std::endl;
+	//should get specific Value
+	std::cout << "At random Point x=0.5 the spline should interpolate ~40.9: " << myPoly.Value(0.5) << std::endl;
+
+
+	std::vector<double> vdBreakPoints = { 0, 1 };
+	std::vector<double> vdCoeff = { 1,1,1 };
+	int iOrder = 2;
+	CPiecewisePolynomial myPoly2 = CPiecewisePolynomial(vdBreakPoints, vdCoeff, iOrder);
+
+	//deviation test
+	CPiecewisePolynomial myPoly3 = myPoly2.Derivation();
+	std::cout << "The deviation of x^2+x+1 should be: " << myPoly3.Coefficients()[0] << " * x + " << myPoly3.Coefficients()[1] << std::endl;
+	std::cout << "so the new polynoial only got " << myPoly3.NumCoefficients() << " coefficients." << std::endl;
+
+	//exceptions for Piecewise Polynoms
+	std::cout << "Testing the Value function with Argument out of it's range, without extrapolation:" << std::endl;
+	try { myPoly2.Value(-2); }
+	catch (ITAException& err) {
+		std::cout << err << std::endl;
+	}
+	std::cout << "Testing the Value function with Arguments out of it's range, with extrapolation:" << std::endl;
+	std::cout << "At -2, the calculated value should be -1: " << myPoly2.Value(-2, true) << std::endl;
+	std::cout << "At 2, the calculated value should be 6: " << myPoly2.Value(2, true) << std::endl;
+	//exceptions for spline
+	std::cout << "Testing spline with to few Points:" << std::endl;
+	try {
+		std::vector<double> vdSupportingPoints{ -10, -9 };
+		std::vector<double> vdDataPoints{ 77,    80 };
+		myPoly = CubicSpline(vdSupportingPoints, vdDataPoints);
+	}
+	catch (ITAException& err) {
+		std::cout << err << std::endl;
+	}
+	std::cout << "Testing non matching dimensions:" << std::endl;
+	try {
+		std::vector<double> vdSupportingPoints{ -10, -5 ,-1,0,3 };//5points
+		std::vector<double> vdDataPoints{ 77, 80,4,5,-4,-1 };//6 Points
+		myPoly = CubicSpline(vdSupportingPoints, vdDataPoints);
+	}
+	catch (ITAException& err) {
+		std::cout << err << std::endl;
+	}
+	std::cout << "Testing with non ascending supportingPoints" << std::endl;
+	try {
+		std::vector<double> vdSupportingPoints{ -10, 5 ,-1,0,3 };
+		std::vector<double> vdDataPoints{ 77, 80,4,5,-4 };
+		myPoly = CubicSpline(vdSupportingPoints, vdDataPoints);
+	}
+	catch (ITAException& err) {
+		std::cout << err << std::endl;
+	}
+	*/
+	return true;
+	
 }
+
 //! SplineTest.cpp consists of several Test for Speed, functionality and DataExport to MATLAB, to compare and plot splines
 int main(int iNumInArgs, char* pcInArgs[])
 {
+	/*
 	std::cout << "Checking starts" << std::endl;
 	std::cout << "Test 1: general Test for functions" << std::endl << std::endl;
 	GeneralTest();
@@ -158,6 +262,6 @@ int main(int iNumInArgs, char* pcInArgs[])
 
 	std::cout << "The next function will write 3 .txt files that need to be imported to MATLAB with the help of SplineTest.m" << std::endl;
 	Compare2MATLAB();
-
+	*/
 	return 0;
 }

tests/coeff.txt

@@ -16,5 +16,5 @@
 -75.4804, 119.925, -20.4449, 35
 77.5513, -106.516, -7.03549, 59
 -85.725, 126.138, 12.5868, 23
-73.3487, -131.037, 7.68815, 76
+73.3487, -131.037, 7.68816, 76
 -29.6697, 89.0092, -34.3395, 26

tests/derivate.txt

@@ -4,7 +4,7 @@
 100.69, -121.813, 23.343
 -66.0135, 79.568, 2.22051
 49.3634, -52.459, 15.775
--92.4402, 46.2679, 12.6795
+-92.4403, 46.2679, 12.6795
 164.398, -138.613, -33.4929
 -142.15, 190.183, -7.70791
 14.2029, -94.1177, 40.3245
@@ -16,5 +16,5 @@
 -226.441, 239.85, -20.4449
 232.654, -213.032, -7.03549
 -257.175, 252.276, 12.5868
-220.046, -262.074, 7.68815
+220.046, -262.074, 7.68816
 -89.0092, 178.018, -34.3395