inner_product

Articolo
03/26/2013

Calcola la somma del prodotto come un elemento di due intervalli e aggiunta a un valore iniziale specificato o calcola il risultato di una routine generalizzata in cui la somma e le operazioni binari del prodotto vengono sostituite da altre operazioni binarie specificate.

template<class InputIterator1, class InputIterator2, class Type>
   Type inner_product(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      Type _Val
   );

template<class InputIterator1, class InputIterator2, class Type,
   class BinaryOperation1, class BinaryOperation2>
   Type inner_product(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      Type _Val, 
      BinaryOperation1 _Binary_op1, 
      BinaryOperation2 _Binary_op2
   );

Parametri

_First1
Un iteratore di input destinato al primo elemento del primo intervallo di cui il prodotto interno o prodotto interno generalizzato con il secondo intervallo è possibile calcolare.
_Last1
Un iteratore di input destinato all'ultimo elemento del primo intervallo di cui il prodotto interno o prodotto interno generalizzato con il secondo intervallo è possibile calcolare.
_First2
Un iteratore di input destinato al primo elemento del secondo intervallo di cui il prodotto interno o prodotto interno generalizzato con il primo intervallo è possibile calcolare.
_Val
Un valore iniziale a cui il prodotto interno o il prodotto interno generalizzato tra gli intervalli deve essere aggiunto.
_Binary_op1
Un'operazione binaria che sostituisce l'operazione del prodotto interno della somma viene applicata ai prodotti come un elemento nella generalizzazione del prodotto interno.
_Binary_op2
Un'operazione binaria di cui sostituisce l'operazione come un elemento del prodotto interno si moltiplica la generalizzazione del prodotto interno.

Valore restituito

La prima funzione membro restituisce la somma dei prodotti come un elemento e aggiunto al valore iniziale specificato.Come per gli intervalli di valori e allaBi, restituisce:

_Val + ( a1 * *b)*1 + ( a2 * *b)*2 +

in maniera iterativa sostituendo _Val con _Val + (*ai * *b)i.

I secondi la funzione membro:

_Val _Binary_op1 ( a1 _Binary_op2_Binary_op2b1 ) _Binary_op1 ( a2 _Binary_op2_b2 ) _Binary_op1

in maniera iterativa sostituendo _Val con _Val _Binary_op1 (*b) di *ai _Binary_op2i.

Note

Il valore iniziale garantisce che sia presente un risultato ben definito se l'intervallo è vuoto, nel qual caso _Val viene restituito.Le operazioni binarie non devono essere associative o commutative.L'intervallo deve essere valido e complessità è lineare con la dimensione dell'intervallo.Il tipo restituito dell'operatore binario deve essere convertibile in Tipo garantire la chiusura durante un'iterazione.

Esempio

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

Output

The original vector v1 is:
 ( 1 2 3 4 5 6 7 ).
The original list l1 is:
 ( 1 2 3 4 5 6 7 ).
The inner_product of the vector v1 and the list l1 is: 140.
Vector of partial inner_products between v1 & l1 is:
 ( 1 5 14 30 55 91 140 ).

The sum of the element-wise products of v1 and l1 is: 645120.
Vector of partial sums of element-wise products is:
 ( 2 8 48 384 3840 46080 645120 ).

Requisiti

intestazione: <numeric>

Spazio dei nomi: deviazione standard

Vedere anche

Riferimenti

inner_product (STL Samples)

Libreria di modelli standard

Condividi tramite