Copy vector [need advice]

Hi all,

Is there a better way of copying the lines of 4 two dimension vectors?

The idea is to copy the contents of line X from v1 to v2, v2 to v3, v3 to v4 and v4 to v1.

I'm using to two aux variables and then calling std::copy, something like below:

Code:

std::vector v1 (3,std::vector<int> >(3,1));
std::vector v2 (3,std::vector<int> >(3,2));
... and so on

std::vector<int> aux0;
std::vector<int> aux1;
aux0 = v2[0];
std::copy(v1[0].begin(),v1[0].end(),v2[0].begin());
aux1 = v3[0];
std::copy(aux0.begin(),aux0.end(),v3[0].begin());
aux0 = v4[0];
std::copy(aux1.begin(),aux1.end(),v4[0].begin());
std::copy(aux0.begin(),aux0.end(),v1[0].begin());

Thanks in advance!

Copy the contents of v4 to aux0. Now, copy v3 to v4, then v2 to v3, then v1 to v2, then aux0 to v1.

Ooh. How didn't I think of that. Maybe its time for a break. Thank you laserlight.

Or perhaps use swap? Swap v1 and v2, v1 and v3, v1 and v4. Now v1 has the contents of v4, v2 has the contents of v1, v3 of v2 and v4 of v3.

Originally Posted by anon

Or perhaps use swap? Swap v1 and v2, v1 and v3, v1 and v4. Now v1 has the contents of v4, v2 has the contents of v1, v3 of v2 and v4 of v3.

I'm thinking that's fewer lines of code that you have to write, but more actual work the machine has to do (six copies instead of five). OTOH I have no idea how time-critical the code actually is.

hmm... on the other hand, member swap is likely to swap the internal pointers, which would result in quite a gain in efficiency.

I'm thinking that's fewer lines of code that you have to write, but more actual work the machine has to do (six copies instead of five). OTOH I have no idea how time-critical the code actually is.

That would both be fewer lines, and much less work, regardless of whether you use the member function or the overload of global swap. swap

Come to think about it though: why do you have four separate objects named v1, v2, v3 and v4? It seems like you should have say, a std::vector<int>[4], or std::tr1::array<std::vector<int>, 4>. If so, you could use std::rotate, though it would result in full copies rather than a rotation of internal pointers. (On the other hand, you could store a separate array of pointers to the first elements of these vectors, and rotate that instead.)

EDIT:
Interestingly, the standard mentions number of swaps when talking about the complexity of std::rotate, but number of assignments when talking about the complexity of std::rotate_copy.

Hadn't thought about member swap. Using the code:

Code:

int main(void) {

    std::vector<std::vector<int> > v1(3);
    std::vector<std::vector<int> > v2(3);
    std::vector<std::vector<int> > v3(3);
    std::vector<std::vector<int> > v4(3);

    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 10000000; ++j) {
            v1[i].push_back(rand());
            v2[i].push_back(rand());
            v3[i].push_back(rand());
            v4[i].push_back(rand());
        }
    }

    //We'll move the middle row
    std::vector<int> aux = v4[1];
    v4[1] = v3[1];
    v3[1] = v2[1];
    v2[1] = v1[1];
    v1[1] = aux;

    /*std::swap(v1[1], v2[1]);
    std::swap(v1[1], v3[1]);
    std::swap(v1[1], v4[1]);*/

    /*v1[1].swap(v2[1]);
    v1[1].swap(v3[1]);
    v1[1].swap(v4[1]);*/

    std::cout << "Just to make sure: " << v3[1][50] << " " << v2[1][85] << std::endl;
    return 0;
}

as the tests give rough timing of
Option 1 11.438 s
Option 2 11.343 s
Option 3 11.344 s
(using the time printed by Code::Blocks auto-run thing). So at least on this time trial, the swaps were better (albeit by 0.8%).

Originally Posted by tabstop

Hadn't thought about member swap. Using the code:

Code:

int main(void) {

    std::vector<std::vector<int> > v1(3);
    std::vector<std::vector<int> > v2(3);
    std::vector<std::vector<int> > v3(3);
    std::vector<std::vector<int> > v4(3);

    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 10000000; ++j) {
            v1[i].push_back(rand());
            v2[i].push_back(rand());
            v3[i].push_back(rand());
            v4[i].push_back(rand());
        }
    }

    //We'll move the middle row
    std::vector<int> aux = v4[1];
    v4[1] = v3[1];
    v3[1] = v2[1];
    v2[1] = v1[1];
    v1[1] = aux;

    /*std::swap(v1[1], v2[1]);
    std::swap(v1[1], v3[1]);
    std::swap(v1[1], v4[1]);*/

    /*v1[1].swap(v2[1]);
    v1[1].swap(v3[1]);
    v1[1].swap(v4[1]);*/

    std::cout << "Just to make sure: " << v3[1][50] << " " << v2[1][85] << std::endl;
    return 0;
}

as the tests give rough timing of
Option 1 11.438 s
Option 2 11.343 s
Option 3 11.344 s
(using the time printed by Code::Blocks auto-run thing). So at least on this time trial, the swaps were better (albeit by 0.8%).

Then you must be timing the execution time of the whole program, including all the reallocations happening inside of push_back, and IO synchronisation inside cout. Besides, that code surely can't be what you timed because you're only using the middle vector of the three each time.

The actual difference between the three swaps vs the five large vector copies, should be on the order of swap easily being 10000+ times faster here. A vector swap literally only swaps a few pointers around (three in practically all cases) and that's it.

If I remember correctly, Effective STL says that assign should be used for vector copying. It also discourages manually copying the vector in a for loop.

Member functions in the STL should be used whenever possible (if they are available) as they are fine tuned for that particular container.

Originally Posted by iMalc

Then you must be timing the execution time of the whole program, including all the reallocations happening inside of push_back, and IO synchronisation inside cout.

Well spotted. OTOH I thought that was the point.... (how much difference does changing the mechanism of moving things around in the program as a whole)

Originally Posted by iMalc

Besides, that code surely can't be what you timed because you're only using the middle vector of the three each time.

Well, duh. That's what the question is: "I have a 2-d vector of vectors and I want to move line X from each vector around in a cyclic sort of way." So that's what I did. (I mean I picked the value of 1 for X, but I can't see that making a huge timing difference.)

My minor confusion there due to the fact that you had presented timings to three cases and there were three vectors in each vector.