Freigeben über

<numeric> -Funktionen

  • Artikel

accumulate

Berechnet die Summe aller Elemente in einem angegebenen Bereich, einschließlich eines Anfangswerts, durch Berechnen aufeinander folgender Teilsummen. Oder berechnet das Ergebnis aufeinander folgender Teilergebnisse eines angegebenen binären Vorgangs.

template <class InputIterator, class Type>
Type accumulate(
    InputIterator first,
    InputIterator last,
    Type init);

template <class InputIterator, class Type, class BinaryOperation>
Type accumulate(
    InputIterator first,
    InputIterator last,
    Type init,
    BinaryOperation binary_op);

Parameter

first
Ein Eingabe-Iterator, der das erste Element im Bereich adressiert, um entweder zu addieren oder mithilfe von binary_op zu kombinieren.

last
Ein Eingabe-Iterator, der das letzte Element im Bereich adressiert, um entweder zu summieren oder zu kombinieren, indem binary_op verwendet wird. Dies ist eine Position, die über das letzte Element hinausgeht, das tatsächlich in der iterierten Akkumulation enthalten ist.

init
Ein Anfangswert, dem jedes Element mithilfe von binary_op hinzugefügt oder kombiniert wird.

binary_op
Der binäre Vorgang, der auf jedes Element im angegebenen Bereich und auf das Ergebnis seiner vorherigen Anwendungen angewendet werden soll.

Rückgabewert

Die Summe des Init-Elements und aller Elemente im angegebenen Bereich für die erste Vorlagenfunktion oder für die zweite Vorlagenfunktion das Ergebnis der Anwendung des binären Vorgangs binary_op anstelle des Summenvorgangs auf (*PartialResult, in_iter), wobei PartialResult das Ergebnis früherer Anwendungen des Vorgangs ist und in_iter ein Iterator ist, der auf das nächste Element im Bereich zeigt.

Hinweise

Der Anfangswert stellt sicher, dass ein klar definiertes Ergebnis vorhanden ist, wenn der Bereich leer ist, in diesem Fall wird init zurückgegeben. Der binäre Vorgang muss nicht assoziativ oder kommutativ sein. Das Ergebnis wird init initialisiert und dann binary_op = (Ergebnis, in_iter) iterativ über den Bereich berechnet, wobei in_iter ein Iterator ist, der auf jedes aufeinander folgende Element im Bereich zeigt. Der Bereich muss gültig sein, und die Komplexität ist linear mit der Größe des Bereichs. Der Rückgabetyp des binären Operators muss in Typ konvertierbar sein, um Closure während der Iteration sicherzustellen.

Beispiel

// numeric_accum.cpp
// compile with: /EHsc
#include <vector>
#include <numeric>
#include <functional>
#include <iostream>

int main( )
{
   using namespace std;

   vector <int> v1, v2(20);
   vector <int>::iterator iter1, iter2;

   int i;
   for (i = 1; i < 21; i++)
   {
      v1.push_back(i);
   }

   cout << "The original vector v1 is:\n ( " ;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
      cout << *iter1 << " ";
   cout << ")." << endl;

   // The first member function for the accumulated sum
   int total;
   total = accumulate(v1.begin(), v1.end(), 0);

   cout << "The sum of the integers from 1 to 20 is: "
        << total << "." << endl;

   // Constructing a vector of partial sums
   int j = 0, partotal;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
   {
      partotal = accumulate(v1.begin(), iter1 + 1, 0);
      v2[j] = partotal;
      j++;
   }

   cout << "The vector of partial sums is:\n ( " ;
   for (iter2 = v2.begin(); iter2 != v2.end(); iter2++)
      cout << *iter2 << " ";
   cout << ")." << endl << endl;

   // The second member function for the accumulated product
   vector <int> v3, v4(10);
   vector <int>::iterator iter3, iter4;

   int s;
   for (s = 1; s < 11; s++)
   {
      v3.push_back(s);
   }

   cout << "The original vector v3 is:\n ( " ;
   for (iter3 = v3.begin(); iter3 != v3.end(); iter3++)
      cout << *iter3 << " ";
   cout << ")." << endl;

   int ptotal;
   ptotal = accumulate(v3.begin(), v3.end(), 1, multiplies<int>());

   cout << "The product of the integers from 1 to 10 is: "
        << ptotal << "." << endl;

   // Constructing a vector of partial products
   int k = 0, ppartotal;
   for (iter3 = v3.begin(); iter3 != v3.end(); iter3++) {
      ppartotal = accumulate(v3.begin(), iter3 + 1, 1, multiplies<int>());
      v4[k] = ppartotal;
      k++;
   }

   cout << "The vector of partial products is:\n ( " ;
   for (iter4 = v4.begin(); iter4 != v4.end(); iter4++)
      cout << *iter4 << " ";
   cout << ")." << endl;
}

The original vector v1 is:
( 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ).
The sum of the integers from 1 to 20 is: 210.
The vector of partial sums is:
( 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210 ).

The original vector v3 is:
( 1 2 3 4 5 6 7 8 9 10 ).
The product of the integers from 1 to 10 is: 3628800.
The vector of partial products is:
( 1 2 6 24 120 720 5040 40320 362880 3628800 ).

adjacent_difference

Berechnet die aufeinander folgenden Unterschiede zwischen jedem Element und seinem Vorgänger in einem Eingabebereich. Gibt die Ergebnisse in einen Zielbereich aus. Oder berechnet das Ergebnis einer generalisierten Prozedur, bei der der Unterschiedsvorgang durch einen anderen, angegebenen binären Vorgang ersetzt wird.

template <class InputIterator, class OutIterator>
OutputIterator adjacent_difference(
    InputIterator first,
    InputIterator last,
    OutputIterator result);

template <class InputIterator, class OutIterator, class BinaryOperation>
OutputIterator adjacent_difference(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op);

template <class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 adjacent_difference(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result);

template <class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
class BinaryOperation>
ForwardIterator2 adjacent_difference(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    BinaryOperation binary_op);

Parameter

exec
Eine Ausführungsrichtlinie.

first
Ein Eingabeiterator, der das erste Element im Eingabebereich adressiert, dessen Elemente mit ihren jeweiligen Vorgängern differenziert werden sollen oder in dem die Wertpaare durch einen anderen angegebenen binären Vorgang verarbeitet werden sollen.

last
Ein Eingabeiterator, der das letzte Element im Eingabebereich adressiert, dessen Elemente mit ihren jeweiligen Vorgängern differenziert werden sollen oder in dem die Wertpaare durch einen anderen angegebenen binären Vorgang verarbeitet werden sollen.

result
Ein Ausgabeiterator, der das erste Element eines Zielbereichs adressiert, in dem die Reihe von Differenzen oder die Ergebnisse des angegebenen Vorgangs gespeichert werden sollen.

binary_op
Der binäre Vorgang, der im generalisierten Vorgang angewendet werden soll, ersetzt den Vorgang der Subtraktion in der unterschiedlichen Prozedur.

Rückgabewert

Ein Ausgabe-Iterator, der das Ende des Zielbereichs angibt: result + ( - lastfirst).

Hinweise

Das Ausgabe iterator-Ergebnis darf zuerst denselben Iterator wie der Eingabe iterator sein, sodass adjacent_difference Die Werte möglicherweise direkt berechnet werden.

Bei einer Abfolge von Werten 1, a2, a3 in einem Eingabebereich speichert die erste Vorlagenfunktion aufeinanderfolgende adjacent_difference Werte 1, a2 - a1, a3 - a2 – imZielbereich.

Bei einer Abfolge von Werten 1, a2, a3 in einem Eingabebereich speichert die zweite Vorlagenfunktion aufeinanderfolgende adjacent_difference Werte 1, ein2 binary_op ein1, ein3 binary_op ein2 im Zielbereich.

Der binäre Vorgang binary_op ist nicht erforderlich, um entweder assoziativ oder kommutativ zu sein, da die Reihenfolge der angewendeten Vorgänge angegeben ist.

Beispiel

// numeric_adj_diff.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <numeric>
#include <functional>
#include <iostream>

int main( )
{
   using namespace std;

   vector<int> V1( 10 ), V2( 10 );
   vector<int>::iterator VIter1, VIter2, VIterend, VIterend2;

   list <int> L1;
   list <int>::iterator LIter1, LIterend, LIterend2;

   int t;
   for ( t = 1 ; t <= 10 ; t++ )
   {
      L1.push_back( t * t );
   }

   cout << "The input list L1 is:\n ( " ;
   for ( LIter1 = L1.begin( ) ; LIter1 != L1.end( ) ; LIter1++ )
      cout << *LIter1 << " ";
   cout << ")." << endl;

   // The first member function for the adjacent_differences of
   // elements in a list output to a vector
   VIterend = adjacent_difference ( L1.begin ( ) , L1.end ( ) ,
      V1.begin ( ) );

   cout << "Output vector containing adjacent_differences is:\n ( " ;
   for ( VIter1 = V1.begin( ) ; VIter1 != VIterend ; VIter1++ )
      cout << *VIter1 << " ";
   cout << ")." << endl;

   // The second member function used to compute
   // the adjacent products of the elements in a list
   VIterend2 = adjacent_difference ( L1.begin ( ) , L1.end ( ) , V2.begin ( ) ,
      multiplies<int>( ) );

   cout << "The output vector with the adjacent products is:\n ( " ;
   for ( VIter2 = V2.begin( ) ; VIter2 != VIterend2 ; VIter2++ )
      cout << *VIter2 << " ";
   cout << ")." << endl;

   // Computation of adjacent_differences in place
   LIterend2 = adjacent_difference ( L1.begin ( ) , L1.end ( ) , L1.begin ( ) );
   cout << "In place output adjacent_differences in list L1 is:\n ( " ;
   for ( LIter1 = L1.begin( ) ; LIter1 != LIterend2 ; LIter1++ )
      cout << *LIter1 << " ";
   cout << ")." << endl;
}

exclusive_scan

Berechnet einen exklusiven Präfixsummenvorgang mithilfe std::plus<>() eines oder eines angegebenen binären Operators über einen Bereich, wobei ein Anfangswert angegeben ist. Schreibt die Ergebnisse in den Bereich, der am angegebenen Ziel beginnt. Eine exklusive Präfixsumme bedeutet, dass das n-th-Eingabeelementnicht in der n-th-Summeenthalten ist. Überladungen, die ein Ausführungsrichtlinienargument enthalten, werden gemäß der angegebenen Richtlinie ausgeführt.

template<class InputIterator, class OutputIterator, class Type>
OutputIterator exclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    Type init);

template<class InputIterator, class OutputIterator, class Type, class BinaryOperation>
OutputIterator exclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    Type init,
    BinaryOperation binary_op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type>
ForwardIterator2 exclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    Type init);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type, class BinaryOperation>
ForwardIterator2 exclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    Type init,
    BinaryOperation binary_op);

Parameter

exec
Eine Ausführungsrichtlinie.

first
Ein Eingabe-Iterator, der das erste Element im Bereich adressiert, um entweder zu addieren oder mithilfe von binary_op zu kombinieren.

last
Ein Eingabe-Iterator, der das letzte Element im Bereich adressiert, um entweder zu summieren oder zu kombinieren, indem binary_op verwendet wird. Dies ist eine Position, die über das letzte Element hinausgeht, das tatsächlich in der iterierten Akkumulation enthalten ist.

result
Ein Ausgabe-Iterator, der das erste Element angibt, ein Zielbereich, in dem die Reihe von Summen oder die Ergebnisse des angegebenen Vorgangs gespeichert werden sollen.

init
Ein Anfangswert, dem jedes Element mithilfe von binary_op hinzugefügt oder kombiniert wird.

binary_op
Der binäre Vorgang, der auf jedes Element im angegebenen Bereich und auf das Ergebnis seiner vorherigen Anwendungen angewendet werden soll.

Rückgabewert

Ein Ausgabe-Iterator, der das Ende des Zielbereichs angibt: ergebnis + (zuletzt zuerst - ).

größter gemeinsamer Teiler

Berechnet den größten gemeinsamen Divisor der ganzen Zahl m und n.

template <class M, class N>
constexpr common_type_t<M,N> gcd(M m, N n);

Parameter

m, n
Werte des integralen Typs.

Rückgabewert

Gibt den größten gemeinsamen Divisor der absoluten Werte von m und n oder Null zurück, wenn sowohl m als auch n null sind. Die Ergebnisse sind nicht definiert, wenn die absoluten Werte von m oder n nicht als Werte vom Typ common_type_t<M,N>dargestellt werden können.

inclusive_scan

Berechnet einen inklusiven Präfixsummenvorgang mithilfe std::plus<>() eines oder eines angegebenen binären Operators über einen Bereich, wobei ein Anfangswert angegeben ist. Schreibt die Ergebnisse in den Bereich, der am angegebenen Ziel beginnt. Eine inklusive Präfixsumme bedeutet, dass das n-th-Eingabeelementin der n-th-Summeenthalten ist. Überladungen, die ein Ausführungsrichtlinienargument enthalten, werden gemäß der angegebenen Richtlinie ausgeführt.

template<class InputIterator, class OutputIterator>
OutputIterator inclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result);

template<class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator inclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op);

template<class InputIterator, class OutputIterator, class BinaryOperation, class Type>
OutputIterator inclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op,
    Type init);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 inclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
class BinaryOperation>
ForwardIterator2 inclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    BinaryOperation binary_op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
class BinaryOperation, class Type>
ForwardIterator2 inclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    BinaryOperation binary_op,
    Type init);

Parameter

exec
Eine Ausführungsrichtlinie.

first
Ein Eingabe-Iterator, der das erste Element im Bereich adressiert, um entweder zu addieren oder mithilfe von binary_op zu kombinieren.

last
Ein Eingabe-Iterator, der das letzte Element im Bereich adressiert, um entweder zu summieren oder zu kombinieren, indem binary_op verwendet wird. Dies ist eine Position, die über das letzte Element hinausgeht, das tatsächlich in der iterierten Akkumulation enthalten ist.

result
Ein Ausgabe-Iterator, der das erste Element angibt, ein Zielbereich, in dem die Reihe von Summen oder die Ergebnisse des angegebenen Vorgangs gespeichert werden sollen.

init
Ein Anfangswert, dem jedes Element mithilfe von binary_op hinzugefügt oder kombiniert wird.

binary_op
Der binäre Vorgang, der auf jedes Element im angegebenen Bereich und auf das Ergebnis seiner vorherigen Anwendungen angewendet werden soll.

Rückgabewert

Ein Ausgabe-Iterator, der das Ende des Zielbereichs angibt: ergebnis + (zuletzt zuerst - ).

inner_product

Berechnet die Summe des elementweisen Produkts von zwei Bereichen und fügt sie einem angegebenen Anfangswert hinzu oder berechnet das Ergebnis einer allgemeinen Prozedur, in der die Summen- und Produktvorgänge durch andere angegebene binäre Vorgänge ersetzt werden.

template <class InputIterator1, class InputIterator2, class Type>
Type inner_product(
    InputIterator1   first1,
    InputIterator1   last1,
    InputIterator2   first2,
    Type             init);

template <class InputIterator1, class InputIterator2, class Type, class BinaryOperation1, class BinaryOperation2>
Type inner_product(
    InputIterator1   first1,
    InputIterator1   last1,
    InputIterator2   first2,
    Type             init,
    BinaryOperation1 binary_op1,
    BinaryOperation2 binary_op2);

Parameter

first1
Ein Eingabeiterator, der das erste Element im ersten Bereich adressiert, dessen inneres oder generalisiertes inneres Produkt mit dem zweiten Bereich neu zu berechnen ist.

letzte 1
Ein Eingabeiterator, der das letzte Element im ersten Bereich adressiert, dessen inneres oder generalisiertes inneres Produkt mit dem zweiten Bereich neu zu berechnen ist.

First2
Ein Eingabeiterator, der das erste Element im zweiten Bereich adressiert, dessen inneres oder generalisiertes inneres Produkt mit dem ersten Bereich neu zu berechnen ist.

init
Einen Anfangswert für den das innere oder generalisierte innere Produkt zwischen den Bereichen hinzugefügt wird.

binary_op1
Der binäre Vorgang, der das innere Produkt des Summenvorgangs ersetzt, wird auf die elementweisen Produkte in der Generalisierung des inneren Produkts angewendet.

binary_op2
Der binäre Vorgang, der das innere Produkt des elementweisen Produkt des Multiplizierungsvorgangs in der Generalisierung des inneren Produkts ersetzt.

Rückgabewert

Der erste Memberfunktion gibt die Summe des elementweisen Produkts zurück und fügt den angegebenen Anfangswert hinzu. Für Wertebereiche ai und bi wird folgendes zurückgegeben:

init + (a1 * b1) + (a2 * b2) + ... + (an * bn)

durch iterativ ersetzen init + (a* bi).

Die zweite Memberfunktion gibt folgendes zurück:

init binary_op1 (a1 binary_op2 b1) binary_op1 (a2 binary_op2 b2) binary_op1 ... binary_op1 (an binary_op2 bn)

durch iteratives Ersetzen von Init durch init binary_op1 (ai binary_op2 bi).

Hinweise

Der Anfangswert stellt sicher, dass ein gut definiertes Ergebnis vorhanden ist, wenn der Bereich leer ist. In diesem Fall wird init zurückgegeben. Die binären Vorgänge müssen nicht assoziativ oder kommutativ sein. Der Bereich muss gültig sein, und die Komplexität ist linear mit der Größe des Bereichs. Der Rückgabetyp des binären Operators muss in Typ konvertierbar sein, um Closure während der Iteration sicherzustellen.

Beispiel

// numeric_inner_prod.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <numeric>
#include <functional>
#include <iostream>

int main()
{
   using namespace std;

   vector <int> v1, v2(7), v3(7);
   vector <int>::iterator iter1, iter2, iter3;

   int i;
   for (i = 1; i <= 7; i++)
   {
      v1.push_back(i);
   }

   cout << "The original vector v1 is:\n ( " ;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
      cout << *iter1 << " ";
   cout << ")." << endl;

   list <int> l1, l2(7);
   list <int>::iterator lIter1, lIter2;

   int t;
   for (t = 1; t <= 7; t++)
   {
      l1.push_back(t);
   }

   cout << "The original list l1 is:\n ( " ;
   for (lIter1 = l1.begin(); lIter1 != l1.end(); lIter1++)
      cout << *lIter1 << " ";
   cout << ")." << endl;

   // The first member function for the inner product
   int inprod;
   inprod = inner_product(v1.begin(), v1.end(), l1.begin(), 0);

   cout << "The inner_product of the vector v1 and the list l1 is: "
        << inprod << "." << endl;

   // Constructing a vector of partial inner_products between v1 & l1
   int j = 0, parinprod;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++) {
      parinprod = inner_product(v1.begin(), iter1 + 1, l1.begin(), 0);
      v2[j] = parinprod;
      j++;
   }

   cout << "Vector of partial inner_products between v1 & l1 is:\n ( " ;
   for (iter2 = v2.begin(); iter2 != v2.end(); iter2++)
      cout << *iter2 << " ";
   cout << ")." << endl << endl;

   // The second member function used to compute
   // the product of the element-wise sums
   int inprod2;
   inprod2 = inner_product (v1.begin(), v1.end(),
      l1.begin(), 1, multiplies<int>(), plus<int>());

   cout << "The sum of the element-wise products of v1 and l1 is: "
        << inprod2 << "." << endl;

   // Constructing a vector of partial sums of element-wise products
   int k = 0, parinprod2;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
   {
      parinprod2 =
         inner_product(v1.begin(), iter1 + 1, l1.begin(), 1,
         multiplies<int>(), plus<int>());
      v3[k] = parinprod2;
      k++;
   }

   cout << "Vector of partial sums of element-wise products is:\n ( " ;
   for (iter3 = v3.begin(); iter3 != v3.end(); iter3++)
      cout << *iter3 << " ";
   cout << ")." << endl << endl;
}

iota

Speichert einen Anfangswert, beginnend mit dem ersten Element und dem Ausfüllen mit aufeinander folgenden Schritten dieses Werts (value++) in jedem der Elemente im Intervall [first, last).

template <class ForwardIterator, class Type>
void iota(ForwardIterator first, ForwardIterator last, Type value);

Parameter

first
Ein Eingabeiterator, der das erste Element im aufzufüllenden Bereich adressiert.

last
Ein Eingabeiterator, der das letzte Element im aufzufüllenden Bereich adressiert.

value
Der Startwert, der im ersten Element gespeichert werden soll, und nacheinander inkrementell für spätere Elemente.

Beispiel

Das folgende Beispiel veranschaulicht einige Verwendungsmöglichkeiten für die iota-Funktion durch Ausfüllen einer list von ganzen Zahlen und Ausfüllen eines vector mit list, damit die random_shuffle-Funktion verwendet werden kann.

// compile by using: cl /EHsc /nologo /W4 /MTd
#include <algorithm>
#include <numeric>
#include <list>
#include <vector>
#include <iostream>

using namespace std;

int main(void)
{
    list <int> intList(10);
    vector <list<int>::iterator> intVec(intList.size());

    // Fill the list
    iota(intList.begin(), intList.end(), 0);

    // Fill the vector with the list so we can shuffle it
    iota(intVec.begin(), intVec.end(), intList.begin());

    random_shuffle(intVec.begin(), intVec.end());

    // Output results
    cout << "Contents of the integer list: " << endl;
    for (auto i: intList) {
        cout << i << ' ';
    }
    cout << endl << endl;

    cout << "Contents of the integer list, shuffled by using a vector: " << endl;
    for (auto i: intVec) {
        cout << *i << ' ';
    }
    cout << endl;
}

kgV

template <class M, class N>
constexpr common_type_t<M,N> lcm(M m, N n);

partial_sum

Berechnet eine Reihe von Summen in einem Eingabebereich vom ersten Element bis zum nth-Elementund speichert das Ergebnis jeder solchen Summe im n-th-Elementeines Zielbereichs. Oder berechnet das Ergebnis einer generalisierten Prozedur, bei der der Summenvorgang durch einen anderen angegebenen binären Vorgang ersetzt wird.

template <class InputIterator, class OutIt>
OutputIterator partial_sum(
    InputIterator first,
    InputIterator last,
    OutputIterator result);

template <class InputIterator, class OutIt, class Fn2>
OutputIterator partial_sum(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op);

Parameter

first
Ein Eingabeiterator, der das erste Element in dem Bereich adressiert, der entsprechend eines angegebenen binären Vorgangs teilweise summiert oder kombiniert werden soll.

last
Ein Eingabeiterator, der das letzte Element in dem Bereich adressiert, der entsprechend eines angegebenen binären Vorgangs teilweise summiert oder kombiniert werden soll und eine Position nach dem letzten Element folgt, das tatsächlich im iterierten Sammelbereich enthalten ist.

result
Ein Ausgabe-Iterator, der das erste Element eines Zielbereichs adressiert, um die Reihe von Teilsummen oder die aufeinander folgenden Ergebnisse des angegebenen binären Vorgangs zu speichern.

binary_op
Der binäre Vorgang, der im generalisierten Vorgang angewendet werden soll, ersetzt den Vorgang der Summe in der Teilsummenprozedur.

Rückgabewert

Ein Ausgabe-Iterator, der das Ende des Zielbereichs angibt: ergebnis + (zuletzt zuerst - ).

Hinweise

Das Ausgabe iteratorergebnis darf derselbe Iterator sein wie der Eingabe iterator zuerst, sodass Teilsummen direkt berechnet werden können.

Für eine Abfolge von Werten 1, a2, ... ineinem Eingabebereich speichert die erste Vorlagenfunktion nachfolgende Teilsummen im Zielbereich. Das n-th-Elementwird durch (1 + a2 + 3 + ... + n) angegeben.

Bei einer Abfolge von Werten von1, a2, a3 in einem Eingabebereich speichert die zweite Vorlagenfunktion aufeinander folgende Teilergebnisse im Zielbereich. Das n-th-Elementwird von ((... (a1 binary_op a2) binary_op a3) binary_op ... ) binary_op n).

Der binäre Vorgang binary_op ist nicht erforderlich, um entweder assoziativ oder kommutativ zu sein, da die Reihenfolge der angewendeten Vorgänge angegeben ist.

Beispiel

// numeric_partial_sum.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <numeric>
#include <functional>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int> V1( 10 ), V2( 10 );
   vector<int>::iterator VIter1, VIter2, VIterend, VIterend2;

   list <int> L1;
   list <int>::iterator LIter1, LIterend;

   int t;
   for ( t = 1 ; t <= 10 ; t++ )
   {
      L1.push_back( t );
   }

   cout << "The input list L1 is:\n ( " ;
   for ( LIter1 = L1.begin( ) ; LIter1 != L1.end( ) ; LIter1++ )
      cout << *LIter1 << " ";
   cout << ")." << endl;

   // The first member function for the partial sums of
   // elements in a list output to a vector
   VIterend = partial_sum ( L1.begin ( ) , L1.end ( ) ,
      V1.begin ( ) );

   cout << "The output vector containing the partial sums is:\n ( " ;
   for ( VIter1 = V1.begin( ) ; VIter1 != VIterend ; VIter1++ )
      cout << *VIter1 << " ";
   cout << ")." << endl;

   // The second member function used to compute
   // the partial product of the elements in a list
   VIterend2 = partial_sum ( L1.begin ( ) , L1.end ( ) , V2.begin ( ) ,
      multiplies<int>( ) );

   cout << "The output vector with the partial products is:\n ( " ;
   for ( VIter2 = V2.begin( ) ; VIter2 != VIterend2 ; VIter2++ )
      cout << *VIter2 << " ";
   cout << ")." << endl;

   // Computation of partial sums in place
   LIterend = partial_sum ( L1.begin ( ) , L1.end ( ) , L1.begin ( ) );
   cout << "The in place output partial_sum list L1 is:\n ( " ;
   for ( LIter1 = L1.begin( ) ; LIter1 != LIterend ; LIter1++ )
      cout << *LIter1 << " ";
   cout << ")." << endl;
}

reduce

Reduziert alle Elemente in einem angegebenen Bereich, z. B. einen bestimmten Anfangswert, durch Berechnung von Summen in einer beliebigen und möglicherweise permutierten Reihenfolge. Oder reduzieren Sie die Ergebnisse eines angegebenen binären Vorgangs. Überladungen, die ein Ausführungsrichtlinienargument enthalten, werden gemäß der angegebenen Richtlinie ausgeführt.

template<class InputIterator>
typename iterator_traits<InputIterator>::value_type reduce(
    InputIterator first,
    InputIterator last);

template<class InputIterator, class Type>
Type reduce(
    InputIterator first,
    InputIterator last,
    Type init);

template<class InputIterator, class Type, class BinaryOperation>
Type reduce(
    InputIterator first,
    InputIterator last,
    Type init,
    BinaryOperation binary_op);

template<class ExecutionPolicy, class ForwardIterator>
typename iterator_traits<ForwardIterator>::value_type reduce(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator, class Type>
Type reduce(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Type init);

template<class ExecutionPolicy, class ForwardIterator, class Type, class BinaryOperation>
Type reduce(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Type init,
    BinaryOperation binary_op);

Parameter

exec
Eine Ausführungsrichtlinie.

first
Ein Eingabe-Iterator, der das erste Element im Bereich adressiert, um entweder zu addieren oder mithilfe von binary_op zu kombinieren.

last
Ein Eingabe-Iterator, der das letzte Element im Bereich adressiert, um entweder zu summieren oder zu kombinieren, indem binary_op verwendet wird. Dies ist eine Position, die über das letzte Element hinausgeht, das tatsächlich in der iterierten Akkumulation enthalten ist.

result
Ein Ausgabe-Iterator, der das erste Element angibt, ein Zielbereich, in dem die Reihe von Summen oder die Ergebnisse des angegebenen Vorgangs gespeichert werden sollen.

init
Ein Anfangswert, dem jedes Element mithilfe von binary_op hinzugefügt oder kombiniert wird.

binary_op
Der binäre Vorgang, der auf jedes Element im angegebenen Bereich und auf das Ergebnis seiner vorherigen Anwendungen angewendet werden soll.

Rückgabewert

Das Ergebnis des Anwendens binary_op oder std::plus<>() des Initierens und aller Elemente im angegebenen Bereich auf (*PartialResult, in_iter), wobei PartialResult das Ergebnis früherer Anwendungen des Vorgangs ist und in_iter ein Iterator ist, der auf ein Element im Bereich zeigt. In Überladungen, die "init" nicht angeben, entspricht typename iterator_traits<InputIterator>::value_type{}der verwendete Init-Wert .

Hinweise

reduce Das Verhalten ist nicht deterministisch, es sei denn , binary_op ist assoziativ und kommutativ. Das Verhalten ist nicht definiert, wenn binary_op elemente ändert oder alle Iteratoren im Intervall [first, last], inclusive, ungültig macht.

transform_exclusive_scan

Transformiert die Elemente eines Bereichs mit einem angegebenen unären Operator und berechnet dann einen exklusiven Präfixsummenvorgang mithilfe std::plus<>() eines angegebenen binären Operators über den Bereich, wobei ein Anfangswert angegeben wird. Schreibt die Ergebnisse in den Bereich, der am angegebenen Ziel beginnt. Eine exklusive Präfixsumme bedeutet, dass das n-th-Eingabeelementnicht in der n-th-Summeenthalten ist. Überladungen, die ein Ausführungsrichtlinienargument enthalten, werden gemäß der angegebenen Richtlinie ausgeführt. Die Summe kann in einer beliebigen Reihenfolge ausgeführt werden.

template<class InputIterator, class OutputIterator, class Type, class BinaryOperation, class UnaryOperation>
OutputIterator transform_exclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    Type init,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type, class BinaryOperation, class UnaryOperation>
ForwardIterator2 transform_exclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    Type init,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

Parameter

exec
Eine Ausführungsrichtlinie.

first
Ein Eingabe-Iterator, der das erste Element im Bereich adressiert, um entweder zu addieren oder mithilfe von binary_op zu kombinieren.

last
Ein Eingabe-Iterator, der das letzte Element im Bereich adressiert, um entweder zu summieren oder zu kombinieren, indem binary_op verwendet wird. Dies ist eine Position, die über das letzte Element hinausgeht, das tatsächlich in der iterierten Akkumulation enthalten ist.

result
Ein Ausgabe-Iterator, der das erste Element angibt, ein Zielbereich, in dem die Reihe von Summen oder die Ergebnisse des angegebenen Vorgangs gespeichert werden sollen.

init
Ein Anfangswert, dem jedes Element mithilfe von binary_op hinzugefügt oder kombiniert wird.

binary_op
Der binäre Vorgang, der auf jedes Element im angegebenen Bereich und auf das Ergebnis seiner vorherigen Anwendungen angewendet werden soll.

unary_op
Der unäre Vorgang, der auf jedes Element im angegebenen Bereich angewendet werden soll.

transform_inclusive_scan

Transformiert die Elemente eines Bereichs mit einem angegebenen unären Operator und berechnet dann einen inklusiven Präfixsummenvorgang mithilfe std::plus<>() eines angegebenen binären Operators über den Bereich, wobei ein Anfangswert angegeben wird. Schreibt die Ergebnisse in den Bereich, der am angegebenen Ziel beginnt. Eine inklusive Präfixsumme bedeutet, dass das n-th-Eingabeelementin der n-th-Summeenthalten ist. Überladungen, die ein Ausführungsrichtlinienargument enthalten, werden gemäß der angegebenen Richtlinie ausgeführt. Die Summe kann in einer beliebigen Reihenfolge ausgeführt werden.

template<class InputIterator, class OutputIterator, class BinaryOperation, class UnaryOperation>
OutputIterator transform_inclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

template<class InputIterator, class OutputIterator, class BinaryOperation, class UnaryOperation, class Type>
OutputIterator transform_inclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op,
    UnaryOperation unary_op,
    Type init);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class BinaryOperation, class UnaryOperation>
ForwardIterator2 transform_inclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class BinaryOperation, class UnaryOperation, class Type>
ForwardIterator2 transform_inclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    BinaryOperation binary_op,
    UnaryOperation unary_op,
    Type init);

Parameter

exec
Eine Ausführungsrichtlinie.

first
Ein Eingabe-Iterator, der das erste Element im Bereich adressiert, um entweder zu addieren oder mithilfe von binary_op zu kombinieren.

last
Ein Eingabe-Iterator, der das letzte Element im Bereich adressiert, um entweder zu summieren oder zu kombinieren, indem binary_op verwendet wird. Dies ist eine Position, die über das letzte Element hinausgeht, das tatsächlich in der iterierten Akkumulation enthalten ist.

result
Ein Ausgabe-Iterator, der das erste Element angibt, ein Zielbereich, in dem die Reihe von Summen oder die Ergebnisse des angegebenen Vorgangs gespeichert werden sollen.

binary_op
Der binäre Vorgang, der auf jedes Element im angegebenen Bereich und auf das Ergebnis seiner vorherigen Anwendungen angewendet werden soll.

unary_op
Der unäre Vorgang, der auf jedes Element im angegebenen Bereich angewendet werden soll.

init
Ein Anfangswert, dem jedes Element mithilfe von binary_op hinzugefügt oder kombiniert wird.

transform_reduce

Transformiert einen Bereich von Elementen und wendet dann einen Functor an, der die transformierten Elemente in beliebiger Reihenfolge reduziert. Effektiv, gefolgt transform von einer reduce.

template<class InputIterator1, class InputIterator2, class Type>
Type transform_reduce(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    Type init);

template<class InputIterator1, class InputIterator2, class Type, class BinaryOperation1, class BinaryOperation2>
Type transform_reduce(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    Type init,
    BinaryOperation1 binary_op1,
    BinaryOperation2 binary_op2);

template<class InputIterator, class Type, class BinaryOperation, class UnaryOperation>
Type transform_reduce(
    InputIterator first,
    InputIterator last,
    Type init,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type>
Type transform_reduce(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    Type init);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type, class BinaryOperation1, class BinaryOperation2>
Type transform_reduce(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    Type init,
    BinaryOperation1 binary_op1,
    BinaryOperation2 binary_op2);

template<class ExecutionPolicy, class ForwardIterator, class Type, class BinaryOperation, class UnaryOperation>
Type transform_reduce(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Type init,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

Parameter

exec
Eine Ausführungsrichtlinie.

first
Ein Eingabe-Iterator, der das erste Element im Bereich adressiert, um entweder zu addieren oder mithilfe von binary_op zu kombinieren.

first1
Ein Eingabe-Iterator, der das erste Element im Bereich adressiert, um entweder zu addieren oder mithilfe von binary_op1 zu kombinieren.

last
Ein Eingabe-Iterator, der das letzte Element im Bereich adressiert, um entweder zu summieren oder zu kombinieren, indem binary_op verwendet wird. Dies ist eine Position, die über das letzte Element hinausgeht, das tatsächlich in der iterierten Akkumulation enthalten ist.

letzte 1
Ein Eingabe-Iterator, der das letzte Element im Bereich adressiert, um entweder zu addieren oder zu kombinieren, indem binary_op1 verwendet wird. Dies ist eine Position, die über das letzte Element hinausgeht, das tatsächlich in der iterierten Akkumulation enthalten ist.

result
Ein Ausgabe-Iterator, der das erste Element angibt, ein Zielbereich, in dem die Reihe von Summen oder die Ergebnisse des angegebenen Vorgangs gespeichert werden sollen.

init
Ein Anfangswert, dem jedes Element mithilfe von binary_op hinzugefügt oder kombiniert wird.

binary_op
Der binäre Vorgang, der auf jedes Element im angegebenen Bereich und auf das Ergebnis seiner vorherigen Anwendungen angewendet werden soll.

unary_op
Der unäre Vorgang, der auf jedes Element im angegebenen Bereich angewendet werden soll.

Rückgabewert

Das transformierte Ergebnis wurde dann reduziert.