The default implementation of DenseMatrixAssigner replaces redundant
code in dense matrix constructors taking a primitive data type.

[DenseMatrix] Introduce DenseMatrixAssigner for initializing dense matrices from arbitrary right hand sides

In order to overcome the deficiencies of istl_assign_to_fmatrix() we
propose to always use a struct DenseMatrixAssigner for initializing a
dense matrix. This class can be specialized by users for any right hand
side to be used in an assignment.  The new mechanism can bei default
implemented using existing implementations of istl_assign_to_fmatrix()
as well.

There was one line of diff missing in that patch. Sorry!

Previously, copying a RemoteIndexListModifier resulted in a double
free of a pointer to a list of global indices. There was no need to
use a pointer to this, though. After this patch we store the list directly
by value. Thus the default copy constructor works but makes a rather cheap copy
of a (most often empty) singly linked list and we get rid off the non-default
destructor.

At least Clang 3.2 complains.

DenseVector is the base class of a CRTP. This is kind of an abstract
class that works only if it can be casted into a derived type. Copying
the base class is pointless.

This patch marks the copy constructor of DenseVector private (not even
implementing it), so that it cannot be called anymore. Once we have a
DUNE_DELETE macro, we should use it, here.

At the same time, the default constructor is marked protected, so that only
derived classes can instantiate a DenseVector. Notice that this does not
prevent the user from building a derivced class which does not pass
itself as implementation to DenseVector. It is (to my knowledge) not possible
to make CRTPs completely fail-safe.

As Carsten pointed out, the hash combining algorithms doesn't work
correctly for 32-bit platforms because it uses a multiplication with
a 64-bit constant.

This patch adds a switch for picking different algorithms based on the
size of std::size_t using a new struct hash_combiner that is templated
on the size of std::size_t.

Right now, there are implementations for 64-bit and 32-bit platforms,
both based on CityHash.

Thanks to Tobias Malkmus for the heads-up.

This patch adds a new header visibility.hh with macros DUNE_EXPORT and DUNE_PRIVATE
to mark symbols as exported or private at the ABI level.

While we do not explicitly mark any symbols as hidden, there are certain situations
in which the compiler creates symbols with incorrect linkage, especially for singleton
accessor methods for templated types and their embedded static variables, which involve
the creation of weak symbols.

The linker is then unable to merge those weak definitions, causing either a link-time
failure (when building static libraries) or undefined runtime behaviour (dynamic libraries).

This problem can be avoided by explicitly marking the singleton accessor methods as
DUNE_EXPORT. For symmetry, there is also a DUNE_PRIVATE macro, but while it works, I don't
see it used very much in the short term.

This patch removes an extra header install command for tests. It
originally came when copying dune/common/CMakeLists.txt to
dune/common/std/CMakeLists.txt. Sorry for the noise.

The majority of developers favor individual headers for (emulation of) C++11
features over collecting them in a single header cxx11.hh. This patch
renames cxx11.hh to constexpr.hh and moves it into the subdirectory std.
This is the place most developers would like these headers in (see
http://users.dune-project.org/doodles/4).

As decided on the developer meeting in Aachen, we support (but do not
rely on) the C++11 keyword constexpr. This patch adds an m4-check for
constexpr and a header (cxx11.hh) defining a macro DUNE_CONSTEXPR either
as constexpr or empty (depending on the compiler support for it). It is
then used in FieldVector and FieldMatrix on size, rows, and cols.

Previously, a variable (found) was only initialized in one branch
of an if statement but used later on in any case. This patch makes
sure that is initialized in both branches.

Steffen Müthing authored 11 years ago and Christoph Grüninger committed 11 years ago

The current algorithm for hash combining behaves very poorly when hashing
multiple short streams of small integers like (0,1,1,0,x) that only differ
by a single large number x. These objects appear frequently in PDELab's ordering
framework, and the resulting bad hash distribution really hurts the performance
of the unordered containers in PDELab.

This patch switches to an algorithm that is inspired by CityHash (see the source
code comment) and has proven to be much more robust in testing.

Because C++11 implements this differently, and we now have an
stl-compliant implementation to switch to.

I would deprecate isPointer and isReference too, but I can't find
a way to do it.

These are replacements for TypeTraits::isPointer, TypeTraits::isReference,
TypeTraits::PointeeType.  They reimplement what is available in the
C++11 standard library, and are expected to supersede the TypeTraits
class eventually.

Note: this patch does not pull in the corresponding stl implementation.

That's easier to maintain.

If not found, our own fallback implementation will be used.

A previous commit introduced a check whether the element to-be-touched
is actually contained in the container.  That patch caused the test
to fail.  The new patch fixes this.