使用矩阵进行计算时擦除C ++ 2d向量行

Question

I'm trying to simulate the mean behaviour of an ensemble of neurons. This means I need to do calculations with a matrix of a couple of billions of elements ( steps ~10 ^₆ , neurons ~10 ^₄ ).

To avoid eating my whole RAM (and dying trying) I decided to delete rows from the matrix as soon as I'm done doing calculations with it. I don't have too much experience with C++, but my understanding is that v.erase( v.begin()-i+1); should allow me to do so.

// Membrane potential matrix using st::vector
vector<vector<double>> v;
v.resize(steps + 1, vector<double>(neurons));
// Initialise v
for (size_t n = 0; n < neurons; n++) {
    v[0][n] = v0;
}

double v_avg[steps + 1] = {v0};

// Loop
for (size_t i = 1; i < steps + 1; i++) {
    for (size_t n = 0; n < neurons; n++) {
        if(v[i-1][n] >= vp) {
            v[i][n] = -vp;
        }
        else {
            v[i][n] = v[i-1][n] + h * ( pow(v[i-1][n], 2) + I[i] + eta[n] );
        }
        v_avg[i] += v[i][n]; // Sum of membrane potentials
    }
    cout << "step " << i << "/" << steps << " done\n";
    v.erase( v.begin()-i+1); // Erase row v[i-1]
    v_avg[i] = v_avg[i]/neurons; // Mean membrane potential
}
v.erase( v.begin()+steps+1 ); // Erase last row

I'm not sure why I'm getting segmentation fault after the steps /2 step (I'm doing tests with a small steps value):

...    
step 10/20 done
[1]    1791 segmentation fault (core dumped)  ./qif_solve_vect

---

Update:

Thanks to @1201ProgramAlarm I see what's my problem. My question would be:

1. How can I work with the matrix in a way it isn't allocated from the very beginning.
2. How can I deallocate/free rows whilst keeping the indices (unlike v.erase( v.begin()) ). This is essential, as I will later implement different refractory times for each neuron when they produce a spike ( v[i][n] = -vp; ).

Answer 1

In your erase statement, you're subtracting from v.begin() , which will result in an invalid iterator since it will point before the start of the vector. You probably meant v.erase( v.begin() + i - 1); .

However, erasing like this isn't saving you any space since you already have the full matrix allocated. The erase will move all the remaining elements down one element, and your indexing for the next loop will be wrong (since you'd want to use v[0] all the time).