According to git blame the last time these constructors were changed was
in 2011.

Reimplement this using Hybrid::forEach. Along the way this
also fixes the bug that operator<< ignores the passed stream
and uses std::cout instead.

The new implementation is based on Hybrid::forEach

Test with non-zero matrix and print results

Reimplement this using Hybrid::forEach. This also adds some
comments and uses proper variable names to make the nan-tracking
easier to understand.

Reimplement this using Hybrid::forEach.

Reimplement this using Hybrid::forEach.

Reimplement this using Hybrid::forEach.

These separate impelmentations could be replaced by a single one,
once we have IsNumber. Currently we could use std::is_arithmetic
instead, but that's not the topic of this change.

Reimplement this using Hybrid::forEach.

Reimplement this using Hybrid::forEach. Along the way this
also fixes the bug that operator<< ignores the passed stream
and uses std::cout instead.

The implementation in MultiTypeBlockMatrix would be even
simpler, if it would provide a static size() method, because
we could then use a simple Hybrid::forEach over its entries
instead of one over all indices.

* Use correct macro
* adjust changes for other types then double, too

Arne Morten Kvarving authored 8 years ago and Christoph Grüninger committed 8 years ago

API for solver routine changed. Since there is no versioning
in SuperLU we have to do a probe to detect the new library.

Here we try to solve A*x=b for x, with
```
      / 1  1 \       / 1 \
  A = |      |,  b = |   |,
      \ 1  1 /       \ 2 /
```
which has no solution.  In the CGSolver, the this leads to a NaN defect after
46 iterations.  In BiCGSTABSolver this leads to "abs(h) < EPSILON" after 1.5
iterations.

BiCGSTABSolver and RestartedGMResSolver also throw SolverAbort when they
detect "breakdown", checking for that is left as a todo.

Fixes dune-common#23

Some tests assume MPI being present, although they are not executed
in parallel. This information got lost in the transition to dune_add_test
and is restored with this patch. Thanks to @markus.blatt for noticing.

Document that `BiCGSTABSolver` and `RestartedGMResSolver` can throw
`SolverAbort` when they detect a breakdown.

The previous commit made fastamg compile, but broke compilation of
matrixredisttest for me.  This makes matrixredisttest compile again.

SolverAbort is derived from ISTLError, so any existing catch-clause should
still apply.

SolverAbort is derived from ISTLError, so any existing catch-clause should
still apply.

recalculateHierarchy() assumed that there is information avaiable
that is only there in parallel runs. This failed miserably.

This commit fixes this be implementing dummy versions for
redistributing matrices in  a sequential run and does not
query any parallel stuff any more

This closes #11.

This allows other code to access field_type and real_type for a MultiTypeBlockVector
using the FieldTraits class.  Caveat: in principle, individual entries of a
MultiTypeBlockVector could use different field_types.  The implementation always
returns the first one.

Adding a new template perameter before the existing ones is
a non-compatible interface change, because code that explicitly
instantiates the template will fail to compile afterwards.

Putting the new template parameter to the end fixes the issue

I missed a few occurrences of 'nblocks' when renaming that to 'rows_',
because it was hidden behind the DUNE_ISTL_WITH_CHECKING macro.

Carsten Gräser authored 9 years ago and Christoph Grüninger committed 9 years ago

There was an unconditional debug output in FastAMG.
With this commit this is will only be printed if
debugLevel>0.

This additional check currently fails.

The comment and surroundig code indicate that FastAMG should
solve during pre() for dirichlet entries. This is determined
by checking if a row does contain a diagonal entry while
all other entries are zero.

The check for this was buggy because hasDiagonal was always false.
Now it's set to true if a diagonal entry is found and nonzero.

The dune-common module now contains short-cuts for static indices of type
integral_constant<size_t,...>, and we should try to standardize on those.

In particular, this means that static indices are integral_constant<std::size_t,...> now,
rather than integral_constant<int,...>.  We decided to standardize on std::size_t.

This array was a left-over from the VariableBlockVector class.  In short,
it stores the length of each matrix row.  Of course that is redundant,
because all rows in a dense matrix have the same length.

This patch makes the class allocate less memory, and use the known row
size to compute the offsets into the data array.  In principle, the code
becomes faster by this, but I am not convinced that the effect will be
measurable.

Still, even without measurable speedup: this patch is an improvement,
because it makes the code simpler.