algorithm needed

That is because it zig_zags in the opposite direction. So you
need to plug-in the transpose

PHP Code:

---

int  my_transpose_matrix[8][8] = {        { 0,  2,  3,  9, 10,20,21,35},

                                        { 1,  4,  8,  11,19,22,34,36},

                                        { 5,  7,  12, 18,23,33,37,48},

                                        { 6,  13, 17, 24,32,38,47,49},

                                        { 14, 16, 25, 31,39,46,50,57},

                                        { 15, 26, 30, 40,45,51,56,58},

                                        { 27, 29, 41, 44,52,55,59,62},

                                        { 38, 42, 43, 53,54,60,61,63}

                                }; 


---

But as far as speed goes, you are probably better with a look
up table, although you can use this function to generate one for any size of matrix

OOPS. You are right. Give me a second and I will fix it. That is if
you are really going to use it?

I am deeply ashamed of myself :sick: :sick: :blush:

yes i am interested to use the look up table.

thats why, i gave in one of mine previous post two matrix.

my_matrix[8][8]

and

my_index[8][8];


i have given the numbering in my_index[8][8] by looking the zigzag control flow in the my_matrix[8][8].

so my_index[8][8] contains 1,2,3,.....63

i thought this is the look-up table or index table( but i have been opposed by Marc G.)


anyway, if i am correctly defined my my_matrix[][] and my_index[][]

then how can i acesses the elements just by looking index-table[][]???? what is the mapping between them??


ALL i need to do is , i first push the zigzag elements into the buffer and then from the buffer i want to create the matrix again

I don't have time to test now because it's friday. But intutively I think you have to do this in anti-zigzag,

new_matrix[fj(k)][fi(k)] = output_buffer[f(i,j)];

It's just to define f(i,j), fj(k) and fi(k). It's probably easy. I'll give it a shot later.

Well, It turns out the function I used does not zig-zag, but
moves along the diagonals always in the same order.
So I changed the order on odd diagonals (m+n odd)

PHP Code:

---

using namespace std;
int GetIndex(const int m, const int n)
{
//after move past the main diagonal, need to account for 
//missing terms from all of NxN
    int j(7 >= m+n ? 0 : (m+n - 7));
    for(int i = 0; i < (7 >= m+n ? 0 : (m+n - 7)); i++)
        j += 2*i ;
    return ((m+n)*(m+n)+3*m+n)/(2) - j;
}
int main(int argc, char *argv[])
{
int  my_vector[64];//buffer
int  my_matrix[8][8] =           {        { 0,  1,  5,  6,  14, 15, 27, 28 },

                                        { 2,  4,  7,  13, 16, 26, 29, 42},

                                        { 3,  8,  12, 17, 25, 30, 41, 43},

                                        { 9,  11, 18, 24, 31, 40, 44, 53},

                                        { 10, 19, 23, 32, 39, 45, 52, 54},

                                        { 20, 22, 33, 38, 46, 51, 55, 60},

                                        { 21, 34, 37, 47, 50, 56, 59, 61},

                                        { 35, 36, 48, 49, 57, 58, 62, 63}

                                };






for(int m=0;m<8;m++)
for(int n =0;n<8;n++)
{
//change direction on odd diagonals
  my_vector[GetIndex(m,n)] = my_matrix[1 == (m+n)%2 ? m:n][1 == (m+n)%2 ? n:m];
}

for(int m=0;m<64;m++) printf("%d ",my_vector[m]);

 
  system("PAUSE");    
  return 0;
} 


---

and here is a simplified form

PHP Code:

---

for(int m=0;m<8;m++)
for(int n =0;n<8;n++)
{
  my_vector[((m+n)*(m+n)+3*(1 == (m+n)%2 ? m:n)+(1 == (m+n)%2 ? n:m))/(2) - ( (7 >= m+n) ? 0 :( (m+n - 7)*(m+n - 7)))] = my_matrix[m][n];
} 


---

Simplified? You mean shortened...

Quote:

---

Originally posted by CornedBee
Simplified? You mean shortened...

---

No, simplified. A loop which was not needed was removed.

By the way, you just change the inequality to get the matrix back

PHP Code:

---

for(int m=0;m<8;m++)
for(int n =0;n<8;n++)
{
  my_matrix[m][n] = my_vector[((m+n)*(m+n)+3*(1 == (m+n)%2 ? m:n)+(1 == (m+n)%2 ? n:m))/(2) - ( (7 >= m+n) ? 0 :( (m+n - 7)*(m+n - 7)))]; 
} 


---

Quote:

---

Originally posted by _uj
I don't have time to test now because it's friday. But intutively I think you have to do this in anti-zigzag,

new_matrix[fj(k)][fi(k)] = output_buffer[f(i,j)];

It's just to define f(i,j), fj(k) and fi(k). It's probably easy. I'll give it a shot later.

---

Well I've thought about it and this is what I would try first (not tested),

new_matrix[k/8][k%8] = output_buffer[j*8 + i];

This should inverse the doings of the first algoritm.

So it seems we are implementing slightly different versions
of this algorithm _uj. Any way I go to thinking about this problem.
here is an implementation using template metaprogramming to
try and unrole the loops.

PHP Code:

---


template<int I, int n>
class Assign_Matrix_Entry_To_Vector_Entry {

public:
    static inline void assign(const int m, std::vector<double>& dest, const std::vector<std::vector<double> >& src)
    {
         dest[((m+n)*(m+n)+3*(1 == (m+n)%2 ? m:n)+(1 == (m+n)%2 ? n:m))/(2) - ( ((I - 1) >= m+n) ? 0 :( (m+n - (I - 1))*(m+n - (I - 1))))] = src[m][n];
    }
};

template<int I, int J>
class Matrix_To_Zig_Zag_VectorLoop {

private:
    enum { go = (J < I - 1)}; 

public:
    static inline void loop(const int first_index, std::vector<double>& dest, const std::vector<std::vector<double> >& src)
    {
        Assign_Matrix_Entry_To_Vector_Entry<I ,J>::assign(first_index, dest, src);
        Matrix_To_Zig_Zag_VectorLoop<go ? I: -1, go ? (J+1) : -1>::loop(first_index, dest, src);
    }
};


class Matrix_To_Zig_Zag_VectorLoop<-1,-1> {

public:
    static inline void loop(const int first_index, std::vector<double>& dest, const std::vector<std::vector<double> >& src)
    {
       
    }
};

template<int S, int N>
class Matrix_To_Zig_Zag_Vector {
private:
    enum { go = (N > 1)}; 

public:
    static inline void assign(std::vector<double>& dest, const std::vector<std::vector<double> >& src)
    {
        Matrix_To_Zig_Zag_VectorLoop<S,0>::loop(N-1, dest, src);
        Matrix_To_Zig_Zag_Vector<go ? S : -1,go ? N-1: -1>::assign(dest, src);
    }
};

class Matrix_To_Zig_Zag_Vector<-1, -1> {
public:
    static inline void assign(std::vector<double>& dest, const std::vector<std::vector<double> >& src)
    {
        
    }
};


template<int I, int n>
class Assign_Vector_Entry_To_Matrix_Entry {

public:
    static inline void assign(const int m, std::vector<std::vector<double> >& dest, const std::vector<double>& src)
    {
       dest[m][n] = src[((m+n)*(m+n)+3*(1 == (m+n)%2 ? m:n)+(1 == (m+n)%2 ? n:m))/(2) - ( ((I - 1) >= m+n) ? 0 :( (m+n - (I - 1))*(m+n - (I - 1))))];
    }
};

template<int I, int J>
class Zig_Zag_Vector_To_MatrixLoop {

private:
    enum { go = (J < I - 1)}; 

public:
    static inline void loop(const int first_index, std::vector<std::vector<double> >& dest, const std::vector<double>& src)
    {
        Assign_Vector_Entry_To_Matrix_Entry<I ,J>::assign(first_index, dest, src);
        Zig_Zag_Vector_To_MatrixLoop<go ? I: -1, go ? (J+1) : -1>::loop(first_index, dest, src);
    }
};


class Zig_Zag_Vector_To_MatrixLoop<-1,-1> {

public:
    static inline void loop(const int first_index, std::vector<std::vector<double> >& dest, const std::vector<double>& src)
    {
       
    }
};

template<int S, int N>
class Zig_Zag_Vector_To_Matrix {
private:
    enum { go = (N > 1)}; 

public:
    static inline void assign(std::vector<std::vector<double> >& dest, const std::vector<double>& src)
    {
        Zig_Zag_Vector_To_MatrixLoop<S,0>::loop(N-1, dest, src);
        Zig_Zag_Vector_To_Matrix<go ? S : -1,go ? N-1: -1>::assign(dest, src);
    }
};

class Zig_Zag_Vector_To_Matrix<-1, -1> {
public:
    static inline void assign(std::vector<std::vector<double> >& dest, const std::vector<double>& src)
    {
        
    }
};





int main(int argc, char *argv[])
{    
std::vector<std::vector<double> > my_matrix;

double  row1[] ={ 0,  1,  5,  6,  14, 15, 27, 28 };
my_matrix.push_back(std::vector<double>(row1, row1 + sizeof(row1)/sizeof(row1[0])));
double  row2[] = { 2,  4,  7,  13, 16, 26, 29, 42};
my_matrix.push_back(std::vector<double>(row2, row2 + sizeof(row2)/sizeof(row2[0])));
double  row3[8] = { 3,  8,  12, 17, 25, 30, 41, 43};
my_matrix.push_back(std::vector<double>(row3, row3 + sizeof(row3)/sizeof(row3[0])));
double  row4[8] = { 9,  11, 18, 24, 31, 40, 44, 53};
my_matrix.push_back(std::vector<double>(row4, row4 + sizeof(row4)/sizeof(row4[0])));
double  row5[8] = { 10, 19, 23, 32, 39, 45, 52, 54};
my_matrix.push_back(std::vector<double>(row5, row5 + sizeof(row5)/sizeof(row5[0])));
double  row6[8] = { 20, 22, 33, 38, 46, 51, 55, 60};
my_matrix.push_back(std::vector<double>(row6, row6 + sizeof(row6)/sizeof(row6[0])));
double  row7[8] = { 21, 34, 37, 47, 50, 56, 59, 61};
my_matrix.push_back(std::vector<double>(row7, row7 + sizeof(row7)/sizeof(row7[0])));
double  row8[8] = { 35, 36, 48, 49, 57, 58, 62, 63};
my_matrix.push_back(std::vector<double>(row8, row8 + sizeof(row8)/sizeof(row8[0])));

for(int m=0;m<8;m++)
{
for(int n =0;n<8;n++)
{
 printf("%1.0f  ",my_matrix[m][n]);
}
printf("\n");
}                             
std::vector<double> my_vector(64, 0.0);
Matrix_To_Zig_Zag_Vector<8, 8>::assign(my_vector, my_matrix);

/*
for(int m=0;m<8;m++)
for(int n =0;n<8;n++)
{
//change direction on odd diagonals
  my_vector[((m+n)*(m+n)+3*(1 == (m+n)%2 ? m:n)+(1 == (m+n)%2 ? n:m))/(2) - ( (7 >= m+n) ? 0 :( (m+n - 7)*(m+n - 7)))] = my_matrix[m][n];
}
*/
for(int m=0;m<64;m++) printf("%1.0f ",my_vector[m]);
printf("\n\n");
/*
for(int m=0;m<8;m++)
for(int n =0;n<8;n++)
{
//change direction on odd diagonals
  my_matrix[m][n] = my_vector[((m+n)*(m+n)+3*(1 == (m+n)%2 ? m:n)+(1 == (m+n)%2 ? n:m))/(2) - ( (7 >= m+n) ? 0 :( (m+n - 7)*(m+n - 7)))];
}
*/
Zig_Zag_Vector_To_Matrix<8,8>::assign(my_matrix, my_vector);
for(int m=0;m<8;m++)
{
for(int n =0;n<8;n++)
{
 printf("%1.0f  ",my_matrix[m][n]);
}
printf("\n");
}

  system("PAUSE");    
  return 0;
} 


---

Quote:

---

Originally posted by souldog
So it seems we are implementing slightly different versions
of this algorithm _uj.

---

Yes, I know and basically the OP should be able to solve it now but it's quite amusing to give algoritms like this a shot. I've a programmers soul (but no dog :)) and I'm new to C++ so I learn from it.

Does anyone know how I can get a listing file from Dev-C++
I would like to look at assembly

That's beautiful code there, souldog! I'm gonna need some time to look it over...

But if you want to look at the disassembly and still haven't found the way in Dev-C++ (which I don't know either), you could compile it and then take a look at something like dumppe or other dump tools. They usually have a -disasm switch, and you can pipe the output to a text file.

Thanks Galathaea, I would appreciate any pointers. That is my first
attempt at template metaprogramming. It is basically an adaptation
of a buble sort implementation I found.