C++: how to sort a complex matrix based on real parts of a complex vector

Question

I have a complex vector (VSII_Complex containing Eigen values) and a complex matrix (CUII_Complex containing Eigen vectors). Each element of VSII_Complex is corresponding to a column of CUII_Complex. My problem is that I want to sort the Eigen values inside VSII_Complex based on their real part (NOT imaginary part) and I will have to sort the columns of CUII_Complex according to the sorted VSII_Complex. The following code is developed by my friend but I feel like something is wrong with this code but I cannot figure it out. I wonder if anybody can tell what is wrong if any.

EIG eigA=EIG(m_IIStiffnessAct,m_IIMassAct,true);
    ComplexColumnVector VSII_Complex=eigA.eigenvalues();
    ComplexMatrix CUII_Complex=eigA.eigenvectors();
///// make eigenvalues in decreasing order, so do eigenvectors
    for (long ii = 0; ii < VSII_Complex.rows(); ii++)
    {
        for (long jj = ii+1; jj < VSII_Complex.rows(); jj++)
        {
          if (VSII_Complex(ii).real() < VSII_Complex(jj).real())
          {
              Complex temp = VSII_Complex(ii);
              VSII_Complex(ii) = VSII_Complex(jj);
              VSII_Complex(jj) = temp;             
              for (long kk = 0; kk < CUII_Complex.rows(); kk++)
              {
                  Complex tempVec =  CUII_Complex(kk,ii);
                  CUII_Complex(kk,ii) = CUII_Complex(kk,jj);
                  CUII_Complex(kk,jj) = tempVec;
              }
          }
        }
    }

PeterT · Accepted Answer · 2014-11-03T19:35:19.997

Just use the build-in sort that returns the position that the element was in previously.

//couldn't find this in the docs, I'm overlooking something probably:
void swapColumns (ComplexMatrix &mat, octave_idx_type colA, octave_idx_type colB)
{
    if(colA == colB) return;
    ComplexColumnVector temp = mat.column(colA);
    mat.insert(mat.column(colB),0,colA);
    mat.insert(temp,0,colB);
}


bool isRealGreater(const Complex& a, const Complex& b)
{
    return a.real() > b.real();
}

//presumably in another function
//int func() {
    EIG eigA=EIG(m_IIStiffnessAct,m_IIMassAct,true);

    ComplexColumnVector VSII_Complex=eigA.eigenvalues();
    ComplexMatrix CUII_Complex=eigA.eigenvectors();
///// make eigenvalues in decreasing order, so do eigenvectors

    //create indices from 1-len(VSII_Complex)
    Array<octave_idx_type> sort_order(VSII_Complex.length(),0);
    for(int i =0 ; i< sort_order.length(); i++)
    {sort_order.elem(i)= i;}

    //create sorting object and sort VSII_Complex in descending order of the real component
    octave_sort<Complex> sort_obj(&isRealGreater);
    sort_obj.sort(VSII_Complex.jit_slice_data(), sort_order.jit_slice_data(), VSII_Complex.length());

    //swap the columns of CUII_Complex in the same way VSII_Complex got sorted
    for(octave_idx_type i=0; i<sort_order.length(); i++)
    {
        if(sort_order.elem(i) > i)
        {
            swapColumns(CUII_Complex,i,sort_order.elem(i));
        }
    }

//}

Haven't actually tested this, because I was too lazy to install octave, I just read the docs.

I added a C++ code as a solution to this question in my answer below. But your solution looks better to me. — Megidd, Nov 03 '14 at 18:12

Megidd · Answer 2 · 2014-11-03T18:22:38.693

I solved the problem with the following code, I developed this code based on the algorithm in the following webpage. But the answer of PeterT looks better to me.

http://www.learncpp.com/cpp-tutorial/64-sorting-an-array-using-selection-sort/

///// make eigenvalues in decreasing order, so do eigenvectors
    ComplexColumnVector ComplexColumnVector_toBesSorted=VSII_Complex;
    ComplexMatrix ComplexMatrix_toBeSorted=CUII_Complex;
    for (long idx_start = 0; idx_start < ComplexColumnVector_toBesSorted.rows(); idx_start++)
    {
        long idx_smallest=idx_start;
        for (long idx_current = idx_start+1; idx_current < ComplexColumnVector_toBesSorted.rows(); idx_current++)
        {
          if (ComplexColumnVector_toBesSorted(idx_current).real() < ComplexColumnVector_toBesSorted(idx_smallest).real())
              idx_smallest=idx_current;
        }
        Complex Complex_temp=ComplexColumnVector_toBesSorted(idx_start);
        ComplexColumnVector_toBesSorted(idx_start)=ComplexColumnVector_toBesSorted(idx_smallest);
        ComplexColumnVector_toBesSorted(idx_smallest)=Complex_temp;
        for (long kk = 0; kk < ComplexMatrix_toBeSorted.rows(); kk++)
        {
            Complex Complex_temp_2 =  ComplexMatrix_toBeSorted(kk,idx_start);
            ComplexMatrix_toBeSorted(kk,idx_start) = ComplexMatrix_toBeSorted(kk,idx_smallest);
            ComplexMatrix_toBeSorted(kk,idx_smallest) = Complex_temp_2;
        }
    }

C++: how to sort a complex matrix based on real parts of a complex vector

2 Answers2