std::inner_product in C++

Compute cumulative inner product of range
Returns the result of accumulating init with the inner products of the pairs formed by the elements of two ranges starting at first1 and first2.

The two default operations (to add up the result of multiplying the pairs) may be overridden by the arguments binary_op1 and binary_op2.

1. Using default inner_product :
Syntax:



Template :
T inner_product (InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, T init);

Parameters :

first1, last1
Input iterators to the initial and final positions in the first
sequence.

first2
Input iterator to the initial position in the second sequence.
The range starts at first2 and has as many elements as the range
above [first1, last1].

init
Initial value for the accumulator.

Neither operations shall modify any of the elements passed as
its arguments.

Return Type :
The result of accumulating init and the products of all the pairs
of elements in the ranges starting at first1 and first2.
filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to illustrate
// std :: inner_product
#include <iostream> // std::cout
#include <functional> // std::minus, std::divides
#include <numeric> // std::inner_product
  
// Driver code
int main()
{
    // The value which is added after
    // finding inner_product b/w elements
    int init = 100;
    int series1[] = { 10, 20, 30 };
    int series2[] = { 1, 2, 3 };
    int n = sizeof(series1) / sizeof(series1[0]);
  
    // Elements in series1
    std::cout << "First array contains :";
    for (int i = 0; i < n; i++)
        std::cout << " " << series1[i];
    std::cout << "\n";
  
    // Elements in series2
    std::cout << "Second array contains :";
    for (int i = 0; i < n; i++)
        std::cout << " " << series2[i];
    std::cout << "\n\n";
  
    std::cout << "Using default inner_product: ";
    std::cout << std::inner_product(series1, series1 + n, series2, init);
    std::cout << '\n';
  
    return 0;
}

chevron_right


Output:

First array contains : 10 20 30
Second array contains : 1 2 3

Using default inner_product: 240

2. Using functional operation :
Syntax:

Template :
T inner_product (InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, T init,
                 BinaryOperation1 binary_op1,
                 BinaryOperation2 binary_op2);

Parameters :

first1, last1, first2, init are same as above.

binary_op1
Binary operation taking two elements of type T as arguments, and
returning the result of an accumulation operation.
This can either be a function pointer or a function object.

binary_op2
Binary operation taking two elements of type T as arguments, and
returning the result of the inner product operation.
This can either be a function pointer or a function object.

Here binary_op1 and binary_op2 are functional operation.

Neither operations shall modify any of the elements passed as
its arguments.

Return Type :
The result of accumulating init and the products of all the pairs
of elements in the ranges starting at first1 and first2.
filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to illustrate
// std :: inner_product
#include <iostream> // std::cout
#include <functional> // std::minus, std::divides
#include <numeric> // std::inner_product
  
// Driver code
int main()
{
    // The value which is added after
    // finding inner_product b/w elements
    int init = 100;
    int series1[] = { 10, 20, 30 };
    int series2[] = { 1, 2, 3 };
    int n = sizeof(series1) / sizeof(series1[0]);
  
    // Elements in series1
    std::cout << "First array contains :";
    for (int i = 0; i < n; i++)
        std::cout << " " << series1[i];
    std::cout << "\n";
  
    // Elements in series2
    std::cout << "Second array contains :";
    for (int i = 0; i < n; i++)
        std::cout << " " << series2[i];
    std::cout << "\n\n";
  
    std::cout << "Using functional operations: ";
    // std :: minus returns the difference b/w
    // each elements of both array
    // std :: divides return the quotient of
    // each elements of both array after performing
    // divide operation
    // The operations is performed b/w number of same index
    // of both array
    std::cout << std::inner_product(series1, series1 + n, series2, init,
                                    std::minus<int>(), std::divides<int>());
    std::cout << '\n';
  
    return 0;
}

chevron_right


Output:

First array contains : 10 20 30
Second array contains : 1 2 3

Using functional operations: 70

3. Using custom functions :
Syntax:

Template :
T inner_product (InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, T init,
                 BinaryOperation1 binary_op1,
                 BinaryOperation2 binary_op2);

Parameters :

first1, last1, first2, init are same as above.

binary_op1
Binary operation taking two elements of type T as arguments, and
returning the result of an accumulation operation.
This can either be a function pointer or a function object.

binary_op2
Binary operation taking two elements of type T as arguments, and
returning the result of the inner product operation.
This can either be a function pointer or a function object.

Neither operations shall modify any of the elements passed as
its arguments.

Return Type :
The result of accumulating init and the products of all the pairs
of elements in the ranges starting at first1 and first2.
filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to illustrate
// std :: inner_product
#include <iostream> // std::cout
#include <functional> // std::minus, std::divides
#include <numeric> // std::inner_product
  
// Custom funcitons
int myaccumulator(int x, int y)
{
    return x - y;
}
int myproduct(int x, int y)
{
    return x + y;
}
  
// Driver code
int main()
{
    // The value which is added after
    // finding inner_product b/w elements
    int init = 100;
    int series1[] = { 10, 20, 30 };
    int series2[] = { 1, 2, 3 };
    int n = sizeof(series1) / sizeof(series1[0]);
  
    // Elements in series1
    std::cout << "First array contains :";
    for (int i = 0; i < n; i++)
        std::cout << " " << series1[i];
    std::cout << "\n";
  
    // Elements in series2
    std::cout << "Second array contains :";
    for (int i = 0; i < n; i++)
        std::cout << " " << series2[i];
    std::cout << "\n\n";
  
    std::cout << "Using custom functions: ";
    std::cout << std::inner_product(series1, series1 + 3, series2, init,
                                    myaccumulator, myproduct);
    std::cout << '\n';
  
    return 0;
}

chevron_right


Output:

First array contains : 10 20 30
Second array contains : 1 2 3

Using custom functions: 34

NOTE :
By using functional value and custom function, we can perform operation by changing the operator ( or using different functional value) in this STL function.

Possible Application : It returns the result of accumulating init with the inner products of the pair formed by the elements of two ranges starting at first1 and first2.

1. It can be used to find sum of products of i th index of both arrays.
For Example:
Array 1 : 1 2 3 4
Array 2 : 10 20 30 40

Sum of products : 300

Explanation : 1 * 10 + 2 * 20 + 3 * 30 + 4 * 40 = 300

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to illustrate
// std :: inner_product
#include <iostream> // std::cout
#include <functional> // std::minus, std::divides
#include <numeric> // std::inner_product
  
// Custom funcitons
int myaccumulator(int x, int y)
{
    return x + y;
}
int myproduct(int x, int y)
{
    return x * y;
}
  
// Driver code
int main()
{
    // The value which is added after
    // finding inner_product b/w elements
    int init = 0;
    int series1[] = { 1, 2, 3, 4 };
    int series2[] = { 10, 20, 30, 40 };
    int n = sizeof(series1) / sizeof(series1[0]);
  
    // Elements in series1
    std::cout << "Array 1 :";
    for (int i = 0; i < n; i++)
        std::cout << " " << series1[i];
    std::cout << "\n";
  
    // Elements in series2
    std::cout << "Array 2 :";
    for (int i = 0; i < n; i++)
        std::cout << " " << series2[i];
    std::cout << "\n\n";
  
    std::cout << "Sum of products : ";
    std::cout << std::inner_product(series1, series1 + n, series2, init,
                                    myaccumulator, myproduct);
    std::cout << '\n';
  
    return 0;
}

chevron_right


OUTPUT :

Array 1 : 1 2 3 4
Array 2 : 10 20 30 40

Sum of products : 300

We can also find the difference of products, or sum of division, or difference of division and more all by changing the operator.

This article is contributed by Sachin Bisht. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.




My Personal Notes arrow_drop_up
Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.