std::max_element real value complex sequence

[ma740988]

Trying to determine how to get the max element from a complex sequence.
Given:

int main()
{

//typedef std::complex < double > C
typedef std::vector < std::complex < double > > complex_vec;
typedef complex_vec::const_iterator cvect_it;
complex_vec x_vec;

x_vec.push_back ( std::complex < double > ( 1., 2. ) );
x_vec.push_back ( std::complex < double > ( 3., 4. ) );
x_vec.push_back ( std::complex < double > ( 0, 0 ) );
x_vec.push_back ( std::complex < double > ( 4., 8. ) );
x_vec.push_back ( std::complex < double > ( 0, 0 ) );

cvect_it beg = x_vec.begin();
cvect_it end = x_vec.end();

// cvect_it iter = std::max_element ( beg, end ); // wont work
obviously ..
// std::cout << *iter << std::endl;

}

I'm perusing both forms of max_element here and I'm in a quandry how to
do this. My current solution involves copying the real values to
another vector then utilizing max_element to determine the max but I
suspect a more viable solution exists. Ideas?

Thanks in advance

 

[Victor Bazarov]

Trying to determine how to get the max element from a complex
sequence.
[..noting of importance..]

I'm perusing both forms of max_element here and I'm in a quandry how
to do this. My current solution involves copying the real values to
another vector then utilizing max_element to determine the max but I
suspect a more viable solution exists. Ideas?

How do you define "max element" for a sequence of complex numbers?
IOW, how do compare two complex numbers and tell which one is "greater"?

V

 

[ma740988]

How do you define "max element" for a sequence of complex numbers?
IOW, how do compare two complex numbers and tell which one is "greater"?

I tend to think too hard when it comes to predicates. The solution is
real simple..

bool real_part ( const std::complex<double> & lhs ,
const std::complex<double> & rhs)
{
return lhs.real() < rhs.real();
}
cvect_it iter = std::max_element ( beg, end , real_part );
Found what I was looking for thanks.

 

[mlimber]

I tend to think too hard when it comes to predicates. The solution is
real simple..

bool real_part ( const std::complex<double> & lhs ,
const std::complex<double> & rhs)
{
return lhs.real() < rhs.real();
}
cvect_it iter = std::max_element ( beg, end , real_part );
Found what I was looking for thanks.

That may be fine for your application, but be aware, as Victor implied,
such a test is not general. Someone else might want to compare the
imaginary parts or their magnitudes or angles. Any could be valid
depending on the application.

Cheers! --M

 

[Victor Bazarov]

[..]
bool real_part ( const std::complex<double> & lhs ,
const std::complex<double> & rhs)
{
return lhs.real() < rhs.real();
}

A nit: naming. I'd probably call this function 'real_less', to
express the fact that it uses the less-than (<) operator. The
name you used does not explain what the nature of the comparison
is. Variation: 'real_ascending'.

V

 

[ma740988]

mlimber wrote:

|| Any could be valid depending on the application.

Indeed and - for what I'm doing - computing the Power Spectrial Density
( PSD ) of a sequence 'x' using a periodgram, the imaginaries for the
the corresponding vector of frequences is irrelevant