ScalarFunctionBuilder Class Reference

#include <ScalarFunctionBuilder.hpp>

Collaboration diagram for ScalarFunctionBuilder:

Collaboration graph
[legend]

List of all members.

Public Member Functions

void setFunction (ConstReferenceCounting< ScalarFunctionBase > f)
void setBinaryOperation (const BinaryOperation type, ConstReferenceCounting< ScalarFunctionBase > g)
void setUnaryMinus ()
void setNot ()
void setCFunction (const std::string &cfunction)
ConstReferenceCounting
< ScalarFunctionBase > 		getBuiltFunction ()
 ScalarFunctionBuilder ()
 ~ScalarFunctionBuilder ()

Private Attributes

ConstReferenceCounting
< ScalarFunctionBase > 		__builtFunction

Classes

class  Simplifier

Detailed Description

Definition at line 37 of file ScalarFunctionBuilder.hpp.

Constructor & Destructor Documentation

ScalarFunctionBuilder::ScalarFunctionBuilder (  )  [inline]

Constructor

Definition at line 100 of file ScalarFunctionBuilder.hpp.

00101     : __builtFunction(0)
00102   {
00103     ;
00104   }

ScalarFunctionBuilder::~ScalarFunctionBuilder (  )  [inline]

Destructor

Definition at line 110 of file ScalarFunctionBuilder.hpp.

00111   {
00112     ;
00113   }

Member Function Documentation

void ScalarFunctionBuilder::setFunction ( ConstReferenceCounting< ScalarFunctionBase >  f  ) 

set a function

Parameters:
f function to set

Definition at line 437 of file ScalarFunctionBuilder.cpp.

References __builtFunction, and ASSERT.

Referenced by PDEVectorialOperatorExpressionOrderTwo::__execute(), PDEScalarOperatorExpressionDivMuGrad::__execute(), VariationalProblemExpression::AlgebraicMinus::convert(), FunctionExpressionUnaryMinus::execute(), FunctionExpressionNot::execute(), FunctionExpressionCFunction::execute(), FunctionExpressionBinaryOperation::execute(), VariationalNuUdxVOperator::operator*(), VariationalNuDxUVOperator::operator*(), VariationalMuGradUGradVOperator::operator*(), VariationalOperatorFV::operator*(), VariationalOperatorFgradGgradV::operator*(), VariationalOperatorFdxV::operator*(), VariationalOperatorFdxGV::operator*(), VariationalAlphaUVOperator::operator*(), VariationalAlphaDxUDxVOperator::operator*(), SecondOrderOperator::operator*(), PDE::operator*(), MassOperator::operator*(), FirstOrderOperator::operator*(), DivMuGrad::operator*(), SecondOrderOperator::operator-(), MassOperator::operator-(), FirstOrderOperator::operator-(), and DivMuGrad::operator-().

00438 {
00439   ASSERT(__builtFunction == 0);
00440   __builtFunction = f;
00441 }

void ScalarFunctionBuilder::setBinaryOperation ( const BinaryOperation  type,
ConstReferenceCounting< ScalarFunctionBase >  g 
)

set binary operation

Parameters:
type the type of the operation
g the second operand

Definition at line 444 of file ScalarFunctionBuilder.cpp.

References __builtFunction, BinaryOperation::and_, ASSERT, BinaryOperation::difference, BinaryOperation::division, BinaryOperation::eq, ffout(), BinaryOperation::ge, BinaryOperation::gt, BinaryOperation::le, BinaryOperation::lt, BinaryOperation::max, BinaryOperation::min, BinaryOperation::modulo, BinaryOperation::ne, BinaryOperation::or_, BinaryOperation::power, BinaryOperation::product, ScalarFunctionBuilder::Simplifier::simplify(), BinaryOperation::sum, BinaryOperation::type(), ErrorHandler::unexpected, and BinaryOperation::xor_.

Referenced by FunctionExpressionBinaryOperation::execute(), VariationalNuUdxVOperator::operator*(), VariationalNuDxUVOperator::operator*(), VariationalMuGradUGradVOperator::operator*(), VariationalOperatorFV::operator*(), VariationalOperatorFgradGgradV::operator*(), VariationalOperatorFdxV::operator*(), VariationalOperatorFdxGV::operator*(), VariationalAlphaUVOperator::operator*(), VariationalAlphaDxUDxVOperator::operator*(), SecondOrderOperator::operator*(), PDE::operator*(), MassOperator::operator*(), FirstOrderOperator::operator*(), and DivMuGrad::operator*().

00446 {
00447   ASSERT(__builtFunction != 0);
00448 
00449   Simplifier simplifier;
00450 
00451   ConstReferenceCounting<ScalarFunctionBase>
00452     simplifiedFunction = simplifier.simplify(binaryOperation,
00453                                              *__builtFunction,
00454                                              *f);
00455   if (simplifiedFunction) {
00456     ffout(4) << " * algebraic simplification of "
00457              << *__builtFunction << ' ' << binaryOperation << ' ' << *f << '\n';
00458     __builtFunction = simplifiedFunction;
00459   } else {
00460     switch (binaryOperation.type()) {
00461     case BinaryOperation::modulo: {
00462       __builtFunction = new ScalarFunctionModulo(__builtFunction, f);
00463       break;
00464     }
00465     case BinaryOperation::sum: {
00466       __builtFunction = new ScalarFunctionSum(__builtFunction, f);
00467       break;
00468     }
00469     case BinaryOperation::difference: {
00470       __builtFunction = new ScalarFunctionDifference(__builtFunction, f);
00471       break;
00472     }
00473     case BinaryOperation::product: {
00474       __builtFunction = new ScalarFunctionProduct(__builtFunction, f);
00475       break;
00476     }
00477     case BinaryOperation::division: {
00478       __builtFunction = new ScalarFunctionDivision(__builtFunction, f);
00479       break;
00480     }
00481     case BinaryOperation::power: {
00482       __builtFunction = new ScalarFunctionPower(__builtFunction, f);
00483       break;
00484     }
00485 
00486     case BinaryOperation::min: {
00487       __builtFunction = new ScalarFunctionMin(__builtFunction, f);
00488       break;
00489     }
00490     case BinaryOperation::max: {
00491       __builtFunction = new ScalarFunctionMax(__builtFunction, f);
00492       break;
00493     }
00494 
00495       // Boolean operations
00496     case BinaryOperation::gt: {
00497       __builtFunction = new ScalarFunctionGreaterThan(__builtFunction, f);
00498       break;
00499     }
00500     case BinaryOperation::ge: {
00501       __builtFunction = new ScalarFunctionGreaterEqual(__builtFunction, f);
00502       break;
00503     }
00504     case BinaryOperation::lt: {
00505       __builtFunction = new ScalarFunctionLowerThan(__builtFunction, f);
00506       break;
00507     }
00508     case BinaryOperation::le: {
00509       __builtFunction = new ScalarFunctionLowerEqual(__builtFunction, f);
00510       break;
00511     }
00512     case BinaryOperation::eq: {
00513       __builtFunction = new ScalarFunctionEqual(__builtFunction, f);
00514       break;
00515     }
00516     case BinaryOperation::ne: {
00517       __builtFunction = new ScalarFunctionNotEqual(__builtFunction, f);
00518       break;
00519     }
00520 
00521     case BinaryOperation::and_: {
00522       __builtFunction = new ScalarFunctionAnd(__builtFunction, f);
00523       break;
00524     }
00525     case BinaryOperation::or_: {
00526       __builtFunction = new ScalarFunctionOr(__builtFunction, f);
00527       break;
00528     }
00529     case BinaryOperation::xor_: {
00530       __builtFunction = new ScalarFunctionXor(__builtFunction, f);
00531       break;
00532     }
00533 
00534     default: {
00535       throw ErrorHandler(__FILE__,__LINE__,
00536                          "Not implemented binary operation",
00537                          ErrorHandler::unexpected);
00538     }
00539     }
00540   }
00541 }

Here is the call graph for this function:

void ScalarFunctionBuilder::setUnaryMinus (  ) 

set unary minus

Definition at line 544 of file ScalarFunctionBuilder.cpp.

References __builtFunction, ASSERT, FEMFunctionBase::baseMesh(), FEMFunctionBuilder::build(), ScalarFunctionBase::constant, FEMFunctionBase::discretizationType(), ScalarFunctionBase::femfunction, ffout(), FEMFunctionBuilder::getBuiltScalarFunction(), FEMFunctionBase::outsideValue(), Vector< T >::size(), and FEMFunctionBase::values().

Referenced by PDEVectorialOperatorExpressionOrderTwo::__execute(), PDEScalarOperatorExpressionDivMuGrad::__execute(), VariationalProblemExpression::AlgebraicMinus::convert(), FunctionExpressionUnaryMinus::execute(), SecondOrderOperator::operator-(), MassOperator::operator-(), FirstOrderOperator::operator-(), and DivMuGrad::operator-().

00545 {
00546   ASSERT(__builtFunction != 0);
00547   switch (__builtFunction->type()) {
00548   case ScalarFunctionBase::constant: {
00549     const ScalarFunctionConstant& f
00550       = static_cast<const ScalarFunctionConstant&>(*__builtFunction);
00551     const real_t value = -f(0);
00552 
00553     ffout(4) << " * algebraic simplification of -" << f << '\n';
00554 
00555     __builtFunction = new ScalarFunctionConstant(value);
00556     break;
00557   }
00558   case ScalarFunctionBase::femfunction: {
00559     const FEMFunctionBase& f
00560       = static_cast<const FEMFunctionBase&>(*__builtFunction);
00561     Vector<real_t> femValues(f.values().size());
00562 
00563     for (size_t i=0; i<femValues.size(); ++i) {
00564       femValues[i] = -f[i];
00565     }
00566 
00567     const real_t outsideValue = -f.outsideValue();
00568 
00569     ffout(4) << " * algebraic simplification of -" << f << '\n';
00570 
00571     FEMFunctionBuilder builder;
00572     builder.build(f.discretizationType(),
00573                   f.baseMesh(),
00574                   femValues,
00575                   outsideValue);
00576     __builtFunction = builder.getBuiltScalarFunction();
00577     break;
00578   }
00579   default: {
00580     __builtFunction = new ScalarFunctionUnaryMinus(__builtFunction);
00581   }
00582   }
00583 }

Here is the call graph for this function:

void ScalarFunctionBuilder::setNot (  ) 

set not function

Definition at line 586 of file ScalarFunctionBuilder.cpp.

References __builtFunction, and ASSERT.

Referenced by FunctionExpressionNot::execute().

00587 {
00588   ASSERT(__builtFunction != 0);
00589   __builtFunction = new ScalarFunctionNot(__builtFunction);
00590 }

void ScalarFunctionBuilder::setCFunction ( const std::string &  cfunction  ) 

Set the C-function labeled by the string cfunction

Parameters:
cfunction the name of a C-function

Definition at line 594 of file ScalarFunctionBuilder.cpp.

References __builtFunction, and ASSERT.

Referenced by FunctionExpressionCFunction::execute().

00595 {
00596   ASSERT(__builtFunction != 0);
00597   __builtFunction = new ScalarFunctionCFunction(cfunction, __builtFunction);
00598 }

ConstReferenceCounting<ScalarFunctionBase> ScalarFunctionBuilder::getBuiltFunction (  )  [inline]

Read-only access to the function

Returns:
__builtFunction

Definition at line 91 of file ScalarFunctionBuilder.hpp.

References __builtFunction.

Referenced by PDEVectorialOperatorExpressionOrderTwo::__execute(), PDEScalarOperatorExpressionDivMuGrad::__execute(), VariationalProblemExpression::AlgebraicMinus::convert(), FunctionExpressionUnaryMinus::execute(), FunctionExpressionNot::execute(), FunctionExpressionCFunction::execute(), FunctionExpressionBinaryOperation::execute(), VariationalNuUdxVOperator::operator*(), VariationalNuDxUVOperator::operator*(), VariationalMuGradUGradVOperator::operator*(), VariationalOperatorFV::operator*(), VariationalOperatorFgradGgradV::operator*(), VariationalOperatorFdxV::operator*(), VariationalOperatorFdxGV::operator*(), VariationalAlphaUVOperator::operator*(), VariationalAlphaDxUDxVOperator::operator*(), SecondOrderOperator::operator*(), PDE::operator*(), MassOperator::operator*(), FirstOrderOperator::operator*(), DivMuGrad::operator*(), SecondOrderOperator::operator-(), MassOperator::operator-(), FirstOrderOperator::operator-(), and DivMuGrad::operator-().

00092   {
00093     return __builtFunction;
00094   }

Member Data Documentation

ConstReferenceCounting<ScalarFunctionBase> ScalarFunctionBuilder::__builtFunction [private]

built function

Definition at line 44 of file ScalarFunctionBuilder.hpp.

Referenced by getBuiltFunction(), setBinaryOperation(), setCFunction(), setFunction(), setNot(), and setUnaryMinus().

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