funciones`<numeric>`

Artículo
06/16/2023

accumulate

Procesa la suma de todos los elementos en un rango especificado, incluidos algunos valores iniciales, al procesar sumas parciales sucesivas. O bien, procesa el resultado de los resultados parciales sucesivos de una operación binaria especificada.

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);

Parámetros

first
Iterador de entrada que direcciona el primer elemento del rango para sumar o combinar mediante binary_op.

last
Un iterador de entrada que direcciona el último elemento del intervalo que se va a sumar o combinar mediante binary_op, es decir, una posición más adelante del último elemento realmente incluido en la acumulación iterada.

init
Un valor inicial al que, a su vez, se agrega o combina cada elemento mediante binary_op.

binary_op
La operación binaria que se va a aplicar en cada elemento del rango especificado y el resultado de sus aplicaciones anteriores.

Valor devuelto

La suma de init y todos los elementos del intervalo especificado para la primera función de plantilla o, para la segunda función de plantilla, el resultado de aplicar la operación binaria binary_op, en lugar de la operación de suma, en (*PartialResult, in_iter), donde PartialResult es el resultado de las aplicaciones anteriores de la operación y in_iter es un iterador que señala a un elemento del rango.

Comentarios

El valor inicial garantiza que hay un resultado bien definido cuando el intervalo esté vacío, en cuyo caso init se devuelve. La operación binaria no necesita ser asociativa o conmutativa. El resultado se inicializa en el valor inicial init y, después, result = binary_op(result, in_iter) se calcula de manera iterativa mediante el rango, donde in_iter es un iterador que señala al elemento sucesivo del intervalo. El intervalo debe ser válido y la complejidad es lineal con el tamaño del intervalo. El tipo devuelto del operador binario debe ser convertible a Type para garantizar el cierre durante la iteración.

Ejemplo

// 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

Procesa las diferencias sucesivas entre cada elemento y su predecesor en un intervalo de entrada. Genera los resultados en un intervalo de destino. O bien, calcula el resultado de un procedimiento generalizado donde la operación de diferencia se reemplaza por otra operación binaria especificada.

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);

Parámetros

exec
Directiva de ejecución.

first
Iterador de entrada que direcciona el primer elemento del intervalo de entrada cuyos elementos se van a diferenciar con sus predecesores respectivos o donde se va a actuar sobre el par de valores mediante otra operación binaria especificada.

last
Iterador de entrada que direcciona el último elemento del intervalo de entrada cuyos elementos se van a diferenciar con sus predecesores respectivos o donde se va a actuar sobre el par de valores mediante otra operación binaria especificada.

result
Iterador de salida que direcciona el primer elemento de un intervalo de destino donde se va a almacenar la serie de diferencias o los resultados de la operación especificada.

binary_op
Operación binaria para aplicar en la operación generalizada reemplazando la operación de resta en el procedimiento de diferenciación.

Valor devuelto

Un iterador de salida que direcciona al final del intervalo de destino: result + ( last - first).

Comentarios

Está permitido que el iterador de salida result sea el mismo que el iterador de entrada first,, de manera que los valores adjacent_difference se puedan calcular en contexto.

En una secuencia de valores a1, a2, a3, de un intervalo de entrada, la primera función de plantilla almacena valores sucesivos adjacent_difference a1, a2 - a1, a3 - a2, en el intervalo de destino.

Para una secuencia de valores 1, un2, un3, en un intervalo de entrada, la segunda función de plantilla almacena valores sucesivos adjacent_difference un1, un2 binary_op un1, un3 binary_op un2, en el intervalo de destino.

No es necesario que la operación binaria binary_op sea asociativa o conmutativa, ya que el orden en que se aplican las operaciones se especifica.

Ejemplo

// 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

Procesa una operación de suma de prefijo exclusiva mediante std::plus<>() o un operador binario especificado en un intervalo, dado un valor inicial. Escribe los resultados en el intervalo que comienza en el destino especificado. Una suma de prefijo exclusiva significa que el n° del elemento de entrada no se incluye en la suma n°. Las sobrecargas que incluyen un argumento de la directiva de ejecución se ejecutan según la directiva especificada.

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);

Parámetros

exec
Directiva de ejecución.

first
Iterador de entrada que direcciona el primer elemento del rango para sumar o combinar mediante binary_op.

result
Iterador de salida que direcciona el primer elemento de un intervalo de destino donde se va a almacenar la serie de sumas o los resultados de la operación especificada.

init
Un valor inicial al que, a su vez, se agrega o combina cada elemento mediante binary_op.

binary_op
La operación binaria que se va a aplicar en cada elemento del rango especificado y el resultado de sus aplicaciones anteriores.

Valor devuelto

Un iterador de salida que direcciona al final del intervalo de destino: result + (last - first).

gcd

Procesa el mayor divisor común de los enteros m y n.

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

Parámetros

m, n
Valores de tipo entero.

Valor devuelto

Devuelve el divisor común mayor de los valores absolutos de m y n, o cero si m y n son cero. Los resultados no están definidos si los valores absolutos de m o n no se pueden representar como valores de tipo common_type_t<M,N>.

inclusive_scan

Procesa una operación de suma de prefijo inclusiva mediante std::plus<>() o un operador binario especificado en un intervalo, dado un valor inicial. Escribe los resultados en el intervalo que comienza en el destino especificado. Una suma del prefijo exclusiva significa que el n° del elemento de entrada no se incluye en la suma n°. Las sobrecargas que incluyen un argumento de la directiva de ejecución se ejecutan según la directiva especificada.

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);

Parámetros

exec
Directiva de ejecución.

first
Iterador de entrada que direcciona el primer elemento del rango para sumar o combinar mediante binary_op.

result
Iterador de salida que direcciona el primer elemento de un intervalo de destino donde se va a almacenar la serie de sumas o los resultados de la operación especificada.

init
Un valor inicial al que, a su vez, se agrega o combina cada elemento mediante binary_op.

binary_op
La operación binaria que se va a aplicar en cada elemento del rango especificado y el resultado de sus aplicaciones anteriores.

Valor devuelto

Un iterador de salida que direcciona al final del intervalo de destino: result + (last - first).

inner_product

Calcula la suma del producto de elementos de dos intervalos y la agrega a un valor inicial especificado, o calcula el resultado de un procedimiento general donde las operaciones binarias de suma y de producto se reemplazan por otras operaciones binarias especificadas.

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);

Parámetros

first1
Un iterador de entrada que direcciona el primer elemento del primer intervalo cuyo producto interno o producto interno generalizado debe calcularse con el segundo intervalo.

last1
Un iterador de entrada que direcciona el último elemento del primer intervalo cuyo producto interno o producto interno generalizado con el segundo intervalo debe calcularse.

first2
Un iterador de entrada que direcciona el primer elemento del segundo intervalo cuyo producto interno o producto interno generalizado con el primer intervalo debe calcularse.

init
Un valor inicial al que se va a agregar el producto interno o el producto interno generalizado entre los intervalos.

binary_op1
La operación binaria que reemplaza la operación de producto interno de suma que se aplica a los productos de elementos en la generalización del producto interno.

binary_op2
La operación binaria que reemplaza la operación de elementos de producto interno de multiplicar en la generalización del producto interno.

Valor devuelto

La primera función miembro devuelve la suma de los productos de elementos y la agrega al valor inicial especificado. Por lo que para los intervalos de valores ai y bi, devuelve:

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

reemplazando iterativamente init por init + (ai * bi).

La segunda función miembro devuelve:

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

reemplazando iterativamente init por init binary_op1 (ai binary_op2 bi).

Comentarios

El valor inicial garantiza que hay un resultado bien definido cuando el intervalo esta vacío. En ese caso, se devuelve init. Las operaciones binarias no necesitan ser asociativas ni conmutativas. El intervalo debe ser válido y la complejidad es lineal con el tamaño del intervalo. El tipo devuelto del operador binario debe ser convertible a Type para garantizar el cierre durante la iteración.

Ejemplo

// 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

Almacena un valor inicial, empezando por el primer elemento y rellenando con incrementos sucesivos de ese valor (value++) en cada uno de los elementos del intervalo [first, last).

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

Parámetros

first
Un iterador de entrada que direcciona el primer elemento del intervalo que se va a rellenar.

last
Un iterador de entrada que direcciona el último elemento del intervalo que se va a rellenar.

value
El valor inicial para almacenar en el primer elemento y para incrementar sucesivamente los elementos posteriores.

Ejemplo

En el siguiente ejemplo se muestran algunos usos de la función iota rellenando una lista de enteros y, después, rellenando un vector con list, de manera que pueda usarse la función random_shuffle.

// 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;
}

lcm

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

partial_sum

Procesa una serie de sumas en un intervalo de entrada desde el primer elemento hasta el elemento n° y almacena el resultado de cada una de estas sumas en el elemento n° de un intervalo de destino. O bien, calcula el resultado de un procedimiento generalizado donde la operación de suma se reemplaza por otra operación binaria especificada.

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);

Parámetros

first
Iterador de entrada que direcciona el primer elemento del intervalo que se va a sumar parcialmente o combinar según una operación binaria especificada.

last
Iterador de entrada que direcciona el último elemento del intervalo que se va a sumar parcialmente o combinar según una operación binaria especificada que está una posición más allá del último elemento incluido realmente en la acumulación iterada.

result
Iterador de salida que direcciona el primer elemento de un intervalo de destino para almacenar la serie de sumas parciales o los resultados sucesivos de la operación especificada.

binary_op
Operación binaria para aplicar en la operación generalizada reemplazando la operación de suma en el procedimiento de suma parcial.

Valor devuelto

Un iterador de salida que direcciona al final del intervalo de destino: result + (last - first).

Comentarios

Está permitido que el iterador de salida result sea el mismo que el iterador de entrada first, de manera que las sumas parciales se puedan calcular en contexto.

En una secuencia de valores a1, a2, ... ax, de un intervalo de entrada, la primera función de plantilla almacena sumas sucesivas en el intervalo de destino. El elemento n° se da por (a1 + a2 + a3 + ... + an).

En una secuencia de valores a1, a2, a3, de un intervalo de entrada, la segunda función de plantilla almacena resultados parciales sucesivos en el intervalo de destino. El nºelemento lo da ((... ((a 1 binary_op a2) binary_op a3) binary_op ... ) binary_op an).

No es necesario que la operación binaria binary_op sea asociativa o conmutativa, ya que el orden en que se aplican las operaciones se especifica.

Ejemplo

// 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

Reduce todos los elementos de un intervalo especificado, incluyendo posiblemente algún valor inicial, al calcular las sumas en un orden arbitrario y posiblemente permutado. O bien, reduce al calcular los resultados de una operación binaria especificada. Las sobrecargas que incluyen un argumento de la directiva de ejecución se ejecutan según la directiva especificada.

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);

Parámetros

exec
Directiva de ejecución.

first
Iterador de entrada que direcciona el primer elemento del rango para sumar o combinar mediante binary_op.

result
Iterador de salida que direcciona el primer elemento de un intervalo de destino donde se va a almacenar la serie de sumas o los resultados de la operación especificada.

init
Un valor inicial al que, a su vez, se agrega o combina cada elemento mediante binary_op.

binary_op
La operación binaria que se va a aplicar en cada elemento del rango especificado y el resultado de sus aplicaciones anteriores.

Valor devuelto

El resultado de aplicar binary_op o std::plus<>() a init y todos los elementos del intervalo especificado a (*PartialResult, in_iter), donde PartialResult es el resultado de las aplicaciones previas de la operación y in_iter es un iterador que apunta a algún elemento del intervalo. En sobrecargas que no especifican init, el valor init usado es equivalente a typename iterator_traits<InputIterator>::value_type{}.

Comentarios

reduce el comportamiento no es determinista a menos que binary_op sea asociativo y conmutante. El comportamiento no está definido si binary_op modifica cualquier elemento o invalida cualquier iterador en el intervalo [first, last], inclusive.

transform_exclusive_scan

Transforma los elementos de un intervalo con un operador unario especificado y después calcula una operación de suma del prefijo exclusivo mediante std::plus<>() o un operador binario especificado en el intervalo, dado un valor inicial. Escribe los resultados en el intervalo que comienza en el destino especificado. Una suma de prefijo exclusiva significa que el n° del elemento de entrada no se incluye en la suma n°. Las sobrecargas que incluyen un argumento de la directiva de ejecución se ejecutan según la directiva especificada. La suma se puede realizar en un orden arbitrario.

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);

Parámetros

exec
Directiva de ejecución.

first
Iterador de entrada que direcciona el primer elemento del rango para sumar o combinar mediante binary_op.

result
Iterador de salida que direcciona el primer elemento de un intervalo de destino donde se va a almacenar la serie de sumas o los resultados de la operación especificada.

init
Un valor inicial al que, a su vez, se agrega o combina cada elemento mediante binary_op.

binary_op
La operación binaria que se va a aplicar en cada elemento del rango especificado y el resultado de sus aplicaciones anteriores.

unary_op
Operación unaria que se va a aplicar a cada elemento del intervalo especificado.

transform_inclusive_scan

Transforma los elementos de un intervalo con un operador unario especificado y después calcula una operación de suma del prefijo inclusivo mediante std::plus<>() o un operador binario especificado en el intervalo, dado un valor inicial. Escribe los resultados en el intervalo que comienza en el destino especificado. Una suma del prefijo exclusiva significa que el n° del elemento de entrada no se incluye en la suma n°. Las sobrecargas que incluyen un argumento de la directiva de ejecución se ejecutan según la directiva especificada. La suma se puede realizar en un orden arbitrario.

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);

Parámetros

exec
Directiva de ejecución.

first
Iterador de entrada que direcciona el primer elemento del rango para sumar o combinar mediante binary_op.

result
Iterador de salida que direcciona el primer elemento de un intervalo de destino donde se va a almacenar la serie de sumas o los resultados de la operación especificada.

binary_op
La operación binaria que se va a aplicar en cada elemento del rango especificado y el resultado de sus aplicaciones anteriores.

unary_op
Operación unaria que se va a aplicar a cada elemento del intervalo especificado.

init
Un valor inicial al que, a su vez, se agrega o combina cada elemento mediante binary_op.

transform_reduce

Transforma un intervalo de elementos y después aplica un functor que reduce los elementos transformados en orden arbitrario. Efectivamente un transform seguido de un 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);

Parámetros

exec
Directiva de ejecución.

first
Iterador de entrada que direcciona el primer elemento del rango para sumar o combinar mediante binary_op.

first1
Iterador de entrada que direcciona el primer elemento del rango para sumar o combinar mediante binary_op1.

last1
Un iterador de entrada que direcciona el último elemento del intervalo que se va a sumar o combinar mediante binary_op1, es decir, una posición más adelante del último elemento realmente incluido en la acumulación iterada.

result
Iterador de salida que direcciona el primer elemento de un intervalo de destino donde se va a almacenar la serie de sumas o los resultados de la operación especificada.

init
Un valor inicial al que, a su vez, se agrega o combina cada elemento mediante binary_op.

binary_op
La operación binaria que se va a aplicar en cada elemento del rango especificado y el resultado de sus aplicaciones anteriores.

unary_op
Operación unaria que se va a aplicar a cada elemento del intervalo especificado.

Valor devuelto

Resultado transformado y reducido.

Compartir a través de

funciones<numeric>

accumulate

Parámetros

Valor devuelto

Comentarios

Ejemplo

adjacent_difference

Parámetros

Valor devuelto

Comentarios

Ejemplo

exclusive_scan

Parámetros

Valor devuelto

gcd

Parámetros

Valor devuelto

inclusive_scan

Parámetros

Valor devuelto

inner_product

Parámetros

Valor devuelto

Comentarios

Ejemplo

iota

Parámetros

Ejemplo

lcm

partial_sum

Parámetros

Valor devuelto

Comentarios

Ejemplo

reduce

Parámetros

Valor devuelto

Comentarios

transform_exclusive_scan

Parámetros

transform_inclusive_scan

Parámetros

transform_reduce

Parámetros

Valor devuelto

Comentarios

Recursos adicionales

funciones`<numeric>`