std::transform_exclusive_scan

template< class InputIt, class OutputIt, class T, 
          class BinaryOp, class UnaryOp >
OutputIt transform_exclusive_scan
    ( InputIt first, InputIt last, OutputIt d_first, T init,
      BinaryOp binary_op, UnaryOp unary_op );

template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2, class T,
          class BinaryOp, class UnaryOp >
ForwardIt2 transform_exclusive_scan
    ( ExecutionPolicy&& policy,
      ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, T init,
      BinaryOp binary_op, UnaryOp unary_op );

Die verallgemeinerte nichtkommutative Summe einer Sequenz von Elementen über einer binären Operation binary_op ist wie folgt definiert:

• Wenn die Sequenz nur ein Element hat, ist die Summe der Wert des Elements.
• Andernfalls werden die folgenden Operationen der Reihe nach ausgeführt:

1. Wählt zwei beliebige benachbarte Elemente elem1 und elem2 aus der Sequenz.
2. Berechnet binary_op(elem1, elem2) und ersetzt die beiden Elemente in der Sequenz durch das Ergebnis.
3. Wiederholt die Schritte 1 und 2, bis nur noch ein Element in der Sequenz vorhanden ist.

Das Ergebnis ist nichtdeterministisch, wenn die binary_op nicht assoziativ ist (wie z. B. Gleitkommaaddition).

Wenn einer der folgenden Werte nicht in T konvertierbar ist, ist das Programm fehlerhaft:

• binary_op(init, init)
• binary_op(init, unary_op(*first))
• binary_op(unary_op(*first), unary_op(*first))

Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert:

• T ist nicht MoveConstructible.
• unary_op oder binary_op modifiziert ein Element von [first, last).
• unary_op oder binary_op macht einen Iterator oder Teilbereich von [first, last] ungültig.

Parameter

Rückgabewert

Iterator auf das Element nach dem letzten geschriebenen Element.

Komplexität

Gegeben \(\scriptsize N\) N als std:: distance ( first, last ) :

Ausnahmen

Die Überladung mit einem Template-Parameter namens ExecutionPolicy meldet Fehler wie folgt:

• Wenn die Ausführung einer als Teil des Algorithmus aufgerufenen Funktion eine Exception wirft und ExecutionPolicy einer der Standard-Policies ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsdefiniert.
• Wenn der Algorithmus keinen Speicher allozieren kann, wird std::bad_alloc geworfen.

Hinweise

unary_op wird niemals auf init angewendet.

Beispiel

#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
int main()
{
    std::vector data{3, 1, 4, 1, 5, 9, 2, 6};
    auto times_10 = [](int x) { return x * 10; };
    std::cout << "10 times exclusive sum: ";
    std::transform_exclusive_scan(data.begin(), data.end(),
                                  std::ostream_iterator<int>(std::cout, " "),
                                  0, std::plus<int>{}, times_10);
    std::cout << "\n10 times inclusive sum: ";
    std::transform_inclusive_scan(data.begin(), data.end(),
                                  std::ostream_iterator<int>(std::cout, " "),
                                  std::plus<int>{}, times_10);
    std::cout << '\n';
}

10 times exclusive sum: 0 30 40 80 90 140 230 250 
10 times inclusive sum: 30 40 80 90 140 230 250 310

Siehe auch