Provided by: librheolef-dev_7.2-2_amd64 #### NAME

```       problem - linear solver (rheolef-7.2)

```

#### DESCRIPTION

```       The problem class solves a given linear system for PDEs in variational formulation.

```

#### DESCRIPTION

```       The degrees of freedom are splitting between unknown degrees of freedom and blocked one.
See also form(2) and space(2). Let a be a bilinear form(2) and lh be the right-hand-side,
as in the previous example. The linear system expands as:

[ a.uu  a.ub ] [ uh.u ]   [ lh.u ]
[            ] [      ] = [      ]
[ a.bu  a.bb ] [ uh.b ]   [ lh.b ]

The uh.b are blocked degrees of freedom: their values are prescribed and the
corresponding values are move to the right-hand-side of the system that reduces to:

a.uu*uh.u =  lh.u - a.ub*uh.b

This writes:

problem p (a);
p.solve (lh, uh);

Observe that, during the p.solve call, uh is both an input variable, for the uh.b
contribution to the right-hand-side, and an output variable, with uh.u. When using an
iterative resolution, the details about its convergence, e.g. the number of iterations and
the final residue, can be obtain via the p.option() member function, see solver_option(4).
Finally, the previous linear system is solved via the solver(4) class: the problem class
is simply a convenient wrapper around the solver(4) one.

```

#### EXAMPLE

```       See dirichlet.cc

```

#### CUSTOMIZATION

```       The solver(4) could be customized via the constructor optional solver_option(4) argument:

problem p (a, sopt);

When using a direct solver(4), the determinant of the linear system matrix is also
available as p.det(). When using an iterative solver(4), the preconditionner could be
customized:

p.set_preconditionner (m);

```

#### TODO

```       The solve method could return a boolean when success.

```

#### IMPLEMENTATION

```       This documentation has been generated from file main/lib/problem.h

The problem class is simply an alias to the problem_basic class

typedef problem_basic<Float> problem;

The problem_basic class provides a generic interface:

template <class T, class M = rheo_default_memory_model>
class problem_basic {
public:

// typedefs:

typedef typename solver_basic<T,M>::size_type         size_type;
typedef typename solver_basic<T,M>::determinant_type  determinant_type;

// allocators:

problem_basic ();
problem_basic (const form_basic<T,M>& a,
const solver_option& sopt = solver_option());

void update_value (const form_basic<T,M>& a);

void set_preconditioner (const solver_basic<T,M>&);

// accessor:

void solve       (const field_basic<T,M>& lh, field_basic<T,M>& uh) const;
void trans_solve (const field_basic<T,M>& lh, field_basic<T,M>& uh) const;

determinant_type det() const;
const solver_option& option() const;
bool initialized() const;

};

```

#### AUTHOR

```       Pierre  Saramito  <Pierre.Saramito@imag.fr>

```

```       Copyright   (C)  2000-2018  Pierre  Saramito  <Pierre.Saramito@imag.fr> GPLv3+: GNU GPL