<Numérico>
Operaciones numéricas generalizadas
Esta cabecera se describe un conjunto de algoritmos para realizar ciertas operaciones en las secuencias de valores numéricos. Debido a su flexibilidad, también se pueden adaptar para otros tipos de secuencias.
1.- std :: acumulan
suma (1) | template <class InputIterator, Clase T>
T acumulan (Primero InputIterator, InputIterator Pasado, T init);
|
personalizado (2) | template <class InputIterator, el clase T, el clase BinaryOperation>
T acumulan (Primero InputIterator, InputIterator Pasado, T init,
BinaryOperation op_binario);
|
Acumular valores en rango
Devuelve el resultado de la acumulación de todos los valores en el rango [primero, último)
a init . La operación predeterminada es agregar los elementos, pero una operación diferente se puede especificar como op_binario . El comportamiento de esta plantilla de función es equivalente a:
1
2
3
4
5
6
7
8
9
| Plantilla < Clase InputIterator, Clase T>
T acumulan (Primero InputIterator, InputIterator Pasado, T init)
{
mientras que (primero! = pasado) {
init init = + * primero; // o: init = op_binario (init, * primero) para la versión op_binario
++ Primero;
}
volver init;
}
| |
Parámetros
- primero, último
- Iteradores de entrada a las posiciones inicial y final de una secuencia. El rango utilizado es
[primero, último)
, que contiene todos los elementos entre la primera y la última , incluyendo el elemento apuntado por primera pero no el elemento apuntado por último .
- init
- Valor inicial para el acumulador.
- op_binario
- Operación binaria teniendo un elemento de tipo T como primer argumento y un elemento en el rango como segundo, y que devuelve un valor que se puede asignar para escribir T.
Esto puede ser o bien un puntero de función o un objeto de función.
La operación no modificará los elementos pasados como sus argumentos.
Valor de retorno
El resultado de la acumulación de init y todos los elementos en el rango [primero, último)
.
Ejemplo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| EJEMPLO // acumulan
# include <iostream> // std :: cout
# include <funcionalmente> // std :: minus
# include <Numérica> // std :: acumulan
int mifuncion ( int x, int y) { volver x + 2 * y;}
struct MiClase {
int Operador () ( int x, int y) { retorno x + 3 * y;}
} MiObjeto;
int main () {
int init = 100;
int Números [] = {10,20,30};
std :: cout << "utilizando acumulan por defecto:" ;
std :: cout << std :: acumulan (números, 3 +, init);
std :: cout << "\ n" ;
std :: cout << "utilizando menos del funcional:" ;
std :: cout << std :: acumulan (números, números + 3, init, std :: minus < int > ());
std :: cout << "\ n" ;
std :: cout << "el uso de la función personalizada:" ;
std :: cout << std :: acumulan (números, números + 3, init myFunction);
std :: cout << "\ n" ;
std :: cout << "el uso de objeto personalizado:" ;
std :: cout << std :: acumulan (números, números + 3, init, MiObjeto);
std :: cout << "\ n" ;
devolver 0;
}
|
|
Salida:
utilizando acumulan por defecto: 160
utilizando menos del funcional: 40
con la función Personal: 220
utilizando objetos personalizados: 280
|
2.- std :: adjacent_difference
diferencia (1) | template <class InputIterator, el clase OutputIterator>
OutputIterator adjacent_difference (Primero InputIterator, InputIterator Pasado,
RESULTADO OutputIterator);
|
personalizado (2) | template <class InputIterator, el clase OutputIterator, el clase BinaryOperation>
OutputIterator adjacent_difference (Primero InputIterator, InputIterator Pasado,
RESULTADO OutputIterator, BinaryOperation op_binario);
|
Calcule la diferencia adyacente de rango
Asigna a cada elemento en el rango que comienza en consecuencia la diferencia entre su elemento correspondiente en el rango [primero, último)
y el que le precede (a excepción de resultado *
, que se asigna primero *
). Si x representa un elemento en [primero , último)
y y representa un elemento de resultado
, el y s se puede calcular como: y
0
= x
0
y
1
x =
1
- x
0
y
2
= x
2
- x
1
y
3
= x
3
- x
2
y
4
= x
4
- x
3
... ... ...
La operación predeterminada es calcular la diferencia, pero alguna otra operación se puede especificar como op_binario lugar. El comportamiento de esta plantilla de función es equivalente a:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| Plantilla < Clase InputIterator, el clase OutputIterator>
OutputIterator adjacent_difference (Primero InputIterator, InputIterator Pasado,
OutputIterator RESULTADO)
{
si (! = Ultimo Primera) {
TYPENAME iterator_traits <InputIterator> :: hrs value_type antes;
* Result = prev = * en primer lugar;
mientras que (++ primero! = pasado) {
val = * en primer lugar;
*++result = val - prev; // or: *++result = binary_op(val,prev)
prev = val;
}
++ Resultado;
}
volver resultado;
}
| |
Parámetros
- primero, último
- Iteradores de entrada a las posiciones inicial y final de una secuencia. El rango utilizado es
[primero, último)
, que contiene todos los elementos entre la primera y la última , incluyendo el elemento apuntado por primera pero no el elemento apuntado por último .
- resultado
- Iterador de salida a la posición inicial en la secuencia de destino donde se almacenan las diferencias. La gama comienza a resultado y deberá tener un tamaño lo suficientemente grande como para contener tantos elementos como el intervalo anterior (
[primero, último)
).
- op_binario
- Operación binaria tomando como argumentos los elementos que tipo de señalado InputIterator, Y devolver el resultado de la sustitución de la operación de diferencia.
Esto puede ser o bien un puntero de función o un objeto de función.
Valor de retorno
Un iterador que señala a pasado el último elemento de la secuencia de destino en el que se han almacenado los elementos resultantes.
Ejemplo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| // EJEMPLO adjacent_difference
# include <iostream> // std :: cout
# include <funcional> // std :: multiplica
# include <Numérico> // std :: adjacent_difference
int myop ( int x, int y) { retorno x + y;}
int main () {
int val [] = {} 1,2,3,5,9,11,12;
int RESULTADO [7];
std :: adjacent_difference (val, val + 7, resultado);
std :: cout << "adjacent_difference usando por defecto" ,
para ( int i = 0; i <7; ++ i) std :: cout << resultado [i] << '' ;
std :: cout << "\ n" ;
std :: adjacent_difference (val, val + 7, resultado, std :: multiplica < int > ());
std :: cout << "se multiplica utilizando operación funcional" ,
para ( int i = 0; i <7; ++ i) std :: cout << resultado [i] << '' ;
std :: cout << "\ n" ;
std :: adjacent_difference (val, val + 7, resultado, myop);
std :: cout << "el uso de la función personalizada:" ;
para ( int i = 0; i <7; i ++) std :: cout << resultado [i] << '' ;
std :: cout << "\ n ' ;
retorno 0;
}
|
|
Salida:
utilizando adjacent_difference defecto: 1 1 1 2 4 2 1
utilizando operación funcional multiplica: 1 2 6 15 45 99 132
utilizando la función personalizada: 1 3 5 8 14 20 23
|
3.- std :: inner_product
suma / multiplicación (1) | template <class InputIterator1, el clase InputIterator2, Clase T>
T inner_product (InputIterator1 first1, InputIterator1 last1,
Primero2 InputIterator2, T init);
|
personalizado (2) | template <class InputIterator1, el clase InputIterator2, el clase T,
BinaryOperation1 Clase, Clase BinaryOperation2>
T inner_product (InputIterator1 first1, InputIterator1 last1,
InputIterator2 primero2, T init,
Binary_op1 BinaryOperation1,
BinaryOperation2 binary_op2);
|
Calcule producto interno acumulado de rango
Devuelve el resultado de la acumulación de inicio con los productos internos de las parejas formadas por los elementos de dos rangos que van desde los first1 y primero2 . Las dos operaciones por defecto (al sumar el resultado de multiplicar los pares) puede ser anulado por el argumentos binary_op1 y binary_op2 . El comportamiento de esta plantilla de función es equivalente a:
1
2
3
4
5
6
7
8
9
10
11
| Plantilla < Clase InputIterator1, el clase InputIterator2, Clase T>
T inner_product (InputIterator1 first1, InputIterator1 last1,
Primero2 InputIterator2, T init)
{
mientras que (first1! = last1) {
init init = + (* first1) * (* primero2);
// O: init = binary_op1 (init, binary_op2 (* first1, * primero2));
++ First1; ++ Primero2;
}
volver init;
}
| |
Parámetros
- first1, last1
- Iteradores de entrada a las posiciones iniciales y finales en la primera secuencia. El rango utilizado es
[first1, last1)
, que contiene todos los elementos entre first1 y last1 , incluyendo el elemento señalado por first1 pero no el elemento señalado por last1 .
- primero2
- Iterador de entrada a la posición inicial en la segunda secuencia. La gama comienza a primero2 y tiene tantos elementos como el intervalo anterior (
[first1, last1)
).
- init
- Valor inicial para el acumulador.
- binary_op1
- Operación binaria de tomar elementos de tipo T como argumentos, y devolver el resultado de una operación de acumulación.
Esto puede ser o bien un puntero de función o un objeto de función.
- binary_op2
- Operación binaria de tomar elementos de tipo T como argumentos, y devolver el resultado de la operación de producto interior.
Esto puede ser o bien un puntero de función o un objeto de función.
Ni las operaciones deberán modificar cualquiera de los elementos pasados como sus argumentos.
Valor de retorno
El resultado de la acumulación de init y los productos de todos los pares de elementos en los rangos que van desde los first1 y primero2 .
Ejemplo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| // Ejemplo inner_product
# include <iostream> // std :: cout
# include <funcional> // std :: menos, std :: divide
# include <numérico> // std :: inner_product
int myaccumulator ( int x, int y) { retorno xy;}
int miproducto ( int x, int y) { volver x + y;}
int main () {
int init = 100;
int series1 [] = {10,20,30};
int series2 [] = {1,2,3};
std :: cout << "utilizando inner_product defecto:" ;
std :: cout << std :: inner_product (series1, series1 + 3, serie 2, init);
std :: cout << "\ n" ;
std :: cout << "el uso de las operaciones funcionales:" ;
std :: cout << std :: inner_product (series1, series1 + 3, serie 2, init,
std :: minus < int > (), std :: Divide < int > ());
std :: cout << "\ n" ;
std :: cout << "el uso de las funciones habituales:" ;
std :: cout << std :: inner_product (series1, series1 + 3, serie 2, init,
myaccumulator, miproducto);
std :: cout << "\ n" ;
devolver 0;
}
|
|
Salida:
utilizando inner_product defecto: 240
usando operaciones funcionales: 70
utilizando funciones personalizadas: 34
|
4.- std :: partial_sum
suma (1) | template <class InputIterator, el clase OutputIterator>
OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
RESULTADO OutputIterator);
|
personalizado (2) | template <class InputIterator, el clase OutputIterator, el clase BinaryOperation>
OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
RESULTADO OutputIterator, BinaryOperation op_binario);
|
Calcula sumas parciales de rango
Asigna a cada elemento en el rango que comienza en consecuencia la suma parcial de los elementos correspondientes en el rango [primero, último)
. Si x representa un elemento en [primero, último)
y y representa un elemento de resultado , el y s puede ser calculado como: y
0
= x
0
y
1
= x
0
+ x
1
y
2
= x
0
+ x
1
+ x
2
y
3
x =
0
+ x
1
+ x
2
+ x
3
y
4
x =
0
x +
1
+ x
2
+ x
3
+ x
4
... ... ...
La operación predeterminada es agregar los elementos, pero una operación diferente se puede especificar como op_binario lugar. El comportamiento de esta plantilla de función es equivalente a:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| Plantilla < Clase InputIterator, el clase OutputIterator>
OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
OutputIterator RESULTADO)
{
SI (! = fina capa de imprimación) {
TypeName iterator_traits <InputIterator> :: elección value_type = * a Lugar de imprimación;
*result = val;
mientras que (++ primero! = pasado) {
elección = selección + * primero; // o: opción = op_binario (alternativamente, * primero)
*++result = val;
}
++ Resultado;
}
volver resultado;
}
| |
Parámetros
- primero, último
- Iteradores de entrada a las posiciones inicial y final de una secuencia. El rango utilizado es
[primero, último)
, que contiene todos los elementos entre la primera y la última , incluyendo el elemento apuntado por primera pero no el elemento apuntado por último .
- resultado
- Iterador de salida a la posición inicial en la secuencia de destino donde se almacenan las sumas parciales. La gama comienza a resultado y deberá tener un tamaño lo suficientemente grande como para contener tantos elementos como el intervalo anterior (
[primero, último)
).
- op_binario
- Operación binaria tomando dos elementos del tipo señalado por el InputIterator como argumentos, y devolver el resultado de la sustitución de la operación de suma.
Esto puede ser o bien un puntero de función o un objeto de función.
Valor de retorno
Un iterador que apunta a más allá del último elemento de la secuencia de destino donde se han almacenado los elementos resultantes, o resultar si [primero, último)
es un rango de vacío.
Ejemplo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| // Ejemplo partial_sum
# include <iostream> // std :: cout
# include <funcional> // std :: multiplica
# include <numérico> // std :: partial_sum
int myop ( int x, int y) { retorno x + y + 1;}
int main () {
int val [] = {1,2,3,4,5};
int RESULTADO [5];
std :: partial_sum (val, val + 5, resultado);
std :: cout << "partial_sum usando por defecto" ,
para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
std :: cout << "\ n" ;
std :: partial_sum (val, val + 5, resultado, std :: multiplica < int > ());
std :: cout << "se multiplica utilizando operación funcional" ,
para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
std :: cout << "\ n" ;
std :: partial_sum (val, val + 5, resultado, myop);
std :: cout << "el uso de la función personalizada:" ;
para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
std :: cout << "\ n ' ;
retorno 0;
}
|
|
Salida:
utilizando partial_sum defecto: 1 3 6 10 15
utilizando multiplica operación funcionales: 1 2 6 24 120
utilizando la función personalizada: 1 4 8 13 19
|
5.- std :: partial_sum
suma (1) | template <class InputIterator, el clase OutputIterator>
OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
RESULTADO OutputIterator);
|
personalizado (2) | template <class InputIterator, el clase OutputIterator, el clase BinaryOperation>
OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
RESULTADO OutputIterator, BinaryOperation op_binario);
|
Calcula sumas parciales de rango
Asigna a cada elemento en el rango que comienza en consecuencia la suma parcial de los elementos correspondientes en el rango [primero, último)
. Si x representa un elemento en [primero, último)
y y representa un elemento de resultado , el y s puede ser calculado como: y
0
= x
0
y
1
= x
0
+ x
1
y
2
= x
0
+ x
1
+ x
2
y
3
x =
0
+ x
1
+ x
2
+ x
3
y
4
x =
0
x +
1
+ x
2
+ x
3
+ x
4
... ... ...
La operación predeterminada es agregar los elementos, pero una operación diferente se puede especificar como op_binario lugar. El comportamiento de esta plantilla de función es equivalente a:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| Plantilla < Clase InputIterator, el clase OutputIterator>
OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
OutputIterator RESULTADO)
{
SI (! = fina capa de imprimación) {
TypeName iterator_traits <InputIterator> :: elección value_type = * a Lugar de imprimación;
*result = val;
mientras que (++ primero! = pasado) {
elección = selección + * primero; // o: opción = op_binario (alternativamente, * primero)
*++result = val;
}
++ Resultado;
}
volver resultado;
}
| |
Parámetros
- primero, último
- Iteradores de entrada a las posiciones inicial y final de una secuencia. El rango utilizado es
[primero, último)
, que contiene todos los elementos entre la primera y la última , incluyendo el elemento apuntado por primera pero no el elemento apuntado por último .
- resultado
- Iterador de salida a la posición inicial en la secuencia de destino donde se almacenan las sumas parciales. La gama comienza a resultado y deberá tener un tamaño lo suficientemente grande como para contener tantos elementos como el intervalo anterior (
[primero, último)
).
- op_binario
- Operación binaria tomando dos elementos del tipo señalado por el InputIterator como argumentos, y devolver el resultado de la sustitución de la operación de suma.
Esto puede ser o bien un puntero de función o un objeto de función.
Valor de retorno
Un iterador que apunta a más allá del último elemento de la secuencia de destino donde se han almacenado los elementos resultantes, o resultar si [primero, último)
es un rango de vacío.
Ejemplo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| // Ejemplo partial_sum
# include <iostream> // std :: cout
# include <funcional> // std :: multiplica
# include <numérico> // std :: partial_sum
int myop ( int x, int y) { retorno x + y + 1;}
int main () {
int val [] = {1,2,3,4,5};
int RESULTADO [5];
std :: partial_sum (val, val + 5, resultado);
std :: cout << "partial_sum usando por defecto" ,
para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
std :: cout << "\ n" ;
std :: partial_sum (val, val + 5, resultado, std :: multiplica < int > ());
std :: cout << "se multiplica utilizando operación funcional" ,
para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
std :: cout << "\ n" ;
std :: partial_sum (val, val + 5, resultado, myop);
std :: cout << "el uso de la función personalizada:" ;
para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
std :: cout << "\ n ' ;
retorno 0;
}
|
|
Salida:
utilizando partial_sum defecto: 1 3 6 10 15
utilizando multiplica operación funcionales: 1 2 6 24 120
utilizando la función personalizada: 1 4 8 13 19
|
std :: partial_sum
suma (1) | template <class InputIterator, el clase OutputIterator>
OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
RESULTADO OutputIterator);
|
personalizado (2) | template <class InputIterator, el clase OutputIterator, el clase BinaryOperation>
OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
RESULTADO OutputIterator, BinaryOperation op_binario);
|
Calcula sumas parciales de rango
Asigna a cada elemento en el rango que comienza en consecuencia la suma parcial de los elementos correspondientes en el rango [primero, último)
. Si x representa un elemento en [primero, último)
y y representa un elemento de resultado , el y s puede ser calculado como: y
0
= x
0
y
1
= x
0
+ x
1
y
2
= x
0
+ x
1
+ x
2
y
3
x =
0
+ x
1
+ x
2
+ x
3
y
4
x =
0
x +
1
+ x
2
+ x
3
+ x
4
... ... ...
La operación predeterminada es agregar los elementos, pero una operación diferente se puede especificar como op_binario lugar. El comportamiento de esta plantilla de función es equivalente a:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| Plantilla < Clase InputIterator, el clase OutputIterator>
OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
OutputIterator RESULTADO)
{
SI (! = fina capa de imprimación) {
TypeName iterator_traits <InputIterator> :: elección value_type = * a Lugar de imprimación;
*result = val;
mientras que (++ primero! = pasado) {
elección = selección + * primero; // o: opción = op_binario (alternativamente, * primero)
*++result = val;
}
++ Resultado;
}
volver resultado;
}
| |
Parámetros
- primero, último
- Iteradores de entrada a las posiciones inicial y final de una secuencia. El rango utilizado es
[primero, último)
, que contiene todos los elementos entre la primera y la última , incluyendo el elemento apuntado por primera pero no el elemento apuntado por último .
- resultado
- Iterador de salida a la posición inicial en la secuencia de destino donde se almacenan las sumas parciales. La gama comienza a resultado y deberá tener un tamaño lo suficientemente grande como para contener tantos elementos como el intervalo anterior (
[primero, último)
).
- op_binario
- Operación binaria tomando dos elementos del tipo señalado por el InputIterator como argumentos, y devolver el resultado de la sustitución de la operación de suma.
Esto puede ser o bien un puntero de función o un objeto de función.
Valor de retorno
Un iterador que apunta a más allá del último elemento de la secuencia de destino donde se han almacenado los elementos resultantes, o resultar si [primero, último)
es un rango de vacío.
Ejemplo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| // Ejemplo partial_sum
# include <iostream> // std :: cout
# include <funcional> // std :: multiplica
# include <numérico> // std :: partial_sum
int myop ( int x, int y) { retorno x + y + 1;}
int main () {
int val [] = {1,2,3,4,5};
int RESULTADO [5];
std :: partial_sum (val, val + 5, resultado);
std :: cout << "partial_sum usando por defecto" ,
para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
std :: cout << "\ n" ;
std :: partial_sum (val, val + 5, resultado, std :: multiplica < int > ());
std :: cout << "se multiplica utilizando operación funcional" ,
para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
std :: cout << "\ n" ;
std :: partial_sum (val, val + 5, resultado, myop);
std :: cout << "el uso de la función personalizada:" ;
para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
std :: cout << "\ n ' ;
retorno 0;
}
|
|
Salida:
utilizando partial_sum defecto: 1 3 6 10 15
utilizando multiplica operación funcionales: 1 2 6 24 120
utilizando la función personalizada: 1 4 8 13 19
|
std :: iota
template <class ForwardIterator, Clase T>
void iota (Primero ForwardIterator, Ultima ForwardIterator, T val);
Tienda sucesión creciente
Asigna a cada elemento en el rango [primero, último)
los valores sucesivos de val , como si se incrementa con ++ val
después se escribe cada elemento. El comportamiento de esta plantilla de función es equivalente a:
1
2
3
4
5
6
7
8
9
| Plantilla < Clase ForwardIterator, Clase T>
void iota (Primero ForwardIterator, Pasado ForwardIterator, T val)
{
mientras que (primero! = pasado) {
* Primero = val;
++ Primero;
++ Horas;
}
}
| |
Parámetros
- primero, último
- Iteradores Adelante a las posiciones inicial y final de la secuencia que se escriban. El rango utilizado es
[primero, último)
, que contiene todos los elementos entre la primera y la última , incluyendo el elemento apuntado por primera pero no el elemento apuntado por último .
- h
- Valor inicial para el acumulador.
Ejemplo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| // EJEMPLO Apice
# include <iostream> // std :: cout
# include <Numérico> // std :: iota
int principales) {(
int números [10];
std :: iota (números, números + 10 100);
std :: cout << "números" ,
para ( int i +: los números) std :: cout << "" << i;
std :: cout << "\ n" ;
devolver 0;
}
|
|
Salida:
números: 100 101 102 103 104 105 106 107 108 109
|
https://docs.google.com/document/d/1TuZqgnc0GE8TWvVKnS8rmXEDomKdY6vAMStq8QBIiMA/edit
Funciones
- acumular
- Acumular valores en el rango (plantilla de función)
- adjacent_difference
- Calcule la diferencia adyacente de rango (plantilla de función)
- inner_product
- Producto interno acumulado Compute de rango (plantilla de función)
- partial_sum
- Calcula sumas parciales de rango (plantilla de función)
- iota
- Tienda sucesión creciente (plantilla de función)
No hay comentarios:
Publicar un comentario