========================
Funktionen als Parameter
========================

Bislang war die Funktion zur Initialisierung einer Matrix
wenig flexibel:

---- CODE (type=cpp) ----------------------------------------------------------
template <typename T, typename Index>
void
initGeMatrix(Index m, Index n, T *A, Index incRowA, Index incColA)
{
    std::random_device                random;
    std::mt19937                      mt(random());
    std::uniform_real_distribution<T> uniform(-100, 100);

    for (Index j=0; j<n; ++j) {
        for (Index i=0; i<m; ++i) {
            A[i*incRowA+j*incColA] = uniform(mt);
        }
    }
}
-------------------------------------------------------------------------------

In manchen Fällen wäre es angemessener, eine andere Verteilung
zu wählen oder die Initialisierung deterministisch festzulegen.
Gerade bei Tests und Benchmarks wird die Reproduzierbarkeit
häufig vorausgesetzt. Somit liegt es nahe, die Initialisierung
von der Bestimmung des zu initialisierenden Werts zu trennen.

Naheliegend wäre es hier, der `initGeMatrix`-Funktion eine
Funktion mitzugeben, die als Parameter die Indizes `i` und
`j` und die Dimensionen `m` und `n` erhält und $A_{i,j}$
als Wert zurückliefert. Beginnen
wir mit der ganz einfachen Initialisierung
$A_{i,j} \leftarrow j*n+i+1$:

---- CODE (type=cpp) ----------------------------------------------------------
template<typename T, typename Index>
T init_value(Index i, Index j, Index m, Index n) {
   return T(j)*T(n) + T(i) + T(1);
}
-------------------------------------------------------------------------------

Der allgemeine Datentyp so einer Funktion ist dann
`T(Index, Index, Index, Index)`, d.h. sie erhält
vier Parameter des Typs `Index` und liefert einen
Wert des Typs `T` zurück. Eine Fassung von `initGeMatrix`,
das so einen Funktionsparameter entgegennimmt, könnte so
aussehen:

---- CODE (type=cpp) ----------------------------------------------------------
template <typename T, typename Index>
void
initGeMatrix(Index m, Index n, T *A, Index incRowA, Index incColA,
             T (*initValue)(Index, Index, Index, Index))
{
    for (Index j=0; j<n; ++j) {
        for (Index i=0; i<m; ++i) {
            A[i*incRowA+j*incColA] = initValue(i, j, m, n);
        }
    }
}
-------------------------------------------------------------------------------

Zu beachten ist hier, dass `initValue` nicht die Funktion
selbst, sondern ein Zeiger auf eine Funktion ist, so
dass der Parametername mit dem Dereferenzierungsoperator `*`
versehen ist.

Die entsprechende Funktion aus `gematrix.h` muss dann
analog erweitert werden:

---- CODE (type=cpp) ----------------------------------------------------------
template <typename GeMatrix>
void
initGeMatrix(GeMatrix &A,
             typename GeMatrix::ElementType
		 (*initValue)(
		     typename GeMatrix::Index,
		     typename GeMatrix::Index,
		     typename GeMatrix::Index,
		     typename GeMatrix::Index))
{
    bench::initGeMatrix(A.m, A.n, A.data, A.incRow, A.incCol, initValue);
}
-------------------------------------------------------------------------------

Der Aufruf könnte dann so aussehen:

---- CODE (type=cpp) ----------------------------------------------------------
GeMatrix<double> A(3, 7, StorageOrder::ColMajor);
initGeMatrix(A, init_value<double, std::size_t>);
-------------------------------------------------------------------------------

Aufgabe
=======

Wieso musste `typename` vor `GeMatrix::Index` angegeben werden?

Schreiben Sie analog zu `init_value` eine Variante `init_complex`,
die für komplexe Zahlen funktioniert.

Die Parameterliste der beiden `initGeMatrix`-Funktionen wurde
etwas unhandlich. Versuchen Sie dies mit Hilfe eines weiteren
Template-Parameters zu vereinfachen.

Vorlage
=======
:import: session11/step01/bench.h
:import: session11/step01/gematrix.h
:import: session11/step01/test_initmatrix.cpp

:navigate: up    -> doc:index
           next  -> doc:session11/page02