How to access a vector inside a vector?

Question

So I have a vector of vectors type double. I basically need to be able to set 360 numbers to cosY, and then put those 360 numbers into cosineY[0], then get another 360 numbers that are calculated with a different a now, and put them into cosineY[1].Technically my vector is going to be cosineYa I then need to be able to take out just cosY for a that I specify...

My code is saying this:

for (int a = 0; a < 8; a++)
{
   for int n=0; n <= 360; n++
   {
      cosY[n] = cos(a*vectorOfY[n]);
   }
   cosineY.push_back(cosY);
 }

which I hope is the correct way of actually setting it.

But then I need to take cosY for a that I specify, and calculate another another 360 vector, which will be stored in another vector again as a vector of vectors.

Right now I've got:

for (int a = 0; a < 8; a++
{
    for (int n = 0; n <= 360; n++)
    {
       cosProductPt[n] = (VectorOfY[n]*cosY[n]);
    }
    CosProductY.push_back(cosProductPt);
 }

The VectorOfY is besically the amplitude of an input wave. What I am doing is trying to create a cosine wave with different frequencies (a). I am then calculation the product of the input and cosine wave at each frequency. I need to be able to access these 360 points for each frequency later on in the program, and right now also I need to calculate the addition of all elements in cosProductPt, for every frequency (stored in cosProductY), and store it in a vector dotProductCos[a].

I've been trying to work it out but I don't know how to access all the elements in a vector of vectors to add them. I've been trying to do this for the whole day without any results. Right now I know so little that I don't even know how I would display or access a vector inside a vector, but I need to use that access point for the addition.

Thank you for your help.

Answer 1

for (int a = 0; a < 8; a++)
{
   for int n=0; n < 360; n++) // note traded in <= for <. I think you had an off by one 
                              // error here.
   {
      cosY[n] = cos(a*vectorOfY[n]);
   }
   cosineY.push_back(cosY);
 }

Is sound so long as cosY has been pre-allocated to contain at least 360 elements. You could

std::vector<std::vector<double>> cosineY;
std::vector<double> cosY(360); // strongly consider replacing the 360 with a well-named 
                               // constant
for (int a = 0; a < 8; a++) // same with that 8
{
   for int n=0; n < 360; n++)
   {
      cosY[n] = cos(a*vectorOfY[n]);
   }
   cosineY.push_back(cosY);
 }

for example, but this hangs on to cosY longer than you need to and could cause problems later, so I'd probably scope cosY by throwing the above code into a function.

std::vector<std::vector<double>> buildStageOne(std::vector<double> &vectorOfY)
{
    std::vector<std::vector<double>> cosineY;
    std::vector<double> cosY(NumDegrees);
    for (int a = 0; a < NumVectors; a++)
    {
       for int n=0; n < NumDegrees; n++)
       {
          cosY[n] = cos(a*vectorOfY[n]); // take radians into account if needed.
       }
       cosineY.push_back(cosY);
     }
    return cosineY;
}

This looks horrible, returning the vector by value, but the vast majority of compilers will take advantage of Copy Elision or some other sneaky optimization to eliminate the copying.

Then I'd do almost the exact same thing for the second step.

std::vector<std::vector<double>> buildStageTwo(std::vector<double> &vectorOfY,
                                               std::vector<std::vector<double>> &cosineY)
{
    std::vector<std::vector<double>> CosProductY;
    for (int a = 0; a < numVectors; a++)
    {
        for (int n = 0; n < NumDegrees; n++)
        {
           cosProductPt[n] = (VectorOfY[n]*cosineY[a][n]);
        }
        CosProductY.push_back(cosProductPt);
     }
    return CosProductY;
}

But we can make a couple optimizations

std::vector<std::vector<double>> buildStageTwo(std::vector<double> &vectorOfY,
                                               std::vector<std::vector<double>> &cosineY)
{
    std::vector<std::vector<double>> CosProductY;
    for (int a = 0; a < numVectors; a++)
    {
        // why risk constantly looking up cosineY[a]? grab it once and cache it
        std::vector<double> & cosY = cosineY[a]; // note the reference
        for (int n = 0; n < numDegrees; n++)
        {
           cosProductPt[n] = (VectorOfY[n]*cosY[n]);
        }
        CosProductY.push_back(cosProductPt);
     }
    return CosProductY;
}

And the next is kind of an extension of the first:

std::vector<std::vector<double>> buildStageTwo(std::vector<double> &vectorOfY,
                                               std::vector<std::vector<double>> &cosineY)
{
    std::vector<std::vector<double>> CosProductY;
    std::vector<double> cosProductPt(360);

    for (std::vector<double> & cosY: cosineY) // range based for. Gets rid of 
    {
        for (int n = 0; n < NumDegrees; n++)
        {
           cosProductPt[n] = (VectorOfY[n]*cosY[n]);
        }
        CosProductY.push_back(cosProductPt);
     }
    return CosProductY;
}

We could do the same range-based for trick for the for (int n = 0; n < NumDegrees; n++), but since we are iterating multiple arrays here it's not all that helpful.