mirror of
https://github.com/CoolProp/CoolProp.git
synced 2026-04-23 03:00:17 -04:00
Merge branch 'master' of https://github.com/coolprop/coolprop
This commit is contained in:
Ian bell
@@ -25,12 +25,12 @@ public:
|
||||
// Destructor. No implementation
|
||||
virtual ~BasePolynomial(){};
|
||||
|
||||
protected:
|
||||
public:
|
||||
/// Basic checks for coefficient vectors.
|
||||
/** Starts with only the first coefficient dimension
|
||||
* and checks the vector length against parameter n. */
|
||||
bool checkCoefficients(const std::vector<long double> &coefficients, const unsigned int n);
|
||||
bool checkCoefficients(const std::vector< std::vector<long double> > &coefficients, const unsigned int rows, const unsigned int columns);
|
||||
bool checkCoefficients(const std::vector<double> &coefficients, const unsigned int n);
|
||||
bool checkCoefficients(const std::vector< std::vector<double> > &coefficients, const unsigned int rows, const unsigned int columns);
|
||||
|
||||
/** Integrating coefficients for polynomials is done by dividing the
|
||||
* original coefficients by (i+1) and elevating the order by 1
|
||||
@@ -40,8 +40,8 @@ protected:
|
||||
* avoids this expensive operation. However, it is included for the
|
||||
* sake of completeness.
|
||||
*/
|
||||
std::vector<long double> integrateCoeffs(const std::vector<long double> &coefficients);
|
||||
std::vector< std::vector<long double> > integrateCoeffs(const std::vector< std::vector<long double> > &coefficients, bool axis);
|
||||
std::vector<double> integrateCoeffs(const std::vector<double> &coefficients);
|
||||
std::vector< std::vector<double> > integrateCoeffs(const std::vector< std::vector<double> > &coefficients, bool axis);
|
||||
|
||||
/** Deriving coefficients for polynomials is done by multiplying the
|
||||
* original coefficients with i and lowering the order by 1.
|
||||
@@ -49,8 +49,8 @@ protected:
|
||||
* It is not really deprecated, but untested and therefore a warning
|
||||
* is issued. Please check this method before you use it.
|
||||
*/
|
||||
std::vector<long double> deriveCoeffs(const std::vector<long double> &coefficients);
|
||||
std::vector< std::vector<long double> > deriveCoeffs(const std::vector< std::vector<long double> > &coefficients, unsigned int axis);
|
||||
std::vector<double> deriveCoeffs(const std::vector<double> &coefficients);
|
||||
std::vector< std::vector<double> > deriveCoeffs(const std::vector< std::vector<double> > &coefficients, unsigned int axis);
|
||||
|
||||
private:
|
||||
/** The core of the polynomial wrappers are the different
|
||||
@@ -65,77 +65,77 @@ private:
|
||||
/// Simple polynomial function generator. <- Deprecated due to poor performance, use Horner-scheme instead
|
||||
/** Base function to produce n-th order polynomials
|
||||
* based on the length of the coefficient vector.
|
||||
* Starts with only the first coefficient at T^0. */
|
||||
DEPRECATED(long double simplePolynomial(const std::vector<long double> &coefficients, long double T));
|
||||
DEPRECATED(long double simplePolynomial(const std::vector<std::vector<long double> > &coefficients, long double x, long double T));
|
||||
* Starts with only the first coefficient at x^0. */
|
||||
DEPRECATED(double simplePolynomial(const std::vector<double> &coefficients, double x));
|
||||
DEPRECATED(double simplePolynomial(const std::vector<std::vector<double> > &coefficients, double x, double y));
|
||||
|
||||
/// Simple integrated polynomial function generator.
|
||||
/** Base function to produce integrals of n-th order polynomials based on
|
||||
* the length of the coefficient vector.
|
||||
* Starts with only the first coefficient at T^0 */
|
||||
///Indefinite integral in T-direction
|
||||
long double simplePolynomialInt(const std::vector<long double> &coefficients, long double T);
|
||||
///Indefinite integral in T-direction only
|
||||
long double simplePolynomialInt(const std::vector<std::vector<long double> > &coefficients, long double x, long double T);
|
||||
* Starts with only the first coefficient at x^0 */
|
||||
///Indefinite integral in x-direction
|
||||
double simplePolynomialInt(const std::vector<double> &coefficients, double x);
|
||||
///Indefinite integral in y-direction only
|
||||
double simplePolynomialInt(const std::vector<std::vector<double> > &coefficients, double x, double y);
|
||||
|
||||
/// Simple integrated polynomial function generator divided by independent variable.
|
||||
/** Base function to produce integrals of n-th order
|
||||
* polynomials based on the length of the coefficient
|
||||
* vector. Starts with only the first coefficient at T^0 */
|
||||
* vector. Starts with only the first coefficient at x^0 */
|
||||
///Indefinite integral of a polynomial divided by its independent variable
|
||||
long double simpleFracInt(const std::vector<long double> &coefficients, long double T);
|
||||
double simpleFracInt(const std::vector<double> &coefficients, double x);
|
||||
///Indefinite integral of a polynomial divided by its 2nd independent variable
|
||||
long double simpleFracInt(const std::vector<std::vector<long double> > &coefficients, long double x, long double T);
|
||||
double simpleFracInt(const std::vector<std::vector<double> > &coefficients, double x, double y);
|
||||
|
||||
/** Simple integrated centred(!) polynomial function generator divided by independent variable.
|
||||
* We need to rewrite some of the functions in order to
|
||||
* use central fit. Having a central temperature Tbase
|
||||
* use central fit. Having a central temperature xbase
|
||||
* allows for a better fit, but requires a different
|
||||
* formulation of the fracInt function group. Other
|
||||
* functions are not affected.
|
||||
* Starts with only the first coefficient at T^0 */
|
||||
* Starts with only the first coefficient at x^0 */
|
||||
///Helper function to calculate the D vector:
|
||||
long double factorial(long double nValue);
|
||||
long double binom(long double nValue, long double nValue2);
|
||||
std::vector<long double> fracIntCentralDvector(int m, long double T, long double Tbase);
|
||||
double factorial(double nValue);
|
||||
double binom(double nValue, double nValue2);
|
||||
std::vector<double> fracIntCentralDvector(int m, double x, double xbase);
|
||||
///Indefinite integral of a centred polynomial divided by its independent variable
|
||||
long double fracIntCentral(const std::vector<long double> &coefficients, long double T, long double Tbase);
|
||||
double fracIntCentral(const std::vector<double> &coefficients, double x, double xbase);
|
||||
|
||||
/// Horner function generator implementations
|
||||
/** Represent polynomials according to Horner's scheme.
|
||||
* This avoids unnecessary multiplication and thus
|
||||
* speeds up calculation.
|
||||
*/
|
||||
long double baseHorner(const std::vector<long double> &coefficients, long double T);
|
||||
long double baseHorner(const std::vector< std::vector<long double> > &coefficients, long double x, long double T);
|
||||
///Indefinite integral in T-direction
|
||||
long double baseHornerInt(const std::vector<long double> &coefficients, long double T);
|
||||
///Indefinite integral in T-direction only
|
||||
long double baseHornerInt(const std::vector<std::vector<long double> > &coefficients, long double x, long double T);
|
||||
double baseHorner(const std::vector<double> &coefficients, double x);
|
||||
double baseHorner(const std::vector< std::vector<double> > &coefficients, double x, double y);
|
||||
///Indefinite integral in x-direction
|
||||
double baseHornerInt(const std::vector<double> &coefficients, double x);
|
||||
///Indefinite integral in y-direction only
|
||||
double baseHornerInt(const std::vector<std::vector<double> > &coefficients, double x, double y);
|
||||
///Indefinite integral of a polynomial divided by its independent variable
|
||||
long double baseHornerFracInt(const std::vector<long double> &coefficients, long double T);
|
||||
double baseHornerFracInt(const std::vector<double> &coefficients, double x);
|
||||
///Indefinite integral of a polynomial divided by its 2nd independent variable
|
||||
long double baseHornerFracInt(const std::vector<std::vector<long double> > &coefficients, long double x, long double T);
|
||||
double baseHornerFracInt(const std::vector<std::vector<double> > &coefficients, double x, double y);
|
||||
|
||||
/** Alternatives
|
||||
* Simple functions that heavily rely on other parts of this file.
|
||||
* We still need to check which combinations yield the best
|
||||
* performance.
|
||||
*/
|
||||
///Derivative in T-direction
|
||||
long double deriveIn2Steps(const std::vector<long double> &coefficients, long double T);
|
||||
///Derivative in terms of x(axis=true) or T(axis=false).
|
||||
long double deriveIn2Steps(const std::vector< std::vector<long double> > &coefficients, long double x, long double T, bool axis);
|
||||
///Indefinite integral in T-direction
|
||||
long double integrateIn2Steps(const std::vector<long double> &coefficients, long double T);
|
||||
///Indefinite integral in terms of x(axis=true) or T(axis=false).
|
||||
long double integrateIn2Steps(const std::vector< std::vector<long double> > &coefficients, long double x, long double T, bool axis);
|
||||
///Indefinite integral in T-direction of a polynomial divided by its independent variable
|
||||
long double fracIntIn2Steps(const std::vector<long double> &coefficients, long double T);
|
||||
///Indefinite integral in T-direction of a polynomial divided by its 2nd independent variable
|
||||
long double fracIntIn2Steps(const std::vector<std::vector<long double> > &coefficients, long double x, long double T);
|
||||
///Derivative in x-direction
|
||||
double deriveIn2Steps(const std::vector<double> &coefficients, double x); // TODO: Check results!
|
||||
///Derivative in terms of x(axis=true) or y(axis=false).
|
||||
double deriveIn2Steps(const std::vector< std::vector<double> > &coefficients, double x, double y, bool axis); // TODO: Check results!
|
||||
///Indefinite integral in x-direction
|
||||
double integrateIn2Steps(const std::vector<double> &coefficients, double x);
|
||||
///Indefinite integral in terms of x(axis=true) or y(axis=false).
|
||||
double integrateIn2Steps(const std::vector< std::vector<double> > &coefficients, double x, double y, bool axis);
|
||||
///Indefinite integral in x-direction of a polynomial divided by its independent variable
|
||||
double fracIntIn2Steps(const std::vector<double> &coefficients, double x);
|
||||
///Indefinite integral in y-direction of a polynomial divided by its 2nd independent variable
|
||||
double fracIntIn2Steps(const std::vector<std::vector<double> > &coefficients, double x, double y);
|
||||
///Indefinite integral of a centred polynomial divided by its 2nd independent variable
|
||||
long double fracIntCentral2Steps(const std::vector<std::vector<long double> > &coefficients, long double x, long double T, long double Tbase);
|
||||
double fracIntCentral2Steps(const std::vector<std::vector<double> > &coefficients, double x, double y, double ybase);
|
||||
|
||||
public:
|
||||
/** Here we define the functions that should be used by the
|
||||
@@ -146,491 +146,381 @@ public:
|
||||
*/
|
||||
|
||||
/** Everything related to the normal polynomials goes in this
|
||||
* section, holds functions for both evaluation and solving
|
||||
* of polynomials.
|
||||
* section, holds all the functions for evaluating polynomials.
|
||||
*/
|
||||
/// Evaluates a one-dimensional polynomial for the given coefficients
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x long double value that represents the current input
|
||||
inline long double polyval(const std::vector<long double> &coefficients, long double x){
|
||||
/// @param x double value that represents the current input
|
||||
virtual inline double polyval(const std::vector<double> &coefficients, double x){
|
||||
return baseHorner(coefficients,x);
|
||||
}
|
||||
|
||||
/// Evaluates a two-dimensional polynomial for the given coefficients
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param y long double value that represents the current input in the 2nd dimension
|
||||
inline long double polyval(const std::vector< std::vector<long double> > &coefficients, long double x, long double y){
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param y double value that represents the current input in the 2nd dimension
|
||||
virtual inline double polyval(const std::vector< std::vector<double> > &coefficients, double x, double y){
|
||||
return baseHorner(coefficients,x,y);
|
||||
}
|
||||
|
||||
|
||||
/** Everything related to the integrated polynomials goes in this
|
||||
* section, holds functions for both evaluation and solving
|
||||
* of polynomials.
|
||||
* section, holds all the functions for evaluating polynomials.
|
||||
*/
|
||||
/// Evaluates the indefinite integral of a one-dimensional polynomial
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param T long double value that represents the current input
|
||||
inline long double polyint(const std::vector<long double> &coefficients, long double T){
|
||||
return baseHornerInt(coefficients,T);
|
||||
/// @param x double value that represents the current input
|
||||
virtual inline double polyint(const std::vector<double> &coefficients, double x){
|
||||
return baseHornerInt(coefficients,x);
|
||||
}
|
||||
|
||||
/// Evaluates the indefinite integral of a two-dimensional polynomial along the 2nd axis (T)
|
||||
/// Evaluates the indefinite integral of a two-dimensional polynomial along the 2nd axis (y)
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param T long double value that represents the current input in the 2nd dimension
|
||||
inline long double polyint(const std::vector< std::vector<long double> > &coefficients, long double x, long double T){
|
||||
return baseHornerInt(coefficients,x,T);
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param y double value that represents the current input in the 2nd dimension
|
||||
virtual inline double polyint(const std::vector< std::vector<double> > &coefficients, double x, double y){
|
||||
return baseHornerInt(coefficients,x,y);
|
||||
}
|
||||
|
||||
|
||||
/** Everything related to the derived polynomials goes in this
|
||||
* section, holds functions for both evaluation and solving
|
||||
* of polynomials.
|
||||
* section, holds all the functions for evaluating polynomials.
|
||||
*/
|
||||
/// Evaluates the derivative of a one-dimensional polynomial
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param T long double value that represents the current input
|
||||
inline long double polyder(const std::vector<long double> &coefficients, long double T){
|
||||
return deriveIn2Steps(coefficients,T);
|
||||
/// @param x double value that represents the current input
|
||||
virtual inline double polyder(const std::vector<double> &coefficients, double x){
|
||||
return deriveIn2Steps(coefficients,x);
|
||||
}
|
||||
|
||||
/// Evaluates the derivative of a two-dimensional polynomial along the 2nd axis (T)
|
||||
/// Evaluates the derivative of a two-dimensional polynomial along the 2nd axis (y)
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param T long double value that represents the current input in the 2nd dimension
|
||||
inline long double polyder(const std::vector< std::vector<long double> > &coefficients, long double x, long double T){
|
||||
return deriveIn2Steps(coefficients,x,T,false);
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param y double value that represents the current input in the 2nd dimension
|
||||
virtual inline double polyder(const std::vector< std::vector<double> > &coefficients, double x, double y){
|
||||
return deriveIn2Steps(coefficients,x,y,false);
|
||||
}
|
||||
|
||||
|
||||
/** Everything related to the polynomials divided by one variable goes in this
|
||||
* section, holds functions for both evaluation and solving
|
||||
* of polynomials.
|
||||
* section, holds all the functions for evaluating polynomials.
|
||||
*/
|
||||
/// Evaluates the indefinite integral of a one-dimensional polynomial divided by its independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param T long double value that represents the current position
|
||||
inline long double polyfracval(const std::vector<long double> &coefficients, long double T){
|
||||
return baseHornerFracInt(coefficients,T);
|
||||
/// @param x double value that represents the current position
|
||||
virtual inline double polyfracval(const std::vector<double> &coefficients, double x){
|
||||
return baseHornerFracInt(coefficients,x);
|
||||
}
|
||||
|
||||
/// Evaluates the indefinite integral of a two-dimensional polynomial divided by its 2nd independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param T long double value that represents the current input in the 2nd dimension
|
||||
inline long double polyfracval(const std::vector< std::vector<long double> > &coefficients, long double x, long double T){
|
||||
return baseHornerFracInt(coefficients,x,T);
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param y double value that represents the current input in the 2nd dimension
|
||||
virtual inline double polyfracval(const std::vector< std::vector<double> > &coefficients, double x, double y){
|
||||
return baseHornerFracInt(coefficients,x,y);
|
||||
}
|
||||
|
||||
|
||||
/** Everything related to the integrated polynomials divided by one variable goes in this
|
||||
* section, holds all the functions for solving polynomials.
|
||||
*/
|
||||
/// Evaluates the indefinite integral of a one-dimensional polynomial divided by its independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param T long double value that represents the current position
|
||||
inline long double polyfracint(const std::vector<long double> &coefficients, long double T){
|
||||
return baseHornerFracInt(coefficients,T);
|
||||
/// @param x double value that represents the current position
|
||||
virtual inline double polyfracint(const std::vector<double> &coefficients, double x){
|
||||
return baseHornerFracInt(coefficients,x);
|
||||
}
|
||||
|
||||
/// Evaluates the indefinite integral of a two-dimensional polynomial divided by its 2nd independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param T long double value that represents the current input in the 2nd dimension
|
||||
inline long double polyfracint(const std::vector< std::vector<long double> > &coefficients, long double x, long double T){
|
||||
return baseHornerFracInt(coefficients,x,T);
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param y double value that represents the current input in the 2nd dimension
|
||||
virtual inline double polyfracint(const std::vector< std::vector<double> > &coefficients, double x, double y){
|
||||
return baseHornerFracInt(coefficients,x,y);
|
||||
}
|
||||
|
||||
/// Evaluates the indefinite integral of a centred one-dimensional polynomial divided by its independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param T long double value that represents the current position
|
||||
/// @param Tbase central temperature for fitted function
|
||||
inline long double polyfracintcentral(const std::vector<long double> &coefficients, long double T, long double Tbase){
|
||||
return fracIntCentral(coefficients,T,Tbase);
|
||||
/// @param x double value that represents the current position
|
||||
/// @param xbase central temperature for fitted function
|
||||
virtual inline double polyfracintcentral(const std::vector<double> &coefficients, double x, double xbase){
|
||||
return fracIntCentral(coefficients,x,xbase);
|
||||
}
|
||||
|
||||
/// Evaluates the indefinite integral of a centred two-dimensional polynomial divided by its 2nd independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param T long double value that represents the current input in the 2nd dimension
|
||||
/// @param Tbase central temperature for fitted function
|
||||
inline long double polyfracintcentral(const std::vector< std::vector<long double> > &coefficients, long double x, long double T, long double Tbase){
|
||||
return fracIntCentral2Steps(coefficients,x,T,Tbase);
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param y double value that represents the current input in the 2nd dimension
|
||||
/// @param ybase central temperature for fitted function
|
||||
virtual inline double polyfracintcentral(const std::vector< std::vector<double> > &coefficients, double x, double y, double ybase){
|
||||
return fracIntCentral2Steps(coefficients,x,y,ybase);
|
||||
}
|
||||
|
||||
|
||||
/** Everything related to the derived polynomials divided by one variable goes in this
|
||||
* section, holds all the functions for solving polynomials.
|
||||
*/
|
||||
/// Evaluates the derivative of a one-dimensional polynomial divided by its independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x double value that represents the current position
|
||||
virtual inline double polyfracder(const std::vector<double> &coefficients, double x){
|
||||
throw CoolProp::NotImplementedError("Derivatives of polynomials divided by their independent variable have not been implemented."); // TODO: Implement polyfracder1D
|
||||
}
|
||||
|
||||
/// Evaluates the derivative of a two-dimensional polynomial divided by its 2nd independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param y double value that represents the current input in the 2nd dimension
|
||||
virtual inline double polyfracder(const std::vector< std::vector<double> > &coefficients, double x, double y){
|
||||
throw CoolProp::NotImplementedError("Derivatives of polynomials divided by their independent variable have not been implemented."); // TODO: Implement polyfracder2D
|
||||
}
|
||||
|
||||
/// Evaluates the derivative of a centred one-dimensional polynomial divided by its independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x double value that represents the current position
|
||||
/// @param xbase central temperature for fitted function
|
||||
virtual inline double polyfracdercentral(const std::vector<double> &coefficients, double x, double xbase){
|
||||
throw CoolProp::NotImplementedError("Derivatives of polynomials divided by their independent variable have not been implemented."); // TODO: Implement polyfracdercentral1D
|
||||
}
|
||||
|
||||
/// Evaluates the derivative of a centred two-dimensional polynomial divided by its 2nd independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param y double value that represents the current input in the 2nd dimension
|
||||
/// @param ybase central temperature for fitted function
|
||||
virtual inline double polyfracdercentral(const std::vector< std::vector<double> > &coefficients, double x, double y, double ybase){
|
||||
throw CoolProp::NotImplementedError("Derivatives of polynomials divided by their independent variable have not been implemented."); // TODO: Implement polyfracdercentral2D
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
/** Implements the function wrapper interface and can be
|
||||
* used by the solvers.
|
||||
* TODO: Make multidimensional
|
||||
*/
|
||||
class PolyResidual : public FuncWrapper1D {
|
||||
protected:
|
||||
enum dims {i1D, i2D};
|
||||
/// Object that evaluates the equation
|
||||
BasePolynomial poly;
|
||||
/// Current output value
|
||||
double output, firstDim;
|
||||
int dim;
|
||||
std::vector< std::vector<double> > coefficients;
|
||||
private:
|
||||
PolyResidual();
|
||||
public:
|
||||
PolyResidual(const std::vector<double> &coefficients, double y);
|
||||
PolyResidual(const std::vector< std::vector<double> > &coefficients, double x, double z);
|
||||
virtual ~PolyResidual(){};
|
||||
virtual double call(double x);
|
||||
virtual double deriv(double x);
|
||||
};
|
||||
class PolyIntResidual : public PolyResidual {
|
||||
public:
|
||||
virtual double call(double x);
|
||||
virtual double deriv(double x);
|
||||
};
|
||||
class PolyFracIntResidual : public PolyResidual {
|
||||
public:
|
||||
virtual double call(double x);
|
||||
virtual double deriv(double x);
|
||||
};
|
||||
class PolyDerResidual : public PolyResidual {
|
||||
public:
|
||||
virtual double call(double x);
|
||||
virtual double deriv(double x);
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
/** Implements the same public functions as the
|
||||
* but solves the polynomial for the given value
|
||||
* instead of evaluating it.
|
||||
* TODO: This class does not check for bijective
|
||||
* polynomials and is therefore a little
|
||||
* fragile.
|
||||
*/
|
||||
class PolynomialSolver : public BasePolynomial{
|
||||
private:
|
||||
enum solvers {iNewton, iBrent};
|
||||
int uses;
|
||||
double guess, min, max;
|
||||
double macheps, tol;
|
||||
int maxiter;
|
||||
|
||||
public:
|
||||
// Constructor
|
||||
PolynomialSolver();
|
||||
// Destructor. No implementation
|
||||
virtual ~PolynomialSolver(){};
|
||||
|
||||
public:
|
||||
/** Here we redefine the functions that solve the polynomials.
|
||||
* These implementations all use the base class to evaluate
|
||||
* the polynomial during the solution process.
|
||||
*/
|
||||
|
||||
/** Everything related to the normal polynomials goes in this
|
||||
* section, holds all the functions for solving polynomials.
|
||||
*/
|
||||
/// Solves a one-dimensional polynomial for the given coefficients
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y double value that represents the current input
|
||||
virtual double polyval(const std::vector<double> &coefficients, double y);
|
||||
|
||||
/// Solves a two-dimensional polynomial for the given coefficients
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param z double value that represents the current output
|
||||
virtual double polyval(const std::vector< std::vector<double> > &coefficients, double x, double z);
|
||||
|
||||
|
||||
/** Everything related to the integrated polynomials goes in this
|
||||
* section, holds all the functions for solving polynomials.
|
||||
*/
|
||||
/// Solves the indefinite integral of a one-dimensional polynomial
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y double value that represents the current output
|
||||
virtual double polyint(const std::vector<double> &coefficients, double y);
|
||||
|
||||
/// Solves the indefinite integral of a two-dimensional polynomial along the 2nd axis (y)
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param z double value that represents the current output
|
||||
virtual double polyint(const std::vector< std::vector<double> > &coefficients, double x, double z);
|
||||
|
||||
|
||||
/** Everything related to the derived polynomials goes in this
|
||||
* section, holds all the functions for solving polynomials.
|
||||
*/
|
||||
/// Solves the derivative of a one-dimensional polynomial
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y double value that represents the current output
|
||||
virtual double polyder(const std::vector<double> &coefficients, double y);
|
||||
|
||||
/// Solves the derivative of a two-dimensional polynomial along the 2nd axis (y)
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param z double value that represents the current output
|
||||
virtual double polyder(const std::vector< std::vector<double> > &coefficients, double x, double z);
|
||||
|
||||
|
||||
/** Everything related to the polynomials divided by one variable goes in this
|
||||
* section, holds all the functions for solving polynomials.
|
||||
*/
|
||||
/// Solves the indefinite integral of a one-dimensional polynomial divided by its independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y double value that represents the current output
|
||||
virtual double polyfracval(const std::vector<double> &coefficients, double y);
|
||||
|
||||
/// Solves the indefinite integral of a two-dimensional polynomial divided by its 2nd independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param z double value that represents the current output
|
||||
virtual double polyfracval(const std::vector< std::vector<double> > &coefficients, double x, double z);
|
||||
|
||||
|
||||
/** Everything related to the integrated polynomials divided by one variable goes in this
|
||||
* section, holds all the functions for solving polynomials.
|
||||
*/
|
||||
/// Solves the indefinite integral of a one-dimensional polynomial divided by its independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y double value that represents the current output
|
||||
virtual double polyfracint(const std::vector<double> &coefficients, double y);
|
||||
|
||||
/// Solves the indefinite integral of a two-dimensional polynomial divided by its 2nd independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param z double value that represents the current output
|
||||
virtual double polyfracint(const std::vector< std::vector<double> > &coefficients, double x, double z);
|
||||
|
||||
/// Solves the indefinite integral of a centred one-dimensional polynomial divided by its independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y double value that represents the current output
|
||||
/// @param xbase central x-value for fitted function
|
||||
virtual double polyfracintcentral(const std::vector<double> &coefficients, double y, double xbase);
|
||||
|
||||
/// Solves the indefinite integral of a centred two-dimensional polynomial divided by its 2nd independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param z double value that represents the current output
|
||||
/// @param ybase central y-value for fitted function
|
||||
virtual double polyfracintcentral(const std::vector< std::vector<double> > &coefficients, double x, double z, double ybase);
|
||||
|
||||
|
||||
/** Everything related to the derived polynomials divided by one variable goes in this
|
||||
* section, holds all the functions for solving polynomials.
|
||||
*/
|
||||
/// Solves the derivative of a one-dimensional polynomial divided by its independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y double value that represents the current output
|
||||
virtual double polyfracder(const std::vector<double> &coefficients, double y);
|
||||
|
||||
/// Solves the derivative of a two-dimensional polynomial divided by its 2nd independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param z double value that represents the current output
|
||||
virtual double polyfracder(const std::vector< std::vector<double> > &coefficients, double x, double z);
|
||||
|
||||
/// Solves the derivative of a centred one-dimensional polynomial divided by its independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y double value that represents the current output
|
||||
/// @param xbase central x-value for fitted function
|
||||
virtual double polyfracdercentral(const std::vector<double> &coefficients, double y, double xbase);
|
||||
|
||||
/// Solves the derivative of a centred two-dimensional polynomial divided by its 2nd independent variable
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param z double value that represents the current output
|
||||
/// @param ybase central y-value for fitted function
|
||||
virtual double polyfracdercentral(const std::vector< std::vector<double> > &coefficients, double x, double z, double ybase);
|
||||
|
||||
|
||||
/** Set the solvers and updates either the guess values or the
|
||||
* boundaries for the variable to solve for.
|
||||
*/
|
||||
/// Sets the guess value for the Newton solver and enables it.
|
||||
/// @param guess double value that represents the guess value
|
||||
virtual void setGuess(double guess);
|
||||
/// Sets the limits for the Brent solver and enables it.
|
||||
/// @param min double value that represents the lower boundary
|
||||
/// @param max double value that represents the upper boundary
|
||||
virtual void setLimits(double min, double max);
|
||||
/// Solves the equations based on previously defined parameters.
|
||||
/// @param min double value that represents the lower boundary
|
||||
/// @param max double value that represents the upper boundary
|
||||
virtual double solve(PolyResidual &res);
|
||||
};
|
||||
|
||||
|
||||
/// The base class for exponential functions
|
||||
class BaseExponential{
|
||||
|
||||
protected:
|
||||
BasePolynomial poly;
|
||||
bool DEBUG;
|
||||
|
||||
public:
|
||||
BaseExponential();
|
||||
virtual ~BaseExponential(){};
|
||||
|
||||
public:
|
||||
/// Evaluates an exponential function for the given coefficients
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param T long double value that represents the current input
|
||||
/// @param x double value that represents the current input
|
||||
/// @param n int value that determines the kind of exponential function
|
||||
long double expval(const std::vector<long double> &coefficients, long double T, int n);
|
||||
double expval(const std::vector<double> &coefficients, double x, int n);
|
||||
|
||||
/// Evaluates an exponential function for the given coefficients
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param T long double value that represents the current input in the 2nd dimension
|
||||
/// @param x double value that represents the current input in the 1st dimension
|
||||
/// @param y double value that represents the current input in the 2nd dimension
|
||||
/// @param n int value that determines the kind of exponential function
|
||||
long double expval(const std::vector< std::vector<long double> > &coefficients, long double x, long double T, int n);
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/// The classes for Polynomials
|
||||
class PolynomialImpl1D : public BasePolynomial{
|
||||
protected:
|
||||
std::vector<long double> coefficients;
|
||||
/// A nested class that is used by the solvers to calculate
|
||||
/// residuals and derivatives during the solution process.
|
||||
class Residual : public FuncWrapper1D {
|
||||
private:
|
||||
PolynomialImpl1D *poly;
|
||||
long double y;
|
||||
Residual();
|
||||
public:
|
||||
Residual(PolynomialImpl1D *poly, long double y);
|
||||
virtual double call(double x);
|
||||
virtual double deriv(double x);
|
||||
};
|
||||
class ResidualInt : public Residual {
|
||||
public:
|
||||
virtual double call(double x);
|
||||
virtual double deriv(double x);
|
||||
};
|
||||
class ResidualDer : public Residual {
|
||||
public:
|
||||
virtual double call(double x);
|
||||
virtual double deriv(double x);
|
||||
};
|
||||
private:
|
||||
PolynomialImpl1D();
|
||||
public:
|
||||
PolynomialImpl1D(const std::vector<long double> &coefficients);
|
||||
virtual ~PolynomialImpl1D(){};
|
||||
/// Evaluates a one-dimensional polynomial for the given coefficients
|
||||
/// @param x long double value that represents the current input
|
||||
virtual long double eval(long double x);
|
||||
/// Evaluates the indefinite integral of a one-dimensional polynomial
|
||||
/// @param x long double value that represents the current input
|
||||
virtual long double integ(long double x);
|
||||
/// Evaluates the derivative of a one-dimensional polynomial
|
||||
/// @param x long double value that represents the current input
|
||||
virtual long double deriv(long double x);
|
||||
/// Solves a one-dimensional polynomial for the given coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x0 long double value that represents the first guess for x
|
||||
virtual long double solve(long double y, long double x0);
|
||||
/// Solves a one-dimensional polynomial for the given coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param xmin long double value that represents the lower limit for x
|
||||
/// @param xmax long double value that represents the upper limit for x
|
||||
virtual long double solve(long double y, long double xmin, long double xmax);
|
||||
/// Solves an integrated one-dimensional polynomial for the given coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x0 long double value that represents the first guess for x
|
||||
virtual long double solveInt(long double y, long double x0);
|
||||
/// Solves an integrated one-dimensional polynomial for the given coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param xmin long double value that represents the lower limit for x
|
||||
/// @param xmax long double value that represents the upper limit for x
|
||||
virtual long double solveInt(long double y, long double xmin, long double xmax);
|
||||
/// Solves the derivative of a one-dimensional polynomial for the given coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x0 long double value that represents the first guess for x
|
||||
virtual long double solveDer(long double y, long double x0);
|
||||
/// Solves the derivative of a one-dimensional polynomial for the given coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param xmin long double value that represents the lower limit for x
|
||||
/// @param xmax long double value that represents the upper limit for x
|
||||
virtual long double solveDer(long double y, long double xmin, long double xmax);
|
||||
};
|
||||
|
||||
class PolynomialImpl2D : public BasePolynomial{
|
||||
protected:
|
||||
std::vector< std::vector<long double> > coefficients;
|
||||
/// A nested class that is used by the solvers to calculate
|
||||
/// residuals and derivatives during the solution process.
|
||||
class Residual : public FuncWrapper1D {
|
||||
private:
|
||||
PolynomialImpl2D *poly;
|
||||
long double x, y;
|
||||
Residual();
|
||||
public:
|
||||
Residual(PolynomialImpl2D *poly, long double y, long double x);
|
||||
virtual double call(double z);
|
||||
virtual double deriv(double z);
|
||||
};
|
||||
class ResidualInt : public Residual {
|
||||
public:
|
||||
virtual double call(double z);
|
||||
virtual double deriv(double z);
|
||||
};
|
||||
class ResidualDer : public Residual {
|
||||
public:
|
||||
virtual double call(double z);
|
||||
virtual double deriv(double z);
|
||||
};
|
||||
private:
|
||||
PolynomialImpl2D();
|
||||
public:
|
||||
PolynomialImpl2D(const std::vector< std::vector<long double> > &coefficients);
|
||||
virtual ~PolynomialImpl2D(){};
|
||||
/// Evaluates a two-dimensional polynomial for the given coefficients
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param z long double value that represents the current input in the 2nd dimension
|
||||
virtual long double eval(long double x, long double z);
|
||||
/// Evaluates the indefinite integral of a two-dimensional polynomial along the 2nd axis (z)
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param z long double value that represents the current input in the 2nd dimension
|
||||
virtual long double integ(long double x, long double z);
|
||||
/// Evaluates the derivative of a two-dimensional polynomial along the 2nd axis (z)
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param z long double value that represents the current input in the 2nd dimension
|
||||
virtual long double deriv(long double x, long double z);
|
||||
/// Solves a two-dimensional polynomial for the 2nd input (z)
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param z0 long double value that represents the first guess for z
|
||||
virtual long double solve(long double y, long double x, long double z0);
|
||||
/// Solves a two-dimensional polynomial for the 2nd input (z)
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param zmin long double value that represents the lower limit for z
|
||||
/// @param zmax long double value that represents the upper limit for z
|
||||
virtual long double solve(long double y, long double x, long double zmin, long double zmax);
|
||||
/// Solves an integrated two-dimensional polynomial for the 2nd input (z)
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param z0 long double value that represents the first guess for z
|
||||
virtual long double solveInt(long double y, long double x, long double z0);
|
||||
/// Solves an integrated two-dimensional polynomial for the 2nd input (z)
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param zmin long double value that represents the lower limit for z
|
||||
/// @param zmax long double value that represents the upper limit for z
|
||||
virtual long double solveInt(long double y, long double x, long double zmin, long double zmax);
|
||||
/// Solves the derivative of a two-dimensional polynomial for the 2nd input (z)
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param z0 long double value that represents the first guess for z
|
||||
virtual long double solveDer(long double y, long double x, long double z0);
|
||||
/// Solves the derivative of a two-dimensional polynomial for the 2nd input (z)
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param zmin long double value that represents the lower limit for z
|
||||
/// @param zmax long double value that represents the upper limit for z
|
||||
virtual long double solveDer(long double y, long double x, long double zmin, long double zmax);
|
||||
};
|
||||
|
||||
class PolynomialFrac1D : public PolynomialImpl1D{
|
||||
private:
|
||||
PolynomialFrac1D();
|
||||
public:
|
||||
PolynomialFrac1D(const std::vector<long double> &coefficients);
|
||||
virtual ~PolynomialFrac1D(){};
|
||||
/// Evaluates a one-dimensional polynomial for the given coefficients
|
||||
/// @param x long double value that represents the current input
|
||||
virtual long double eval(long double x);
|
||||
/// Evaluates the indefinite integral of a one-dimensional polynomial
|
||||
/// @param x long double value that represents the current input
|
||||
virtual long double integ(long double x);
|
||||
/// Evaluates the derivative of a one-dimensional polynomial
|
||||
/// @param x long double value that represents the current input
|
||||
virtual long double deriv(long double x);
|
||||
/// Solves a one-dimensional polynomial for the given coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x0 long double value that represents the first guess for x
|
||||
virtual long double solve(long double y, long double x0);
|
||||
/// Solves a one-dimensional polynomial for the given coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param xmin long double value that represents the lower limit for x
|
||||
/// @param xmax long double value that represents the upper limit for x
|
||||
virtual long double solve(long double y, long double xmin, long double xmax);
|
||||
/// Solves an integrated one-dimensional polynomial for the given coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x0 long double value that represents the first guess for x
|
||||
virtual long double solveInt(long double y, long double x0);
|
||||
/// Solves an integrated one-dimensional polynomial for the given coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param xmin long double value that represents the lower limit for x
|
||||
/// @param xmax long double value that represents the upper limit for x
|
||||
virtual long double solveInt(long double y, long double xmin, long double xmax);
|
||||
// virtual long double solveIntCentral(long double y, long double xBase, long double x0); // TODO: implement solveIntCentral with x0
|
||||
/// Solves an integrated one-dimensional polynomial
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param xBase long double value that represents the central value for x
|
||||
/// @param xmin long double value that represents the lower limit for x
|
||||
/// @param xmax long double value that represents the upper limit for x
|
||||
virtual long double solveIntCentral(long double y, long double xBase, long double xmin, long double xmax);
|
||||
/// Solves the derivative of a one-dimensional polynomial for the given coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x0 long double value that represents the first guess for x
|
||||
virtual long double solveDer(long double y, long double x0);
|
||||
/// Solves the derivative of a one-dimensional polynomial for the given coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param xmin long double value that represents the lower limit for x
|
||||
/// @param xmax long double value that represents the upper limit for x
|
||||
virtual long double solveDer(long double y, long double xmin, long double xmax);
|
||||
// virtual long double solveDerCentral(long double y, long double xBase, long double x0); // TODO: implement solveDerCentral with x0
|
||||
// virtual long double solveDerCentral(long double y, long double xBase, long double xmin, long double xmax); // TODO: implement solveDerCentral with xmin, xmax
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/// Solves a one-dimensional polynomial for the given coefficients
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x0 long double value that represents the first guess for x
|
||||
virtual long double solve(const std::vector<long double> &coefficients, long double y, long double x0);
|
||||
/// Solves a two-dimensional polynomial for the 2nd input (z)
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param z0 long double value that represents the first guess for z
|
||||
virtual long double solve(const std::vector< std::vector<long double> > &coefficients, long double y, long double x, long double z0);
|
||||
/// Solves a one-dimensional polynomial for the given coefficients
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param xmin long double value that represents the lower limit for x
|
||||
/// @param xmax long double value that represents the upper limit for x
|
||||
virtual long double solve(const std::vector<long double> &coefficients, long double y, long double xmin, long double xmax);
|
||||
/// Solves a two-dimensional polynomial for the 2nd input (z)
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param zmin long double value that represents the lower limit for z
|
||||
/// @param zmax long double value that represents the upper limit for z
|
||||
virtual long double solve(const std::vector< std::vector<long double> > &coefficients, long double y, long double x, long double zmin, long double zmax);
|
||||
/// Solves an integrated one-dimensional polynomial for the given coefficients
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x0 long double value that represents the first guess for x
|
||||
virtual long double solveInt(const std::vector<long double> &coefficients, long double y, long double x0);
|
||||
/// Solves an integrated two-dimensional polynomial for the 2nd input (z)
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param z0 long double value that represents the first guess for z
|
||||
virtual long double solveInt(const std::vector< std::vector<long double> > &coefficients, long double y, long double x, long double z0);
|
||||
/// Solves an integrated one-dimensional polynomial for the given coefficients
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param xmin long double value that represents the lower limit for x
|
||||
/// @param xmax long double value that represents the upper limit for x
|
||||
virtual long double solveInt(const std::vector<long double> &coefficients, long double y, long double xmin, long double xmax);
|
||||
/// Solves an integrated two-dimensional polynomial for the 2nd input (z)
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param zmin long double value that represents the lower limit for z
|
||||
/// @param zmax long double value that represents the upper limit for z
|
||||
virtual long double solveInt(const std::vector< std::vector<long double> > &coefficients, long double y, long double x, long double zmin, long double zmax);
|
||||
/// Solves the derivative of a one-dimensional polynomial for the given coefficients
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x0 long double value that represents the first guess for x
|
||||
virtual long double solveDer(const std::vector<long double> &coefficients, long double y, long double x0);
|
||||
/// Solves the derivative of a one-dimensional polynomial for the given coefficients
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param xmin long double value that represents the lower limit for x
|
||||
/// @param xmax long double value that represents the upper limit for x
|
||||
virtual long double solveDer(const std::vector<long double> &coefficients, long double y, long double xmin, long double xmax);
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/// Solves the derivative of a two-dimensional polynomial for the 2nd input (z)
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param z0 long double value that represents the first guess for z
|
||||
virtual long double solveDer(const std::vector< std::vector<long double> > &coefficients, long double y, long double x, long double z0);
|
||||
/// Solves the derivative of a two-dimensional polynomial for the 2nd input (z)
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param y long double value that represents the current function output
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param zmin long double value that represents the lower limit for z
|
||||
/// @param zmax long double value that represents the upper limit for z
|
||||
virtual long double solveDer(const std::vector< std::vector<long double> > &coefficients, long double y, long double x, long double zmin, long double zmax);
|
||||
// virtual long double solveDerCentral(long double y, long double x, long double zBase, long double z0); // TODO: implement solveDerCentral with z0
|
||||
// virtual long double solveDerCentral(long double y, long double x, long double zBase, long double zmin, long double zmax); // TODO: implement solveDerCentral with zmin, zmax
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
};
|
||||
|
||||
class PolynomialFrac2D : public PolynomialImpl2D{
|
||||
private:
|
||||
PolynomialFrac2D();
|
||||
public:
|
||||
PolynomialFrac2D(const std::vector< std::vector<long double> > &coefficients);
|
||||
virtual ~PolynomialFrac2D(){};
|
||||
/// Evaluates a two-dimensional polynomial for the given coefficients
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param z long double value that represents the current input in the 2nd dimension
|
||||
virtual long double eval(long double x, long double z);
|
||||
/// Evaluates the indefinite integral of a two-dimensional polynomial along the 2nd axis (z)
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param z long double value that represents the current input in the 2nd dimension
|
||||
virtual long double integ(long double x, long double z);
|
||||
/// Evaluates the indefinite integral of a two-dimensional polynomial along the 2nd axis (z)
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param z long double value that represents the current input in the 2nd dimension
|
||||
/// @param zBase long double value that represents the central value for z
|
||||
virtual long double integCentral(long double x, long double z, long double zBase);
|
||||
/// Evaluates the derivative of a two-dimensional polynomial along the 2nd axis (z)
|
||||
/// @param coefficients vector containing the ordered coefficients
|
||||
/// @param x long double value that represents the current input in the 1st dimension
|
||||
/// @param z long double value that represents the current input in the 2nd dimension
|
||||
virtual long double deriv(long double x, long double z);
|
||||
|
||||
|
||||
double expval(const std::vector< std::vector<double> > &coefficients, double x, double y, int n);
|
||||
};
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user