ROOT logo
// @(#)root/matrix:$Id: TVectorT.cxx 30130 2009-09-14 06:46:32Z brun $
// Authors: Fons Rademakers, Eddy Offermann  Nov 2003

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TVectorT                                                             //
//                                                                      //
// Template class of Vectors in the linear algebra package              //
//                                                                      //
// Unless otherwise specified, vector indices always start with 0,      //
// spanning up to the specified limit-1.                                //
//                                                                      //
// For (n) vectors where n <= kSizeMax (5 currently) storage space is   //
// available on the stack, thus avoiding expensive allocation/          //
// deallocation of heap space . However, this introduces of course      //
// kSizeMax overhead for each vector object . If this is an issue       //
// recompile with a new appropriate value (>=0) for kSizeMax            //
//                                                                      //
// Another way to assign and store vector data is through Use           //
// see for instance stressLinear.cxx file .                             //
//                                                                      //
// Note that Constructors/assignments exists for all different matrix   //
// views                                                                //
//                                                                      //
// For usage examples see $ROOTSYS/test/stressLinear.cxx                //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TVectorT.h"
#include "TClass.h"
#include "TMath.h"
#include "TROOT.h"
#include "Varargs.h"

#ifndef R__ALPHA
templateClassImp(TVectorT)
#endif

//______________________________________________________________________________
template<class Element>
void TVectorT<Element>::Delete_m(Int_t size,Element *&m)
{
// Delete data pointer m, if it was assigned on the heap

   if (m) {
      if (size > kSizeMax)
         delete [] m;
      m = 0;
   }
}

//______________________________________________________________________________
template<class Element>
Element* TVectorT<Element>::New_m(Int_t size)
{
// Return data pointer . if requested size <= kSizeMax, assign pointer
// to the stack space

   if (size == 0) return 0;
   else {
      if ( size <= kSizeMax )
         return fDataStack;
      else {
         Element *heap = new Element[size];
         return heap;
      }
   }
}

//______________________________________________________________________________
template<class Element>
void TVectorT<Element>::Add(const TVectorT<Element> &v)
{
// Add vector v to this vector

   if (gMatrixCheck && !AreCompatible(*this,v)) {
      Error("Add(TVectorT<Element> &)","vector's not compatible");
      return;
   }

   const Element *sp = v.GetMatrixArray();
         Element *tp = this->GetMatrixArray();
   const Element * const tp_last = tp+fNrows;
   while (tp < tp_last)
      *tp++ += *sp++;
}

//______________________________________________________________________________
template<class Element>
void TVectorT<Element>::Add(const TVectorT<Element> &v1,const TVectorT<Element> &v2)
{
// Set this vector to v1+v2

   if (gMatrixCheck) {
      if ( !AreCompatible(*this,v1) && !AreCompatible(*this,v2)) {
         Error("Add(TVectorT<Element> &)","vectors not compatible");
         return;
      }
   }

   const Element *sv1 = v1.GetMatrixArray();
   const Element *sv2 = v2.GetMatrixArray();
         Element *tp = this->GetMatrixArray();
   const Element * const tp_last = tp+fNrows;
   while (tp < tp_last)
      *tp++ = *sv1++ + *sv2++;
}

//______________________________________________________________________________
template<class Element>
Int_t TVectorT<Element>::Memcpy_m(Element *newp,const Element *oldp,Int_t copySize,
                                  Int_t newSize,Int_t oldSize)
{
// Copy copySize doubles from *oldp to *newp . However take care of the
// situation where both pointers are assigned to the same stack space

   if (copySize == 0 || oldp == newp) return 0;
   else {
      if ( newSize <= kSizeMax && oldSize <= kSizeMax ) {
         // both pointers are inside fDataStack, be careful with copy direction !
         if (newp > oldp) {
            for (Int_t i = copySize-1; i >= 0; i--)
               newp[i] = oldp[i];
         } else {
            for (Int_t i = 0; i < copySize; i++)
               newp[i] = oldp[i];
         }
      }
      else {
         memcpy(newp,oldp,copySize*sizeof(Element));
      }
   }
   return 0;
}

//______________________________________________________________________________
template<class Element>
void TVectorT<Element>::Allocate(Int_t nrows,Int_t row_lwb,Int_t init)
{
// Allocate new vector. Arguments are number of rows and row
// lowerbound (0 default).

   fIsOwner  = kTRUE;
   fNrows    = 0;
   fRowLwb   = 0;
   fElements = 0;

   if (nrows < 0)
   {
      Error("Allocate","nrows=%d",nrows);
      return;
   }

   MakeValid();
   fNrows   = nrows;
   fRowLwb  = row_lwb;

   fElements = New_m(fNrows);
   if (init)
      memset(fElements,0,fNrows*sizeof(Element));
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element>::TVectorT(Int_t n)
{
// Constructor n-vector

   Allocate(n,0,1);
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element>::TVectorT(Int_t lwb,Int_t upb)
{
// Constructor [lwb..upb]-vector

   Allocate(upb-lwb+1,lwb,1);
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element>::TVectorT(Int_t n,const Element *elements)
{
// Constructor n-vector with data copied from array elements

   Allocate(n,0);
   SetElements(elements);
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element>::TVectorT(Int_t lwb,Int_t upb,const Element *elements)
{
// Constructor [lwb..upb]-vector with data copied from array elements

   Allocate(upb-lwb+1,lwb);
   SetElements(elements);
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element>::TVectorT(const TVectorT &another) : TObject(another)
{
// Copy constructor

   R__ASSERT(another.IsValid());
   Allocate(another.GetUpb()-another.GetLwb()+1,another.GetLwb());
   *this = another;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element>::TVectorT(const TMatrixTRow_const<Element> &mr) : TObject()
{
// Constructor : create vector from matrix row

   const TMatrixTBase<Element> *mt = mr.GetMatrix();
   R__ASSERT(mt->IsValid());
   Allocate(mt->GetColUpb()-mt->GetColLwb()+1,mt->GetColLwb());
   *this = mr;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element>::TVectorT(const TMatrixTColumn_const<Element> &mc) : TObject()
{
// Constructor : create vector from matrix column

   const TMatrixTBase<Element> *mt = mc.GetMatrix();
   R__ASSERT(mt->IsValid());
   Allocate(mt->GetRowUpb()-mt->GetRowLwb()+1,mt->GetRowLwb());
   *this = mc;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element>::TVectorT(const TMatrixTDiag_const<Element> &md) : TObject()
{
// Constructor : create vector from matrix diagonal

   const TMatrixTBase<Element> *mt = md.GetMatrix();
   R__ASSERT(mt->IsValid());
   Allocate(TMath::Min(mt->GetNrows(),mt->GetNcols()));
   *this = md;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element>::TVectorT(Int_t lwb,Int_t upb,Element va_(iv1), ...)
{
// Make a vector and assign initial values. Argument list should contain
// Element values to assign to vector elements. The list must be
// terminated by the string "END". Example:
// TVectorT foo(1,3,0.0,1.0,1.5,"END");

   if (upb < lwb) {
      Error("TVectorT(Int_t, Int_t, ...)","upb(%d) < lwb(%d)");
      return;
   }

   Allocate(upb-lwb+1,lwb);

   va_list args;
   va_start(args,va_(iv1));             // Init 'args' to the beginning of
                                        // the variable length list of args

   (*this)(lwb) = iv1;
   for (Int_t i = lwb+1; i <= upb; i++)
      (*this)(i) = (Element)va_arg(args,Double_t);

   if (strcmp((char *)va_arg(args,char *),"END"))
      Error("TVectorT(Int_t, Int_t, ...)","argument list must be terminated by \"END\"");

   va_end(args);
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::ResizeTo(Int_t lwb,Int_t upb)
{
// Resize the vector to [lwb:upb] .
// New dynamic elemenst are created, the overlapping part of the old ones are
// copied to the new structures, then the old elements are deleleted.

   R__ASSERT(IsValid());
   if (!fIsOwner) {
      Error("ResizeTo(lwb,upb)","Not owner of data array,cannot resize");
      return *this;
   }

   const Int_t new_nrows = upb-lwb+1;

   if (fNrows > 0) {

      if (fNrows == new_nrows && fRowLwb == lwb)
         return *this;
      else if (new_nrows == 0) {
         Clear();
         return *this;
      }

      Element    *elements_old = GetMatrixArray();
      const Int_t  nrows_old    = fNrows;
      const Int_t  rowLwb_old   = fRowLwb;

      Allocate(new_nrows,lwb);
      R__ASSERT(IsValid());
      if (fNrows > kSizeMax || nrows_old > kSizeMax)
         memset(GetMatrixArray(),0,fNrows*sizeof(Element));
      else if (fNrows > nrows_old)
         memset(GetMatrixArray()+nrows_old,0,(fNrows-nrows_old)*sizeof(Element));

    // Copy overlap
      const Int_t rowLwb_copy = TMath::Max(fRowLwb,rowLwb_old);
      const Int_t rowUpb_copy = TMath::Min(fRowLwb+fNrows-1,rowLwb_old+nrows_old-1);
      const Int_t nrows_copy  = rowUpb_copy-rowLwb_copy+1;

      const Int_t nelems_new = fNrows;
      Element *elements_new = GetMatrixArray();
      if (nrows_copy > 0) {
         const Int_t rowOldOff = rowLwb_copy-rowLwb_old;
         const Int_t rowNewOff = rowLwb_copy-fRowLwb;
         Memcpy_m(elements_new+rowNewOff,elements_old+rowOldOff,nrows_copy,nelems_new,nrows_old);
      }

      Delete_m(nrows_old,elements_old);
   } else {
      Allocate(upb-lwb+1,lwb,1);
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::Use(Int_t lwb,Int_t upb,Element *data)
{
// Use the array data to fill the vector lwb..upb]

   if (upb < lwb) {
      Error("Use","upb(%d) < lwb(%d)");
      return *this;
   }

   Clear();
   fNrows    = upb-lwb+1;
   fRowLwb   = lwb;
   fElements = data;
   fIsOwner  = kFALSE;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::GetSub(Int_t row_lwb,Int_t row_upb,TVectorT<Element> &target,Option_t *option) const
{
// Get subvector [row_lwb..row_upb]; The indexing range of the
// returned vector depends on the argument option:
//
// option == "S" : return [0..row_upb-row_lwb+1] (default)
// else          : return [row_lwb..row_upb]

   if (gMatrixCheck) {
      R__ASSERT(IsValid());
      if (row_lwb < fRowLwb || row_lwb > fRowLwb+fNrows-1) {
         Error("GetSub","row_lwb out of bounds");
         return target;
      }
      if (row_upb < fRowLwb || row_upb > fRowLwb+fNrows-1) {
         Error("GetSub","row_upb out of bounds");
         return target;
      }
      if (row_upb < row_lwb) {
         Error("GetSub","row_upb < row_lwb");
         return target;
      }
   }

   TString opt(option);
   opt.ToUpper();
   const Int_t shift = (opt.Contains("S")) ? 1 : 0;

   Int_t row_lwb_sub;
   Int_t row_upb_sub;
   if (shift) {
      row_lwb_sub = 0;
      row_upb_sub = row_upb-row_lwb;
   } else {
      row_lwb_sub = row_lwb;
      row_upb_sub = row_upb;
   }

   target.ResizeTo(row_lwb_sub,row_upb_sub);
   const Int_t nrows_sub = row_upb_sub-row_lwb_sub+1;

   const Element *ap = this->GetMatrixArray()+(row_lwb-fRowLwb);
         Element *bp = target.GetMatrixArray();

   for (Int_t irow = 0; irow < nrows_sub; irow++)
      *bp++ = *ap++;

   return target;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::SetSub(Int_t row_lwb,const TVectorT<Element> &source)
{
// Insert vector source starting at [row_lwb], thereby overwriting the part
// [row_lwb..row_lwb+nrows_source];

   if (gMatrixCheck) {
      R__ASSERT(IsValid());
      R__ASSERT(source.IsValid());

      if (row_lwb < fRowLwb && row_lwb > fRowLwb+fNrows-1) {
         Error("SetSub","row_lwb outof bounds");
         return *this;
      }
      if (row_lwb+source.GetNrows() > fRowLwb+fNrows) {
         Error("SetSub","source vector too large");
         return *this;
      }
   }

   const Int_t nRows_source = source.GetNrows();

   const Element *bp = source.GetMatrixArray();
         Element *ap = this->GetMatrixArray()+(row_lwb-fRowLwb);

   for (Int_t irow = 0; irow < nRows_source; irow++)
      *ap++ = *bp++;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::Zero()
{
// Set vector elements to zero

   R__ASSERT(IsValid());
   memset(this->GetMatrixArray(),0,fNrows*sizeof(Element));
   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::Abs()
{
// Take an absolute value of a vector, i.e. apply Abs() to each element.

   R__ASSERT(IsValid());

         Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp) {
      *ep = TMath::Abs(*ep);
      ep++;
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::Sqr()
{
// Square each element of the vector.

   R__ASSERT(IsValid());

         Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp) {
      *ep = (*ep) * (*ep);
      ep++;
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::Sqrt()
{
// Take square root of all elements.

   R__ASSERT(IsValid());

         Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp) {
      R__ASSERT(*ep >= 0);
      if (*ep >= 0)
         *ep = TMath::Sqrt(*ep);
      else
         Error("Sqrt()","v(%d) = %g < 0",ep-this->GetMatrixArray(),*ep);
      ep++;
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::Invert()
{
// v[i] = 1/v[i]

   R__ASSERT(IsValid());

         Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp) {
      R__ASSERT(*ep != 0.0);
      if (*ep != 0.0)
         *ep = 1./ *ep;
      else
         Error("Invert()","v(%d) = %g",ep-this->GetMatrixArray(),*ep);
      ep++;
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::SelectNonZeros(const TVectorT<Element> &select)
{
// Keep only element as selected through array select non-zero

   if (gMatrixCheck && !AreCompatible(*this,select)) {
      Error("SelectNonZeros(const TVectorT<Element> &","vector's not compatible");
      return *this;
   }

   const Element *sp = select.GetMatrixArray();
         Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp) {
      if (*sp == 0.0)
         *ep = 0.0;
      sp++; ep++;
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
Element TVectorT<Element>::Norm1() const
{
// Compute the 1-norm of the vector SUM{ |v[i]| }.

   R__ASSERT(IsValid());

   Element norm = 0;
   const Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      norm += TMath::Abs(*ep++);

   return norm;
}

//______________________________________________________________________________
template<class Element>
Element TVectorT<Element>::Norm2Sqr() const
{
// Compute the square of the 2-norm SUM{ v[i]^2 }.

   R__ASSERT(IsValid());

   Element norm = 0;
   const Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp) {
      norm += (*ep) * (*ep);
      ep++;
   }

   return norm;
}

//______________________________________________________________________________
template<class Element>
Element TVectorT<Element>::NormInf() const
{
// Compute the infinity-norm of the vector MAX{ |v[i]| }.

   R__ASSERT(IsValid());

   Element norm = 0;
   const Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      norm = TMath::Max(norm,TMath::Abs(*ep++));

   return norm;
}

//______________________________________________________________________________
template<class Element>
Int_t TVectorT<Element>::NonZeros() const
{
// Compute the number of elements != 0.0

   R__ASSERT(IsValid());

   Int_t nr_nonzeros = 0;
   const Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      if (*ep++) nr_nonzeros++;

   return nr_nonzeros;
}

//______________________________________________________________________________
template<class Element>
Element TVectorT<Element>::Sum() const
{
// Compute sum of elements

   R__ASSERT(IsValid());

   Element sum = 0.0;
   const Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      sum += *ep++;

   return sum;
}

//______________________________________________________________________________
template<class Element>
Element TVectorT<Element>::Min() const
{
// return minimum vector element value

   R__ASSERT(IsValid());

   const Int_t index = TMath::LocMin(fNrows,fElements);
   return fElements[index];
}

//______________________________________________________________________________
template<class Element>
Element TVectorT<Element>::Max() const
{
// return maximum vector element value

   R__ASSERT(IsValid());

   const Int_t index = TMath::LocMax(fNrows,fElements);
   return fElements[index];
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator=(const TVectorT<Element> &source)
{
// Notice that this assignment does NOT change the ownership :
// if the storage space was adopted, source is copied to
// this space .

   if (gMatrixCheck && !AreCompatible(*this,source)) {
      Error("operator=(const TVectorT<Element> &)","vectors not compatible");
      return *this;
   }

   if (this->GetMatrixArray() != source.GetMatrixArray()) {
      TObject::operator=(source);
      memcpy(fElements,source.GetMatrixArray(),fNrows*sizeof(Element));
   }
   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator=(const TMatrixTRow_const<Element> &mr)
{
// Assign a matrix row to a vector.

   const TMatrixTBase<Element> *mt = mr.GetMatrix();

   if (gMatrixCheck) {
      R__ASSERT(IsValid());
      R__ASSERT(mt->IsValid());
      if (mt->GetColLwb() != fRowLwb || mt->GetNcols() != fNrows) {
         Error("operator=(const TMatrixTRow_const &)","vector and row not compatible");
         return *this;
      }
   }

   const Int_t inc   = mr.GetInc();
   const Element *rp = mr.GetPtr();              // Row ptr
         Element *ep = this->GetMatrixArray();   // Vector ptr
   const Element * const fp = ep+fNrows;
   while (ep < fp) {
      *ep++ = *rp;
       rp += inc;
   }

   R__ASSERT(rp == mr.GetPtr()+mt->GetNcols());

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator=(const TMatrixTColumn_const<Element> &mc)
{
// Assign a matrix column to a vector.

   const TMatrixTBase<Element> *mt = mc.GetMatrix();

   if (gMatrixCheck) {
      R__ASSERT(IsValid());
      R__ASSERT(mt->IsValid());
      if (mt->GetRowLwb() != fRowLwb || mt->GetNrows() != fNrows) {
         Error("operator=(const TMatrixTColumn_const &)","vector and column not compatible");
         return *this;
      }
   }

   const Int_t inc    = mc.GetInc();
   const Element *cp = mc.GetPtr();              // Column ptr
         Element *ep = this->GetMatrixArray();   // Vector ptr
   const Element * const fp = ep+fNrows;
   while (ep < fp) {
      *ep++ = *cp;
       cp += inc;
   }

   R__ASSERT(cp == mc.GetPtr()+mt->GetNoElements());

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator=(const TMatrixTDiag_const<Element> &md)
{
// Assign the matrix diagonal to a vector.

   const TMatrixTBase<Element> *mt = md.GetMatrix();

   if (gMatrixCheck) {
      R__ASSERT(IsValid());
      R__ASSERT(mt->IsValid());
      if (md.GetNdiags() != fNrows) {
         Error("operator=(const TMatrixTDiag_const &)","vector and matrix-diagonal not compatible");
        return *this;
      }
   }

   const Int_t    inc = md.GetInc();
   const Element *dp = md.GetPtr();              // Diag ptr
         Element *ep = this->GetMatrixArray();   // Vector ptr
   const Element * const fp = ep+fNrows;
   while (ep < fp) {
      *ep++ = *dp;
       dp += inc;
   }

   R__ASSERT(dp < md.GetPtr()+mt->GetNoElements()+inc);

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator=(const TMatrixTSparseRow_const<Element> &mr)
{
// Assign a sparse matrix row to a vector. The matrix row is implicitly transposed
// to allow the assignment in the strict sense.

   const TMatrixTBase<Element> *mt = mr.GetMatrix();

   if (gMatrixCheck) {
      R__ASSERT(IsValid());
      R__ASSERT(mt->IsValid());
      if (mt->GetColLwb() != fRowLwb || mt->GetNcols() != fNrows) {
         Error("operator=(const TMatrixTSparseRow_const &)","vector and row not compatible");
         return *this;
      }
   }

   const Int_t nIndex = mr.GetNindex();
   const Element * const prData = mr.GetDataPtr();          // Row Data ptr
   const Int_t    * const prCol  = mr.GetColPtr();           // Col ptr
         Element * const pvData = this->GetMatrixArray();   // Vector ptr

   memset(pvData,0,fNrows*sizeof(Element));
   for (Int_t index = 0; index < nIndex; index++) {
      const Int_t icol = prCol[index];
      pvData[icol] = prData[index];
   }

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator=(const TMatrixTSparseDiag_const<Element> &md)
{
// Assign a sparse matrix diagonal to a vector.

  const TMatrixTBase<Element> *mt = md.GetMatrix();

   if (gMatrixCheck) {
      R__ASSERT(IsValid());
      R__ASSERT(mt->IsValid());
      if (md.GetNdiags() != fNrows) {
         Error("operator=(const TMatrixTSparseDiag_const &)","vector and matrix-diagonal not compatible");
         return *this;
      }
   }

   Element * const pvData = this->GetMatrixArray();
   for (Int_t idiag = 0; idiag < fNrows; idiag++)
      pvData[idiag] = md(idiag);

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator=(Element val)
{
// Assign val to every element of the vector.

   R__ASSERT(IsValid());

         Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      *ep++ = val;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator+=(Element val)
{
// Add val to every element of the vector.

   R__ASSERT(IsValid());

         Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      *ep++ += val;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator-=(Element val)
{
// Subtract val from every element of the vector.

   R__ASSERT(IsValid());

         Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      *ep++ -= val;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator*=(Element val)
{
// Multiply every element of the vector with val.

   R__ASSERT(IsValid());

         Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      *ep++ *= val;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator+=(const TVectorT<Element> &source)
{
// Add vector source

   if (gMatrixCheck && !AreCompatible(*this,source)) {
      Error("operator+=(const TVectorT<Element> &)","vector's not compatible");
      return *this;
   }

   const Element *sp = source.GetMatrixArray();
         Element *tp = this->GetMatrixArray();
   const Element * const tp_last = tp+fNrows;
   while (tp < tp_last)
      *tp++ += *sp++;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator-=(const TVectorT<Element> &source)
{
// Subtract vector source

   if (gMatrixCheck && !AreCompatible(*this,source)) {
      Error("operator-=(const TVectorT<Element> &)","vector's not compatible");
      return *this;
   }

   const Element *sp = source.GetMatrixArray();
         Element *tp = this->GetMatrixArray();
   const Element * const tp_last = tp+fNrows;
   while (tp < tp_last)
      *tp++ -= *sp++;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator*=(const TMatrixT<Element> &a)
{
// "Inplace" multiplication target = A*target. A needn't be a square one
// If target has to be resized, it should own the storage: fIsOwner = kTRUE

   if (gMatrixCheck) {
      R__ASSERT(IsValid());
      R__ASSERT(a.IsValid());
      if (a.GetNcols() != fNrows || a.GetColLwb() != fRowLwb) {
         Error("operator*=(const TMatrixT &)","vector and matrix incompatible");
         return *this;
      }
   }

   const Bool_t doResize = (fNrows != a.GetNrows() || fRowLwb != a.GetRowLwb());
   if (doResize && !fIsOwner) {
      Error("operator*=(const TMatrixT &)","vector has to be resized but not owner");
      return *this;
   }

   Element work[kWorkMax];
   Bool_t isAllocated = kFALSE;
   Element *elements_old = work;
   const Int_t nrows_old = fNrows;
   if (nrows_old > kWorkMax) {
      isAllocated = kTRUE;
      elements_old = new Element[nrows_old];
   }
   memcpy(elements_old,fElements,nrows_old*sizeof(Element));

   if (doResize) {
      const Int_t rowlwb_new = a.GetRowLwb();
      const Int_t nrows_new  = a.GetNrows();
      ResizeTo(rowlwb_new,rowlwb_new+nrows_new-1);
   }
   memset(fElements,0,fNrows*sizeof(Element));

   const Element *mp = a.GetMatrixArray();     // Matrix row ptr
         Element *tp = this->GetMatrixArray(); // Target vector ptr
#ifdef CBLAS
   if (typeid(Element) == typeid(Double_t))
      cblas_dgemv(CblasRowMajor,CblasNoTrans,a.GetNrows(),a.GetNcols(),1.0,mp,
                  a.GetNcols(),elements_old,1,0.0,tp,1);
   else if (typeid(Element) != typeid(Float_t))
      cblas_sgemv(CblasRowMajor,CblasNoTrans,a.GetNrows(),a.GetNcols(),1.0,mp,
                  a.GetNcols(),elements_old,1,0.0,tp,1);
   else
      Error("operator*=","type %s not implemented in BLAS library",typeid(Element));
#else
   const Element * const tp_last = tp+fNrows;
   while (tp < tp_last) {
      Element sum = 0;
      for (const Element *sp = elements_old; sp < elements_old+nrows_old; )
         sum += *sp++ * *mp++;
      *tp++ = sum;
   }
   R__ASSERT(mp == a.GetMatrixArray()+a.GetNoElements());
#endif

   if (isAllocated)
      delete [] elements_old;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator*=(const TMatrixTSparse<Element> &a)
{
// "Inplace" multiplication target = A*target. A needn't be a square one
// If target has to be resized, it should own the storage: fIsOwner = kTRUE

   if (gMatrixCheck) {
      R__ASSERT(IsValid());
      R__ASSERT(a.IsValid());
      if (a.GetNcols() != fNrows || a.GetColLwb() != fRowLwb) {
         Error("operator*=(const TMatrixTSparse &)","vector and matrix incompatible");
         return *this;
      }
   }

   const Bool_t doResize = (fNrows != a.GetNrows() || fRowLwb != a.GetRowLwb());
   if (doResize && !fIsOwner) {
      Error("operator*=(const TMatrixTSparse &)","vector has to be resized but not owner");
      return *this;
   }

   Element work[kWorkMax];
   Bool_t isAllocated = kFALSE;
   Element *elements_old = work;
   const Int_t nrows_old = fNrows;
   if (nrows_old > kWorkMax) {
      isAllocated = kTRUE;
      elements_old = new Element[nrows_old];
   }
   memcpy(elements_old,fElements,nrows_old*sizeof(Element));

   if (doResize) {
      const Int_t rowlwb_new = a.GetRowLwb();
      const Int_t nrows_new  = a.GetNrows();
      ResizeTo(rowlwb_new,rowlwb_new+nrows_new-1);
   }
   memset(fElements,0,fNrows*sizeof(Element));

   const Int_t   * const pRowIndex = a.GetRowIndexArray();
   const Int_t   * const pColIndex = a.GetColIndexArray();
   const Element * const mp        = a.GetMatrixArray();     // Matrix row ptr

   const Element * const sp = elements_old;
         Element *       tp = this->GetMatrixArray(); // Target vector ptr

   for (Int_t irow = 0; irow < fNrows; irow++) {
      const Int_t sIndex = pRowIndex[irow];
      const Int_t eIndex = pRowIndex[irow+1];
      Element sum = 0.0;
      for (Int_t index = sIndex; index < eIndex; index++) {
         const Int_t icol = pColIndex[index];
         sum += mp[index]*sp[icol];
      }
      tp[irow] = sum;
   }

   if (isAllocated)
      delete [] elements_old;

   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::operator*=(const TMatrixTSym<Element> &a)
{
// "Inplace" multiplication target = A*target. A is symmetric .
// vector size will not change

  if (gMatrixCheck) {
     R__ASSERT(IsValid());
     R__ASSERT(a.IsValid());
     if (a.GetNcols() != fNrows || a.GetColLwb() != fRowLwb) {
        Error("operator*=(const TMatrixTSym &)","vector and matrix incompatible");
        return *this;
     }
  }

   Element work[kWorkMax];
   Bool_t isAllocated = kFALSE;
   Element *elements_old = work;
   const Int_t nrows_old = fNrows;
   if (nrows_old > kWorkMax) {
      isAllocated = kTRUE;
      elements_old = new Element[nrows_old];
   }
   memcpy(elements_old,fElements,nrows_old*sizeof(Element));
   memset(fElements,0,fNrows*sizeof(Element));

   const Element *mp = a.GetMatrixArray();     // Matrix row ptr
         Element *tp = this->GetMatrixArray(); // Target vector ptr
#ifdef CBLAS
   if (typeid(Element) == typeid(Double_t))
      cblas_dsymv(CblasRowMajor,CblasUpper,fNrows,1.0,mp,
                  fNrows,elements_old,1,0.0,tp,1);
   else if (typeid(Element) != typeid(Float_t))
      cblas_ssymv(CblasRowMajor,CblasUpper,fNrows,1.0,mp,
                  fNrows,elements_old,1,0.0,tp,1);
   else
      Error("operator*=","type %s not implemented in BLAS library",typeid(Element));
#else
   const Element * const tp_last = tp+fNrows;
   while (tp < tp_last) {
      Element sum = 0;
      for (const Element *sp = elements_old; sp < elements_old+nrows_old; )
         sum += *sp++ * *mp++;
      *tp++ = sum;
   }
   R__ASSERT(mp == a.GetMatrixArray()+a.GetNoElements());
#endif

   if (isAllocated)
      delete [] elements_old;

   return *this;
}

//______________________________________________________________________________
template<class Element>
Bool_t TVectorT<Element>::operator==(Element val) const
{
// Are all vector elements equal to val?

   R__ASSERT(IsValid());

   const Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      if (!(*ep++ == val))
         return kFALSE;

   return kTRUE;
}

//______________________________________________________________________________
template<class Element>
Bool_t TVectorT<Element>::operator!=(Element val) const
{
// Are all vector elements not equal to val?

   R__ASSERT(IsValid());

   const Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      if (!(*ep++ != val))
         return kFALSE;

   return kTRUE;
}

//______________________________________________________________________________
template<class Element>
Bool_t TVectorT<Element>::operator<(Element val) const
{
// Are all vector elements < val?

   R__ASSERT(IsValid());

   const Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      if (!(*ep++ < val))
         return kFALSE;

   return kTRUE;
}

//______________________________________________________________________________
template<class Element>
Bool_t TVectorT<Element>::operator<=(Element val) const
{
// Are all vector elements <= val?

   R__ASSERT(IsValid());

   const Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      if (!(*ep++ <= val))
         return kFALSE;

   return kTRUE;
}

//______________________________________________________________________________
template<class Element>
Bool_t TVectorT<Element>::operator>(Element val) const
{
// Are all vector elements > val?

   R__ASSERT(IsValid());

   const Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      if (!(*ep++ > val))
         return kFALSE;

   return kTRUE;
}

//______________________________________________________________________________
template<class Element>
Bool_t TVectorT<Element>::operator>=(Element val) const
{
// Are all vector elements >= val?

   R__ASSERT(IsValid());

   const Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      if (!(*ep++ >= val))
         return kFALSE;

   return kTRUE;
}

//______________________________________________________________________________
template<class Element>
Bool_t TVectorT<Element>::MatchesNonZeroPattern(const TVectorT<Element> &select)
{
// Check if vector elements as selected through array select are non-zero

   if (gMatrixCheck && !AreCompatible(*this,select)) {
      Error("MatchesNonZeroPattern(const TVectorT&)","vector's not compatible");
      return kFALSE;
   }

   const Element *sp = select.GetMatrixArray();
   const Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp) {
      if (*sp == 0.0 && *ep != 0.0)
         return kFALSE;
      sp++; ep++;
   }

   return kTRUE;
}

//______________________________________________________________________________
template<class Element>
Bool_t TVectorT<Element>::SomePositive(const TVectorT<Element> &select)
{
// Check if vector elements as selected through array select are all positive

   if (gMatrixCheck && !AreCompatible(*this,select)) {
      Error("SomePositive(const TVectorT&)","vector's not compatible");
      return kFALSE;
   }

   const Element *sp = select.GetMatrixArray();
   const Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp) {
      if (*sp != 0.0 && *ep <= 0.0)
         return kFALSE;
      sp++; ep++;
   }

   return kTRUE;
}

//______________________________________________________________________________
template<class Element>
void TVectorT<Element>::AddSomeConstant(Element val,const TVectorT<Element> &select)
{
// Add to vector elements as selected through array select the value val

   if (gMatrixCheck && !AreCompatible(*this,select))
      Error("AddSomeConstant(Element,const TVectorT&)(const TVectorT&)","vector's not compatible");

   const Element *sp = select.GetMatrixArray();
         Element *ep = this->GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp) {
      if (*sp)
         *ep += val;
      sp++; ep++;
   }
}

extern Double_t Drand(Double_t &ix);

//______________________________________________________________________________
template<class Element>
void TVectorT<Element>::Randomize(Element alpha,Element beta,Double_t &seed)
{
// randomize vector elements value

   R__ASSERT(IsValid());

   const Element scale = beta-alpha;
   const Element shift = alpha/scale;

         Element *       ep = GetMatrixArray();
   const Element * const fp = ep+fNrows;
   while (ep < fp)
      *ep++ = scale*(Drand(seed)+shift);
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::Apply(const TElementActionT<Element> &action)
{
// Apply action to each element of the vector.

   R__ASSERT(IsValid());
   for (Element *ep = fElements; ep < fElements+fNrows; ep++)
      action.Operation(*ep);
   return *this;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &TVectorT<Element>::Apply(const TElementPosActionT<Element> &action)
{
// Apply action to each element of the vector. In action the location
// of the current element is known.

   R__ASSERT(IsValid());

   Element *ep = fElements;
   for (action.fI = fRowLwb; action.fI < fRowLwb+fNrows; action.fI++)
      action.Operation(*ep++);

   R__ASSERT(ep == fElements+fNrows);

   return *this;
}

//______________________________________________________________________________
template<class Element>
void TVectorT<Element>::Draw(Option_t *option)
{
// Draw this vector
// The histogram is named "TVectorT" by default and no title

   gROOT->ProcessLine(Form("THistPainter::PaintSpecialObjects((TObject*)0x%lx,\"%s\");",this,option));
}

//______________________________________________________________________________
template<class Element>
void TVectorT<Element>::Print(Option_t *flag) const
{
// Print the vector as a list of elements.

  if (!IsValid()) {
      Error("Print","Vector is invalid");
      return;
   }

   printf("\nVector (%d) %s is as follows",fNrows,flag);

   printf("\n\n     |   %6d  |", 1);
   printf("\n%s\n", "------------------");
   for (Int_t i = 0; i < fNrows; i++) {
      printf("%4d |",i+fRowLwb);
      //printf("%11.4g \n",(*this)(i+fRowLwb));
      printf("%g \n",(*this)(i+fRowLwb));
   }
   printf("\n");
}

//______________________________________________________________________________
template<class Element>
Bool_t operator==(const TVectorT<Element> &v1,const TVectorT<Element> &v2)
{
// Check to see if two vectors are identical.

   if (!AreCompatible(v1,v2)) return kFALSE;
   return (memcmp(v1.GetMatrixArray(),v2.GetMatrixArray(),v1.GetNrows()*sizeof(Element)) == 0);
}

//______________________________________________________________________________
template<class Element>
Element operator*(const TVectorT<Element> &v1,const TVectorT<Element> &v2)
{
// Compute the scalar product.

   if (gMatrixCheck) {
      if (!AreCompatible(v1,v2)) {
         Error("operator*(const TVectorT<Element> &,const TVectorT<Element> &)","vector's are incompatible");
         return 0.0;
      }
   }

   return Dot(v1,v2);
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> operator+(const TVectorT<Element> &source1,const TVectorT<Element> &source2)
{
// Return source1+source2

   TVectorT<Element> target = source1;
   target += source2;
   return target;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> operator-(const TVectorT<Element> &source1,const TVectorT<Element> &source2)
{
// Return source1-source2

   TVectorT<Element> target = source1;
   target -= source2;
   return target;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> operator*(const TMatrixT<Element> &a,const TVectorT<Element> &source)
{
// return A * source

   R__ASSERT(a.IsValid());
   TVectorT<Element> target(a.GetRowLwb(),a.GetRowUpb());
   return Add(target,Element(1.0),a,source);
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> operator*(const TMatrixTSym<Element> &a,const TVectorT<Element> &source)
{
// return A * source

   R__ASSERT(a.IsValid());
   TVectorT<Element> target(a.GetRowLwb(),a.GetRowUpb());
   return Add(target,Element(1.0),a,source);
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> operator*(const TMatrixTSparse<Element> &a,const TVectorT<Element> &source)
{
// return A * source

   R__ASSERT(a.IsValid());
   TVectorT<Element> target(a.GetRowLwb(),a.GetRowUpb());
   return Add(target,Element(1.0),a,source);
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> operator*(Element val,const TVectorT<Element> &source)
{
// return val * source

   TVectorT<Element> target = source;
   target *= val;
   return target;
}

//______________________________________________________________________________
template<class Element>
Element Dot(const TVectorT<Element> &v1,const TVectorT<Element> &v2)
{
// return inner-produvt v1 . v2

   const Element *v1p = v1.GetMatrixArray();
   const Element *v2p = v2.GetMatrixArray();
   Element sum = 0.0;
   const Element * const fv1p = v1p+v1.GetNrows();
   while (v1p < fv1p)
      sum += *v1p++ * *v2p++;

   return sum;
}

//______________________________________________________________________________
template <class Element1, class Element2>
TMatrixT<Element1>
OuterProduct(const TVectorT<Element1> &v1,const TVectorT<Element2> &v2)
{
   // Return the matrix M = v1 * v2'

   // TMatrixD::GetSub does:
   //   TMatrixT tmp;
   // Doesn't compile here, because we are outside the class?
   // So we'll be explicit:
   TMatrixT<Element1> target;

   return OuterProduct(target,v1,v2);
}

//______________________________________________________________________________
template <class Element1,class Element2,class Element3>
TMatrixT<Element1>
&OuterProduct(TMatrixT<Element1> &target,const TVectorT<Element2> &v1,const TVectorT<Element3> &v2)
{
   // Return the matrix M = v1 * v2'

   target.ResizeTo(v1.GetLwb(), v1.GetUpb(), v2.GetLwb(), v2.GetUpb());

         Element1 *       mp      = target.GetMatrixArray();
   const Element1 * const m_last  = mp + target.GetNoElements();
  
   const Element2 *       v1p     = v1.GetMatrixArray();
   const Element2 * const v1_last = v1p + v1.GetNrows();

   const Element3 * const v20     = v2.GetMatrixArray();
   const Element3 *       v2p     = v20;
   const Element3 * const v2_last = v2p + v2.GetNrows();

   while (v1p < v1_last) {
      v2p = v20;
      while (v2p < v2_last) {
         *mp++ = *v1p * *v2p++ ;
      }
      v1p++;
  }

  R__ASSERT(v1p == v1_last && mp == m_last && v2p == v2_last);

  return target;
}

//______________________________________________________________________________
template <class Element1, class Element2, class Element3>
Element1 Mult(const TVectorT<Element1> &v1,const TMatrixT<Element2> &m,
              const TVectorT<Element3> &v2)
{
  // Perform v1 * M * v2, a scalar result

   if (gMatrixCheck) {
      if (!AreCompatible(v1, m)) {
         ::Error("Mult", "Vector v1 and matrix m incompatible");
         return 0;
      }
      if (!AreCompatible(m, v2)) {
         ::Error("Mult", "Matrix m and vector v2 incompatible");
         return 0;
      }
   }

   const Element1 *       v1p     = v1.GetMatrixArray();    // first of v1
   const Element1 * const v1_last = v1p + v1.GetNrows();    // last of  v1

   const Element2 *       mp      = m.GetMatrixArray();     // first of m
   const Element2 * const m_last  = mp + m.GetNoElements(); // last of  m

   const Element3 * const v20     = v2.GetMatrixArray();    // first of v2
   const Element3 *       v2p     = v20;                    // running  v2
   const Element3 * const v2_last = v2p + v2.GetNrows();    // last of  v2

   Element1 sum     = 0;      // scalar result accumulator
   Element3 dot     = 0;      // M_row * v2 dot product accumulator

   while (v1p < v1_last) {
      v2p  = v20;               // at beginning of v2
      while (v2p < v2_last) {   // compute (M[i] * v2) dot product
         dot += *mp++ * *v2p++;
      }
      sum += *v1p++ * dot;      // v1[i] * (M[i] * v2)
      dot  = 0;                 // start next dot product
   }

   R__ASSERT(v1p == v1_last && mp == m_last && v2p == v2_last);
  
   return sum;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &Add(TVectorT<Element> &target,Element scalar,const TVectorT<Element> &source)
{
// Modify addition: target += scalar * source.

   if (gMatrixCheck && !AreCompatible(target,source)) {
      Error("Add(TVectorT<Element> &,Element,const TVectorT<Element> &)","vector's are incompatible");
      return target;
   }

   const Element *       sp  = source.GetMatrixArray();
         Element *       tp  = target.GetMatrixArray();
   const Element * const ftp = tp+target.GetNrows();
   if (scalar == 1.0 ) {
      while ( tp < ftp )
         *tp++ += *sp++;
   } else if (scalar == -1.0) {
      while ( tp < ftp )
         *tp++ -= *sp++;
   } else {
      while ( tp < ftp )
         *tp++ += scalar * *sp++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &Add(TVectorT<Element> &target,Element scalar,
                       const TMatrixT<Element> &a,const TVectorT<Element> &source)
{
// Modify addition: target += scalar * A * source.
// NOTE: in case scalar=0, do  target = A * source.

   if (gMatrixCheck) {
      R__ASSERT(target.IsValid());
      R__ASSERT(a.IsValid());
      if (a.GetNrows() != target.GetNrows() || a.GetRowLwb() != target.GetLwb()) {
         Error("Add(TVectorT &,const TMatrixT &,const TVectorT &)","target vector and matrix are incompatible");
         return target;
      }

      R__ASSERT(source.IsValid());
      if (a.GetNcols() != source.GetNrows() || a.GetColLwb() != source.GetLwb()) {
         Error("Add(TVectorT &,const TMatrixT &,const TVectorT &)","source vector and matrix are incompatible");
         return target;
      }
   }

   const Element * const sp = source.GetMatrixArray();  // sources vector ptr
   const Element *       mp = a.GetMatrixArray();       // Matrix row ptr
         Element *       tp = target.GetMatrixArray();  // Target vector ptr
#ifdef CBLAS
   if (typeid(Element) == typeid(Double_t))
      cblas_dsymv(CblasRowMajor,CblasUpper,fNrows,scalar,mp,
                  fNrows,sp,1,0.0,tp,1);
   else if (typeid(Element) != typeid(Float_t))
      cblas_ssymv(CblasRowMajor,CblasUpper,fNrows,scalar,mp,
                  fNrows,sp,1,0.0,tp,1);
   else
      Error("operator*=","type %s not implemented in BLAS library",typeid(Element));
#else
   const Element * const sp_last = sp+source.GetNrows();
   const Element * const tp_last = tp+target.GetNrows();
   if (scalar == 1.0) {
      while (tp < tp_last) {
         const Element *sp1 = sp;
         Element sum = 0;
         while (sp1 < sp_last)
            sum += *sp1++ * *mp++;
         *tp++ += sum;
      }
   } else if (scalar == 0.0) {
      while (tp < tp_last) {
         const Element *sp1 = sp;
         Element sum = 0;
         while (sp1 < sp_last)
            sum += *sp1++ * *mp++;
         *tp++  = sum;
      }
   } else if (scalar == -1.0) {
      while (tp < tp_last) {
         const Element *sp1 = sp;
         Element sum = 0;
         while (sp1 < sp_last)
            sum += *sp1++ * *mp++;
         *tp++ -= sum;
      }
   } else {
      while (tp < tp_last) {
        const Element *sp1 = sp;
        Element sum = 0;
        while (sp1 < sp_last)
           sum += *sp1++ * *mp++;
        *tp++ += scalar * sum;
      }
   }

   if (gMatrixCheck) R__ASSERT(mp == a.GetMatrixArray()+a.GetNoElements());
#endif

   return target;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &Add(TVectorT<Element> &target,Element scalar,
                       const TMatrixTSym<Element> &a,const TVectorT<Element> &source)
{
// Modify addition: target += A * source.
// NOTE: in case scalar=0, do  target = A * source.

   if (gMatrixCheck) {
      R__ASSERT(target.IsValid());
      R__ASSERT(source.IsValid());
      R__ASSERT(a.IsValid());
      if (a.GetNrows() != target.GetNrows() || a.GetRowLwb() != target.GetLwb()) {
         Error("Add(TVectorT &,const TMatrixT &,const TVectorT &)","target vector and matrix are incompatible");
         return target;
      }
   }

   const Element * const sp = source.GetMatrixArray();  // sources vector ptr
   const Element *       mp = a.GetMatrixArray();       // Matrix row ptr
         Element *       tp = target.GetMatrixArray();  // Target vector ptr
#ifdef CBLAS
   if (typeid(Element) == typeid(Double_t))
      cblas_dsymv(CblasRowMajor,CblasUpper,fNrows,1.0,mp,
                  fNrows,sp,1,0.0,tp,1);
   else if (typeid(Element) != typeid(Float_t))
      cblas_ssymv(CblasRowMajor,CblasUpper,fNrows,1.0,mp,
                  fNrows,sp,1,0.0,tp,1);
   else
      Error("operator*=","type %s not implemented in BLAS library",typeid(Element));
#else
   const Element * const sp_last = sp+source.GetNrows();
   const Element * const tp_last = tp+target.GetNrows();
   if (scalar == 1.0) {
      while (tp < tp_last) {
         const Element *sp1 = sp;
         Element sum = 0;
         while (sp1 < sp_last)
            sum += *sp1++ * *mp++;
         *tp++ += sum;
      }
   } else if (scalar == 0.0) {
      while (tp < tp_last) {
         const Element *sp1 = sp;
         Element sum = 0;
         while (sp1 < sp_last)
            sum += *sp1++ * *mp++;
         *tp++  = sum;
      }
   } else if (scalar == -1.0) {
      while (tp < tp_last) {
         const Element *sp1 = sp;
         Element sum = 0;
         while (sp1 < sp_last)
            sum += *sp1++ * *mp++;
         *tp++ -= sum;
      }
   } else {
      while (tp < tp_last) {
         const Element *sp1 = sp;
         Element sum = 0;
         while (sp1 < sp_last)
            sum += *sp1++ * *mp++;
         *tp++ += scalar * sum;
      }
   }
   R__ASSERT(mp == a.GetMatrixArray()+a.GetNoElements());
#endif

   return target;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &Add(TVectorT<Element> &target,Element scalar,
                       const TMatrixTSparse<Element> &a,const TVectorT<Element> &source)
{
// Modify addition: target += A * source.
// NOTE: in case scalar=0, do  target = A * source.

   if (gMatrixCheck) {
      R__ASSERT(target.IsValid());
      R__ASSERT(a.IsValid());
      if (a.GetNrows() != target.GetNrows() || a.GetRowLwb() != target.GetLwb()) {
         Error("Add(TVectorT &,const TMatrixT &,const TVectorT &)","target vector and matrix are incompatible");
         return target;
      }

      R__ASSERT(source.IsValid());
      if (a.GetNcols() != source.GetNrows() || a.GetColLwb() != source.GetLwb()) {
         Error("Add(TVectorT &,const TMatrixT &,const TVectorT &)","source vector and matrix are incompatible");
         return target;
      }
   }

   const Int_t   * const pRowIndex = a.GetRowIndexArray();
   const Int_t   * const pColIndex = a.GetColIndexArray();
   const Element * const mp        = a.GetMatrixArray();     // Matrix row ptr

   const Element * const sp = source.GetMatrixArray(); // Source vector ptr
         Element *       tp = target.GetMatrixArray(); // Target vector ptr

   if (scalar == 1.0) {
      for (Int_t irow = 0; irow < a.GetNrows(); irow++) {
         const Int_t sIndex = pRowIndex[irow];
         const Int_t eIndex = pRowIndex[irow+1];
         Element sum = 0.0;
         for (Int_t index = sIndex; index < eIndex; index++) {
            const Int_t icol = pColIndex[index];
            sum += mp[index]*sp[icol];
         }
         tp[irow] += sum;
      }
   } else if (scalar == 0.0) {
      for (Int_t irow = 0; irow < a.GetNrows(); irow++) {
         const Int_t sIndex = pRowIndex[irow];
         const Int_t eIndex = pRowIndex[irow+1];
         Element sum = 0.0;
         for (Int_t index = sIndex; index < eIndex; index++) {
            const Int_t icol = pColIndex[index];
            sum += mp[index]*sp[icol];
         }
         tp[irow]  = sum;
      }
   } else if (scalar == -1.0) {
     for (Int_t irow = 0; irow < a.GetNrows(); irow++) {
        const Int_t sIndex = pRowIndex[irow];
        const Int_t eIndex = pRowIndex[irow+1];
        Element sum = 0.0;
        for (Int_t index = sIndex; index < eIndex; index++) {
           const Int_t icol = pColIndex[index];
           sum += mp[index]*sp[icol];
        }
        tp[irow] -= sum;
      }
   } else {
      for (Int_t irow = 0; irow < a.GetNrows(); irow++) {
        const Int_t sIndex = pRowIndex[irow];
        const Int_t eIndex = pRowIndex[irow+1];
        Element sum = 0.0;
        for (Int_t index = sIndex; index < eIndex; index++) {
           const Int_t icol = pColIndex[index];
           sum += mp[index]*sp[icol];
        }
        tp[irow] += scalar * sum;
      }
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &AddElemMult(TVectorT<Element> &target,Element scalar,
                      const TVectorT<Element> &source1,const TVectorT<Element> &source2)
{
// Modify addition: target += scalar * ElementMult(source1,source2) .

   if (gMatrixCheck && !(AreCompatible(target,source1) && AreCompatible(target,source1))) {
      Error("AddElemMult(TVectorT<Element> &,Element,const TVectorT<Element> &,const TVectorT<Element> &)",
             "vector's are incompatible");
      return target;
   }

   const Element *       sp1 = source1.GetMatrixArray();
   const Element *       sp2 = source2.GetMatrixArray();
         Element *       tp  = target.GetMatrixArray();
   const Element * const ftp = tp+target.GetNrows();

   if (scalar == 1.0 ) {
      while ( tp < ftp )
         *tp++ += *sp1++ * *sp2++;
   } else if (scalar == -1.0) {
      while ( tp < ftp )
         *tp++ -= *sp1++ * *sp2++;
   } else {
      while ( tp < ftp )
         *tp++ += scalar * *sp1++ * *sp2++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &AddElemMult(TVectorT<Element> &target,Element scalar,
                      const TVectorT<Element> &source1,const TVectorT<Element> &source2,const TVectorT<Element> &select)
{
// Modify addition: target += scalar * ElementMult(source1,source2) only for those elements
// where select[i] != 0.0

   if (gMatrixCheck && !( AreCompatible(target,source1) && AreCompatible(target,source1) &&
          AreCompatible(target,select) )) {
      Error("AddElemMult(TVectorT<Element> &,Element,const TVectorT<Element> &,const TVectorT<Element> &,onst TVectorT<Element> &)",
             "vector's are incompatible");
      return target;
   }

   const Element *       sp1 = source1.GetMatrixArray();
   const Element *       sp2 = source2.GetMatrixArray();
   const Element *       mp  = select.GetMatrixArray();
         Element *       tp  = target.GetMatrixArray();
   const Element * const ftp = tp+target.GetNrows();

   if (scalar == 1.0 ) {
      while ( tp < ftp ) {
         if (*mp) *tp += *sp1 * *sp2;
         mp++; tp++; sp1++; sp2++;
      }
   } else if (scalar == -1.0) {
      while ( tp < ftp ) {
         if (*mp) *tp -= *sp1 * *sp2;
         mp++; tp++; sp1++; sp2++;
      }
   } else {
      while ( tp < ftp ) {
         if (*mp) *tp += scalar * *sp1 * *sp2;
         mp++; tp++; sp1++; sp2++;
      }
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &AddElemDiv(TVectorT<Element> &target,Element scalar,
                     const TVectorT<Element> &source1,const TVectorT<Element> &source2)
{
// Modify addition: target += scalar * ElementDiv(source1,source2) .

   if (gMatrixCheck && !(AreCompatible(target,source1) && AreCompatible(target,source1))) {
      Error("AddElemDiv(TVectorT<Element> &,Element,const TVectorT<Element> &,const TVectorT<Element> &)",
             "vector's are incompatible");
      return target;
   }

   const Element *       sp1 = source1.GetMatrixArray();
   const Element *       sp2 = source2.GetMatrixArray();
         Element *       tp  = target.GetMatrixArray();
   const Element * const ftp = tp+target.GetNrows();

   if (scalar == 1.0 ) {
      while ( tp < ftp ) {
         if (*sp2 != 0.0)
            *tp += *sp1 / *sp2;
         else {
            const Int_t irow = (sp2-source2.GetMatrixArray())/source2.GetNrows();
            Error("AddElemDiv","source2 (%d) is zero",irow);
         }
         tp++; sp1++; sp2++;
      }
   } else if (scalar == -1.0) {
      while ( tp < ftp ) {
         if (*sp2 != 0.0)
            *tp -= *sp1 / *sp2;
         else {
            const Int_t irow = (sp2-source2.GetMatrixArray())/source2.GetNrows();
            Error("AddElemDiv","source2 (%d) is zero",irow);
         }
         tp++; sp1++; sp2++;
      }
   } else {
      while ( tp < ftp ) {
         if (*sp2 != 0.0)
            *tp += scalar * *sp1 / *sp2;
         else {
            const Int_t irow = (sp2-source2.GetMatrixArray())/source2.GetNrows();
            Error("AddElemDiv","source2 (%d) is zero",irow);
         }
         tp++; sp1++; sp2++;
      }
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &AddElemDiv(TVectorT<Element> &target,Element scalar,
                     const TVectorT<Element> &source1,const TVectorT<Element> &source2,const TVectorT<Element> &select)
{
// Modify addition: target += scalar * ElementDiv(source1,source2) only for those elements
// where select[i] != 0.0

   if (gMatrixCheck && !( AreCompatible(target,source1) && AreCompatible(target,source1) &&
          AreCompatible(target,select) )) {
      Error("AddElemDiv(TVectorT<Element> &,Element,const TVectorT<Element> &,const TVectorT<Element> &,onst TVectorT<Element> &)",
             "vector's are incompatible");
      return target;
   }

   const Element *       sp1 = source1.GetMatrixArray();
   const Element *       sp2 = source2.GetMatrixArray();
   const Element *       mp  = select.GetMatrixArray();
         Element *       tp  = target.GetMatrixArray();
   const Element * const ftp = tp+target.GetNrows();

   if (scalar == 1.0 ) {
      while ( tp < ftp ) {
         if (*mp) {
            if (*sp2 != 0.0)
               *tp += *sp1 / *sp2;
            else {
               const Int_t irow = (sp2-source2.GetMatrixArray())/source2.GetNrows();
               Error("AddElemDiv","source2 (%d) is zero",irow);
            }
         }
         mp++; tp++; sp1++; sp2++;
      }
   } else if (scalar == -1.0) {
      while ( tp < ftp ) {
         if (*mp) {
            if (*sp2 != 0.0)
               *tp -= *sp1 / *sp2;
            else {
               const Int_t irow = (sp2-source2.GetMatrixArray())/source2.GetNrows();
               Error("AddElemDiv","source2 (%d) is zero",irow);
            }
         }
         mp++; tp++; sp1++; sp2++;
      }
   } else {
      while ( tp < ftp ) {
         if (*mp) {
            if (*sp2 != 0.0)
               *tp += scalar * *sp1 / *sp2;
            else {
               const Int_t irow = (sp2-source2.GetMatrixArray())/source2.GetNrows();
               Error("AddElemDiv","source2 (%d) is zero",irow);
            }
         }
         mp++; tp++; sp1++; sp2++;
      }
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &ElementMult(TVectorT<Element> &target,const TVectorT<Element> &source)
{
// Multiply target by the source, element-by-element.

   if (gMatrixCheck && !AreCompatible(target,source)) {
      Error("ElementMult(TVectorT<Element> &,const TVectorT<Element> &)","vector's are incompatible");
      return target;
   }

   const Element *       sp  = source.GetMatrixArray();
         Element *       tp  = target.GetMatrixArray();
   const Element * const ftp = tp+target.GetNrows();
   while ( tp < ftp )
      *tp++ *= *sp++;

   return target;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &ElementMult(TVectorT<Element> &target,const TVectorT<Element> &source,const TVectorT<Element> &select)
{
// Multiply target by the source, element-by-element only where select[i] != 0.0

   if (gMatrixCheck && !(AreCompatible(target,source) && AreCompatible(target,select))) {
      Error("ElementMult(TVectorT<Element> &,const TVectorT<Element> &,const TVectorT<Element> &)","vector's are incompatible");
      return target;
   }

   const Element *       sp  = source.GetMatrixArray();
   const Element *       mp  = select.GetMatrixArray();
         Element *       tp  = target.GetMatrixArray();
   const Element * const ftp = tp+target.GetNrows();
   while ( tp < ftp ) {
      if (*mp) *tp *= *sp;
      mp++; tp++; sp++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &ElementDiv(TVectorT<Element> &target,const TVectorT<Element> &source)
{
// Divide target by the source, element-by-element.

   if (gMatrixCheck && !AreCompatible(target,source)) {
      Error("ElementDiv(TVectorT<Element> &,const TVectorT<Element> &)","vector's are incompatible");
      return target;
   }

   const Element *       sp  = source.GetMatrixArray();
         Element *       tp  = target.GetMatrixArray();
   const Element * const ftp = tp+target.GetNrows();
   while ( tp < ftp ) {
      if (*sp  != 0.0)
         *tp++ /= *sp++;
      else {
         const Int_t irow = (sp-source.GetMatrixArray())/source.GetNrows();
         Error("ElementDiv","source (%d) is zero",irow);
      }
   }

   return target;
}

//______________________________________________________________________________
template<class Element>
TVectorT<Element> &ElementDiv(TVectorT<Element> &target,const TVectorT<Element> &source,const TVectorT<Element> &select)
{
// Divide target by the source, element-by-element only where select[i] != 0.0

   if (gMatrixCheck && !AreCompatible(target,source)) {
      Error("ElementDiv(TVectorT<Element> &,const TVectorT<Element> &,const TVectorT<Element> &)","vector's are incompatible");
      return target;
   }

   const Element *       sp  = source.GetMatrixArray();
   const Element *       mp  = select.GetMatrixArray();
         Element *       tp  = target.GetMatrixArray();
   const Element * const ftp = tp+target.GetNrows();
   while ( tp < ftp ) {
      if (*mp) {
         if (*sp != 0.0)
            *tp /= *sp;
         else {
            const Int_t irow = (sp-source.GetMatrixArray())/source.GetNrows();
            Error("ElementDiv","source (%d) is zero",irow);
         }
      }
      mp++; tp++; sp++;
   }

   return target;
}

//______________________________________________________________________________
template<class Element1,class Element2>
Bool_t AreCompatible(const TVectorT<Element1> &v1,const TVectorT<Element2> &v2,Int_t verbose)
{
// Check if v1 and v2 are both valid and have the same shape

   if (!v1.IsValid()) {
      if (verbose)
         ::Error("AreCompatible", "vector 1 not valid");
      return kFALSE;
   }
   if (!v2.IsValid()) {
      if (verbose)
         ::Error("AreCompatible", "vector 2 not valid");
      return kFALSE;
   }

   if (v1.GetNrows() != v2.GetNrows() || v1.GetLwb() != v2.GetLwb()) {
      if (verbose)
         ::Error("AreCompatible", "matrices 1 and 2 not compatible");
      return kFALSE;
   }

   return kTRUE;
}

//______________________________________________________________________________
template<class Element1, class Element2>
Bool_t AreCompatible(const TMatrixT<Element1> &m,const TVectorT<Element2> &v,Int_t verbose)
{
  // Check if m and v are both valid and have compatible shapes for M * v

   if (!m.IsValid()) {
      if (verbose)
         ::Error("AreCompatible", "Matrix not valid");
      return kFALSE;
   }
   if (!v.IsValid()) {
      if (verbose)
         ::Error("AreCompatible", "vector not valid");
      return kFALSE;
   }
  
   if (m.GetNcols() != v.GetNrows() ) {
      if (verbose)
         ::Error("AreCompatible", "matrix and vector not compatible");
      return kFALSE;
   }
  
   return kTRUE;
}

//______________________________________________________________________________
template<class Element1, class Element2>
Bool_t AreCompatible(const TVectorT<Element1> &v,const TMatrixT<Element2> &m,Int_t verbose)
{
  // Check if m and v are both valid and have compatible shapes for v * M

   if (!m.IsValid()) {
      if (verbose)
         ::Error("AreCompatible", "Matrix not valid");
      return kFALSE;
   }
   if (!v.IsValid()) {
      if (verbose)
         ::Error("AreCompatible", "vector not valid");
      return kFALSE;
   }

   if (v.GetNrows() != m.GetNrows() ) {
      if (verbose)
         ::Error("AreCompatible", "vector and matrix not compatible");
      return kFALSE;
   }

   return kTRUE;
}

//______________________________________________________________________________
template<class Element>
void Compare(const TVectorT<Element> &v1,const TVectorT<Element> &v2)
{
// Compare two vectors and print out the result of the comparison.

   if (!AreCompatible(v1,v2)) {
      Error("Compare(const TVectorT<Element> &,const TVectorT<Element> &)","vectors are incompatible");
      return;
   }

   printf("\n\nComparison of two TVectorTs:\n");

   Element norm1  = 0;       // Norm of the Matrices
   Element norm2  = 0;       // Norm of the Matrices
   Element ndiff  = 0;       // Norm of the difference
   Int_t    imax   = 0;       // For the elements that differ most
   Element difmax = -1;
   const Element *mp1 = v1.GetMatrixArray();    // Vector element pointers
   const Element *mp2 = v2.GetMatrixArray();

   for (Int_t i = 0; i < v1.GetNrows(); i++) {
      const Element mv1  = *mp1++;
      const Element mv2  = *mp2++;
      const Element diff = TMath::Abs(mv1-mv2);

      if (diff > difmax) {
         difmax = diff;
         imax = i;
      }
      norm1 += TMath::Abs(mv1);
      norm2 += TMath::Abs(mv2);
      ndiff += TMath::Abs(diff);
   }

   imax += v1.GetLwb();
   printf("\nMaximal discrepancy    \t\t%g",difmax);
   printf("\n   occured at the point\t\t(%d)",imax);
   const Element mv1 = v1(imax);
   const Element mv2 = v2(imax);
   printf("\n Vector 1 element is    \t\t%g",mv1);
   printf("\n Vector 2 element is    \t\t%g",mv2);
   printf("\n Absolute error v2[i]-v1[i]\t\t%g",mv2-mv1);
   printf("\n Relative error\t\t\t\t%g\n",
          (mv2-mv1)/TMath::Max(TMath::Abs(mv2+mv1)/2,(Element)1e-7));

   printf("\n||Vector 1||   \t\t\t%g",norm1);
   printf("\n||Vector 2||   \t\t\t%g",norm2);
   printf("\n||Vector1-Vector2||\t\t\t\t%g",ndiff);
   printf("\n||Vector1-Vector2||/sqrt(||Vector1|| ||Vector2||)\t%g\n\n",
          ndiff/TMath::Max(TMath::Sqrt(norm1*norm2),1e-7));
}

//______________________________________________________________________________
template<class Element>
Bool_t VerifyVectorValue(const TVectorT<Element> &v,Element val,
                         Int_t verbose,Element maxDevAllow)
{
// Validate that all elements of vector have value val within maxDevAllow .

   Int_t   imax      = 0;
   Element maxDevObs = 0;

   if (TMath::Abs(maxDevAllow) <= 0.0)
      maxDevAllow = std::numeric_limits<Element>::epsilon();

   for (Int_t i = v.GetLwb(); i <= v.GetUpb(); i++) {
      const Element dev = TMath::Abs(v(i)-val);
      if (dev > maxDevObs) {
         imax      = i;
         maxDevObs = dev;
      }
   }

   if (maxDevObs == 0)
      return kTRUE;

   if (verbose) {
      printf("Largest dev for (%d); dev = |%g - %g| = %g\n",imax,v(imax),val,maxDevObs);
      if (maxDevObs > maxDevAllow)
         Error("VerifyVectorValue","Deviation > %g\n",maxDevAllow);
   }

   if (maxDevObs > maxDevAllow)
      return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
template<class Element>
Bool_t VerifyVectorIdentity(const TVectorT<Element> &v1,const TVectorT<Element> &v2,
                            Int_t verbose, Element maxDevAllow)
{
// Verify that elements of the two vectors are equal within maxDevAllow .

   Int_t   imax      = 0;
   Element maxDevObs = 0;

   if (!AreCompatible(v1,v2))
      return kFALSE;

   if (TMath::Abs(maxDevAllow) <= 0.0)
      maxDevAllow = std::numeric_limits<Element>::epsilon();

   for (Int_t i = v1.GetLwb(); i <= v1.GetUpb(); i++) {
      const Element dev = TMath::Abs(v1(i)-v2(i));
      if (dev > maxDevObs) {
         imax      = i;
         maxDevObs = dev;
      }
   }

   if (maxDevObs == 0)
      return kTRUE;

   if (verbose) {
      printf("Largest dev for (%d); dev = |%g - %g| = %g\n",imax,v1(imax),v2(imax),maxDevObs);
      if (maxDevObs > maxDevAllow)
         Error("VerifyVectorIdentity","Deviation > %g\n",maxDevAllow);
   }

   if (maxDevObs > maxDevAllow) {
      return kFALSE;
   }
   return kTRUE;
}

//______________________________________________________________________________
template<class Element>
void TVectorT<Element>::Streamer(TBuffer &R__b)
{
// Stream an object of class TVectorT.

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = R__b.ReadVersion(&R__s,&R__c);
      if (R__v > 1) {
         Clear();
         R__b.ReadClassBuffer(TVectorT<Element>::Class(),this,R__v,R__s,R__c);
      } else { //====process old versions before automatic schema evolution
         TObject::Streamer(R__b);
         R__b >> fRowLwb;
         fNrows = R__b.ReadArray(fElements);
         R__b.CheckByteCount(R__s, R__c, TVectorT<Element>::IsA());
      }
      if (fNrows > 0 && fNrows <= kSizeMax) {
         memcpy(fDataStack,fElements,fNrows*sizeof(Element));
         delete [] fElements;
         fElements = fDataStack;
      } else if (fNrows < 0)
         Invalidate();

      if (R__v < 3)
         MakeValid();
    } else {
       R__b.WriteClassBuffer(TVectorT<Element>::Class(),this);
   }
}

#ifndef ROOT_TMatrixFfwd
#include "TMatrixFfwd.h"
#endif
#ifndef ROOT_TMatrixFSymfwd
#include "TMatrixFSymfwd.h"
#endif
#ifndef ROOT_TMatrixFSparsefwd
#include "TMatrixFSparsefwd.h"
#endif

template class TVectorT<Float_t>;

template Bool_t    operator==          <Float_t>(const TVectorF       &source1,const TVectorF &source2);
template TVectorF  operator+           <Float_t>(const TVectorF       &source1,const TVectorF &source2);
template TVectorF  operator-           <Float_t>(const TVectorF       &source1,const TVectorF &source2);
template Float_t   operator*           <Float_t>(const TVectorF       &source1,const TVectorF &source2);
template TVectorF  operator*           <Float_t>(const TMatrixF       &a,      const TVectorF &source);
template TVectorF  operator*           <Float_t>(const TMatrixFSym    &a,      const TVectorF &source);
template TVectorF  operator*           <Float_t>(const TMatrixFSparse &a,      const TVectorF &source);
template TVectorF  operator*           <Float_t>(      Float_t         val,    const TVectorF &source);

template Float_t   Dot                 <Float_t>(const TVectorF       &v1,     const TVectorF &v2);
template TMatrixF  OuterProduct        <Float_t,Float_t>
                                                (const TVectorF       &v1,     const TVectorF &v2);
template TMatrixF &OuterProduct        <Float_t,Float_t,Float_t>
                                                (      TMatrixF       &target, const TVectorF &v1,     const TVectorF       &v2);
template Float_t   Mult                <Float_t,Float_t,Float_t>
                                                (const TVectorF       &v1,     const TMatrixF &m,      const TVectorF       &v2);

template TVectorF &Add                 <Float_t>(      TVectorF       &target,       Float_t   scalar, const TVectorF       &source);
template TVectorF &Add                 <Float_t>(      TVectorF       &target,       Float_t   scalar, const TMatrixF       &a,
                                                                               const TVectorF &source);
template TVectorF &Add                 <Float_t>(      TVectorF       &target,       Float_t   scalar, const TMatrixFSym    &a,
                                                                               const TVectorF &source);
template TVectorF &Add                 <Float_t>(      TVectorF       &target,       Float_t   scalar, const TMatrixFSparse &a,
                                                                               const TVectorF &source);
template TVectorF &AddElemMult         <Float_t>(      TVectorF       &target,       Float_t   scalar, const TVectorF       &source1,
                                                                               const TVectorF &source2);
template TVectorF &AddElemMult         <Float_t>(      TVectorF       &target,       Float_t   scalar, const TVectorF       &source1,
                                                                               const TVectorF &source2,const TVectorF       &select);
template TVectorF &AddElemDiv          <Float_t>(      TVectorF       &target,       Float_t   scalar, const TVectorF       &source1,
                                                                               const TVectorF &source2);
template TVectorF &AddElemDiv          <Float_t>(      TVectorF       &target,       Float_t   scalar, const TVectorF       &source1,
                                                                               const TVectorF &source2,const TVectorF       &select);
template TVectorF &ElementMult         <Float_t>(      TVectorF       &target, const TVectorF &source);
template TVectorF &ElementMult         <Float_t>(      TVectorF       &target, const TVectorF &source, const TVectorF       &select);
template TVectorF &ElementDiv          <Float_t>(      TVectorF       &target, const TVectorF &source);
template TVectorF &ElementDiv          <Float_t>(      TVectorF       &target, const TVectorF &source, const TVectorF       &select);

template Bool_t    AreCompatible       <Float_t,Float_t> (const TVectorF &v1,const TVectorF &v2,Int_t verbose);
template Bool_t    AreCompatible       <Float_t,Double_t>(const TVectorF &v1,const TVectorD &v2,Int_t verbose);
template Bool_t    AreCompatible       <Float_t,Float_t> (const TMatrixF &m, const TVectorF &v, Int_t verbose);
template Bool_t    AreCompatible       <Float_t,Float_t> (const TVectorF &v, const TMatrixF &m, Int_t verbose);

template void      Compare             <Float_t>         (const TVectorF &v1,const TVectorF &v2);
template Bool_t    VerifyVectorValue   <Float_t>         (const TVectorF &m,       Float_t   val,Int_t verbose,Float_t maxDevAllow);
template Bool_t    VerifyVectorIdentity<Float_t>         (const TVectorF &m1,const TVectorF &m2, Int_t verbose,Float_t maxDevAllow);

#ifndef ROOT_TMatrixDfwd
#include "TMatrixDfwd.h"
#endif
#ifndef ROOT_TMatrixDSymfwd
#include "TMatrixDSymfwd.h"
#endif
#ifndef ROOT_TMatrixDSparsefwd
#include "TMatrixDSparsefwd.h"
#endif

template class TVectorT<Double_t>;

template Bool_t    operator==          <Double_t>(const TVectorD       &source1,const TVectorD &source2);
template TVectorD  operator+           <Double_t>(const TVectorD       &source1,const TVectorD &source2);
template TVectorD  operator-           <Double_t>(const TVectorD       &source1,const TVectorD &source2);
template Double_t  operator*           <Double_t>(const TVectorD       &source1,const TVectorD &source2);
template TVectorD  operator*           <Double_t>(const TMatrixD       &a,      const TVectorD &source);
template TVectorD  operator*           <Double_t>(const TMatrixDSym    &a,      const TVectorD &source);
template TVectorD  operator*           <Double_t>(const TMatrixDSparse &a,      const TVectorD &source);
template TVectorD  operator*           <Double_t>(      Double_t        val,    const TVectorD &source);

template Double_t  Dot                 <Double_t>(const TVectorD       &v1,     const TVectorD &v2);
template TMatrixD  OuterProduct        <Double_t,Double_t>
                                                 (const TVectorD       &v1,     const TVectorD &v2);
template TMatrixD &OuterProduct        <Double_t,Double_t,Double_t>
                                                 (      TMatrixD       &target, const TVectorD &v1,     const TVectorD       &v2);
template Double_t  Mult                <Double_t,Double_t,Double_t>
                                                 (const TVectorD       &v1,     const TMatrixD &m,      const TVectorD       &v2);

template TVectorD &Add                 <Double_t>(      TVectorD       &target,       Double_t  scalar, const TVectorD       &source);
template TVectorD &Add                 <Double_t>(      TVectorD       &target,       Double_t  scalar, const TMatrixD       &a,
                                                                                const TVectorD &source);
template TVectorD &Add                 <Double_t>(      TVectorD       &target,       Double_t  scalar, const TMatrixDSym    &a
                                                                                ,      const TVectorD &source);
template TVectorD &Add                 <Double_t>(      TVectorD       &target,       Double_t  scalar, const TMatrixDSparse &a
                                                                                ,      const TVectorD &source);
template TVectorD &AddElemMult         <Double_t>(      TVectorD       &target,       Double_t  scalar, const TVectorD       &source1,
                                                                                const TVectorD &source2);
template TVectorD &AddElemMult         <Double_t>(      TVectorD       &target,       Double_t  scalar, const TVectorD       &source1,
                                                                                const TVectorD &source2,const TVectorD       &select);
template TVectorD &AddElemDiv          <Double_t>(      TVectorD       &target,       Double_t  scalar, const TVectorD       &source1,
                                                                                const TVectorD &source2);
template TVectorD &AddElemDiv          <Double_t>(      TVectorD       &target,       Double_t  scalar, const TVectorD       &source1,
                                                                                const TVectorD &source2,const TVectorD       &select);
template TVectorD &ElementMult         <Double_t>(      TVectorD       &target, const TVectorD &source);
template TVectorD &ElementMult         <Double_t>(      TVectorD       &target, const TVectorD &source, const TVectorD       &select);
template TVectorD &ElementDiv          <Double_t>(      TVectorD       &target, const TVectorD &source);
template TVectorD &ElementDiv          <Double_t>(      TVectorD       &target, const TVectorD &source, const TVectorD       &select);

template Bool_t    AreCompatible       <Double_t,Double_t>(const TVectorD &v1,const TVectorD &v2,Int_t verbose);
template Bool_t    AreCompatible       <Double_t,Float_t> (const TVectorD &v1,const TVectorF &v2,Int_t verbose);
template Bool_t    AreCompatible       <Double_t,Double_t>(const TMatrixD &m, const TVectorD &v, Int_t verbose);
template Bool_t    AreCompatible       <Double_t,Double_t>(const TVectorD &v, const TMatrixD &m, Int_t verbose);

template void      Compare             <Double_t>         (const TVectorD &v1,const TVectorD &v2);
template Bool_t    VerifyVectorValue   <Double_t>         (const TVectorD &m,       Double_t  val,Int_t verbose,Double_t maxDevAllow);
template Bool_t    VerifyVectorIdentity<Double_t>         (const TVectorD &m1,const TVectorD &m2, Int_t verbose,Double_t maxDevAllow);
 TVectorT.cxx:1
 TVectorT.cxx:2
 TVectorT.cxx:3
 TVectorT.cxx:4
 TVectorT.cxx:5
 TVectorT.cxx:6
 TVectorT.cxx:7
 TVectorT.cxx:8
 TVectorT.cxx:9
 TVectorT.cxx:10
 TVectorT.cxx:11
 TVectorT.cxx:12
 TVectorT.cxx:13
 TVectorT.cxx:14
 TVectorT.cxx:15
 TVectorT.cxx:16
 TVectorT.cxx:17
 TVectorT.cxx:18
 TVectorT.cxx:19
 TVectorT.cxx:20
 TVectorT.cxx:21
 TVectorT.cxx:22
 TVectorT.cxx:23
 TVectorT.cxx:24
 TVectorT.cxx:25
 TVectorT.cxx:26
 TVectorT.cxx:27
 TVectorT.cxx:28
 TVectorT.cxx:29
 TVectorT.cxx:30
 TVectorT.cxx:31
 TVectorT.cxx:32
 TVectorT.cxx:33
 TVectorT.cxx:34
 TVectorT.cxx:35
 TVectorT.cxx:36
 TVectorT.cxx:37
 TVectorT.cxx:38
 TVectorT.cxx:39
 TVectorT.cxx:40
 TVectorT.cxx:41
 TVectorT.cxx:42
 TVectorT.cxx:43
 TVectorT.cxx:44
 TVectorT.cxx:45
 TVectorT.cxx:46
 TVectorT.cxx:47
 TVectorT.cxx:48
 TVectorT.cxx:49
 TVectorT.cxx:50
 TVectorT.cxx:51
 TVectorT.cxx:52
 TVectorT.cxx:53
 TVectorT.cxx:54
 TVectorT.cxx:55
 TVectorT.cxx:56
 TVectorT.cxx:57
 TVectorT.cxx:58
 TVectorT.cxx:59
 TVectorT.cxx:60
 TVectorT.cxx:61
 TVectorT.cxx:62
 TVectorT.cxx:63
 TVectorT.cxx:64
 TVectorT.cxx:65
 TVectorT.cxx:66
 TVectorT.cxx:67
 TVectorT.cxx:68
 TVectorT.cxx:69
 TVectorT.cxx:70
 TVectorT.cxx:71
 TVectorT.cxx:72
 TVectorT.cxx:73
 TVectorT.cxx:74
 TVectorT.cxx:75
 TVectorT.cxx:76
 TVectorT.cxx:77
 TVectorT.cxx:78
 TVectorT.cxx:79
 TVectorT.cxx:80
 TVectorT.cxx:81
 TVectorT.cxx:82
 TVectorT.cxx:83
 TVectorT.cxx:84
 TVectorT.cxx:85
 TVectorT.cxx:86
 TVectorT.cxx:87
 TVectorT.cxx:88
 TVectorT.cxx:89
 TVectorT.cxx:90
 TVectorT.cxx:91
 TVectorT.cxx:92
 TVectorT.cxx:93
 TVectorT.cxx:94
 TVectorT.cxx:95
 TVectorT.cxx:96
 TVectorT.cxx:97
 TVectorT.cxx:98
 TVectorT.cxx:99
 TVectorT.cxx:100
 TVectorT.cxx:101
 TVectorT.cxx:102
 TVectorT.cxx:103
 TVectorT.cxx:104
 TVectorT.cxx:105
 TVectorT.cxx:106
 TVectorT.cxx:107
 TVectorT.cxx:108
 TVectorT.cxx:109
 TVectorT.cxx:110
 TVectorT.cxx:111
 TVectorT.cxx:112
 TVectorT.cxx:113
 TVectorT.cxx:114
 TVectorT.cxx:115
 TVectorT.cxx:116
 TVectorT.cxx:117
 TVectorT.cxx:118
 TVectorT.cxx:119
 TVectorT.cxx:120
 TVectorT.cxx:121
 TVectorT.cxx:122
 TVectorT.cxx:123
 TVectorT.cxx:124
 TVectorT.cxx:125
 TVectorT.cxx:126
 TVectorT.cxx:127
 TVectorT.cxx:128
 TVectorT.cxx:129
 TVectorT.cxx:130
 TVectorT.cxx:131
 TVectorT.cxx:132
 TVectorT.cxx:133
 TVectorT.cxx:134
 TVectorT.cxx:135
 TVectorT.cxx:136
 TVectorT.cxx:137
 TVectorT.cxx:138
 TVectorT.cxx:139
 TVectorT.cxx:140
 TVectorT.cxx:141
 TVectorT.cxx:142
 TVectorT.cxx:143
 TVectorT.cxx:144
 TVectorT.cxx:145
 TVectorT.cxx:146
 TVectorT.cxx:147
 TVectorT.cxx:148
 TVectorT.cxx:149
 TVectorT.cxx:150
 TVectorT.cxx:151
 TVectorT.cxx:152
 TVectorT.cxx:153
 TVectorT.cxx:154
 TVectorT.cxx:155
 TVectorT.cxx:156
 TVectorT.cxx:157
 TVectorT.cxx:158
 TVectorT.cxx:159
 TVectorT.cxx:160
 TVectorT.cxx:161
 TVectorT.cxx:162
 TVectorT.cxx:163
 TVectorT.cxx:164
 TVectorT.cxx:165
 TVectorT.cxx:166
 TVectorT.cxx:167
 TVectorT.cxx:168
 TVectorT.cxx:169
 TVectorT.cxx:170
 TVectorT.cxx:171
 TVectorT.cxx:172
 TVectorT.cxx:173
 TVectorT.cxx:174
 TVectorT.cxx:175
 TVectorT.cxx:176
 TVectorT.cxx:177
 TVectorT.cxx:178
 TVectorT.cxx:179
 TVectorT.cxx:180
 TVectorT.cxx:181
 TVectorT.cxx:182
 TVectorT.cxx:183
 TVectorT.cxx:184
 TVectorT.cxx:185
 TVectorT.cxx:186
 TVectorT.cxx:187
 TVectorT.cxx:188
 TVectorT.cxx:189
 TVectorT.cxx:190
 TVectorT.cxx:191
 TVectorT.cxx:192
 TVectorT.cxx:193
 TVectorT.cxx:194
 TVectorT.cxx:195
 TVectorT.cxx:196
 TVectorT.cxx:197
 TVectorT.cxx:198
 TVectorT.cxx:199
 TVectorT.cxx:200
 TVectorT.cxx:201
 TVectorT.cxx:202
 TVectorT.cxx:203
 TVectorT.cxx:204
 TVectorT.cxx:205
 TVectorT.cxx:206
 TVectorT.cxx:207
 TVectorT.cxx:208
 TVectorT.cxx:209
 TVectorT.cxx:210
 TVectorT.cxx:211
 TVectorT.cxx:212
 TVectorT.cxx:213
 TVectorT.cxx:214
 TVectorT.cxx:215
 TVectorT.cxx:216
 TVectorT.cxx:217
 TVectorT.cxx:218
 TVectorT.cxx:219
 TVectorT.cxx:220
 TVectorT.cxx:221
 TVectorT.cxx:222
 TVectorT.cxx:223
 TVectorT.cxx:224
 TVectorT.cxx:225
 TVectorT.cxx:226
 TVectorT.cxx:227
 TVectorT.cxx:228
 TVectorT.cxx:229
 TVectorT.cxx:230
 TVectorT.cxx:231
 TVectorT.cxx:232
 TVectorT.cxx:233
 TVectorT.cxx:234
 TVectorT.cxx:235
 TVectorT.cxx:236
 TVectorT.cxx:237
 TVectorT.cxx:238
 TVectorT.cxx:239
 TVectorT.cxx:240
 TVectorT.cxx:241
 TVectorT.cxx:242
 TVectorT.cxx:243
 TVectorT.cxx:244
 TVectorT.cxx:245
 TVectorT.cxx:246
 TVectorT.cxx:247
 TVectorT.cxx:248
 TVectorT.cxx:249
 TVectorT.cxx:250
 TVectorT.cxx:251
 TVectorT.cxx:252
 TVectorT.cxx:253
 TVectorT.cxx:254
 TVectorT.cxx:255
 TVectorT.cxx:256
 TVectorT.cxx:257
 TVectorT.cxx:258
 TVectorT.cxx:259
 TVectorT.cxx:260
 TVectorT.cxx:261
 TVectorT.cxx:262
 TVectorT.cxx:263
 TVectorT.cxx:264
 TVectorT.cxx:265
 TVectorT.cxx:266
 TVectorT.cxx:267
 TVectorT.cxx:268
 TVectorT.cxx:269
 TVectorT.cxx:270
 TVectorT.cxx:271
 TVectorT.cxx:272
 TVectorT.cxx:273
 TVectorT.cxx:274
 TVectorT.cxx:275
 TVectorT.cxx:276
 TVectorT.cxx:277
 TVectorT.cxx:278
 TVectorT.cxx:279
 TVectorT.cxx:280
 TVectorT.cxx:281
 TVectorT.cxx:282
 TVectorT.cxx:283
 TVectorT.cxx:284
 TVectorT.cxx:285
 TVectorT.cxx:286
 TVectorT.cxx:287
 TVectorT.cxx:288
 TVectorT.cxx:289
 TVectorT.cxx:290
 TVectorT.cxx:291
 TVectorT.cxx:292
 TVectorT.cxx:293
 TVectorT.cxx:294
 TVectorT.cxx:295
 TVectorT.cxx:296
 TVectorT.cxx:297
 TVectorT.cxx:298
 TVectorT.cxx:299
 TVectorT.cxx:300
 TVectorT.cxx:301
 TVectorT.cxx:302
 TVectorT.cxx:303
 TVectorT.cxx:304
 TVectorT.cxx:305
 TVectorT.cxx:306
 TVectorT.cxx:307
 TVectorT.cxx:308
 TVectorT.cxx:309
 TVectorT.cxx:310
 TVectorT.cxx:311
 TVectorT.cxx:312
 TVectorT.cxx:313
 TVectorT.cxx:314
 TVectorT.cxx:315
 TVectorT.cxx:316
 TVectorT.cxx:317
 TVectorT.cxx:318
 TVectorT.cxx:319
 TVectorT.cxx:320
 TVectorT.cxx:321
 TVectorT.cxx:322
 TVectorT.cxx:323
 TVectorT.cxx:324
 TVectorT.cxx:325
 TVectorT.cxx:326
 TVectorT.cxx:327
 TVectorT.cxx:328
 TVectorT.cxx:329
 TVectorT.cxx:330
 TVectorT.cxx:331
 TVectorT.cxx:332
 TVectorT.cxx:333
 TVectorT.cxx:334
 TVectorT.cxx:335
 TVectorT.cxx:336
 TVectorT.cxx:337
 TVectorT.cxx:338
 TVectorT.cxx:339
 TVectorT.cxx:340
 TVectorT.cxx:341
 TVectorT.cxx:342
 TVectorT.cxx:343
 TVectorT.cxx:344
 TVectorT.cxx:345
 TVectorT.cxx:346
 TVectorT.cxx:347
 TVectorT.cxx:348
 TVectorT.cxx:349
 TVectorT.cxx:350
 TVectorT.cxx:351
 TVectorT.cxx:352
 TVectorT.cxx:353
 TVectorT.cxx:354
 TVectorT.cxx:355
 TVectorT.cxx:356
 TVectorT.cxx:357
 TVectorT.cxx:358
 TVectorT.cxx:359
 TVectorT.cxx:360
 TVectorT.cxx:361
 TVectorT.cxx:362
 TVectorT.cxx:363
 TVectorT.cxx:364
 TVectorT.cxx:365
 TVectorT.cxx:366
 TVectorT.cxx:367
 TVectorT.cxx:368
 TVectorT.cxx:369
 TVectorT.cxx:370
 TVectorT.cxx:371
 TVectorT.cxx:372
 TVectorT.cxx:373
 TVectorT.cxx:374
 TVectorT.cxx:375
 TVectorT.cxx:376
 TVectorT.cxx:377
 TVectorT.cxx:378
 TVectorT.cxx:379
 TVectorT.cxx:380
 TVectorT.cxx:381
 TVectorT.cxx:382
 TVectorT.cxx:383
 TVectorT.cxx:384
 TVectorT.cxx:385
 TVectorT.cxx:386
 TVectorT.cxx:387
 TVectorT.cxx:388
 TVectorT.cxx:389
 TVectorT.cxx:390
 TVectorT.cxx:391
 TVectorT.cxx:392
 TVectorT.cxx:393
 TVectorT.cxx:394
 TVectorT.cxx:395
 TVectorT.cxx:396
 TVectorT.cxx:397
 TVectorT.cxx:398
 TVectorT.cxx:399
 TVectorT.cxx:400
 TVectorT.cxx:401
 TVectorT.cxx:402
 TVectorT.cxx:403
 TVectorT.cxx:404
 TVectorT.cxx:405
 TVectorT.cxx:406
 TVectorT.cxx:407
 TVectorT.cxx:408
 TVectorT.cxx:409
 TVectorT.cxx:410
 TVectorT.cxx:411
 TVectorT.cxx:412
 TVectorT.cxx:413
 TVectorT.cxx:414
 TVectorT.cxx:415
 TVectorT.cxx:416
 TVectorT.cxx:417
 TVectorT.cxx:418
 TVectorT.cxx:419
 TVectorT.cxx:420
 TVectorT.cxx:421
 TVectorT.cxx:422
 TVectorT.cxx:423
 TVectorT.cxx:424
 TVectorT.cxx:425
 TVectorT.cxx:426
 TVectorT.cxx:427
 TVectorT.cxx:428
 TVectorT.cxx:429
 TVectorT.cxx:430
 TVectorT.cxx:431
 TVectorT.cxx:432
 TVectorT.cxx:433
 TVectorT.cxx:434
 TVectorT.cxx:435
 TVectorT.cxx:436
 TVectorT.cxx:437
 TVectorT.cxx:438
 TVectorT.cxx:439
 TVectorT.cxx:440
 TVectorT.cxx:441
 TVectorT.cxx:442
 TVectorT.cxx:443
 TVectorT.cxx:444
 TVectorT.cxx:445
 TVectorT.cxx:446
 TVectorT.cxx:447
 TVectorT.cxx:448
 TVectorT.cxx:449
 TVectorT.cxx:450
 TVectorT.cxx:451
 TVectorT.cxx:452
 TVectorT.cxx:453
 TVectorT.cxx:454
 TVectorT.cxx:455
 TVectorT.cxx:456
 TVectorT.cxx:457
 TVectorT.cxx:458
 TVectorT.cxx:459
 TVectorT.cxx:460
 TVectorT.cxx:461
 TVectorT.cxx:462
 TVectorT.cxx:463
 TVectorT.cxx:464
 TVectorT.cxx:465
 TVectorT.cxx:466
 TVectorT.cxx:467
 TVectorT.cxx:468
 TVectorT.cxx:469
 TVectorT.cxx:470
 TVectorT.cxx:471
 TVectorT.cxx:472
 TVectorT.cxx:473
 TVectorT.cxx:474
 TVectorT.cxx:475
 TVectorT.cxx:476
 TVectorT.cxx:477
 TVectorT.cxx:478
 TVectorT.cxx:479
 TVectorT.cxx:480
 TVectorT.cxx:481
 TVectorT.cxx:482
 TVectorT.cxx:483
 TVectorT.cxx:484
 TVectorT.cxx:485
 TVectorT.cxx:486
 TVectorT.cxx:487
 TVectorT.cxx:488
 TVectorT.cxx:489
 TVectorT.cxx:490
 TVectorT.cxx:491
 TVectorT.cxx:492
 TVectorT.cxx:493
 TVectorT.cxx:494
 TVectorT.cxx:495
 TVectorT.cxx:496
 TVectorT.cxx:497
 TVectorT.cxx:498
 TVectorT.cxx:499
 TVectorT.cxx:500
 TVectorT.cxx:501
 TVectorT.cxx:502
 TVectorT.cxx:503
 TVectorT.cxx:504
 TVectorT.cxx:505
 TVectorT.cxx:506
 TVectorT.cxx:507
 TVectorT.cxx:508
 TVectorT.cxx:509
 TVectorT.cxx:510
 TVectorT.cxx:511
 TVectorT.cxx:512
 TVectorT.cxx:513
 TVectorT.cxx:514
 TVectorT.cxx:515
 TVectorT.cxx:516
 TVectorT.cxx:517
 TVectorT.cxx:518
 TVectorT.cxx:519
 TVectorT.cxx:520
 TVectorT.cxx:521
 TVectorT.cxx:522
 TVectorT.cxx:523
 TVectorT.cxx:524
 TVectorT.cxx:525
 TVectorT.cxx:526
 TVectorT.cxx:527
 TVectorT.cxx:528
 TVectorT.cxx:529
 TVectorT.cxx:530
 TVectorT.cxx:531
 TVectorT.cxx:532
 TVectorT.cxx:533
 TVectorT.cxx:534
 TVectorT.cxx:535
 TVectorT.cxx:536
 TVectorT.cxx:537
 TVectorT.cxx:538
 TVectorT.cxx:539
 TVectorT.cxx:540
 TVectorT.cxx:541
 TVectorT.cxx:542
 TVectorT.cxx:543
 TVectorT.cxx:544
 TVectorT.cxx:545
 TVectorT.cxx:546
 TVectorT.cxx:547
 TVectorT.cxx:548
 TVectorT.cxx:549
 TVectorT.cxx:550
 TVectorT.cxx:551
 TVectorT.cxx:552
 TVectorT.cxx:553
 TVectorT.cxx:554
 TVectorT.cxx:555
 TVectorT.cxx:556
 TVectorT.cxx:557
 TVectorT.cxx:558
 TVectorT.cxx:559
 TVectorT.cxx:560
 TVectorT.cxx:561
 TVectorT.cxx:562
 TVectorT.cxx:563
 TVectorT.cxx:564
 TVectorT.cxx:565
 TVectorT.cxx:566
 TVectorT.cxx:567
 TVectorT.cxx:568
 TVectorT.cxx:569
 TVectorT.cxx:570
 TVectorT.cxx:571
 TVectorT.cxx:572
 TVectorT.cxx:573
 TVectorT.cxx:574
 TVectorT.cxx:575
 TVectorT.cxx:576
 TVectorT.cxx:577
 TVectorT.cxx:578
 TVectorT.cxx:579
 TVectorT.cxx:580
 TVectorT.cxx:581
 TVectorT.cxx:582
 TVectorT.cxx:583
 TVectorT.cxx:584
 TVectorT.cxx:585
 TVectorT.cxx:586
 TVectorT.cxx:587
 TVectorT.cxx:588
 TVectorT.cxx:589
 TVectorT.cxx:590
 TVectorT.cxx:591
 TVectorT.cxx:592
 TVectorT.cxx:593
 TVectorT.cxx:594
 TVectorT.cxx:595
 TVectorT.cxx:596
 TVectorT.cxx:597
 TVectorT.cxx:598
 TVectorT.cxx:599
 TVectorT.cxx:600
 TVectorT.cxx:601
 TVectorT.cxx:602
 TVectorT.cxx:603
 TVectorT.cxx:604
 TVectorT.cxx:605
 TVectorT.cxx:606
 TVectorT.cxx:607
 TVectorT.cxx:608
 TVectorT.cxx:609
 TVectorT.cxx:610
 TVectorT.cxx:611
 TVectorT.cxx:612
 TVectorT.cxx:613
 TVectorT.cxx:614
 TVectorT.cxx:615
 TVectorT.cxx:616
 TVectorT.cxx:617
 TVectorT.cxx:618
 TVectorT.cxx:619
 TVectorT.cxx:620
 TVectorT.cxx:621
 TVectorT.cxx:622
 TVectorT.cxx:623
 TVectorT.cxx:624
 TVectorT.cxx:625
 TVectorT.cxx:626
 TVectorT.cxx:627
 TVectorT.cxx:628
 TVectorT.cxx:629
 TVectorT.cxx:630
 TVectorT.cxx:631
 TVectorT.cxx:632
 TVectorT.cxx:633
 TVectorT.cxx:634
 TVectorT.cxx:635
 TVectorT.cxx:636
 TVectorT.cxx:637
 TVectorT.cxx:638
 TVectorT.cxx:639
 TVectorT.cxx:640
 TVectorT.cxx:641
 TVectorT.cxx:642
 TVectorT.cxx:643
 TVectorT.cxx:644
 TVectorT.cxx:645
 TVectorT.cxx:646
 TVectorT.cxx:647
 TVectorT.cxx:648
 TVectorT.cxx:649
 TVectorT.cxx:650
 TVectorT.cxx:651
 TVectorT.cxx:652
 TVectorT.cxx:653
 TVectorT.cxx:654
 TVectorT.cxx:655
 TVectorT.cxx:656
 TVectorT.cxx:657
 TVectorT.cxx:658
 TVectorT.cxx:659
 TVectorT.cxx:660
 TVectorT.cxx:661
 TVectorT.cxx:662
 TVectorT.cxx:663
 TVectorT.cxx:664
 TVectorT.cxx:665
 TVectorT.cxx:666
 TVectorT.cxx:667
 TVectorT.cxx:668
 TVectorT.cxx:669
 TVectorT.cxx:670
 TVectorT.cxx:671
 TVectorT.cxx:672
 TVectorT.cxx:673
 TVectorT.cxx:674
 TVectorT.cxx:675
 TVectorT.cxx:676
 TVectorT.cxx:677
 TVectorT.cxx:678
 TVectorT.cxx:679
 TVectorT.cxx:680
 TVectorT.cxx:681
 TVectorT.cxx:682
 TVectorT.cxx:683
 TVectorT.cxx:684
 TVectorT.cxx:685
 TVectorT.cxx:686
 TVectorT.cxx:687
 TVectorT.cxx:688
 TVectorT.cxx:689
 TVectorT.cxx:690
 TVectorT.cxx:691
 TVectorT.cxx:692
 TVectorT.cxx:693
 TVectorT.cxx:694
 TVectorT.cxx:695
 TVectorT.cxx:696
 TVectorT.cxx:697
 TVectorT.cxx:698
 TVectorT.cxx:699
 TVectorT.cxx:700
 TVectorT.cxx:701
 TVectorT.cxx:702
 TVectorT.cxx:703
 TVectorT.cxx:704
 TVectorT.cxx:705
 TVectorT.cxx:706
 TVectorT.cxx:707
 TVectorT.cxx:708
 TVectorT.cxx:709
 TVectorT.cxx:710
 TVectorT.cxx:711
 TVectorT.cxx:712
 TVectorT.cxx:713
 TVectorT.cxx:714
 TVectorT.cxx:715
 TVectorT.cxx:716
 TVectorT.cxx:717
 TVectorT.cxx:718
 TVectorT.cxx:719
 TVectorT.cxx:720
 TVectorT.cxx:721
 TVectorT.cxx:722
 TVectorT.cxx:723
 TVectorT.cxx:724
 TVectorT.cxx:725
 TVectorT.cxx:726
 TVectorT.cxx:727
 TVectorT.cxx:728
 TVectorT.cxx:729
 TVectorT.cxx:730
 TVectorT.cxx:731
 TVectorT.cxx:732
 TVectorT.cxx:733
 TVectorT.cxx:734
 TVectorT.cxx:735
 TVectorT.cxx:736
 TVectorT.cxx:737
 TVectorT.cxx:738
 TVectorT.cxx:739
 TVectorT.cxx:740
 TVectorT.cxx:741
 TVectorT.cxx:742
 TVectorT.cxx:743
 TVectorT.cxx:744
 TVectorT.cxx:745
 TVectorT.cxx:746
 TVectorT.cxx:747
 TVectorT.cxx:748
 TVectorT.cxx:749
 TVectorT.cxx:750
 TVectorT.cxx:751
 TVectorT.cxx:752
 TVectorT.cxx:753
 TVectorT.cxx:754
 TVectorT.cxx:755
 TVectorT.cxx:756
 TVectorT.cxx:757
 TVectorT.cxx:758
 TVectorT.cxx:759
 TVectorT.cxx:760
 TVectorT.cxx:761
 TVectorT.cxx:762
 TVectorT.cxx:763
 TVectorT.cxx:764
 TVectorT.cxx:765
 TVectorT.cxx:766
 TVectorT.cxx:767
 TVectorT.cxx:768
 TVectorT.cxx:769
 TVectorT.cxx:770
 TVectorT.cxx:771
 TVectorT.cxx:772
 TVectorT.cxx:773
 TVectorT.cxx:774
 TVectorT.cxx:775
 TVectorT.cxx:776
 TVectorT.cxx:777
 TVectorT.cxx:778
 TVectorT.cxx:779
 TVectorT.cxx:780
 TVectorT.cxx:781
 TVectorT.cxx:782
 TVectorT.cxx:783
 TVectorT.cxx:784
 TVectorT.cxx:785
 TVectorT.cxx:786
 TVectorT.cxx:787
 TVectorT.cxx:788
 TVectorT.cxx:789
 TVectorT.cxx:790
 TVectorT.cxx:791
 TVectorT.cxx:792
 TVectorT.cxx:793
 TVectorT.cxx:794
 TVectorT.cxx:795
 TVectorT.cxx:796
 TVectorT.cxx:797
 TVectorT.cxx:798
 TVectorT.cxx:799
 TVectorT.cxx:800
 TVectorT.cxx:801
 TVectorT.cxx:802
 TVectorT.cxx:803
 TVectorT.cxx:804
 TVectorT.cxx:805
 TVectorT.cxx:806
 TVectorT.cxx:807
 TVectorT.cxx:808
 TVectorT.cxx:809
 TVectorT.cxx:810
 TVectorT.cxx:811
 TVectorT.cxx:812
 TVectorT.cxx:813
 TVectorT.cxx:814
 TVectorT.cxx:815
 TVectorT.cxx:816
 TVectorT.cxx:817
 TVectorT.cxx:818
 TVectorT.cxx:819
 TVectorT.cxx:820
 TVectorT.cxx:821
 TVectorT.cxx:822
 TVectorT.cxx:823
 TVectorT.cxx:824
 TVectorT.cxx:825
 TVectorT.cxx:826
 TVectorT.cxx:827
 TVectorT.cxx:828
 TVectorT.cxx:829
 TVectorT.cxx:830
 TVectorT.cxx:831
 TVectorT.cxx:832
 TVectorT.cxx:833
 TVectorT.cxx:834
 TVectorT.cxx:835
 TVectorT.cxx:836
 TVectorT.cxx:837
 TVectorT.cxx:838
 TVectorT.cxx:839
 TVectorT.cxx:840
 TVectorT.cxx:841
 TVectorT.cxx:842
 TVectorT.cxx:843
 TVectorT.cxx:844
 TVectorT.cxx:845
 TVectorT.cxx:846
 TVectorT.cxx:847
 TVectorT.cxx:848
 TVectorT.cxx:849
 TVectorT.cxx:850
 TVectorT.cxx:851
 TVectorT.cxx:852
 TVectorT.cxx:853
 TVectorT.cxx:854
 TVectorT.cxx:855
 TVectorT.cxx:856
 TVectorT.cxx:857
 TVectorT.cxx:858
 TVectorT.cxx:859
 TVectorT.cxx:860
 TVectorT.cxx:861
 TVectorT.cxx:862
 TVectorT.cxx:863
 TVectorT.cxx:864
 TVectorT.cxx:865
 TVectorT.cxx:866
 TVectorT.cxx:867
 TVectorT.cxx:868
 TVectorT.cxx:869
 TVectorT.cxx:870
 TVectorT.cxx:871
 TVectorT.cxx:872
 TVectorT.cxx:873
 TVectorT.cxx:874
 TVectorT.cxx:875
 TVectorT.cxx:876
 TVectorT.cxx:877
 TVectorT.cxx:878
 TVectorT.cxx:879
 TVectorT.cxx:880
 TVectorT.cxx:881
 TVectorT.cxx:882
 TVectorT.cxx:883
 TVectorT.cxx:884
 TVectorT.cxx:885
 TVectorT.cxx:886
 TVectorT.cxx:887
 TVectorT.cxx:888
 TVectorT.cxx:889
 TVectorT.cxx:890
 TVectorT.cxx:891
 TVectorT.cxx:892
 TVectorT.cxx:893
 TVectorT.cxx:894
 TVectorT.cxx:895
 TVectorT.cxx:896
 TVectorT.cxx:897
 TVectorT.cxx:898
 TVectorT.cxx:899
 TVectorT.cxx:900
 TVectorT.cxx:901
 TVectorT.cxx:902
 TVectorT.cxx:903
 TVectorT.cxx:904
 TVectorT.cxx:905
 TVectorT.cxx:906
 TVectorT.cxx:907
 TVectorT.cxx:908
 TVectorT.cxx:909
 TVectorT.cxx:910
 TVectorT.cxx:911
 TVectorT.cxx:912
 TVectorT.cxx:913
 TVectorT.cxx:914
 TVectorT.cxx:915
 TVectorT.cxx:916
 TVectorT.cxx:917
 TVectorT.cxx:918
 TVectorT.cxx:919
 TVectorT.cxx:920
 TVectorT.cxx:921
 TVectorT.cxx:922
 TVectorT.cxx:923
 TVectorT.cxx:924
 TVectorT.cxx:925
 TVectorT.cxx:926
 TVectorT.cxx:927
 TVectorT.cxx:928
 TVectorT.cxx:929
 TVectorT.cxx:930
 TVectorT.cxx:931
 TVectorT.cxx:932
 TVectorT.cxx:933
 TVectorT.cxx:934
 TVectorT.cxx:935
 TVectorT.cxx:936
 TVectorT.cxx:937
 TVectorT.cxx:938
 TVectorT.cxx:939
 TVectorT.cxx:940
 TVectorT.cxx:941
 TVectorT.cxx:942
 TVectorT.cxx:943
 TVectorT.cxx:944
 TVectorT.cxx:945
 TVectorT.cxx:946
 TVectorT.cxx:947
 TVectorT.cxx:948
 TVectorT.cxx:949
 TVectorT.cxx:950
 TVectorT.cxx:951
 TVectorT.cxx:952
 TVectorT.cxx:953
 TVectorT.cxx:954
 TVectorT.cxx:955
 TVectorT.cxx:956
 TVectorT.cxx:957
 TVectorT.cxx:958
 TVectorT.cxx:959
 TVectorT.cxx:960
 TVectorT.cxx:961
 TVectorT.cxx:962
 TVectorT.cxx:963
 TVectorT.cxx:964
 TVectorT.cxx:965
 TVectorT.cxx:966
 TVectorT.cxx:967
 TVectorT.cxx:968
 TVectorT.cxx:969
 TVectorT.cxx:970
 TVectorT.cxx:971
 TVectorT.cxx:972
 TVectorT.cxx:973
 TVectorT.cxx:974
 TVectorT.cxx:975
 TVectorT.cxx:976
 TVectorT.cxx:977
 TVectorT.cxx:978
 TVectorT.cxx:979
 TVectorT.cxx:980
 TVectorT.cxx:981
 TVectorT.cxx:982
 TVectorT.cxx:983
 TVectorT.cxx:984
 TVectorT.cxx:985
 TVectorT.cxx:986
 TVectorT.cxx:987
 TVectorT.cxx:988
 TVectorT.cxx:989
 TVectorT.cxx:990
 TVectorT.cxx:991
 TVectorT.cxx:992
 TVectorT.cxx:993
 TVectorT.cxx:994
 TVectorT.cxx:995
 TVectorT.cxx:996
 TVectorT.cxx:997
 TVectorT.cxx:998
 TVectorT.cxx:999
 TVectorT.cxx:1000
 TVectorT.cxx:1001
 TVectorT.cxx:1002
 TVectorT.cxx:1003
 TVectorT.cxx:1004
 TVectorT.cxx:1005
 TVectorT.cxx:1006
 TVectorT.cxx:1007
 TVectorT.cxx:1008
 TVectorT.cxx:1009
 TVectorT.cxx:1010
 TVectorT.cxx:1011
 TVectorT.cxx:1012
 TVectorT.cxx:1013
 TVectorT.cxx:1014
 TVectorT.cxx:1015
 TVectorT.cxx:1016
 TVectorT.cxx:1017
 TVectorT.cxx:1018
 TVectorT.cxx:1019
 TVectorT.cxx:1020
 TVectorT.cxx:1021
 TVectorT.cxx:1022
 TVectorT.cxx:1023
 TVectorT.cxx:1024
 TVectorT.cxx:1025
 TVectorT.cxx:1026
 TVectorT.cxx:1027
 TVectorT.cxx:1028
 TVectorT.cxx:1029
 TVectorT.cxx:1030
 TVectorT.cxx:1031
 TVectorT.cxx:1032
 TVectorT.cxx:1033
 TVectorT.cxx:1034
 TVectorT.cxx:1035
 TVectorT.cxx:1036
 TVectorT.cxx:1037
 TVectorT.cxx:1038
 TVectorT.cxx:1039
 TVectorT.cxx:1040
 TVectorT.cxx:1041
 TVectorT.cxx:1042
 TVectorT.cxx:1043
 TVectorT.cxx:1044
 TVectorT.cxx:1045
 TVectorT.cxx:1046
 TVectorT.cxx:1047
 TVectorT.cxx:1048
 TVectorT.cxx:1049
 TVectorT.cxx:1050
 TVectorT.cxx:1051
 TVectorT.cxx:1052
 TVectorT.cxx:1053
 TVectorT.cxx:1054
 TVectorT.cxx:1055
 TVectorT.cxx:1056
 TVectorT.cxx:1057
 TVectorT.cxx:1058
 TVectorT.cxx:1059
 TVectorT.cxx:1060
 TVectorT.cxx:1061
 TVectorT.cxx:1062
 TVectorT.cxx:1063
 TVectorT.cxx:1064
 TVectorT.cxx:1065
 TVectorT.cxx:1066
 TVectorT.cxx:1067
 TVectorT.cxx:1068
 TVectorT.cxx:1069
 TVectorT.cxx:1070
 TVectorT.cxx:1071
 TVectorT.cxx:1072
 TVectorT.cxx:1073
 TVectorT.cxx:1074
 TVectorT.cxx:1075
 TVectorT.cxx:1076
 TVectorT.cxx:1077
 TVectorT.cxx:1078
 TVectorT.cxx:1079
 TVectorT.cxx:1080
 TVectorT.cxx:1081
 TVectorT.cxx:1082
 TVectorT.cxx:1083
 TVectorT.cxx:1084
 TVectorT.cxx:1085
 TVectorT.cxx:1086
 TVectorT.cxx:1087
 TVectorT.cxx:1088
 TVectorT.cxx:1089
 TVectorT.cxx:1090
 TVectorT.cxx:1091
 TVectorT.cxx:1092
 TVectorT.cxx:1093
 TVectorT.cxx:1094
 TVectorT.cxx:1095
 TVectorT.cxx:1096
 TVectorT.cxx:1097
 TVectorT.cxx:1098
 TVectorT.cxx:1099
 TVectorT.cxx:1100
 TVectorT.cxx:1101
 TVectorT.cxx:1102
 TVectorT.cxx:1103
 TVectorT.cxx:1104
 TVectorT.cxx:1105
 TVectorT.cxx:1106
 TVectorT.cxx:1107
 TVectorT.cxx:1108
 TVectorT.cxx:1109
 TVectorT.cxx:1110
 TVectorT.cxx:1111
 TVectorT.cxx:1112
 TVectorT.cxx:1113
 TVectorT.cxx:1114
 TVectorT.cxx:1115
 TVectorT.cxx:1116
 TVectorT.cxx:1117
 TVectorT.cxx:1118
 TVectorT.cxx:1119
 TVectorT.cxx:1120
 TVectorT.cxx:1121
 TVectorT.cxx:1122
 TVectorT.cxx:1123
 TVectorT.cxx:1124
 TVectorT.cxx:1125
 TVectorT.cxx:1126
 TVectorT.cxx:1127
 TVectorT.cxx:1128
 TVectorT.cxx:1129
 TVectorT.cxx:1130
 TVectorT.cxx:1131
 TVectorT.cxx:1132
 TVectorT.cxx:1133
 TVectorT.cxx:1134
 TVectorT.cxx:1135
 TVectorT.cxx:1136
 TVectorT.cxx:1137
 TVectorT.cxx:1138
 TVectorT.cxx:1139
 TVectorT.cxx:1140
 TVectorT.cxx:1141
 TVectorT.cxx:1142
 TVectorT.cxx:1143
 TVectorT.cxx:1144
 TVectorT.cxx:1145
 TVectorT.cxx:1146
 TVectorT.cxx:1147
 TVectorT.cxx:1148
 TVectorT.cxx:1149
 TVectorT.cxx:1150
 TVectorT.cxx:1151
 TVectorT.cxx:1152
 TVectorT.cxx:1153
 TVectorT.cxx:1154
 TVectorT.cxx:1155
 TVectorT.cxx:1156
 TVectorT.cxx:1157
 TVectorT.cxx:1158
 TVectorT.cxx:1159
 TVectorT.cxx:1160
 TVectorT.cxx:1161
 TVectorT.cxx:1162
 TVectorT.cxx:1163
 TVectorT.cxx:1164
 TVectorT.cxx:1165
 TVectorT.cxx:1166
 TVectorT.cxx:1167
 TVectorT.cxx:1168
 TVectorT.cxx:1169
 TVectorT.cxx:1170
 TVectorT.cxx:1171
 TVectorT.cxx:1172
 TVectorT.cxx:1173
 TVectorT.cxx:1174
 TVectorT.cxx:1175
 TVectorT.cxx:1176
 TVectorT.cxx:1177
 TVectorT.cxx:1178
 TVectorT.cxx:1179
 TVectorT.cxx:1180
 TVectorT.cxx:1181
 TVectorT.cxx:1182
 TVectorT.cxx:1183
 TVectorT.cxx:1184
 TVectorT.cxx:1185
 TVectorT.cxx:1186
 TVectorT.cxx:1187
 TVectorT.cxx:1188
 TVectorT.cxx:1189
 TVectorT.cxx:1190
 TVectorT.cxx:1191
 TVectorT.cxx:1192
 TVectorT.cxx:1193
 TVectorT.cxx:1194
 TVectorT.cxx:1195
 TVectorT.cxx:1196
 TVectorT.cxx:1197
 TVectorT.cxx:1198
 TVectorT.cxx:1199
 TVectorT.cxx:1200
 TVectorT.cxx:1201
 TVectorT.cxx:1202
 TVectorT.cxx:1203
 TVectorT.cxx:1204
 TVectorT.cxx:1205
 TVectorT.cxx:1206
 TVectorT.cxx:1207
 TVectorT.cxx:1208
 TVectorT.cxx:1209
 TVectorT.cxx:1210
 TVectorT.cxx:1211
 TVectorT.cxx:1212
 TVectorT.cxx:1213
 TVectorT.cxx:1214
 TVectorT.cxx:1215
 TVectorT.cxx:1216
 TVectorT.cxx:1217
 TVectorT.cxx:1218
 TVectorT.cxx:1219
 TVectorT.cxx:1220
 TVectorT.cxx:1221
 TVectorT.cxx:1222
 TVectorT.cxx:1223
 TVectorT.cxx:1224
 TVectorT.cxx:1225
 TVectorT.cxx:1226
 TVectorT.cxx:1227
 TVectorT.cxx:1228
 TVectorT.cxx:1229
 TVectorT.cxx:1230
 TVectorT.cxx:1231
 TVectorT.cxx:1232
 TVectorT.cxx:1233
 TVectorT.cxx:1234
 TVectorT.cxx:1235
 TVectorT.cxx:1236
 TVectorT.cxx:1237
 TVectorT.cxx:1238
 TVectorT.cxx:1239
 TVectorT.cxx:1240
 TVectorT.cxx:1241
 TVectorT.cxx:1242
 TVectorT.cxx:1243
 TVectorT.cxx:1244
 TVectorT.cxx:1245
 TVectorT.cxx:1246
 TVectorT.cxx:1247
 TVectorT.cxx:1248
 TVectorT.cxx:1249
 TVectorT.cxx:1250
 TVectorT.cxx:1251
 TVectorT.cxx:1252
 TVectorT.cxx:1253
 TVectorT.cxx:1254
 TVectorT.cxx:1255
 TVectorT.cxx:1256
 TVectorT.cxx:1257
 TVectorT.cxx:1258
 TVectorT.cxx:1259
 TVectorT.cxx:1260
 TVectorT.cxx:1261
 TVectorT.cxx:1262
 TVectorT.cxx:1263
 TVectorT.cxx:1264
 TVectorT.cxx:1265
 TVectorT.cxx:1266
 TVectorT.cxx:1267
 TVectorT.cxx:1268
 TVectorT.cxx:1269
 TVectorT.cxx:1270
 TVectorT.cxx:1271
 TVectorT.cxx:1272
 TVectorT.cxx:1273
 TVectorT.cxx:1274
 TVectorT.cxx:1275
 TVectorT.cxx:1276
 TVectorT.cxx:1277
 TVectorT.cxx:1278
 TVectorT.cxx:1279
 TVectorT.cxx:1280
 TVectorT.cxx:1281
 TVectorT.cxx:1282
 TVectorT.cxx:1283
 TVectorT.cxx:1284
 TVectorT.cxx:1285
 TVectorT.cxx:1286
 TVectorT.cxx:1287
 TVectorT.cxx:1288
 TVectorT.cxx:1289
 TVectorT.cxx:1290
 TVectorT.cxx:1291
 TVectorT.cxx:1292
 TVectorT.cxx:1293
 TVectorT.cxx:1294
 TVectorT.cxx:1295
 TVectorT.cxx:1296
 TVectorT.cxx:1297
 TVectorT.cxx:1298
 TVectorT.cxx:1299
 TVectorT.cxx:1300
 TVectorT.cxx:1301
 TVectorT.cxx:1302
 TVectorT.cxx:1303
 TVectorT.cxx:1304
 TVectorT.cxx:1305
 TVectorT.cxx:1306
 TVectorT.cxx:1307
 TVectorT.cxx:1308
 TVectorT.cxx:1309
 TVectorT.cxx:1310
 TVectorT.cxx:1311
 TVectorT.cxx:1312
 TVectorT.cxx:1313
 TVectorT.cxx:1314
 TVectorT.cxx:1315
 TVectorT.cxx:1316
 TVectorT.cxx:1317
 TVectorT.cxx:1318
 TVectorT.cxx:1319
 TVectorT.cxx:1320
 TVectorT.cxx:1321
 TVectorT.cxx:1322
 TVectorT.cxx:1323
 TVectorT.cxx:1324
 TVectorT.cxx:1325
 TVectorT.cxx:1326
 TVectorT.cxx:1327
 TVectorT.cxx:1328
 TVectorT.cxx:1329
 TVectorT.cxx:1330
 TVectorT.cxx:1331
 TVectorT.cxx:1332
 TVectorT.cxx:1333
 TVectorT.cxx:1334
 TVectorT.cxx:1335
 TVectorT.cxx:1336
 TVectorT.cxx:1337
 TVectorT.cxx:1338
 TVectorT.cxx:1339
 TVectorT.cxx:1340
 TVectorT.cxx:1341
 TVectorT.cxx:1342
 TVectorT.cxx:1343
 TVectorT.cxx:1344
 TVectorT.cxx:1345
 TVectorT.cxx:1346
 TVectorT.cxx:1347
 TVectorT.cxx:1348
 TVectorT.cxx:1349
 TVectorT.cxx:1350
 TVectorT.cxx:1351
 TVectorT.cxx:1352
 TVectorT.cxx:1353
 TVectorT.cxx:1354
 TVectorT.cxx:1355
 TVectorT.cxx:1356
 TVectorT.cxx:1357
 TVectorT.cxx:1358
 TVectorT.cxx:1359
 TVectorT.cxx:1360
 TVectorT.cxx:1361
 TVectorT.cxx:1362
 TVectorT.cxx:1363
 TVectorT.cxx:1364
 TVectorT.cxx:1365
 TVectorT.cxx:1366
 TVectorT.cxx:1367
 TVectorT.cxx:1368
 TVectorT.cxx:1369
 TVectorT.cxx:1370
 TVectorT.cxx:1371
 TVectorT.cxx:1372
 TVectorT.cxx:1373
 TVectorT.cxx:1374
 TVectorT.cxx:1375
 TVectorT.cxx:1376
 TVectorT.cxx:1377
 TVectorT.cxx:1378
 TVectorT.cxx:1379
 TVectorT.cxx:1380
 TVectorT.cxx:1381
 TVectorT.cxx:1382
 TVectorT.cxx:1383
 TVectorT.cxx:1384
 TVectorT.cxx:1385
 TVectorT.cxx:1386
 TVectorT.cxx:1387
 TVectorT.cxx:1388
 TVectorT.cxx:1389
 TVectorT.cxx:1390
 TVectorT.cxx:1391
 TVectorT.cxx:1392
 TVectorT.cxx:1393
 TVectorT.cxx:1394
 TVectorT.cxx:1395
 TVectorT.cxx:1396
 TVectorT.cxx:1397
 TVectorT.cxx:1398
 TVectorT.cxx:1399
 TVectorT.cxx:1400
 TVectorT.cxx:1401
 TVectorT.cxx:1402
 TVectorT.cxx:1403
 TVectorT.cxx:1404
 TVectorT.cxx:1405
 TVectorT.cxx:1406
 TVectorT.cxx:1407
 TVectorT.cxx:1408
 TVectorT.cxx:1409
 TVectorT.cxx:1410
 TVectorT.cxx:1411
 TVectorT.cxx:1412
 TVectorT.cxx:1413
 TVectorT.cxx:1414
 TVectorT.cxx:1415
 TVectorT.cxx:1416
 TVectorT.cxx:1417
 TVectorT.cxx:1418
 TVectorT.cxx:1419
 TVectorT.cxx:1420
 TVectorT.cxx:1421
 TVectorT.cxx:1422
 TVectorT.cxx:1423
 TVectorT.cxx:1424
 TVectorT.cxx:1425
 TVectorT.cxx:1426
 TVectorT.cxx:1427
 TVectorT.cxx:1428
 TVectorT.cxx:1429
 TVectorT.cxx:1430
 TVectorT.cxx:1431
 TVectorT.cxx:1432
 TVectorT.cxx:1433
 TVectorT.cxx:1434
 TVectorT.cxx:1435
 TVectorT.cxx:1436
 TVectorT.cxx:1437
 TVectorT.cxx:1438
 TVectorT.cxx:1439
 TVectorT.cxx:1440
 TVectorT.cxx:1441
 TVectorT.cxx:1442
 TVectorT.cxx:1443
 TVectorT.cxx:1444
 TVectorT.cxx:1445
 TVectorT.cxx:1446
 TVectorT.cxx:1447
 TVectorT.cxx:1448
 TVectorT.cxx:1449
 TVectorT.cxx:1450
 TVectorT.cxx:1451
 TVectorT.cxx:1452
 TVectorT.cxx:1453
 TVectorT.cxx:1454
 TVectorT.cxx:1455
 TVectorT.cxx:1456
 TVectorT.cxx:1457
 TVectorT.cxx:1458
 TVectorT.cxx:1459
 TVectorT.cxx:1460
 TVectorT.cxx:1461
 TVectorT.cxx:1462
 TVectorT.cxx:1463
 TVectorT.cxx:1464
 TVectorT.cxx:1465
 TVectorT.cxx:1466
 TVectorT.cxx:1467
 TVectorT.cxx:1468
 TVectorT.cxx:1469
 TVectorT.cxx:1470
 TVectorT.cxx:1471
 TVectorT.cxx:1472
 TVectorT.cxx:1473
 TVectorT.cxx:1474
 TVectorT.cxx:1475
 TVectorT.cxx:1476
 TVectorT.cxx:1477
 TVectorT.cxx:1478
 TVectorT.cxx:1479
 TVectorT.cxx:1480
 TVectorT.cxx:1481
 TVectorT.cxx:1482
 TVectorT.cxx:1483
 TVectorT.cxx:1484
 TVectorT.cxx:1485
 TVectorT.cxx:1486
 TVectorT.cxx:1487
 TVectorT.cxx:1488
 TVectorT.cxx:1489
 TVectorT.cxx:1490
 TVectorT.cxx:1491
 TVectorT.cxx:1492
 TVectorT.cxx:1493
 TVectorT.cxx:1494
 TVectorT.cxx:1495
 TVectorT.cxx:1496
 TVectorT.cxx:1497
 TVectorT.cxx:1498
 TVectorT.cxx:1499
 TVectorT.cxx:1500
 TVectorT.cxx:1501
 TVectorT.cxx:1502
 TVectorT.cxx:1503
 TVectorT.cxx:1504
 TVectorT.cxx:1505
 TVectorT.cxx:1506
 TVectorT.cxx:1507
 TVectorT.cxx:1508
 TVectorT.cxx:1509
 TVectorT.cxx:1510
 TVectorT.cxx:1511
 TVectorT.cxx:1512
 TVectorT.cxx:1513
 TVectorT.cxx:1514
 TVectorT.cxx:1515
 TVectorT.cxx:1516
 TVectorT.cxx:1517
 TVectorT.cxx:1518
 TVectorT.cxx:1519
 TVectorT.cxx:1520
 TVectorT.cxx:1521
 TVectorT.cxx:1522
 TVectorT.cxx:1523
 TVectorT.cxx:1524
 TVectorT.cxx:1525
 TVectorT.cxx:1526
 TVectorT.cxx:1527
 TVectorT.cxx:1528
 TVectorT.cxx:1529
 TVectorT.cxx:1530
 TVectorT.cxx:1531
 TVectorT.cxx:1532
 TVectorT.cxx:1533
 TVectorT.cxx:1534
 TVectorT.cxx:1535
 TVectorT.cxx:1536
 TVectorT.cxx:1537
 TVectorT.cxx:1538
 TVectorT.cxx:1539
 TVectorT.cxx:1540
 TVectorT.cxx:1541
 TVectorT.cxx:1542
 TVectorT.cxx:1543
 TVectorT.cxx:1544
 TVectorT.cxx:1545
 TVectorT.cxx:1546
 TVectorT.cxx:1547
 TVectorT.cxx:1548
 TVectorT.cxx:1549
 TVectorT.cxx:1550
 TVectorT.cxx:1551
 TVectorT.cxx:1552
 TVectorT.cxx:1553
 TVectorT.cxx:1554
 TVectorT.cxx:1555
 TVectorT.cxx:1556
 TVectorT.cxx:1557
 TVectorT.cxx:1558
 TVectorT.cxx:1559
 TVectorT.cxx:1560
 TVectorT.cxx:1561
 TVectorT.cxx:1562
 TVectorT.cxx:1563
 TVectorT.cxx:1564
 TVectorT.cxx:1565
 TVectorT.cxx:1566
 TVectorT.cxx:1567
 TVectorT.cxx:1568
 TVectorT.cxx:1569
 TVectorT.cxx:1570
 TVectorT.cxx:1571
 TVectorT.cxx:1572
 TVectorT.cxx:1573
 TVectorT.cxx:1574
 TVectorT.cxx:1575
 TVectorT.cxx:1576
 TVectorT.cxx:1577
 TVectorT.cxx:1578
 TVectorT.cxx:1579
 TVectorT.cxx:1580
 TVectorT.cxx:1581
 TVectorT.cxx:1582
 TVectorT.cxx:1583
 TVectorT.cxx:1584
 TVectorT.cxx:1585
 TVectorT.cxx:1586
 TVectorT.cxx:1587
 TVectorT.cxx:1588
 TVectorT.cxx:1589
 TVectorT.cxx:1590
 TVectorT.cxx:1591
 TVectorT.cxx:1592
 TVectorT.cxx:1593
 TVectorT.cxx:1594
 TVectorT.cxx:1595
 TVectorT.cxx:1596
 TVectorT.cxx:1597
 TVectorT.cxx:1598
 TVectorT.cxx:1599
 TVectorT.cxx:1600
 TVectorT.cxx:1601
 TVectorT.cxx:1602
 TVectorT.cxx:1603
 TVectorT.cxx:1604
 TVectorT.cxx:1605
 TVectorT.cxx:1606
 TVectorT.cxx:1607
 TVectorT.cxx:1608
 TVectorT.cxx:1609
 TVectorT.cxx:1610
 TVectorT.cxx:1611
 TVectorT.cxx:1612
 TVectorT.cxx:1613
 TVectorT.cxx:1614
 TVectorT.cxx:1615
 TVectorT.cxx:1616
 TVectorT.cxx:1617
 TVectorT.cxx:1618
 TVectorT.cxx:1619
 TVectorT.cxx:1620
 TVectorT.cxx:1621
 TVectorT.cxx:1622
 TVectorT.cxx:1623
 TVectorT.cxx:1624
 TVectorT.cxx:1625
 TVectorT.cxx:1626
 TVectorT.cxx:1627
 TVectorT.cxx:1628
 TVectorT.cxx:1629
 TVectorT.cxx:1630
 TVectorT.cxx:1631
 TVectorT.cxx:1632
 TVectorT.cxx:1633
 TVectorT.cxx:1634
 TVectorT.cxx:1635
 TVectorT.cxx:1636
 TVectorT.cxx:1637
 TVectorT.cxx:1638
 TVectorT.cxx:1639
 TVectorT.cxx:1640
 TVectorT.cxx:1641
 TVectorT.cxx:1642
 TVectorT.cxx:1643
 TVectorT.cxx:1644
 TVectorT.cxx:1645
 TVectorT.cxx:1646
 TVectorT.cxx:1647
 TVectorT.cxx:1648
 TVectorT.cxx:1649
 TVectorT.cxx:1650
 TVectorT.cxx:1651
 TVectorT.cxx:1652
 TVectorT.cxx:1653
 TVectorT.cxx:1654
 TVectorT.cxx:1655
 TVectorT.cxx:1656
 TVectorT.cxx:1657
 TVectorT.cxx:1658
 TVectorT.cxx:1659
 TVectorT.cxx:1660
 TVectorT.cxx:1661
 TVectorT.cxx:1662
 TVectorT.cxx:1663
 TVectorT.cxx:1664
 TVectorT.cxx:1665
 TVectorT.cxx:1666
 TVectorT.cxx:1667
 TVectorT.cxx:1668
 TVectorT.cxx:1669
 TVectorT.cxx:1670
 TVectorT.cxx:1671
 TVectorT.cxx:1672
 TVectorT.cxx:1673
 TVectorT.cxx:1674
 TVectorT.cxx:1675
 TVectorT.cxx:1676
 TVectorT.cxx:1677
 TVectorT.cxx:1678
 TVectorT.cxx:1679
 TVectorT.cxx:1680
 TVectorT.cxx:1681
 TVectorT.cxx:1682
 TVectorT.cxx:1683
 TVectorT.cxx:1684
 TVectorT.cxx:1685
 TVectorT.cxx:1686
 TVectorT.cxx:1687
 TVectorT.cxx:1688
 TVectorT.cxx:1689
 TVectorT.cxx:1690
 TVectorT.cxx:1691
 TVectorT.cxx:1692
 TVectorT.cxx:1693
 TVectorT.cxx:1694
 TVectorT.cxx:1695
 TVectorT.cxx:1696
 TVectorT.cxx:1697
 TVectorT.cxx:1698
 TVectorT.cxx:1699
 TVectorT.cxx:1700
 TVectorT.cxx:1701
 TVectorT.cxx:1702
 TVectorT.cxx:1703
 TVectorT.cxx:1704
 TVectorT.cxx:1705
 TVectorT.cxx:1706
 TVectorT.cxx:1707
 TVectorT.cxx:1708
 TVectorT.cxx:1709
 TVectorT.cxx:1710
 TVectorT.cxx:1711
 TVectorT.cxx:1712
 TVectorT.cxx:1713
 TVectorT.cxx:1714
 TVectorT.cxx:1715
 TVectorT.cxx:1716
 TVectorT.cxx:1717
 TVectorT.cxx:1718
 TVectorT.cxx:1719
 TVectorT.cxx:1720
 TVectorT.cxx:1721
 TVectorT.cxx:1722
 TVectorT.cxx:1723
 TVectorT.cxx:1724
 TVectorT.cxx:1725
 TVectorT.cxx:1726
 TVectorT.cxx:1727
 TVectorT.cxx:1728
 TVectorT.cxx:1729
 TVectorT.cxx:1730
 TVectorT.cxx:1731
 TVectorT.cxx:1732
 TVectorT.cxx:1733
 TVectorT.cxx:1734
 TVectorT.cxx:1735
 TVectorT.cxx:1736
 TVectorT.cxx:1737
 TVectorT.cxx:1738
 TVectorT.cxx:1739
 TVectorT.cxx:1740
 TVectorT.cxx:1741
 TVectorT.cxx:1742
 TVectorT.cxx:1743
 TVectorT.cxx:1744
 TVectorT.cxx:1745
 TVectorT.cxx:1746
 TVectorT.cxx:1747
 TVectorT.cxx:1748
 TVectorT.cxx:1749
 TVectorT.cxx:1750
 TVectorT.cxx:1751
 TVectorT.cxx:1752
 TVectorT.cxx:1753
 TVectorT.cxx:1754
 TVectorT.cxx:1755
 TVectorT.cxx:1756
 TVectorT.cxx:1757
 TVectorT.cxx:1758
 TVectorT.cxx:1759
 TVectorT.cxx:1760
 TVectorT.cxx:1761
 TVectorT.cxx:1762
 TVectorT.cxx:1763
 TVectorT.cxx:1764
 TVectorT.cxx:1765
 TVectorT.cxx:1766
 TVectorT.cxx:1767
 TVectorT.cxx:1768
 TVectorT.cxx:1769
 TVectorT.cxx:1770
 TVectorT.cxx:1771
 TVectorT.cxx:1772
 TVectorT.cxx:1773
 TVectorT.cxx:1774
 TVectorT.cxx:1775
 TVectorT.cxx:1776
 TVectorT.cxx:1777
 TVectorT.cxx:1778
 TVectorT.cxx:1779
 TVectorT.cxx:1780
 TVectorT.cxx:1781
 TVectorT.cxx:1782
 TVectorT.cxx:1783
 TVectorT.cxx:1784
 TVectorT.cxx:1785
 TVectorT.cxx:1786
 TVectorT.cxx:1787
 TVectorT.cxx:1788
 TVectorT.cxx:1789
 TVectorT.cxx:1790
 TVectorT.cxx:1791
 TVectorT.cxx:1792
 TVectorT.cxx:1793
 TVectorT.cxx:1794
 TVectorT.cxx:1795
 TVectorT.cxx:1796
 TVectorT.cxx:1797
 TVectorT.cxx:1798
 TVectorT.cxx:1799
 TVectorT.cxx:1800
 TVectorT.cxx:1801
 TVectorT.cxx:1802
 TVectorT.cxx:1803
 TVectorT.cxx:1804
 TVectorT.cxx:1805
 TVectorT.cxx:1806
 TVectorT.cxx:1807
 TVectorT.cxx:1808
 TVectorT.cxx:1809
 TVectorT.cxx:1810
 TVectorT.cxx:1811
 TVectorT.cxx:1812
 TVectorT.cxx:1813
 TVectorT.cxx:1814
 TVectorT.cxx:1815
 TVectorT.cxx:1816
 TVectorT.cxx:1817
 TVectorT.cxx:1818
 TVectorT.cxx:1819
 TVectorT.cxx:1820
 TVectorT.cxx:1821
 TVectorT.cxx:1822
 TVectorT.cxx:1823
 TVectorT.cxx:1824
 TVectorT.cxx:1825
 TVectorT.cxx:1826
 TVectorT.cxx:1827
 TVectorT.cxx:1828
 TVectorT.cxx:1829
 TVectorT.cxx:1830
 TVectorT.cxx:1831
 TVectorT.cxx:1832
 TVectorT.cxx:1833
 TVectorT.cxx:1834
 TVectorT.cxx:1835
 TVectorT.cxx:1836
 TVectorT.cxx:1837
 TVectorT.cxx:1838
 TVectorT.cxx:1839
 TVectorT.cxx:1840
 TVectorT.cxx:1841
 TVectorT.cxx:1842
 TVectorT.cxx:1843
 TVectorT.cxx:1844
 TVectorT.cxx:1845
 TVectorT.cxx:1846
 TVectorT.cxx:1847
 TVectorT.cxx:1848
 TVectorT.cxx:1849
 TVectorT.cxx:1850
 TVectorT.cxx:1851
 TVectorT.cxx:1852
 TVectorT.cxx:1853
 TVectorT.cxx:1854
 TVectorT.cxx:1855
 TVectorT.cxx:1856
 TVectorT.cxx:1857
 TVectorT.cxx:1858
 TVectorT.cxx:1859
 TVectorT.cxx:1860
 TVectorT.cxx:1861
 TVectorT.cxx:1862
 TVectorT.cxx:1863
 TVectorT.cxx:1864
 TVectorT.cxx:1865
 TVectorT.cxx:1866
 TVectorT.cxx:1867
 TVectorT.cxx:1868
 TVectorT.cxx:1869
 TVectorT.cxx:1870
 TVectorT.cxx:1871
 TVectorT.cxx:1872
 TVectorT.cxx:1873
 TVectorT.cxx:1874
 TVectorT.cxx:1875
 TVectorT.cxx:1876
 TVectorT.cxx:1877
 TVectorT.cxx:1878
 TVectorT.cxx:1879
 TVectorT.cxx:1880
 TVectorT.cxx:1881
 TVectorT.cxx:1882
 TVectorT.cxx:1883
 TVectorT.cxx:1884
 TVectorT.cxx:1885
 TVectorT.cxx:1886
 TVectorT.cxx:1887
 TVectorT.cxx:1888
 TVectorT.cxx:1889
 TVectorT.cxx:1890
 TVectorT.cxx:1891
 TVectorT.cxx:1892
 TVectorT.cxx:1893
 TVectorT.cxx:1894
 TVectorT.cxx:1895
 TVectorT.cxx:1896
 TVectorT.cxx:1897
 TVectorT.cxx:1898
 TVectorT.cxx:1899
 TVectorT.cxx:1900
 TVectorT.cxx:1901
 TVectorT.cxx:1902
 TVectorT.cxx:1903
 TVectorT.cxx:1904
 TVectorT.cxx:1905
 TVectorT.cxx:1906
 TVectorT.cxx:1907
 TVectorT.cxx:1908
 TVectorT.cxx:1909
 TVectorT.cxx:1910
 TVectorT.cxx:1911
 TVectorT.cxx:1912
 TVectorT.cxx:1913
 TVectorT.cxx:1914
 TVectorT.cxx:1915
 TVectorT.cxx:1916
 TVectorT.cxx:1917
 TVectorT.cxx:1918
 TVectorT.cxx:1919
 TVectorT.cxx:1920
 TVectorT.cxx:1921
 TVectorT.cxx:1922
 TVectorT.cxx:1923
 TVectorT.cxx:1924
 TVectorT.cxx:1925
 TVectorT.cxx:1926
 TVectorT.cxx:1927
 TVectorT.cxx:1928
 TVectorT.cxx:1929
 TVectorT.cxx:1930
 TVectorT.cxx:1931
 TVectorT.cxx:1932
 TVectorT.cxx:1933
 TVectorT.cxx:1934
 TVectorT.cxx:1935
 TVectorT.cxx:1936
 TVectorT.cxx:1937
 TVectorT.cxx:1938
 TVectorT.cxx:1939
 TVectorT.cxx:1940
 TVectorT.cxx:1941
 TVectorT.cxx:1942
 TVectorT.cxx:1943
 TVectorT.cxx:1944
 TVectorT.cxx:1945
 TVectorT.cxx:1946
 TVectorT.cxx:1947
 TVectorT.cxx:1948
 TVectorT.cxx:1949
 TVectorT.cxx:1950
 TVectorT.cxx:1951
 TVectorT.cxx:1952
 TVectorT.cxx:1953
 TVectorT.cxx:1954
 TVectorT.cxx:1955
 TVectorT.cxx:1956
 TVectorT.cxx:1957
 TVectorT.cxx:1958
 TVectorT.cxx:1959
 TVectorT.cxx:1960
 TVectorT.cxx:1961
 TVectorT.cxx:1962
 TVectorT.cxx:1963
 TVectorT.cxx:1964
 TVectorT.cxx:1965
 TVectorT.cxx:1966
 TVectorT.cxx:1967
 TVectorT.cxx:1968
 TVectorT.cxx:1969
 TVectorT.cxx:1970
 TVectorT.cxx:1971
 TVectorT.cxx:1972
 TVectorT.cxx:1973
 TVectorT.cxx:1974
 TVectorT.cxx:1975
 TVectorT.cxx:1976
 TVectorT.cxx:1977
 TVectorT.cxx:1978
 TVectorT.cxx:1979
 TVectorT.cxx:1980
 TVectorT.cxx:1981
 TVectorT.cxx:1982
 TVectorT.cxx:1983
 TVectorT.cxx:1984
 TVectorT.cxx:1985
 TVectorT.cxx:1986
 TVectorT.cxx:1987
 TVectorT.cxx:1988
 TVectorT.cxx:1989
 TVectorT.cxx:1990
 TVectorT.cxx:1991
 TVectorT.cxx:1992
 TVectorT.cxx:1993
 TVectorT.cxx:1994
 TVectorT.cxx:1995
 TVectorT.cxx:1996
 TVectorT.cxx:1997
 TVectorT.cxx:1998
 TVectorT.cxx:1999
 TVectorT.cxx:2000
 TVectorT.cxx:2001
 TVectorT.cxx:2002
 TVectorT.cxx:2003
 TVectorT.cxx:2004
 TVectorT.cxx:2005
 TVectorT.cxx:2006
 TVectorT.cxx:2007
 TVectorT.cxx:2008
 TVectorT.cxx:2009
 TVectorT.cxx:2010
 TVectorT.cxx:2011
 TVectorT.cxx:2012
 TVectorT.cxx:2013
 TVectorT.cxx:2014
 TVectorT.cxx:2015
 TVectorT.cxx:2016
 TVectorT.cxx:2017
 TVectorT.cxx:2018
 TVectorT.cxx:2019
 TVectorT.cxx:2020
 TVectorT.cxx:2021
 TVectorT.cxx:2022
 TVectorT.cxx:2023
 TVectorT.cxx:2024
 TVectorT.cxx:2025
 TVectorT.cxx:2026
 TVectorT.cxx:2027
 TVectorT.cxx:2028
 TVectorT.cxx:2029
 TVectorT.cxx:2030
 TVectorT.cxx:2031
 TVectorT.cxx:2032
 TVectorT.cxx:2033
 TVectorT.cxx:2034
 TVectorT.cxx:2035
 TVectorT.cxx:2036
 TVectorT.cxx:2037
 TVectorT.cxx:2038
 TVectorT.cxx:2039
 TVectorT.cxx:2040
 TVectorT.cxx:2041
 TVectorT.cxx:2042
 TVectorT.cxx:2043
 TVectorT.cxx:2044
 TVectorT.cxx:2045
 TVectorT.cxx:2046
 TVectorT.cxx:2047
 TVectorT.cxx:2048
 TVectorT.cxx:2049
 TVectorT.cxx:2050
 TVectorT.cxx:2051
 TVectorT.cxx:2052
 TVectorT.cxx:2053
 TVectorT.cxx:2054
 TVectorT.cxx:2055
 TVectorT.cxx:2056
 TVectorT.cxx:2057
 TVectorT.cxx:2058
 TVectorT.cxx:2059
 TVectorT.cxx:2060
 TVectorT.cxx:2061
 TVectorT.cxx:2062
 TVectorT.cxx:2063
 TVectorT.cxx:2064
 TVectorT.cxx:2065
 TVectorT.cxx:2066
 TVectorT.cxx:2067
 TVectorT.cxx:2068
 TVectorT.cxx:2069
 TVectorT.cxx:2070
 TVectorT.cxx:2071
 TVectorT.cxx:2072
 TVectorT.cxx:2073
 TVectorT.cxx:2074
 TVectorT.cxx:2075
 TVectorT.cxx:2076
 TVectorT.cxx:2077
 TVectorT.cxx:2078
 TVectorT.cxx:2079
 TVectorT.cxx:2080
 TVectorT.cxx:2081
 TVectorT.cxx:2082
 TVectorT.cxx:2083
 TVectorT.cxx:2084
 TVectorT.cxx:2085
 TVectorT.cxx:2086
 TVectorT.cxx:2087
 TVectorT.cxx:2088
 TVectorT.cxx:2089
 TVectorT.cxx:2090
 TVectorT.cxx:2091
 TVectorT.cxx:2092
 TVectorT.cxx:2093
 TVectorT.cxx:2094
 TVectorT.cxx:2095
 TVectorT.cxx:2096
 TVectorT.cxx:2097
 TVectorT.cxx:2098
 TVectorT.cxx:2099
 TVectorT.cxx:2100
 TVectorT.cxx:2101
 TVectorT.cxx:2102
 TVectorT.cxx:2103
 TVectorT.cxx:2104
 TVectorT.cxx:2105
 TVectorT.cxx:2106
 TVectorT.cxx:2107
 TVectorT.cxx:2108
 TVectorT.cxx:2109
 TVectorT.cxx:2110
 TVectorT.cxx:2111
 TVectorT.cxx:2112
 TVectorT.cxx:2113
 TVectorT.cxx:2114
 TVectorT.cxx:2115
 TVectorT.cxx:2116
 TVectorT.cxx:2117
 TVectorT.cxx:2118
 TVectorT.cxx:2119
 TVectorT.cxx:2120
 TVectorT.cxx:2121
 TVectorT.cxx:2122
 TVectorT.cxx:2123
 TVectorT.cxx:2124
 TVectorT.cxx:2125
 TVectorT.cxx:2126
 TVectorT.cxx:2127
 TVectorT.cxx:2128
 TVectorT.cxx:2129
 TVectorT.cxx:2130
 TVectorT.cxx:2131
 TVectorT.cxx:2132
 TVectorT.cxx:2133
 TVectorT.cxx:2134
 TVectorT.cxx:2135
 TVectorT.cxx:2136
 TVectorT.cxx:2137
 TVectorT.cxx:2138
 TVectorT.cxx:2139
 TVectorT.cxx:2140
 TVectorT.cxx:2141
 TVectorT.cxx:2142
 TVectorT.cxx:2143
 TVectorT.cxx:2144
 TVectorT.cxx:2145
 TVectorT.cxx:2146
 TVectorT.cxx:2147
 TVectorT.cxx:2148
 TVectorT.cxx:2149
 TVectorT.cxx:2150
 TVectorT.cxx:2151
 TVectorT.cxx:2152
 TVectorT.cxx:2153
 TVectorT.cxx:2154
 TVectorT.cxx:2155
 TVectorT.cxx:2156
 TVectorT.cxx:2157
 TVectorT.cxx:2158
 TVectorT.cxx:2159
 TVectorT.cxx:2160
 TVectorT.cxx:2161
 TVectorT.cxx:2162
 TVectorT.cxx:2163
 TVectorT.cxx:2164
 TVectorT.cxx:2165
 TVectorT.cxx:2166
 TVectorT.cxx:2167
 TVectorT.cxx:2168
 TVectorT.cxx:2169
 TVectorT.cxx:2170
 TVectorT.cxx:2171
 TVectorT.cxx:2172
 TVectorT.cxx:2173
 TVectorT.cxx:2174
 TVectorT.cxx:2175
 TVectorT.cxx:2176
 TVectorT.cxx:2177
 TVectorT.cxx:2178
 TVectorT.cxx:2179
 TVectorT.cxx:2180
 TVectorT.cxx:2181
 TVectorT.cxx:2182
 TVectorT.cxx:2183
 TVectorT.cxx:2184
 TVectorT.cxx:2185
 TVectorT.cxx:2186
 TVectorT.cxx:2187
 TVectorT.cxx:2188
 TVectorT.cxx:2189
 TVectorT.cxx:2190
 TVectorT.cxx:2191
 TVectorT.cxx:2192
 TVectorT.cxx:2193
 TVectorT.cxx:2194
 TVectorT.cxx:2195
 TVectorT.cxx:2196
 TVectorT.cxx:2197
 TVectorT.cxx:2198
 TVectorT.cxx:2199
 TVectorT.cxx:2200
 TVectorT.cxx:2201
 TVectorT.cxx:2202
 TVectorT.cxx:2203
 TVectorT.cxx:2204
 TVectorT.cxx:2205
 TVectorT.cxx:2206
 TVectorT.cxx:2207
 TVectorT.cxx:2208
 TVectorT.cxx:2209
 TVectorT.cxx:2210
 TVectorT.cxx:2211
 TVectorT.cxx:2212
 TVectorT.cxx:2213
 TVectorT.cxx:2214
 TVectorT.cxx:2215
 TVectorT.cxx:2216
 TVectorT.cxx:2217
 TVectorT.cxx:2218
 TVectorT.cxx:2219
 TVectorT.cxx:2220
 TVectorT.cxx:2221
 TVectorT.cxx:2222
 TVectorT.cxx:2223
 TVectorT.cxx:2224
 TVectorT.cxx:2225
 TVectorT.cxx:2226
 TVectorT.cxx:2227
 TVectorT.cxx:2228
 TVectorT.cxx:2229
 TVectorT.cxx:2230
 TVectorT.cxx:2231
 TVectorT.cxx:2232
 TVectorT.cxx:2233
 TVectorT.cxx:2234
 TVectorT.cxx:2235
 TVectorT.cxx:2236
 TVectorT.cxx:2237
 TVectorT.cxx:2238
 TVectorT.cxx:2239
 TVectorT.cxx:2240
 TVectorT.cxx:2241
 TVectorT.cxx:2242
 TVectorT.cxx:2243
 TVectorT.cxx:2244
 TVectorT.cxx:2245
 TVectorT.cxx:2246
 TVectorT.cxx:2247
 TVectorT.cxx:2248
 TVectorT.cxx:2249
 TVectorT.cxx:2250
 TVectorT.cxx:2251
 TVectorT.cxx:2252
 TVectorT.cxx:2253
 TVectorT.cxx:2254
 TVectorT.cxx:2255
 TVectorT.cxx:2256
 TVectorT.cxx:2257
 TVectorT.cxx:2258
 TVectorT.cxx:2259
 TVectorT.cxx:2260
 TVectorT.cxx:2261
 TVectorT.cxx:2262
 TVectorT.cxx:2263
 TVectorT.cxx:2264
 TVectorT.cxx:2265
 TVectorT.cxx:2266
 TVectorT.cxx:2267
 TVectorT.cxx:2268
 TVectorT.cxx:2269
 TVectorT.cxx:2270
 TVectorT.cxx:2271
 TVectorT.cxx:2272
 TVectorT.cxx:2273
 TVectorT.cxx:2274
 TVectorT.cxx:2275
 TVectorT.cxx:2276
 TVectorT.cxx:2277
 TVectorT.cxx:2278
 TVectorT.cxx:2279
 TVectorT.cxx:2280
 TVectorT.cxx:2281
 TVectorT.cxx:2282
 TVectorT.cxx:2283
 TVectorT.cxx:2284
 TVectorT.cxx:2285
 TVectorT.cxx:2286
 TVectorT.cxx:2287
 TVectorT.cxx:2288
 TVectorT.cxx:2289
 TVectorT.cxx:2290
 TVectorT.cxx:2291
 TVectorT.cxx:2292
 TVectorT.cxx:2293
 TVectorT.cxx:2294
 TVectorT.cxx:2295
 TVectorT.cxx:2296
 TVectorT.cxx:2297
 TVectorT.cxx:2298
 TVectorT.cxx:2299
 TVectorT.cxx:2300
 TVectorT.cxx:2301
 TVectorT.cxx:2302
 TVectorT.cxx:2303
 TVectorT.cxx:2304
 TVectorT.cxx:2305
 TVectorT.cxx:2306
 TVectorT.cxx:2307
 TVectorT.cxx:2308
 TVectorT.cxx:2309
 TVectorT.cxx:2310
 TVectorT.cxx:2311
 TVectorT.cxx:2312
 TVectorT.cxx:2313
 TVectorT.cxx:2314
 TVectorT.cxx:2315
 TVectorT.cxx:2316
 TVectorT.cxx:2317
 TVectorT.cxx:2318
 TVectorT.cxx:2319
 TVectorT.cxx:2320
 TVectorT.cxx:2321
 TVectorT.cxx:2322
 TVectorT.cxx:2323
 TVectorT.cxx:2324
 TVectorT.cxx:2325
 TVectorT.cxx:2326
 TVectorT.cxx:2327
 TVectorT.cxx:2328
 TVectorT.cxx:2329
 TVectorT.cxx:2330
 TVectorT.cxx:2331
 TVectorT.cxx:2332
 TVectorT.cxx:2333
 TVectorT.cxx:2334
 TVectorT.cxx:2335
 TVectorT.cxx:2336
 TVectorT.cxx:2337
 TVectorT.cxx:2338
 TVectorT.cxx:2339
 TVectorT.cxx:2340
 TVectorT.cxx:2341
 TVectorT.cxx:2342
 TVectorT.cxx:2343
 TVectorT.cxx:2344
 TVectorT.cxx:2345
 TVectorT.cxx:2346
 TVectorT.cxx:2347
 TVectorT.cxx:2348
 TVectorT.cxx:2349
 TVectorT.cxx:2350
 TVectorT.cxx:2351
 TVectorT.cxx:2352
 TVectorT.cxx:2353
 TVectorT.cxx:2354
 TVectorT.cxx:2355
 TVectorT.cxx:2356
 TVectorT.cxx:2357
 TVectorT.cxx:2358
 TVectorT.cxx:2359
 TVectorT.cxx:2360
 TVectorT.cxx:2361
 TVectorT.cxx:2362
 TVectorT.cxx:2363
 TVectorT.cxx:2364
 TVectorT.cxx:2365
 TVectorT.cxx:2366
 TVectorT.cxx:2367
 TVectorT.cxx:2368
 TVectorT.cxx:2369
 TVectorT.cxx:2370
 TVectorT.cxx:2371
 TVectorT.cxx:2372
 TVectorT.cxx:2373
 TVectorT.cxx:2374
 TVectorT.cxx:2375
 TVectorT.cxx:2376
 TVectorT.cxx:2377
 TVectorT.cxx:2378
 TVectorT.cxx:2379
 TVectorT.cxx:2380
 TVectorT.cxx:2381
 TVectorT.cxx:2382
 TVectorT.cxx:2383
 TVectorT.cxx:2384
 TVectorT.cxx:2385
 TVectorT.cxx:2386
 TVectorT.cxx:2387
 TVectorT.cxx:2388
 TVectorT.cxx:2389
 TVectorT.cxx:2390
 TVectorT.cxx:2391
 TVectorT.cxx:2392
 TVectorT.cxx:2393
 TVectorT.cxx:2394
 TVectorT.cxx:2395
 TVectorT.cxx:2396
 TVectorT.cxx:2397
 TVectorT.cxx:2398
 TVectorT.cxx:2399
 TVectorT.cxx:2400
 TVectorT.cxx:2401
 TVectorT.cxx:2402
 TVectorT.cxx:2403
 TVectorT.cxx:2404
 TVectorT.cxx:2405
 TVectorT.cxx:2406
 TVectorT.cxx:2407
 TVectorT.cxx:2408
 TVectorT.cxx:2409
 TVectorT.cxx:2410
 TVectorT.cxx:2411
 TVectorT.cxx:2412
 TVectorT.cxx:2413
 TVectorT.cxx:2414
 TVectorT.cxx:2415
 TVectorT.cxx:2416
 TVectorT.cxx:2417
 TVectorT.cxx:2418
 TVectorT.cxx:2419
 TVectorT.cxx:2420
 TVectorT.cxx:2421
 TVectorT.cxx:2422
 TVectorT.cxx:2423
 TVectorT.cxx:2424
 TVectorT.cxx:2425
 TVectorT.cxx:2426
 TVectorT.cxx:2427
 TVectorT.cxx:2428
 TVectorT.cxx:2429
 TVectorT.cxx:2430
 TVectorT.cxx:2431
 TVectorT.cxx:2432
 TVectorT.cxx:2433
 TVectorT.cxx:2434
 TVectorT.cxx:2435
 TVectorT.cxx:2436
 TVectorT.cxx:2437
 TVectorT.cxx:2438
 TVectorT.cxx:2439
 TVectorT.cxx:2440
 TVectorT.cxx:2441
 TVectorT.cxx:2442
 TVectorT.cxx:2443
 TVectorT.cxx:2444
 TVectorT.cxx:2445
 TVectorT.cxx:2446
 TVectorT.cxx:2447
 TVectorT.cxx:2448
 TVectorT.cxx:2449
 TVectorT.cxx:2450
 TVectorT.cxx:2451
 TVectorT.cxx:2452
 TVectorT.cxx:2453
 TVectorT.cxx:2454
 TVectorT.cxx:2455
 TVectorT.cxx:2456
 TVectorT.cxx:2457
 TVectorT.cxx:2458
 TVectorT.cxx:2459
 TVectorT.cxx:2460
 TVectorT.cxx:2461
 TVectorT.cxx:2462
 TVectorT.cxx:2463
 TVectorT.cxx:2464
 TVectorT.cxx:2465
 TVectorT.cxx:2466
 TVectorT.cxx:2467
 TVectorT.cxx:2468
 TVectorT.cxx:2469
 TVectorT.cxx:2470
 TVectorT.cxx:2471
 TVectorT.cxx:2472
 TVectorT.cxx:2473
 TVectorT.cxx:2474
 TVectorT.cxx:2475