ScalarFunctionBuilder::Simplifier Class Reference

List of all members.

Public Member Functions

ConstReferenceCounting
< ScalarFunctionBase > 		simplify (const BinaryOperation &binaryOperation, const ScalarFunctionBase &f, const ScalarFunctionBase &g) const
 Simplifier ()
 ~Simplifier ()

Private Member Functions

template<typename BinaryOperatorType>
ConstReferenceCounting
< ScalarFunctionBase > 		__getOperatorF1F2SimplifiedFunction (const ScalarFunctionConstant &f1, const ScalarFunctionConstant &f2) const
template<typename BinaryOperatorType>
ConstReferenceCounting
< ScalarFunctionBase > 		__getOperatorF1F2SimplifiedFunction (const ScalarFunctionConstant &f1, const FEMFunctionBase &f2) const
template<typename BinaryOperatorType>
ConstReferenceCounting
< ScalarFunctionBase > 		__getOperatorF1F2SimplifiedFunction (const FEMFunctionBase &f1, const ScalarFunctionConstant &f2) const
template<typename BinaryOperatorType>
ConstReferenceCounting
< ScalarFunctionBase > 		__getOperatorF1F2SimplifiedFunction (const FEMFunctionBase &f1, const FEMFunctionBase &f2) const
template<typename BinaryOperatorType, typename FunctionType1>
ConstReferenceCounting
< ScalarFunctionBase > 		__getOperatorF1SimplifiedFunction (const FunctionType1 &f, const ScalarFunctionBase &f2) const
template<typename BinaryOperatorType>
ConstReferenceCounting
< ScalarFunctionBase > 		__getOperatorSimplifiedFunction (const ScalarFunctionBase &f1, const ScalarFunctionBase &f2) const

Classes

struct  BinaryOperatorDifference
struct  BinaryOperatorDivision
struct  BinaryOperatorMax
struct  BinaryOperatorMin
struct  BinaryOperatorModulo
struct  BinaryOperatorPower
struct  BinaryOperatorProduct
struct  BinaryOperatorSum

Detailed Description

to simplify functions at built time. For instance, if f=1 and g=2, f+g is replaced by 3...

Definition at line 56 of file ScalarFunctionBuilder.cpp.

Constructor & Destructor Documentation

ScalarFunctionBuilder::Simplifier::Simplifier (  )  [inline]

Constructor

Definition at line 421 of file ScalarFunctionBuilder.cpp.

00422   {
00423     ;
00424   }

ScalarFunctionBuilder::Simplifier::~Simplifier (  )  [inline]

Destructor

Definition at line 430 of file ScalarFunctionBuilder.cpp.

00431   {
00432     ;
00433   }

Member Function Documentation

template<typename BinaryOperatorType>
ConstReferenceCounting<ScalarFunctionBase> ScalarFunctionBuilder::Simplifier::__getOperatorF1F2SimplifiedFunction ( const ScalarFunctionConstant &  f1,
const ScalarFunctionConstant &  f2 
) const [inline, private]

Computes constant function resulting of two constant functions

Parameters:
f1 first constant function
f2 second constant function
Returns:
$ f1~\mbox{op}~f2 $

Definition at line 172 of file ScalarFunctionBuilder.cpp.

00174   {
00175     return new ScalarFunctionConstant(BinaryOperatorType::eval(f1(0),
00176                                                                f2(0)));
00177   }

template<typename BinaryOperatorType>
ConstReferenceCounting<ScalarFunctionBase> ScalarFunctionBuilder::Simplifier::__getOperatorF1F2SimplifiedFunction ( const ScalarFunctionConstant &  f1,
const FEMFunctionBase &  f2 
) const [inline, private]

Computes finite element function resulting of a constant function and a finite element function binary operation

Parameters:
f1 constant function
f2 finite element function
Returns:
$ f1~\mbox{op}~f2 $

Definition at line 190 of file ScalarFunctionBuilder.cpp.

References FEMFunctionBase::baseMesh(), FEMFunctionBuilder::build(), FEMFunctionBase::discretizationType(), FEMFunctionBuilder::getBuiltScalarFunction(), FEMFunctionBase::outsideValue(), Vector< T >::size(), and FEMFunctionBase::values().

00192   {
00193     Vector<real_t> femValues(f2.values().size());
00194 
00195     const real_t constantValue = f1(0);
00196 
00197     const real_t outsideValue = BinaryOperatorType::eval(constantValue,
00198                                                          f2.outsideValue());
00199 
00200     for (size_t i=0; i<femValues.size(); ++i) {
00201       femValues[i] = BinaryOperatorType::eval(constantValue,f2[i]);
00202     }
00203 
00204     FEMFunctionBuilder builder;
00205     builder.build(f2.discretizationType(),
00206                   f2.baseMesh(),
00207                   femValues,
00208                   outsideValue);
00209     return builder.getBuiltScalarFunction();
00210   }

Here is the call graph for this function:

template<typename BinaryOperatorType>
ConstReferenceCounting<ScalarFunctionBase> ScalarFunctionBuilder::Simplifier::__getOperatorF1F2SimplifiedFunction ( const FEMFunctionBase &  f1,
const ScalarFunctionConstant &  f2 
) const [inline, private]

Computes finite element function resulting of a finite element function and a constant function binary operation

Parameters:
f1 finite element function
f2 constant function
Returns:
$ f1~\mbox{op}~f2 $

Definition at line 223 of file ScalarFunctionBuilder.cpp.

References FEMFunctionBase::baseMesh(), FEMFunctionBase::discretizationType(), FEMFunctionBase::outsideValue(), Vector< T >::size(), and FEMFunctionBase::values().

00225   {
00226     Vector<real_t> femValues(f1.values().size());
00227 
00228     const real_t constantValue = f2(0);
00229 
00230     for (size_t i=0; i<femValues.size(); ++i) {
00231       femValues[i] = BinaryOperatorType::eval(f1[i],constantValue);
00232     }
00233 
00234     const real_t outsideValue = BinaryOperatorType::eval(f1.outsideValue(),
00235                                                          constantValue);
00236 
00237     FEMFunctionBuilder builder;
00238     builder.build(f1.discretizationType(),
00239                   f1.baseMesh(),
00240                   femValues,
00241                   outsideValue);
00242     return builder.getBuiltScalarFunction();
00243   }

Here is the call graph for this function:

template<typename BinaryOperatorType>
ConstReferenceCounting<ScalarFunctionBase> ScalarFunctionBuilder::Simplifier::__getOperatorF1F2SimplifiedFunction ( const FEMFunctionBase &  f1,
const FEMFunctionBase &  f2 
) const [inline, private]

Computes finite element function resulting of two finite element function binary operation

Parameters:
f1 first finite element function
f2 second finite element function
Returns:
$ f1~\mbox{op}~f2 $

Definition at line 256 of file ScalarFunctionBuilder.cpp.

References ASSERT, FEMFunctionBase::baseMesh(), FEMFunctionBase::discretizationType(), FEMFunctionBase::outsideValue(), Vector< T >::size(), and FEMFunctionBase::values().

00258   {
00259     Vector<real_t> femValues(f1.values().size());
00260 
00261     ASSERT(f1.discretizationType() == f2.discretizationType());
00262     ASSERT(f1.baseMesh() == f2.baseMesh());
00263 
00264     for (size_t i=0; i<femValues.size(); ++i) {
00265       femValues[i] = BinaryOperatorType::eval(f1[i],f2[i]);
00266     }
00267 
00268     const real_t outsideValue = BinaryOperatorType::eval(f1.outsideValue(),
00269                                                          f2.outsideValue());
00270 
00271     FEMFunctionBuilder builder;
00272     builder.build(f1.discretizationType(),
00273                   f1.baseMesh(),
00274                   femValues,
00275                   outsideValue);
00276     return builder.getBuiltScalarFunction();
00277   }

Here is the call graph for this function:

template<typename BinaryOperatorType, typename FunctionType1>
ConstReferenceCounting<ScalarFunctionBase> ScalarFunctionBuilder::Simplifier::__getOperatorF1SimplifiedFunction ( const FunctionType1 &  f,
const ScalarFunctionBase &  f2 
) const [inline, private]

Specialize the first function type of the binary operation

Parameters:
f specialized function
f2 still base function
Returns:
simplified (or not) binary operation

Definition at line 291 of file ScalarFunctionBuilder.cpp.

References ScalarFunctionBase::constant, ScalarFunctionBase::femfunction, ScalarFunctionBase::type(), and ErrorHandler::unexpected.

00293   {
00294     switch (f2.type()) {
00295     case ScalarFunctionBase::constant: {
00296       const ScalarFunctionConstant& g = static_cast<const ScalarFunctionConstant&>(f2);
00297       return this->__getOperatorF1F2SimplifiedFunction<BinaryOperatorType>(f,g);
00298     }
00299     case ScalarFunctionBase::femfunction: {
00300       const FEMFunctionBase& g = static_cast<const FEMFunctionBase&>(f2);
00301       return this->__getOperatorF1F2SimplifiedFunction<BinaryOperatorType>(f,g);
00302     }
00303     default: {
00304       throw ErrorHandler(__FILE__,__LINE__,
00305                          "unexpected function type",
00306                          ErrorHandler::unexpected);
00307     }
00308     }
00309     return 0;
00310   }

Here is the call graph for this function:

template<typename BinaryOperatorType>
ConstReferenceCounting<ScalarFunctionBase> ScalarFunctionBuilder::Simplifier::__getOperatorSimplifiedFunction ( const ScalarFunctionBase &  f1,
const ScalarFunctionBase &  f2 
) const [inline, private]

Specialize the binary operation type

Parameters:
f1 first operand
f2 second operand
Returns:
simplified (or not) binary operation

Definition at line 322 of file ScalarFunctionBuilder.cpp.

References ScalarFunctionBase::constant, ScalarFunctionBase::femfunction, FEMFunctionBase::hasSameType(), ScalarFunctionBase::type(), and ErrorHandler::unexpected.

00324   {
00325     switch (f1.type()) {
00326     case ScalarFunctionBase::constant: {
00327       const ScalarFunctionConstant& f = static_cast<const ScalarFunctionConstant&>(f1);
00328       return this->__getOperatorF1SimplifiedFunction<BinaryOperatorType>(f,f2);
00329     }
00330     case ScalarFunctionBase::femfunction: {
00331       const FEMFunctionBase& f = static_cast<const FEMFunctionBase&>(f1);
00332       if (f2.type() == ScalarFunctionBase::femfunction) {
00333         const FEMFunctionBase& g = static_cast<const FEMFunctionBase&>(f2);
00334         if (not(f.hasSameType(g))) {
00335           return 0;
00336         }
00337       }
00338       return this->__getOperatorF1SimplifiedFunction<BinaryOperatorType>(f,f2);
00339     }
00340     default: {
00341       throw ErrorHandler(__FILE__,__LINE__,
00342                          "unexpected function type",
00343                          ErrorHandler::unexpected);
00344     }
00345     }
00346     return 0;
00347   }

Here is the call graph for this function:

ConstReferenceCounting<ScalarFunctionBase> ScalarFunctionBuilder::Simplifier::simplify ( const BinaryOperation &  binaryOperation,
const ScalarFunctionBase &  f,
const ScalarFunctionBase &  g 
) const [inline]

Simplifies a binary operation

Parameters:
binaryOperation given binary operation
f first function
g second function
Returns:
simplified (if possible) binary operation

Definition at line 360 of file ScalarFunctionBuilder.cpp.

References BinaryOperation::and_, ScalarFunctionBase::canBeSimplified(), BinaryOperation::difference, BinaryOperation::division, BinaryOperation::eq, BinaryOperation::ge, BinaryOperation::gt, BinaryOperation::le, BinaryOperation::lt, BinaryOperation::max, BinaryOperation::min, BinaryOperation::modulo, BinaryOperation::ne, BinaryOperation::or_, BinaryOperation::power, BinaryOperation::product, BinaryOperation::sum, BinaryOperation::type(), BinaryOperation::undefined, ErrorHandler::unexpected, and BinaryOperation::xor_.

Referenced by ScalarFunctionBuilder::setBinaryOperation().

00363   {
00364     if (not(f.canBeSimplified() and g.canBeSimplified())) {
00365       return 0;
00366     }
00367 
00368     switch (binaryOperation.type()) {
00369     case BinaryOperation::modulo: {
00370       return __getOperatorSimplifiedFunction<BinaryOperatorModulo>(f,g);
00371     }
00372     case BinaryOperation::sum: {
00373       return __getOperatorSimplifiedFunction<BinaryOperatorSum>(f,g);
00374     }
00375     case BinaryOperation::difference: {
00376       return __getOperatorSimplifiedFunction<BinaryOperatorDifference>(f,g);
00377     }
00378     case BinaryOperation::product: {
00379       return __getOperatorSimplifiedFunction<BinaryOperatorProduct>(f,g);
00380     }
00381     case BinaryOperation::division: {
00382       return __getOperatorSimplifiedFunction<BinaryOperatorDivision>(f,g);
00383     }
00384     case BinaryOperation::power: {
00385       return __getOperatorSimplifiedFunction<BinaryOperatorPower>(f,g);
00386     }
00387     case BinaryOperation::min: {
00388       return __getOperatorSimplifiedFunction<BinaryOperatorMin>(f,g);
00389     }
00390     case BinaryOperation::max: {
00391       return __getOperatorSimplifiedFunction<BinaryOperatorMax>(f,g);
00392     }
00393       // these functions are not treated
00394     case BinaryOperation::gt:
00395     case BinaryOperation::lt:
00396     case BinaryOperation::ge:
00397     case BinaryOperation::le:
00398     case BinaryOperation::eq:
00399     case BinaryOperation::ne:
00400     case BinaryOperation::or_:
00401     case BinaryOperation::xor_:
00402     case BinaryOperation::and_: {
00403       return 0;
00404     }
00405     case BinaryOperation::undefined:
00406     default: {
00407       throw ErrorHandler(__FILE__,__LINE__,
00408                          "not implemented",
00409                          ErrorHandler::unexpected);
00410       return 0;
00411     }
00412     }
00413     return 0;
00414   }

Here is the call graph for this function:

The documentation for this class was generated from the following file:
Generated on Wed Nov 19 00:12:53 2008 for FreeFEM3D (aka ff3d) by  doxygen 1.5.6