## 5. 2. 3 Function Application

For the application of a function on a linear expression, the function as well as its derivative is required. For this reason, the following functional structure is required in order to apply a function on the linear expression:

``` class sine_on_linear_expression
{
double operator()(double x) const {return sin(x);}

class derivative
{
double operator()(double x) const {return cos(x);}
}
};
```

It can be seen that the class is written as function object which yields the respective function value and which additionally comprises a nested class called derivative. This nested class again is a function object which implements the operator(). The application of this operator yields the derivative of the function.

The application of the function to a linear expression can be treated as follows:

``` template<typename Func, typename NumericT>
apply_func(linearized_expression<NumericT> & expr)
{
linearized_expression<NumericT> result;
Func f;
Func::derivative f_;

double deriv = f_(expr.RHS);
result.RHS = f(expr.RHS);

map_iter_t iter = coefficients.begin();

while (iter != coefficients.end())
{
expr.coefficients[(*iter).first] =
(*iter).second * deriv;
}
}
```

Using further beautifications, typically object generators , explicit function objects can be constructed from the sine_on_linear_expression class so that the application of the expression can be written as follows

```  func<sine_on_linear_expression> Sin;

linearized_expression<double> expr1;
linearized_expression<double> expr2;
...
expr2 = Sin(expr1);
```

Michael 2008-01-16