#include <ScalarFunctionsImpl.h>

Inheritance diagram for ChebychevScalarFunction:

Collaboration diagram for ChebychevScalarFunction:

Public Member Functions
	ChebychevScalarFunction (const std::vector< doublereal > &v, const doublereal &a, const doublereal &b, bool doNotExtrapolate=false)

virtual	~ChebychevScalarFunction (void)

virtual doublereal	operator() (const doublereal x) const

virtual doublereal	ComputeDiff (const doublereal t, const integer order=1) const

Public Member Functions inherited from DifferentiableScalarFunction
virtual	~DifferentiableScalarFunction ()

Public Member Functions inherited from BasicScalarFunction
virtual	~BasicScalarFunction ()

Private Attributes
std::vector< doublereal >	vCoef

const doublereal	da

const doublereal	dfa

const doublereal	dfap

const doublereal	db

const doublereal	dfb

const doublereal	dfbp

bool	doNotExtrapolate

Detailed Description

Definition at line 151 of file ScalarFunctionsImpl.h.

Constructor & Destructor Documentation

ChebychevScalarFunction::ChebychevScalarFunction	(	const std::vector< doublereal > &	v,
		const doublereal &	a,
		const doublereal &	b,
		bool	doNotExtrapolate = `false`
	)

Definition at line 649 of file ScalarFunctionsImpl.cc.

References a, ComputeDiff(), dfa, dfap, dfb, dfbp, and doNotExtrapolate.

 : vCoef(v), da(a), dfa(0.), dfap(0.), db(b), dfb(0.), dfbp(0.),
 doNotExtrapolate(dne)
 {
         if (!doNotExtrapolate) {
                 const_cast<doublereal&>(dfa) = this->operator()(a);
                 const_cast<doublereal&>(dfap) = this->ComputeDiff(a);
                 const_cast<doublereal&>(dfb) = this->operator()(b);
                 const_cast<doublereal&>(dfbp) = this->ComputeDiff(b);
         }
 }

Here is the call graph for this function:

ChebychevScalarFunction::~ChebychevScalarFunction ( void )

virtual

Definition at line 663 of file ScalarFunctionsImpl.cc.

References NO_OP.

 {
         NO_OP;
 }

Member Function Documentation

doublereal ChebychevScalarFunction::ComputeDiff	(	const doublereal	t,
		const integer	order = `1`
	)		const

virtual

Implements DifferentiableScalarFunction.

Definition at line 706 of file ScalarFunctionsImpl.cc.

References ASSERTMSGBREAK, da, db, dfap, dfbp, doNotExtrapolate, MBDYN_EXCEPT_ARGS, operator()(), and vCoef.

Referenced by ChebychevScalarFunction().

 {
         ASSERTMSGBREAK(order >=0, "Error in ChebychevScalarFunction::ComputeDiff, order<0");
 
         switch (order) {
         case 0: 
                 return operator()(x);
 
         case 1:
                 break;
 
         default:
                 silent_cerr("differentiation of order " << order << " not supported yet" << std::endl);
                 throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         if (x < da) {
                 if (doNotExtrapolate) {
                         silent_cerr("Chebychev interpolation: "
                                 "x=" << x << " is out of range "
                                 "[" << da << "," << db << "]" << std::endl);
                         throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                 }
 
                 return dfap;
 
         } else if (x > db) {
                 if (doNotExtrapolate) {
                         silent_cerr("Chebychev interpolation: "
                                 "x=" << x << " is out of range "
                                 "[" << da << "," << db << "]" << std::endl);
                         throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                 }
 
                 return dfbp;
         }
 
         doublereal xi = (2.*x - (da + db))/(db - da);
         doublereal xip = 2./(db - da);
         doublereal d[2] = { 1., xi };
         doublereal dp[2] = { 0., 1. };
         doublereal val = vCoef[1];
 
         for (unsigned i = 2; i < vCoef.size(); i++) {
                 doublereal Tx = 2.*xi*d[1 - i%2] - d[i%2];
                 doublereal Txp = 2.*d[1 - i%2] + 2.*xi*dp[1 - i%2] - dp[i%2];
                 val += vCoef[i]*Txp;
                 d[i%2] = Tx;
                 dp[i%2] = Txp;
         }
 
         return xip*val;
 }

Here is the call graph for this function:

doublereal ChebychevScalarFunction::operator() ( const doublereal x ) const

virtual

Implements DifferentiableScalarFunction.

Definition at line 669 of file ScalarFunctionsImpl.cc.

References da, db, dfa, dfap, dfb, dfbp, doNotExtrapolate, MBDYN_EXCEPT_ARGS, and vCoef.

Referenced by ComputeDiff().

 {
         if (x < da) {
                 if (doNotExtrapolate) {
                         silent_cerr("Chebychev interpolation: "
                                 "x=" << x << " is out of range "
                                 "[" << da << "," << db << "]" << std::endl);
                         throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                 }
 
                 return dfa + dfap*(x - da);
 
         } else if (x > db) {
                 if (doNotExtrapolate) {
                         silent_cerr("Chebychev interpolation: "
                                 "x=" << x << " is out of range "
                                 "[" << da << "," << db << "]" << std::endl);
                         throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
                 }
 
                 return dfb + dfbp*(x - db);
         }
 
         doublereal xi = (2.*x - (da + db))/(db - da);
         doublereal d[2] = { 1., xi };
         doublereal val = vCoef[0] + vCoef[1]*xi;
 
         for (unsigned i = 2; i < vCoef.size(); i++) {
                 doublereal Tx = 2.*xi*d[1 - i%2] - d[i%2];
                 val += vCoef[i]*Tx;
                 d[i%2] = Tx;
         }
 
         return val;
 }