std::inner_product

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de algoritmos

Políticas de ejecución (C++17)
is_execution_policy	execution::seqexecution::parexecution::par_unseq	execution::sequenced_policyexecution::parallel_policyexecution::parallel_unsequenced_policy
Operaciones de secuencia no modificantes
all_ofany_ofnone_of (C++11)(C++11)(C++11) for_each for_each_n (C++17)	countcount_if mismatch equal adjacent_find	findfind_iffind_if_not (C++11) find_end find_first_of	search search_n lexicographical_compare lexicographical_compare_3way (C++20)
Operaciones de secuencia modificantes
copycopy_if (C++11) copy_n (C++11) copy_backward move (C++11) move_backward (C++11) transform	fill fill_n generate generate_n swap iter_swap swap_ranges sample (C++17)	removeremove_if replacereplace_if reverse rotate unique random_shuffle (hasta C++17)	remove_copyremove_copy_if replace_copyreplace_copy_if reverse_copy rotate_copy unique_copy shuffle (C++11)
Operaciones en almacenamiento no inicializado
uninitialized_copy uninitialized_move (C++17)	uninitialized_copy_n (C++11) uninitialized_move_n (C++17)	uninitialized_fill	uninitialized_fill_n
Operaciones de partición
is_partitioned (C++11) partition_point (C++11)	partition partition_copy (C++11)	stable_partition
Operaciones de ordenación
is_sorted (C++11) is_sorted_until (C++11)	sort stable_sort	partial_sort partial_sort_copy	nth_element
Operaciones de búsqueda binaria
lower_bound	upper_bound	binary_search	equal_range
Operaciones de conjuntos (en rangos ordenados)
merge inplace_merge	set_difference set_intersection	set_symmetric_difference set_union	includes
Operaciones de pila
is_heap (C++11) is_heap_until (C++11)	make_heap sort_heap	push_heap pop_heap
Operaciones mínimo/máximo
max max_element	min min_element	minmax (C++11) minmax_element (C++11)	clamp (C++17) compare_3way (C++20)
Permutaciones
is_permutation (C++11)	next_permutation	prev_permutation
Operaciones numéricas
iota (C++11) inner_product adjacent_difference	accumulate reduce (C++17) transform_reduce (C++17)	partial_sum inclusive_scan (C++17) exclusive_scan (C++17)	transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)
Bibliotecas C
qsort	bsearch

 

Definido en el archivo de encabezado <numeric>
	(1)
template<class InputIt1, class InputIt2, class T > T inner_product( InputIt1 first1, InputIt1 last1,                  InputIt2 first2, T init );			(hasta C++20)
template<class InputIt1, class InputIt2, class T > constexpr T inner_product( InputIt1 first1, InputIt1 last1,                            InputIt2 first2, T init );			(desde C++20)
		(2)
template<class InputIt1, class InputIt2, class T,           class BinaryOperation1, class BinaryOperation2 > T inner_product( InputIt1 first1, InputIt1 last1,                  InputIt2 first2, T init,                  BinaryOperation1 op1,                  BinaryOperation2 op2 );				(hasta C++20)
template<class InputIt1, class InputIt2, class T,           class BinaryOperation1, class BinaryOperation2 > constexpr T inner_product( InputIt1 first1, InputIt1 last1,                            InputIt2 first2, T init,                            BinaryOperation1 op1,                            BinaryOperation2 op2 );				(desde C++20)

Calcula el producto interno (es decir, la suma de los productos) o realiza una operación ordenada de mapa/reducción en el rango [first1, last1) y el rango que comienza en first2.

1) Inicializa el acumulador acc con el valor inicial init y luego

lo modifica con la expresión acc = acc +*first1 **first2, luego lo modifica de nuevo con la expresión acc = acc +*(first1+1)**(first2+1), etc.	(hasta C++20)
lo modifica con la expresión acc = std::move(acc)+*first1 **first2, luego lo modifica de nuevo con la expresión acc = std::move(acc)+*(first1+1)**(first2+1), etc.,	(desde C++20)

hasta llegar a last1. Para el significado integrado de + y *, esto calcula el producto interno de los dos rangos.

2) Inicializa el acumulador acc con el valor inicial init y luego

lo modifica con la expresión acc = op1(acc, op2(*first1, *first2)), luego lo modifica de nuevo con la expresión acc = op1(acc, op2(*(first1+1), *(first2+1))), etc.,	(hasta C++20)
lo modifica con la expresión acc = op1(std::move(acc), op2(*first1, *first2)), luego lo modifica de nuevo con la expresión acc = op1(std::move(acc), op2(*(first1+1), *(first2+1))), etc.,	(desde C++20)

hasta llegar a last1.

op1 o op2 no debe tener efectos secundarios.	(hasta C++11)
op1 o op2 no deben invalidar ningún iterador, incluidos los iteradores finales, ni modificar ningún elemento del rango involucrado.	(desde C++11)

Parámetros

first1, last1	-	El primer rango de elementos.
first2	-	El comienzo del segundo rango de elementos.
init	-	El valor inicial de la suma de los productos.
op1	-	Función objeto de operación binaria que se aplicará. Esta función "suma" toma un valor devuelto por op2 y el valor actual del acumulador y produce un nuevo valor para ser almacenado en el acumulador. La signatura de la función deberá ser equivalente a lo siguiente:  Ret fun(const Type1 &a, const Type2 &b); La signatura no necesita tener const&. Los tipos Type1 y Type2 deben ser tales que objetos de tipo T y Type3 puedan convertirse implícitamente a Type1 y Type2 respectivamente. El tipo Ret debe ser tal que un objeto de tipo T puede ser asignado un valor de tipo Ret. ​
op2	-	Función objeto de operación binaria que se aplicará. Esta función "producto" toma un valor de cada rango y produce un nuevo valor. La signatura de la función deberá ser equivalente a lo siguiente:  Ret fun(const Type1 &a, const Type2 &b); La signatura no necesita tener const&. Los tipos Type1 y Type2 deben ser tales que objetos de tipo InputIt1 y InputIt2 pueden ser desreferenciados y luego convertidos implícitamente a Type1 and Type2 respectively. El tipo Ret debe ser tal que un objeto de tipo Type3 puede ser asignado un valor de tipo Ret. ​
Requisitos de tipo
- InputIt1, InputIt2 debe satisfacer los requisitos de InputIterator.
- ForwardIt1, ForwardIt2 debe satisfacer los requisitos de ForwardIterator.
- T debe satisfacer los requisitos de CopyAssignable y CopyConstructible.

Valor de retorno

El valor final de acc como se describe arriba.

Posible implementación

Primera versión
template<class InputIt1, class InputIt2, class T>constexpr// desde C++20 T inner_product(InputIt1 first1, InputIt1 last1, InputIt2 first2, T init){while(first1 != last1){ init = std::move(init)+*first1 **first2;// std::move desde C++20++first1;++first2;}return init;}
Segunda versión
template<class InputIt1, class InputIt2, class T, class BinaryOperation1, class BinaryOperation2>constexpr// desde C++20 T inner_product(InputIt1 first1, InputIt1 last1, InputIt2 first2, T init, BinaryOperation1 op1 BinaryOperation2 op2){while(first1 != last1){ init = op1(std::move(init), op2(*first1, *first2));// std::move desde C++20++first1;++first2;}return init;}

Notas

La versión paralelizable de este algoritmo, std::transform_reduce, requiere que op1 y op2 sean conmutativos y asociativos, pero {{tt|std::inner_product} } no tiene tal requisito y siempre realiza las operaciones en el orden dado.

Ejemplo

Ejecuta este código

#include <numeric>#include <iostream>#include <vector>#include <functional>int main(){std::vector<int> a{0, 1, 2, 3, 4};std::vector<int> b{5, 4, 2, 3, 1};   int r1 = std::inner_product(a.begin(), a.end(), b.begin(), 0);std::cout<<"Producto interno de a y b: "<< r1 <<'\n';   int r2 = std::inner_product(a.begin(), a.end(), b.begin(), 0, std::plus<>(), std::equal_to<>());std::cout<<"Número de coincidencias por pares entre a y b: "<< r2 <<'\n';}

Salida:

Producto interno de a y b: 21 Número de coincidencias por pares entre a y b: 2

Véase también

transform_reduce (C++17)	Aplica un invocable, luego reduce fuera de orden (plantilla de función)
accumulate	Suma un rango de elementos (plantilla de función)
partial_sum	Calcula la suma parcial de un rango de elementos (plantilla de función)