// tsncom35.cc
// Nick Macks (macks@fnal.gov), Summer 2002

// CovMatrices: VectorX*VectorX multiplication
//              vector form like in ColumnVector*RowVector

#include <vector>
#include "CovMatrices/Vector2.h"
#include "CovMatrices/Vector3.h"
#include "CovMatrices/Vector4.h"
#include "CovMatrices/Vector5.h"
#include "CovMatrices/Vector6.h"
#include "CovMatrices/CovMatrix.h"
#include "CovMatrices/CovMatrix2.h"
#include "CovMatrices/CovMatrix3.h"
#include "CovMatrices/CovMatrix4.h"
#include "CovMatrices/CovMatrix5.h"
#include "CovMatrices/CovMatrix6.h"

using namespace std;

using CovMatrices::Vector2;
using CovMatrices::Vector3;
using CovMatrices::Vector4;
using CovMatrices::Vector5;
using CovMatrices::Vector6;
using CovMatrices::CovMatrix;
using CovMatrices::CovMatrix2;
using CovMatrices::CovMatrix3;
using CovMatrices::CovMatrix4;
using CovMatrices::CovMatrix5;
using CovMatrices::CovMatrix6;

// Function declarations
void Identification();
void GetDimension(int&);
void Describe(const int&);
void BuildVector(vector<double>&);
void BuildVector2(Vector2&);
void BuildVector3(Vector3&);
void BuildVector4(Vector4&);
void BuildVector5(Vector5&);
void BuildVector6(Vector6&);
void Show(const vector<double>&, const vector<double>&);
void Show2(const Vector2&, const Vector2&);
void Show3(const Vector3&, const Vector3&);
void Show4(const Vector4&, const Vector4&);
void Show5(const Vector5&, const Vector5&);
void Show6(const Vector6&, const Vector6&);
void GetCalcs(int&);
void GetRuns(int&);
void Calculate(vector<double>&, vector<double>&, const int&, const int&);
void Calculate2(Vector2&, Vector2&, const int&, const int&);
void Calculate3(Vector3&, Vector3&, const int&, const int&);
void Calculate4(Vector4&, Vector4&, const int&, const int&);
void Calculate5(Vector5&, Vector5&, const int&, const int&);
void Calculate6(Vector6&, Vector6&, const int&, const int&);


// Package ID
void Identification()
{
  cout << "Using CovMatrices\n";
}

// Ask for the desired dimension
void GetDimension(int& dimension)
{
  cout << "Enter the desired dimension(1-6): ";
  cin >> dimension;

  while ( (dimension < 1) || (dimension > 6) )
  {
    cout << "Enter an integer between 1 and 6: ";
    cin >> dimension;
  }
}

// Describe how the vectors were defined
void Describe(const int& dimension)
{
  if (dimension == 1)
    cout << "Vectors were defined 'vector<double>'\n";
  else
    cout << "Vectors were defined 'Vector" << dimension << "'\n";
}

// Build a 1-dimensional Vector
void BuildVector(vector<double>& vector)
{
  vector.push_back(2);
}

// Build a 2-dimensional Vector
void BuildVector2(Vector2& vector2)
{
  for (int i=0; i<2; ++i)
  {
    vector2[i] = 2 + 2*i;
  }
}

// Build a 3-dimensional Vector
void BuildVector3(Vector3& vector3)
{
  for (int i=0; i<3; ++i)
  {
    vector3[i] = 2 + 2*i;
  }
}

// Build a 4-dimensional Vector
void BuildVector4(Vector4& vector4)
{
  for (int i=0; i<4; ++i)
  {
    vector4[i] = 2 + 2*i;
  }
}

// Build a 5-dimensional Vector
void BuildVector5(Vector5& vector5)
{
  for (int i=0; i<5; ++i)
  {
    vector5[i] = 2 + 2*i;
  }
}

// Build a 6-dimensional Vector
void BuildVector6(Vector6& vector6)
{
  for (int i=0; i<6; ++i)
  {
    vector6[i] = 2 + 2*i;
  }
}

// Show the 1-dimensional vectors
void Show(const vector<double>& vector1, const vector<double>& vector2)
{
  cout << "Using vector =\n" << vector1[0] << "\n";
  cout << "Using vector =\n" << vector2[0] << "\n";
}

// Show the 2-dimensional vectors
void Show2(const Vector2& vector1, const Vector2& vector2)
{
  cout << "Using vector =\n" << vector1 << "\n";
  cout << "Using vector =\n" << vector2 << "\n";
}

// Show the 3-dimensional vectors
void Show3(const Vector3& vector1, const Vector3& vector2)
{
  cout << "Using vector =\n" << vector1 << "\n";
  cout << "Using vector =\n" << vector2 << "\n";
}

// Show the 4-dimensional vectors
void Show4(const Vector4& vector1, const Vector4& vector2)
{
  cout << "Using vector =\n" << vector1 << "\n";
  cout << "Using vector =\n" << vector2 << "\n";
}

// Show the 5-dimensional vectors
void Show5(const Vector5& vector1, const Vector5& vector2)
{
  cout << "Using vector =\n" << vector1 << "\n";
  cout << "Using vector =\n" << vector2 << "\n";
}

// Show the 6-dimensional vectors
void Show6(const Vector6& vector1, const Vector6& vector2)
{
  cout << "Using vector =\n" << vector1 << "\n";
  cout << "Using vector =\n" << vector2 << "\n";
}

// Get the number of calculations
void GetCalcs(int& N)
{
  cout << "How many multiplications? ";
  cin >> N;
}

// Get the number of runs
void GetRuns(int& run)
{
  cout << "How many runs? ";
  cin >> run;
  cout << "\n";
}

// Multiply the 1-dimensional vectors
void Calculate(vector<double>& vector1, vector<double>& vector2,
               const int& N, const int& runs)
{
  // Define a counter
  int counter = 0;

  // Define a vector of doubles (to initialize the CovMatrix later)
  vector<double> init;
  //  and assign a 0 to its first element
  init.push_back(0.);

  // Define a CovMatrix to hold the product
  // and use the vector to initialize it
  CovMatrix product(init);

  // Loop "run" times
  for (int r=0; r<runs; ++r)
  {
    // Do the multiplications (dot product)
    for (int n=0; n<N; ++n)
    {
      for (int i=0; i<1; ++i)
      {
        for (int j=0; j<1; ++j)
	{
	  // We don't use '=' but '+=' so we have to
	  // initialize the product to zeros
          product(i,j) += vector1[i] * vector2[j];
	}
      }
    ++counter;
    }

    // Write the output
    cout << counter << " multiplications took place\n";
    cout << "Product =\n" << product << "\n";

    // Reset the counter
    counter = 0;
  }
}

// Multiply the 2-dimensional vectors
void Calculate2(Vector2& vector1, Vector2& vector2,
                const int& N, const int& runs)
{
  // Define a counter
  int counter2 = 0;

  // Define a CovMatrix to hold the result and initialize it to zeros
  CovMatrix2 product2(0., 0., 0.);

  // Loop "run" times
  for (int r=0; r<runs; ++r)
  {
    // Do the multiplications (dot product)
    for (int n=0; n<N; ++n)
    {
      for (int i=0; i<2; ++i)
      {
        for (int j=0; j<2; ++j)
	{
	  // We don't use '=' but '+=' so we have to
	  // initialize the product to zeros
          product2(i,j) += vector1[i] * vector2[j];
	}
      }
    ++counter2;
    }

    // Write the output
    cout << counter2 << " multiplications took place\n";
    cout << "Product =\n" << product2 << "\n";

    // Reset the counter
    counter2 = 0;
  }
}
 
// Multiply the 3-dimensional vectors
void Calculate3(Vector3& vector1, Vector3& vector2,
                const int& N, const int& runs)
{
  // Define a counter
  int counter3 = 0;

  // Define a CovMatrix to hold the result and initialize it to zeros
  CovMatrix3 product3(0., 0., 0., 0., 0., 0.);

  // Loop "run" times
  for (int r=0; r<runs; ++r)
  {
    // Do the multiplications (dot product)
    for (int n=0; n<N; ++n)
    {
      for (int i=0; i<3; ++i)
      {
        for (int j=0; j<3; ++j)
	{
	  // We don't use '=' but '+=' so we have to
	  // initialize the product to zeros
          product3(i,j) += vector1[i] * vector2[j];
	}
      }
    ++counter3;
    }

    // Write the output  
    cout << counter3 << " multiplications took place\n";
    cout << "Product =\n" << product3 << "\n";

    // Reset the counter
    counter3 = 0;
  }
}

// Multiply the 4-dimensional vectors
void Calculate4(Vector4& vector1, Vector4& vector2,
                const int& N, const int& runs)
{
  // Define a counter
  int counter4 = 0;

  // Define a CovMatrix to hold the result and initialize it to zeros
  CovMatrix4 product4(0., 0., 0., 0., 0., 0., 0., 0., 0., 0);

  // Loop "run" times
  for (int r=0; r<runs; ++r)
  {
    // Do the multiplications (dot product)
    for (int n=0; n<N; ++n)
    {
      for (int i=0; i<4; ++i)
      {
        for (int j=0; j<4; ++j)
	{
	  // We don't use '=' but '+=' so we have to
	  // initialize the product to zeros
          product4(i,j) += vector1[i] * vector2[j];
	}
      }
    ++counter4;
    }

    // Write the output
    cout << counter4 << " multiplications took place\n";
    cout << "Product =\n" << product4 << "\n";

    // Reset the counter
    counter4 = 0;
  }
}

// Multiply the 5-dimensional vectors
void Calculate5(Vector5& vector1, Vector5& vector2,
                const int& N, const int& runs)
{
  // Define a counter
  int counter5 = 0;
  
  // Define a CovMatrix to hold the result and initialize it to zeros
  CovMatrix5 product5(0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
                      0., 0., 0.);

  // Loop "run" times
  for (int r=0; r<runs; ++r)
  {
    // Do the multiplications (dot product)
    for (int n=0; n<N; ++n)
    {
      for (int i=0; i<5; ++i)
      {
        for (int j=0; j<5; ++j)
        {
	  // We don't use '=' but '+=' so we have to
	  // initialize the product to zeros
          product5(i,j) += vector1[i] * vector2[j];
	}
      }
    ++counter5;
    }

    // Write the output
    cout << counter5 << " multiplications took place\n";
    cout << "Product =\n" << product5 << "\n";

    // Reset the counter
    counter5 = 0;
  }
}

// Multiply the 6-dimensional vectors
void Calculate6(Vector6& vector1, Vector6& vector2,
                const int& N, const int& runs)
{
  // Define a counter
  int counter6 = 0;

  // Define a CovMatrix to hold the result and initialize it to zeros
  CovMatrix6 product6(0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
                      0., 0., 0., 0., 0., 0., 0., 0., 0.);

  // Loop "run" times
  for (int r=0; r<runs; ++r)
  {
    // Do the multiplications (dot product)
    for (int n=0; n<N; ++n)
    {
      for (int i=0; i<6; ++i)
      {
        for (int j=0; j<6; ++j)
	{
	  // We don't use '=' but '+=' so we have to
	  // initialize the product to zeros
          product6(i,j) += vector1[i] * vector2[j];
	}
      }
    ++counter6;
    }

    // Write the output
    cout << counter6 << " multiplications took place\n";
    cout << "Product =\n" << product6 << "\n";

    // Reset the counter
    counter6 = 0;
  }
}


int main()
{
  // What package are we using?
  Identification();

  // Get the dim(-ension)
  int dim = 0; GetDimension(dim);

  // Define the Vectors
  vector<double> v11, v12;
  Vector2 v21, v22;
  Vector3 v31, v32;
  Vector4 v41, v42;
  Vector5 v51, v52;
  Vector6 v61, v62;

  // Describe how the vectors were defined
  Describe (dim);

  // Build the vectors
  switch(dim)
  {
    case 1:
      BuildVector(v11);
      BuildVector(v12);
      break;
    case 2:
      BuildVector2(v21);
      BuildVector2(v22);
      break;
    case 3:
      BuildVector3(v31);
      BuildVector3(v32);
      break;
    case 4:
      BuildVector4(v41);
      BuildVector4(v42);
      break;
    case 5:
      BuildVector5(v51);
      BuildVector5(v52);
      break;
    case 6:
      BuildVector6(v61);
      BuildVector6(v62);
      break;
  }

  // Show the actual vectors
  switch(dim)
  {
    case 1:
      Show(v11, v12);
      break;
    case 2:
      Show2(v21, v22);
      break;
    case 3:
      Show3(v31, v32);
      break;
    case 4:
      Show4(v41, v42);
      break;
    case 5:
      Show5(v51, v52);
      break;
    case 6:
      Show6(v61, v62);
      break;
  }

  // Calculation parameters
  int calc = 0; GetCalcs(calc); // times to perform the calculation
  int run = 0;  GetRuns(run);   // number of runs

  // Do the multiplications
  switch(dim)
  {
    case 1:
      Calculate(v11, v12, calc, run);
      break;
    case 2:
      Calculate2(v21, v22, calc, run);
      break;
    case 3:
      Calculate3(v31, v32, calc, run);
      break;
    case 4:
      Calculate4(v41, v42, calc, run);
      break;
    case 5:
      Calculate5(v51, v52, calc, run);
      break;
    case 6:
      Calculate6(v61, v62, calc, run);
      break;
  }

  return 0;
}