fix disableCopyMove for empty arguments

See merge request core/dune-common!383

add fallback implementation of `is_invocable` and `is_invocable_r`

See merge request core/dune-common!393

Remove Pardiso from script am2cmake.py

See merge request core/dune-common!397

Pardiso isn't supported anymore by dune-istl.

[test] check whether default-constructed forward iterators compare equal

See merge request core/dune-common!350

Fixed usage of std::abs in fmatrixtest.cc to allow ADL

See merge request core/dune-common!391

The implementations simply forward to the current implementation of
`is_callable`. See #83 for more details.

[Sphinx] Support special cmake_params.

See merge request core/dune-common!390

These are parameters that cannot be easily fit into the other categories.  For
instance a family of single-value parameters:

  [NAME1 value1 [NAME2 value2 ...]]

You can pass the exact string to appear in the synopsis via :argname:.

This also allows to work around a with multi-valued positional
parameters (a.k.a. ARGV-like parameters).

quotient must be representable without error

See merge request core/dune-common!387

The quotient must be representable exactly for the division test to
work on i386 as `1./3. == 1./3.` can be false when using the FPU due
to store/load cycles.

[cmake] Update UseLATEX.cmake to upstream 2.4.6

See merge request core/dune-common!380

Removed a trailing white space

add changelogs from release to master

See merge request core/dune-common!385

fix several typos

See merge request core/dune-common!386

This introduces a helper function that enables `auto` type deduction even in
the presence of proxies and pre-C++11 libraries with a tendency to capture
references to temporaries.

Note: the motivating examples below make use of specializations of
      `autoCopy()` that will be introduced in later commits.

Example 1: deducing the element type of a vector when proxies are a
possibility:
```c++
template<class Vector>
auto pop_and_clear(Vector &v)
{
  auto head = autoCopy(v[0]);
  v.clear();
  return head;
}
```
Without `autoCopy()` this would be undefined behaviour if `Vector` happens to
be `std::vector<bool>`.

Example 2: a custom number type with lazy evaluation:
```c++
template<class MaybeCustomType>
auto f(MaybeCustomType v)
{
  return 2 * v - 1;
}
```
This fails for the custom number type from the automatic differentiation
library Adept, because Adept constructs an expression object that holds
references to its subexpressions and is evaluated only when it is assigned to
a number object later.  Due to the use of `auto` this expression object is
passed out of the function, but the temporary object for the subexpression
`2*v` is destroyed when the function returns.  Wrapping the expression in the
`return` statement with `autoCopy()` ensures that the evaluation happens while
the reference to the subexpression is still valid, and has no ill effect when
fundamental types instead of Adept's custom types are used.

See merge request core/dune-common!345

Since C++14, default-constructed forward iterators are specified as the end
iterator of the same, empty sequence. Hence, they should compare equal.
This patch enhances our test accordingly.

On default construction, the pointer in `ArrayListIterator` and
`ArrayListConstIterator` was uninitialized. This caused an assertion to fail
upon comparing them, but the code otherwise worked fine. This patch correctly
initializes the pointer to `nullptr` to avoid unspecified behavior.

Remove noexcept from ParallelIndexSet::operator[]

See merge request core/dune-common!238

[cmake] enable position independent code by default

See merge request core/dune-common!360

added empty changelog

See merge request core/dune-common!375

[selectiontest] Clean up includes.

See merge request core/dune-common!373

This replaces `remoteindices.hh` with `plocalindices.hh`; as a result this
test can now be compiled without MPI.

Thanks to @felix.gruber for the initial report (see !372).

Deal with dune/common/array.hh

Closes #13

See merge request core/dune-common!359

[bugfix] make `dune_add_test` play nicely with MPICH

Closes #24

See merge request core/dune-common!363

Thanks to @smuething for the hint.

Note: This patch changes the semantics of the command. Up to now, the command
      was allowed to contain arguments (unless it was a target). With this patch,
      the arguments must be passed separately.

[cmake] Fix vverb not recognized as MINIMAL_DEBUG_LEVEL

See merge request core/dune-common!356

This deprecates the header `<dune/common/array.hh>` and all of its members.
- `Dune::array`: use `std::array` instead.
- `Dune::make_array()`: use `Dune::Std::make_array()` instead.
- `Dune::fill_array()`: use `Dune::filledArray()` instead.

Note that deprecation warnings for `array` and `make_array` could not be
implemented, since those were implemented by using declarations and it seems
to be impossible to deprecate those.  Users should still get a note though
since the entire header is deprecated.

For `fill_array()` there was no replacement, so this commit introduces
`filledArray()` with a slightly improved calling syntax, a better name, and
(in C++17) support for `constexpr` arrays.  To make it possible to deprecate
`array.hh`, that replacement is in its own header `filledarray.hh`.

This commit also introduces two unit tests:
- `filledarraytest.cc` to test `filledArray()`, and
- `arraydeprecationtest.cc` to make sure the deprecation syntax is supported
  for all tested compilers.  (It also has a feature to check that deprecation
  warnings are really displayed, but that is disabled for regular unit testing
  since the logs have to be checked manually for the warnings.)

[bugfix] fix version detection in `dune_python_find_package`

Closes #75

See merge request core/dune-common!364

There were two bugs:
- The variable `PYPACKAGE_RESULT` was set instead of `${PYPACKAGE_RESULT}`.
- The output script `pyversion.py` was silently ignored, yielding an
empty version string.

This fixes #75.

The standard `add_test` allows CMake targets to be passed as commands.
However, when passing them to MPI, this does not work in two cases:
- MPICH does not search for the executable in the current working
directory.
- The name of the executable need not coincide with the name of the
target (e.g., on Windows).

This patch fixes both issues by checking whether the command is a CMake
target and obtaining the location of the primary output file in this
case. This name is then passed to MPI or `add_test`, respectively.

This closes #24.

[debugalign.hh] Fix indentation.

See merge request core/dune-common!362