// @(#)root/foam:$Id$
// Author: S. Jadach <mailto:Stanislaw.jadach@ifj.edu.pl>, P.Sawicki <mailto:Pawel.Sawicki@ifj.edu.pl>

//_____________________________________________________________________________
//                                                                            //
// Auxiliary class TFoamVect of n-dimensional vector, with dynamic allocation //
// used for the cartesian geometry of the TFoam  cells                        //
//                                                                            //
//_____________________________________________________________________________

#include "Riostream.h"
#include "TSystem.h"
#include "TFoamVect.h"

/** \class TFoamVect

Auxiliary class TFoamVect of n-dimensional vector, with dynamic allocation
used for the cartesian geometry of the TFoam cells

*/

ClassImp(TFoamVect);

////////////////////////////////////////////////////////////////////////////////
/// Default constructor for streamer

TFoamVect::TFoamVect()
{
   fDim    =0;
   fCoords =0;
}

////////////////////////////////////////////////////////////////////////////////
/// User constructor creating n-dimensional vector
/// and allocating dynamically array of components

TFoamVect::TFoamVect(Int_t n)
{
   Int_t i;
   fDim=n;
   fCoords = 0;
   if (n>0) {
      fCoords = new Double_t[fDim];
      if(gDebug) {
         if(fCoords == 0)
            Error("TFoamVect", "Constructor failed to allocate\n");
      }
      for (i=0; i<n; i++) *(fCoords+i)=0.0;
   }
   if(gDebug) Info("TFoamVect", "USER CONSTRUCTOR TFoamVect(const Int_t)\n ");
}

////////////////////////////////////////////////////////////////////////////////
/// Copy constructor

TFoamVect::TFoamVect(const TFoamVect &Vect): TObject(Vect)
{
   fDim = Vect.fDim; fCoords = 0;
   if(fDim > 0)  fCoords = new Double_t[fDim];

   if(gDebug) {
      if(fCoords == 0) {
         Error("TFoamVect", "Constructor failed to allocate fCoords\n");
      }
   }

   for(Int_t i=0; i<fDim; i++)
      fCoords[i] = Vect.fCoords[i];

}

////////////////////////////////////////////////////////////////////////////////
/// Destructor

TFoamVect::~TFoamVect()
{
   if(gDebug) Info("TFoamVect"," DESTRUCTOR TFoamVect~ \n");
   delete [] fCoords; //  free(fCoords)
   fCoords=0;
}

////////////////////////////////////////////////////////////////////////////////
/// substitution operator

TFoamVect& TFoamVect::operator =(const TFoamVect& Vect)
{
   Int_t i;
   if (&Vect == this) return *this;
   if( Vect.fDim < 0 )
       Error("TFoamVect","operator= : invalid  dimensions : %d and %d \n ",fDim,Vect.fDim);
   if( fDim != Vect.fDim ) {  // cleanup
      delete [] fCoords;
      fCoords = new Double_t[Vect.fDim];
   }
   fDim=Vect.fDim;
   for(i=0; i<fDim; i++)
      fCoords[i] = Vect.fCoords[i];
   if(gDebug)  Info("TFoamVect", "SUBSITUTE operator =\n ");
   return *this;
}

////////////////////////////////////////////////////////////////////////////////
/// [] is for access to elements as in ordinary matrix like a[j]=b[j]
/// (Perhaps against some strict rules but rather practical.)
/// Range protection is built in, consequently for substitution
/// one should use rather use a=b than explicit loop!

Double_t &TFoamVect::operator[](Int_t n)
{
   if ((n<0) || (n>=fDim)) {
      Error( "TFoamVect","operator[], out of range \n");
   }
   return fCoords[n];
}

////////////////////////////////////////////////////////////////////////////////
/// unary multiplication operator *=

TFoamVect& TFoamVect::operator*=(const Double_t &x)
{
   for(Int_t i=0;i<fDim;i++)
      fCoords[i] = fCoords[i]*x;
   return *this;
}

////////////////////////////////////////////////////////////////////////////////
/// unary addition operator +=; adding vector c*=x,

TFoamVect& TFoamVect::operator+=(const TFoamVect& Shift)
{
   if( fDim != Shift.fDim){
      Error( "TFoamVect","operator+, different dimensions= %d %d \n",fDim,Shift.fDim);
   }
   for(Int_t i=0;i<fDim;i++)
      fCoords[i] = fCoords[i]+Shift.fCoords[i];
   return *this;
}

////////////////////////////////////////////////////////////////////////////////
/// unary subtraction operator -=

TFoamVect& TFoamVect::operator-=(const TFoamVect& Shift)
{
   if( fDim != Shift.fDim) {
      Error( "TFoamVect","operator+, different dimensions= %d %d \n",fDim,Shift.fDim);
   }
   for(Int_t i=0;i<fDim;i++)
      fCoords[i] = fCoords[i]-Shift.fCoords[i];
   return *this;
}

////////////////////////////////////////////////////////////////////////////////
/// addition operator +; sum of 2 vectors: c=a+b, a=a+b,
/// NEVER USE IT, VERY SLOW!!!

TFoamVect TFoamVect::operator+(const TFoamVect &p2)
{
   TFoamVect temp(fDim);
   temp  = (*this);
   temp += p2;
   return temp;
}

////////////////////////////////////////////////////////////////////////////////
/// subtraction operator -; difference of 2 vectors; c=a-b, a=a-b,
/// NEVER USE IT, VERY SLOW!!!

TFoamVect TFoamVect::operator-(const TFoamVect &p2)
{
   TFoamVect temp(fDim);
   temp  = (*this);
   temp -= p2;
   return temp;
}

////////////////////////////////////////////////////////////////////////////////
/// Loading in ordinary double prec. vector, sometimes can be useful

TFoamVect& TFoamVect::operator =(Double_t Vect[])
{
   Int_t i;
   for(i=0; i<fDim; i++)
      fCoords[i] = Vect[i];
   return *this;
}

////////////////////////////////////////////////////////////////////////////////
/// Loading in double prec. number, sometimes can be useful

TFoamVect& TFoamVect::operator =(Double_t x)
{
   if(fCoords != 0) {
      for(Int_t i=0; i<fDim; i++)
         fCoords[i] = x;
   }
   return *this;
}

////////////////////////////////////////////////////////////////////////////////
/// Printout of all vector components on "std::cout"

void TFoamVect::Print(Option_t *option) const
{
   if(!option) Error("Print ", "No option set \n");
   Int_t i;
   Int_t pr = std::cout.precision(7);
   std::cout << "(";
   for(i=0; i<fDim-1; i++) std::cout  << std::setw(12) << *(fCoords+i) << ",";
   std::cout  << std::setw(12) << *(fCoords+fDim-1);
   std::cout << ")";
   std::cout.precision(pr);
}