how can I get maximum , minimum, and position of the vector complex value in C++?

Question

In Matlab, we can get the max, min, and also the position of the complex vector:

[mag_x idx_x] = max(abs(X));
[mag_y idx_y] = max(abs(Y));

I know that we can do the similar with C++ because Matlab is build from C++. But I could not figure it out. I also have incomplete code, and still working on it:

#include <iostream>     // std::cout
#include <algorithm>    // std::min_element, std::max_element
#include <vector>
#include <complex>
#include <iostream>
int main()
{

//typedef std::complex < double > C
vector <complex<short> > vec;

vec.push_back ( complex <short> (1,1));
vec.push_back ( complex <short> (1,2));
vec.push_back ( complex <short> (3,4));
vec.push_back ( complex <short> (0,0));
vec.push_back ( complex <short> (4,8));
vec.push_back ( complex <short> (0,0));
vec.push_back ( complex <short> (2,3));
vec.push_back ( complex <short> (1,1));

int size = sizeof(x_vec)/sizeof(x_vec[0]);
for(int i =0; i < size; i++)
{
    cout << x_vec[i] << endl;
}
 ...

return 0;
}

I also look at the sample code from this link: http://www.cplusplus.com/reference/algorithm/max_element/ but it work only for vector.

Also when I calculate the size = sizeof(x_vec)/sizeof(x_vec[0]); I am expecting size = 8 (because of 8 vector complex above) but I gave me only size = 6.

Answer 1

To use vector<complex> with std::max_element, you need to provide a function which compares the values of two complex objects. You need to do this as there's multiple ways to compare them.

One way is to write a lambda function which compares two complexes using std::abs. You can write this in your call to max_element:

// C++14
auto maxelem = max_element(vec.begin(), vec.end(),
                           [](auto a, auto b) { return abs(a) < abs(b); });
// C++11
auto maxelem = max_element(vec.begin(), vec.end(),
                           [](const complex<short>& a, const complex<short>& b)
                             { return abs(a) < abs(b); });

cout << "Max: " << *maxelem << endl;

max_element produces an iterator containing the maximum value found. The index of that iterator in the vector can be found using std::distance:

cout << "Max position: " << std::distance(vec.begin(), maxelem) << endl;

The complex comparator function can be stored in an auto for reuse:

// C++14
auto absLess = [](auto a, auto b) { return abs(a) < abs(b); };
// C++11
auto csAbsLess = [](const complex<short> &a,
                    const complex<short> &b) { return abs(a) < abs(b); };

We can use it with various other Standard Library algorithms like min_element and sort.

auto maxelem = max_element(vec.begin(), vec.end(), absLess);
cout << "Max: " << *maxelem << endl;
cout << "Max position: " << std::distance(vec.begin(), maxelem) << endl;

auto minelem = min_element(vec.begin(), vec.end(), absLess);
cout << "Min: " << *minelem << endl;
cout << "Min position: " << std::distance(vec.begin(), minelem) << endl;

sort(vec.begin(), vec.end(), absLess);

for (const auto &c : vec) {
  cout << c << endl;
}

Outputs:

Max: (4,8)
Max position: 4
Min: (0,0)
Min position: 3
(0,0)
(0,0)
(1,1)
(1,1)
(1,2)
(2,3)
(3,4)
(4,8)

Granted, it's not as eloquent as [mag_x idx_x] = max(abs(X));!

An online demonstration is on Wandbox here.