ROOT logo
// @(#)root/quadp:$Id: TQpVar.cxx 35018 2010-08-25 16:40:46Z moneta $
// Author: Eddy Offermann   May 2004

/*************************************************************************
 * 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.             *
 *************************************************************************/

/*************************************************************************
 * Parts of this file are copied from the OOQP distribution and          *
 * are subject to the following license:                                 *
 *                                                                       *
 * COPYRIGHT 2001 UNIVERSITY OF CHICAGO                                  *
 *                                                                       *
 * The copyright holder hereby grants you royalty-free rights to use,    *
 * reproduce, prepare derivative works, and to redistribute this software*
 * to others, provided that any changes are clearly documented. This     *
 * software was authored by:                                             *
 *                                                                       *
 *   E. MICHAEL GERTZ      gertz@mcs.anl.gov                             *
 *   Mathematics and Computer Science Division                           *
 *   Argonne National Laboratory                                         *
 *   9700 S. Cass Avenue                                                 *
 *   Argonne, IL 60439-4844                                              *
 *                                                                       *
 *   STEPHEN J. WRIGHT     swright@cs.wisc.edu                           *
 *   Computer Sciences Department                                        *
 *   University of Wisconsin                                             *
 *   1210 West Dayton Street                                             *
 *   Madison, WI 53706   FAX: (608)262-9777                              *
 *                                                                       *
 * Any questions or comments may be directed to one of the authors.      *
 *                                                                       *
 * ARGONNE NATIONAL LABORATORY (ANL), WITH FACILITIES IN THE STATES OF   *
 * ILLINOIS AND IDAHO, IS OWNED BY THE UNITED STATES GOVERNMENT, AND     *
 * OPERATED BY THE UNIVERSITY OF CHICAGO UNDER PROVISION OF A CONTRACT   *
 * WITH THE DEPARTMENT OF ENERGY.                                        *
 *************************************************************************/

///////////////////////////////////////////////////////////////////////////
//                                                                       //
// Class containing the variables for the general QP formulation         //
//                                                                       //
///////////////////////////////////////////////////////////////////////////

#include "Riostream.h"
#include "TQpVar.h"
#include "TMatrixD.h"

ClassImp(TQpVar)

//______________________________________________________________________________
TQpVar::TQpVar()
{
// Default constructor

   fNx   = 0;
   fMy   = 0;
   fMz   = 0;
   fNxup = 0;
   fNxlo = 0;
   fMcup = 0;
   fMclo = 0;
   fNComplementaryVariables = 0;   
}


//______________________________________________________________________________
TQpVar::TQpVar(TVectorD &x_in,TVectorD &s_in,TVectorD &y_in,TVectorD &z_in,
               TVectorD &v_in,TVectorD &gamma_in,TVectorD &w_in,TVectorD &phi_in,
               TVectorD &t_in,TVectorD &lambda_in,TVectorD &u_in,TVectorD &pi_in,
               TVectorD &ixlow_in,TVectorD &ixupp_in,TVectorD &iclow_in,TVectorD &icupp_in)
{
// Constructor

   if (x_in     .GetNrows() > 0) fX.       Use(x_in     .GetNrows(),x_in     .GetMatrixArray());
   if (s_in     .GetNrows() > 0) fS.       Use(s_in     .GetNrows(),s_in     .GetMatrixArray());
   if (y_in     .GetNrows() > 0) fY.       Use(y_in     .GetNrows(),y_in     .GetMatrixArray());
   if (z_in     .GetNrows() > 0) fZ.       Use(z_in     .GetNrows(),z_in     .GetMatrixArray());
   if (v_in     .GetNrows() > 0) fV.       Use(v_in     .GetNrows(),v_in     .GetMatrixArray());
   if (phi_in   .GetNrows() > 0) fPhi.     Use(phi_in   .GetNrows(),phi_in   .GetMatrixArray());
   if (w_in     .GetNrows() > 0) fW.       Use(w_in     .GetNrows(),w_in     .GetMatrixArray());
   if (gamma_in .GetNrows() > 0) fGamma.   Use(gamma_in .GetNrows(),gamma_in .GetMatrixArray());
   if (t_in     .GetNrows() > 0) fT.       Use(t_in     .GetNrows(),t_in     .GetMatrixArray());
   if (lambda_in.GetNrows() > 0) fLambda.  Use(lambda_in.GetNrows(),lambda_in.GetMatrixArray());
   if (u_in     .GetNrows() > 0) fU.       Use(u_in     .GetNrows(),u_in     .GetMatrixArray());
   if (pi_in    .GetNrows() > 0) fPi.      Use(pi_in    .GetNrows(),pi_in    .GetMatrixArray());
   if (ixlow_in .GetNrows() > 0) fXloIndex.Use(ixlow_in .GetNrows(),ixlow_in .GetMatrixArray());
   if (ixupp_in .GetNrows() > 0) fXupIndex.Use(ixupp_in .GetNrows(),ixupp_in .GetMatrixArray());
   if (iclow_in .GetNrows() > 0) fCloIndex.Use(iclow_in .GetNrows(),iclow_in .GetMatrixArray());
   if (icupp_in .GetNrows() > 0) fCupIndex.Use(icupp_in .GetNrows(),icupp_in .GetMatrixArray());

   fNx = fX.GetNrows();
   fMy = fY.GetNrows();
   fMz = fZ.GetNrows();

   R__ASSERT(fNx == fXloIndex.GetNrows() || 0 == fXloIndex.GetNrows());
   R__ASSERT(fNx == fXloIndex.GetNrows() || 0 == fXloIndex.GetNrows());
   R__ASSERT(fMz == fCloIndex.GetNrows() || 0 == fCloIndex.GetNrows());
   R__ASSERT(fMz == fCupIndex.GetNrows() || 0 == fCupIndex.GetNrows());

   fNxlo = fXloIndex.NonZeros();
   fNxup = fXupIndex.NonZeros();
   fMclo = fCloIndex.NonZeros();
   fMcup = fCupIndex.NonZeros();
   fNComplementaryVariables = fMclo+fMcup+fNxlo+fNxup;

   R__ASSERT(fMz == fS.GetNrows());
   R__ASSERT(fNx == fV     .GetNrows() || (0 == fV     .GetNrows() && fNxlo == 0));
   R__ASSERT(fNx == fGamma .GetNrows() || (0 == fGamma .GetNrows() && fNxlo == 0));

   R__ASSERT(fNx == fW     .GetNrows() || (0 == fW     .GetNrows() && fNxup == 0));
   R__ASSERT(fNx == fPhi   .GetNrows() || (0 == fPhi   .GetNrows() && fNxup == 0));

   R__ASSERT(fMz == fT     .GetNrows() || (0 == fT     .GetNrows() && fMclo == 0));
   R__ASSERT(fMz == fLambda.GetNrows() || (0 == fLambda.GetNrows() && fMclo == 0));

   R__ASSERT(fMz == fU     .GetNrows() || (0 == fU     .GetNrows() && fMcup == 0));
   R__ASSERT(fMz == fPi    .GetNrows() || (0 == fPi    .GetNrows() && fMcup == 0));
}


//______________________________________________________________________________
TQpVar::TQpVar(Int_t nx,Int_t my,Int_t mz,TVectorD &ixlow,TVectorD &ixupp,
               TVectorD &iclow,TVectorD &icupp)
{
// Constructor

   R__ASSERT(nx == ixlow.GetNrows() || 0 == ixlow.GetNrows());
   R__ASSERT(nx == ixlow.GetNrows() || 0 == ixlow.GetNrows());
   R__ASSERT(mz == iclow.GetNrows() || 0 == iclow.GetNrows());
   R__ASSERT(mz == icupp.GetNrows() || 0 == icupp.GetNrows());

   fNxlo = ixlow.NonZeros();
   fNxup = ixupp.NonZeros();
   fMclo = iclow.NonZeros();
   fMcup = icupp.NonZeros();

   if (ixlow.GetNrows() > 0) fXloIndex.Use(ixlow.GetNrows(),ixlow.GetMatrixArray());
   if (ixupp.GetNrows() > 0) fXupIndex.Use(ixupp.GetNrows(),ixupp.GetMatrixArray());
   if (iclow.GetNrows() > 0) fCloIndex.Use(iclow.GetNrows(),iclow.GetMatrixArray());
   if (icupp.GetNrows() > 0) fCupIndex.Use(icupp.GetNrows(),icupp.GetMatrixArray());

   fNx = nx;
   fMy = my;
   fMz = mz;

   if (fMclo > 0) {
      fT.ResizeTo(fMz);
      fLambda.ResizeTo(fMz);
   }
   if (fMcup > 0) {
      fU.ResizeTo(fMz);
      fPi.ResizeTo(fMz);
   }
   if (fNxlo > 0) {
      fV.ResizeTo(fNx);
      fGamma.ResizeTo(fNx);
   }

   if (fNxup > 0) {
      fW.ResizeTo(fNx);
      fPhi.ResizeTo(fNx);
   }

   fS.ResizeTo(fMz);
   fX.ResizeTo(fNx);
   fY.ResizeTo(fMy);
   fZ.ResizeTo(fMz);
   fNComplementaryVariables = fMclo+fMcup+fNxlo+fNxup;
}


//______________________________________________________________________________
TQpVar::TQpVar(const TQpVar &another) : TObject(another)
{
// Copy constructor

   *this = another;
}


//______________________________________________________________________________
Double_t TQpVar::GetMu()
{
// compute complementarity gap, obtained by taking the inner product of the
// complementary vectors and dividing by the total number of components
// computes mu = (t'lambda +u'pi + v'gamma + w'phi)/(mclow+mcupp+nxlow+nxupp)

   Double_t mu = 0.0;
   if (fNComplementaryVariables > 0 ) {
      if (fMclo > 0) mu += fT*fLambda;
      if (fMcup > 0) mu += fU*fPi;
      if (fNxlo > 0) mu += fV*fGamma;
      if (fNxup > 0) mu += fW*fPhi;

      mu /= fNComplementaryVariables;
   }
   return mu;
}


//______________________________________________________________________________
Double_t TQpVar::MuStep(TQpVar *step,Double_t alpha)
{
// Compute the complementarity gap resulting from a step of length "alpha" along
// direction "step"

   Double_t mu = 0.0;
   if (fNComplementaryVariables > 0) {
      if (fMclo > 0)
         mu += (fT+alpha*step->fT)*(fLambda+alpha*step->fLambda);
      if (fMcup > 0)
         mu += (fU+alpha*step->fU)*(fPi+alpha*step->fPi);
      if (fNxlo > 0)
         mu += (fV+alpha*step->fV)*(fGamma+alpha*step->fGamma);
      if (fNxup > 0)
         mu += (fW+alpha*step->fW)*(fPhi+alpha*step->fPhi);
      mu /= fNComplementaryVariables;
   }
   return mu;
}


//______________________________________________________________________________
void TQpVar::Saxpy(TQpVar *b,Double_t alpha)
{
// Perform a "saxpy" operation on all data vectors : x += alpha*y

   Add(fX,alpha,b->fX);
   Add(fY,alpha,b->fY);
   Add(fZ,alpha,b->fZ);
   Add(fS,alpha,b->fS);
   if (fMclo > 0) {
      R__ASSERT((b->fT)     .MatchesNonZeroPattern(fCloIndex) &&
         (b->fLambda).MatchesNonZeroPattern(fCloIndex));

      Add(fT     ,alpha,b->fT);
      Add(fLambda,alpha,b->fLambda);
   }
   if (fMcup > 0) {
      R__ASSERT((b->fU) .MatchesNonZeroPattern(fCupIndex) &&
         (b->fPi).MatchesNonZeroPattern(fCupIndex));

      Add(fU ,alpha,b->fU);
      Add(fPi,alpha,b->fPi);
   }
   if (fNxlo > 0) {
      R__ASSERT((b->fV)    .MatchesNonZeroPattern(fXloIndex) &&
         (b->fGamma).MatchesNonZeroPattern(fXloIndex));

      Add(fV    ,alpha,b->fV);
      Add(fGamma,alpha,b->fGamma);
   }
   if (fNxup > 0) {
      R__ASSERT((b->fW)  .MatchesNonZeroPattern(fXupIndex) &&
         (b->fPhi).MatchesNonZeroPattern(fXupIndex));

      Add(fW  ,alpha,b->fW);
      Add(fPhi,alpha,b->fPhi);
   }
}


//______________________________________________________________________________
void TQpVar::Negate()
{
// Perform a "negate" operation on all data vectors : x =  -x

   fS *= -1.;
   fX *= -1.;
   fY *= -1.;
   fZ *= -1.;
   if (fMclo > 0) {
      fT      *= -1.;
      fLambda *= -1.;
   }
   if (fMcup > 0) {
      fU  *= -1.;
      fPi *= -1.;
   }
   if (fNxlo > 0) {
      fV     *= -1.;
      fGamma *= -1.;
   }
   if (fNxup > 0) {
      fW   *= -1.;
      fPhi *= -1.;
   }
}


//______________________________________________________________________________
Double_t TQpVar::StepBound(TQpVar *b)
{
// calculate the largest alpha in (0,1] such that the/ nonnegative variables stay
// nonnegative in the given search direction. In the general QP problem formulation
// this is the largest value of alpha such that
//     (t,u,v,w,lambda,pi,phi,gamma) + alpha * (b->t,b->u,b->v,b->w,b->lambda,b->pi,
//                                                b->phi,b->gamma) >= 0.

   Double_t maxStep = 1.0;

   if (fMclo > 0 ) {
      R__ASSERT(fT     .SomePositive(fCloIndex));
      R__ASSERT(fLambda.SomePositive(fCloIndex));

      maxStep = this->StepBound(fT,     b->fT,     maxStep);
      maxStep = this->StepBound(fLambda,b->fLambda,maxStep);
   }

   if (fMcup > 0 ) {
      R__ASSERT(fU .SomePositive(fCupIndex));
      R__ASSERT(fPi.SomePositive(fCupIndex));

      maxStep = this->StepBound(fU, b->fU, maxStep);
      maxStep = this->StepBound(fPi,b->fPi,maxStep);
   }

   if (fNxlo > 0 ) {
      R__ASSERT(fV    .SomePositive(fXloIndex));
      R__ASSERT(fGamma.SomePositive(fXloIndex));

      maxStep = this->StepBound(fV,    b->fV,    maxStep);
      maxStep = this->StepBound(fGamma,b->fGamma,maxStep);
   }

   if (fNxup > 0 ) {
      R__ASSERT(fW  .SomePositive(fXupIndex));
      R__ASSERT(fPhi.SomePositive(fXupIndex));

      maxStep = this->StepBound(fW,  b->fW,  maxStep);
      maxStep = this->StepBound(fPhi,b->fPhi,maxStep);
   }

   return maxStep;
}


//______________________________________________________________________________
Double_t TQpVar::StepBound(TVectorD &v,TVectorD &dir,Double_t maxStep)
{
// Find the maximum stepsize of v in direction dir
// before violating the nonnegativity constraints

   if (!AreCompatible(v,dir)) {
      ::Error("StepBound(TVectorD &,TVectorD &,Double_t)","vector's not compatible");
      return kFALSE;
   }

   const Int_t n = v.GetNrows();
   const Double_t * const pD = dir.GetMatrixArray();
   const Double_t * const pV = v.GetMatrixArray();

   Double_t bound = maxStep;
   for (Int_t i = 0; i < n; i++) {
      Double_t tmp = pD[i];
      if ( pV[i] >= 0 && tmp < 0 ) {
         tmp = -pV[i]/tmp;
         if (tmp < bound)
            bound = tmp;
      }
   }
   return bound;
}


//______________________________________________________________________________
Bool_t TQpVar::IsInteriorPoint()
{
// Is the current position an interior point  ?

   Bool_t interior = kTRUE;
   if (fMclo > 0)
      interior = interior &&
         fT.SomePositive(fCloIndex) && fLambda.SomePositive(fCloIndex);

   if (fMcup > 0)
      interior = interior &&
         fU.SomePositive(fCupIndex) && fPi.SomePositive(fCupIndex);

   if (fNxlo > 0)
      interior = interior &&
         fV.SomePositive(fXloIndex) && fGamma.SomePositive(fXloIndex);

   if (fNxup > 0)
      interior = interior &&
         fW.SomePositive(fXupIndex) && fPhi.SomePositive(fXupIndex);

   return interior;
}


//______________________________________________________________________________
Double_t TQpVar::FindBlocking(TQpVar   *step,
                              Double_t &primalValue,
                              Double_t &primalStep,
                              Double_t &dualValue,
                              Double_t &dualStep,
                              Int_t    &fIrstOrSecond)
{
// Performs the same function as StepBound, and supplies additional information about
// which component of the nonnegative variables is responsible for restricting alpha.
// In terms of the abstract formulation, the components have the following meanings :
//
//  primalValue   : the value of the blocking component of the primal variables (u,t,v,w).
//  primalStep    : the corresponding value of the blocking component of the primal step
//                  variables (b->u,b->t,b->v,b->w)
//  dualValue     : the value of the blocking component of the dual variables/
//                  (lambda,pi,phi,gamma).
//  dualStep      : the corresponding value of the blocking component of the dual step
//                   variables (b->lambda,b->pi,b->phi,b->gamma)
//  firstOrSecond : 1 if the primal step is blocking,
//                  2 if the dual step is block,
//                  0 if no step is blocking.

   fIrstOrSecond = 0;
   Double_t alpha = 1.0;
   if (fMclo > 0)
      alpha = FindBlocking(fT,step->fT,fLambda,step->fLambda,alpha,
         primalValue,primalStep,dualValue,dualStep,fIrstOrSecond);

   if (fMcup > 0)
      alpha = FindBlocking(fU,step->fU,fPi,step->fPi,alpha,
         primalValue,primalStep,dualValue,dualStep,fIrstOrSecond);

   if (fNxlo > 0)
      alpha = FindBlocking(fV,step->fV,fGamma,step->fGamma,alpha,
         primalValue,primalStep,dualValue,dualStep,fIrstOrSecond);

   if (fNxup > 0)
      alpha = FindBlocking(fW,step->fW,fPhi,step->fPhi,alpha,
         primalValue,primalStep,dualValue,dualStep,fIrstOrSecond);

   return alpha;
}


//______________________________________________________________________________
Double_t TQpVar::FindBlocking(TVectorD &w,TVectorD &wstep,TVectorD &u,TVectorD &ustep,
                              Double_t maxStep,Double_t &w_elt,Double_t &wstep_elt,Double_t &u_elt,
                              Double_t &ustep_elt,int& fIrst_or_second)
{
// See other FindBlocking function

   return FindBlockingSub(w.GetNrows(),
      w.GetMatrixArray(),    1,
      wstep.GetMatrixArray(),1,
      u.GetMatrixArray(),    1,
      ustep.GetMatrixArray(),1,
      maxStep,
      w_elt,wstep_elt,
      u_elt,ustep_elt,
      fIrst_or_second);
}


//______________________________________________________________________________
Double_t TQpVar::FindBlockingSub(Int_t n,
                                 Double_t *w,    Int_t incw,
                                 Double_t *wstep,Int_t incwstep,
                                 Double_t *u,    Int_t incu,
                                 Double_t *ustep,Int_t incustep,
                                 Double_t maxStep,
                                 Double_t &w_elt,Double_t &wstep_elt,
                                 Double_t &u_elt,Double_t &ustep_elt,
                                 Int_t &fIrst_or_second)
{
// See FindBlocking function

   Double_t bound = maxStep;

   Int_t i = n-1;
   Int_t lastBlocking = -1;

   // Search backward so that we fInd the blocking constraint of lowest
   // index. We do this to make things consistent with MPI's MPI_MINLOC,
   // which returns the processor with smallest rank where a min occurs.
   //
   // Still, going backward is ugly!
   Double_t *pw     = w    +(n-1)*incw;
   Double_t *pwstep = wstep+(n-1)*incwstep;
   Double_t *pu     = u    +(n-1)*incu;
   Double_t *pustep = ustep+(n-1)*incustep;

   while (i >= 0) {
      Double_t tmp = *pwstep;
      if (*pw > 0 && tmp < 0) {
         tmp = -*pw/tmp;
         if( tmp <= bound ) {
            bound = tmp;
            lastBlocking = i;
            fIrst_or_second = 1;
         }
      }
      tmp = *pustep;
      if (*pu > 0 && tmp < 0) {
         tmp = -*pu/tmp;
         if( tmp <= bound ) {
            bound = tmp;
            lastBlocking = i;
            fIrst_or_second = 2;
         }
      }

      i--;
      if (i >= 0) {
         // It is safe to decrement the pointers
         pw     -= incw;
         pwstep -= incwstep;
         pu     -= incu;
         pustep -= incustep;
      }
   }

   if (lastBlocking > -1) {
      // fIll out the elements
      w_elt     = w[lastBlocking];
      wstep_elt = wstep[lastBlocking];
      u_elt     = u[lastBlocking];
      ustep_elt = ustep[lastBlocking];
   }
   return bound;
}


//______________________________________________________________________________
void TQpVar::InteriorPoint(Double_t alpha,Double_t beta)
{
// Sets components of (u,t,v,w) to alpha and of (lambda,pi,phi,gamma) to beta

   fS.Zero();
   fX.Zero();
   fY.Zero();
   fZ.Zero();

   if (fNxlo > 0) {
      fV = alpha;
      fV.SelectNonZeros(fXloIndex);
      fGamma = beta;
      fGamma.SelectNonZeros(fXloIndex);
   }

   if (fNxup > 0) {
      fW = alpha;
      fW.SelectNonZeros(fXupIndex);
      fPhi = beta;
      fPhi.SelectNonZeros(fXupIndex);
   }

   if (fMclo > 0 ) {
      fT = alpha;
      fT.SelectNonZeros(fCloIndex);
      fLambda = beta;
      fLambda.SelectNonZeros(fCloIndex);
   }

   if (fMcup > 0) {
      fU = alpha;
      fU.SelectNonZeros(fCupIndex);
      fPi = beta;
      fPi.SelectNonZeros(fCupIndex);
   }
}


//______________________________________________________________________________
Double_t TQpVar::Violation()
{
// The amount by which the current variables violate the  non-negativity constraints.

   Double_t viol = 0.0;
   Double_t cmin;

   if (fNxlo > 0) {
      cmin = fV.Min();
      if (cmin < viol) viol = cmin;

      cmin = fGamma.Min();
      if (cmin < viol) viol = cmin;
   }
   if (fNxup > 0) {
      cmin = fW.Min();
      if (cmin < viol) viol = cmin;

      cmin = fPhi.Min();
      if (cmin < viol) viol = cmin;
   }
   if (fMclo > 0) {
      cmin = fT.Min();
      if (cmin < viol) viol = cmin;

      cmin = fLambda.Min();
      if (cmin < viol) viol = cmin;
   }
   if (fMcup > 0) {
      cmin = fU.Min();
      if (cmin < viol) viol = cmin;

      cmin = fPi.Min();
      if (cmin < viol) viol = cmin;
   }

   return -viol;
}


//______________________________________________________________________________
void TQpVar::ShiftBoundVariables(Double_t alpha,Double_t beta)
{
// Add alpha to components of (u,t,v,w) and beta to components of (lambda,pi,phi,gamma)

   if (fNxlo > 0) {
      fV    .AddSomeConstant(alpha,fXloIndex);
      fGamma.AddSomeConstant(beta, fXloIndex);
   }
   if (fNxup > 0) {
      fW  .AddSomeConstant(alpha,fXupIndex);
      fPhi.AddSomeConstant(beta, fXupIndex);
   }
   if (fMclo > 0) {
      fT     .AddSomeConstant(alpha,fCloIndex);
      fLambda.AddSomeConstant(beta, fCloIndex);
   }
   if (fMcup > 0) {
      fU .AddSomeConstant(alpha,fCupIndex);
      fPi.AddSomeConstant(beta, fCupIndex);
   }
}


//______________________________________________________________________________
void TQpVar::Print(Option_t * /*option*/) const
{
// Print class members

   cout << "fNx  : " << fNx   << endl;
   cout << "fMy  : " << fMy   << endl;
   cout << "fMz  : " << fMz   << endl;
   cout << "fNxup: " << fNxup << endl;
   cout << "fNxlo: " << fNxlo << endl;
   cout << "fMcup: " << fMcup << endl;
   cout << "fMclo: " << fMclo << endl;

   fXloIndex.Print("fXloIndex");
   fXupIndex.Print("fXupIndex");
   fCupIndex.Print("fCupIndex");
   fCloIndex.Print("fCloIndex");

   fX.Print("fX");
   fS.Print("fS");
   fY.Print("fY");
   fZ.Print("fZ");

   fV.Print("fV");
   fPhi.Print("fPhi");

   fW.Print("fW");
   fGamma.Print("fGamma");

   fT.Print("fT");
   fLambda.Print("fLambda");

   fU.Print("fU");
   fPi.Print("fPi");
}


//______________________________________________________________________________
Double_t TQpVar::Norm1()
{
// Return the sum of the vector-norm1's

   Double_t norm = 0.0;
   norm += fX.Norm1();
   norm += fS.Norm1();
   norm += fY.Norm1();
   norm += fZ.Norm1();

   norm += fV.Norm1();
   norm += fPhi.Norm1();
   norm += fW.Norm1();
   norm += fGamma.Norm1();
   norm += fT.Norm1();
   norm += fLambda.Norm1();
   norm += fU.Norm1();
   norm += fPi.Norm1();

   return norm;
}


//______________________________________________________________________________
Double_t TQpVar::NormInf()
{
// Return the sum of the vector-normInf's

   Double_t norm = 0.0;

   Double_t tmp = fX.NormInf();
   if (tmp > norm) norm = tmp;
   tmp = fS.NormInf();
   if (tmp > norm) norm = tmp;
   tmp = fY.NormInf();
   if (tmp > norm) norm = tmp;
   tmp = fZ.NormInf();
   if (tmp > norm) norm = tmp;

   tmp = fV.NormInf();
   if (tmp > norm) norm = tmp;
   tmp = fPhi.NormInf();
   if (tmp > norm) norm = tmp;

   tmp = fW.NormInf();
   if (tmp > norm) norm = tmp;
   tmp = fGamma.NormInf();
   if (tmp > norm) norm = tmp;

   tmp = fT.NormInf();
   if (tmp > norm) norm = tmp;
   tmp = fLambda.NormInf();
   if (tmp > norm) norm = tmp;

   tmp = fU.NormInf();
   if (tmp > norm) norm = tmp;
   tmp = fPi.NormInf();
   if (tmp > norm) norm = tmp;

   return norm;
}


//______________________________________________________________________________
Bool_t TQpVar::ValidNonZeroPattern()
{
// Check that the variables conform to the non-zero indices

   if (fNxlo > 0 &&
      ( !fV    .MatchesNonZeroPattern(fXloIndex) ||
        !fGamma.MatchesNonZeroPattern(fXloIndex) ) ) {
      return kFALSE;
   }

   if (fNxup > 0 &&
      ( !fW  .MatchesNonZeroPattern(fXupIndex) ||
        !fPhi.MatchesNonZeroPattern(fXupIndex) ) ) {
      return kFALSE;
   }
   if (fMclo > 0 &&
      ( !fT     .MatchesNonZeroPattern(fCloIndex) ||
        !fLambda.MatchesNonZeroPattern(fCloIndex) ) ) {
      return kFALSE;
   }

   if (fMcup > 0 &&
      ( !fU .MatchesNonZeroPattern(fCupIndex) ||
        !fPi.MatchesNonZeroPattern(fCupIndex) ) ) {
      return kFALSE;
   }

   return kTRUE;
}


//______________________________________________________________________________
TQpVar &TQpVar::operator=(const TQpVar &source)
{
// Assignment operator

   if (this != &source) {
      TObject::operator=(source);
      fNx       = source.fNx;
      fMy       = source.fMy;
      fMz       = source.fMz;
      fNxup     = source.fNxup;
      fNxlo     = source.fNxlo;
      fMcup     = source.fMcup;
      fMclo     = source.fMclo;

      fXloIndex = source.fXloIndex;
      fXupIndex = source.fXupIndex;
      fCupIndex = source.fCupIndex;
      fCloIndex = source.fCloIndex;

      fX     .ResizeTo(source.fX);      fX      = source.fX;
      fS     .ResizeTo(source.fS);      fS      = source.fS;
      fY     .ResizeTo(source.fY);      fY      = source.fY;
      fZ     .ResizeTo(source.fZ);      fZ      = source.fZ;

      fV     .ResizeTo(source.fV);      fV      = source.fV;
      fPhi   .ResizeTo(source.fPhi);    fPhi    = source.fPhi;

      fW     .ResizeTo(source.fW);      fW      = source.fW;
      fGamma .ResizeTo(source.fGamma) ; fGamma  = source.fGamma;

      fT     .ResizeTo(source.fT);      fT      = source.fT;
      fLambda.ResizeTo(source.fLambda); fLambda = source.fLambda;

      fU     .ResizeTo(source.fU);      fU      = source.fU;
      fPi    .ResizeTo(source.fPi);     fPi     = source.fPi;

      // LM: copy also this data member
      fNComplementaryVariables = source.fNComplementaryVariables;
   }
   return *this;
}
 TQpVar.cxx:1
 TQpVar.cxx:2
 TQpVar.cxx:3
 TQpVar.cxx:4
 TQpVar.cxx:5
 TQpVar.cxx:6
 TQpVar.cxx:7
 TQpVar.cxx:8
 TQpVar.cxx:9
 TQpVar.cxx:10
 TQpVar.cxx:11
 TQpVar.cxx:12
 TQpVar.cxx:13
 TQpVar.cxx:14
 TQpVar.cxx:15
 TQpVar.cxx:16
 TQpVar.cxx:17
 TQpVar.cxx:18
 TQpVar.cxx:19
 TQpVar.cxx:20
 TQpVar.cxx:21
 TQpVar.cxx:22
 TQpVar.cxx:23
 TQpVar.cxx:24
 TQpVar.cxx:25
 TQpVar.cxx:26
 TQpVar.cxx:27
 TQpVar.cxx:28
 TQpVar.cxx:29
 TQpVar.cxx:30
 TQpVar.cxx:31
 TQpVar.cxx:32
 TQpVar.cxx:33
 TQpVar.cxx:34
 TQpVar.cxx:35
 TQpVar.cxx:36
 TQpVar.cxx:37
 TQpVar.cxx:38
 TQpVar.cxx:39
 TQpVar.cxx:40
 TQpVar.cxx:41
 TQpVar.cxx:42
 TQpVar.cxx:43
 TQpVar.cxx:44
 TQpVar.cxx:45
 TQpVar.cxx:46
 TQpVar.cxx:47
 TQpVar.cxx:48
 TQpVar.cxx:49
 TQpVar.cxx:50
 TQpVar.cxx:51
 TQpVar.cxx:52
 TQpVar.cxx:53
 TQpVar.cxx:54
 TQpVar.cxx:55
 TQpVar.cxx:56
 TQpVar.cxx:57
 TQpVar.cxx:58
 TQpVar.cxx:59
 TQpVar.cxx:60
 TQpVar.cxx:61
 TQpVar.cxx:62
 TQpVar.cxx:63
 TQpVar.cxx:64
 TQpVar.cxx:65
 TQpVar.cxx:66
 TQpVar.cxx:67
 TQpVar.cxx:68
 TQpVar.cxx:69
 TQpVar.cxx:70
 TQpVar.cxx:71
 TQpVar.cxx:72
 TQpVar.cxx:73
 TQpVar.cxx:74
 TQpVar.cxx:75
 TQpVar.cxx:76
 TQpVar.cxx:77
 TQpVar.cxx:78
 TQpVar.cxx:79
 TQpVar.cxx:80
 TQpVar.cxx:81
 TQpVar.cxx:82
 TQpVar.cxx:83
 TQpVar.cxx:84
 TQpVar.cxx:85
 TQpVar.cxx:86
 TQpVar.cxx:87
 TQpVar.cxx:88
 TQpVar.cxx:89
 TQpVar.cxx:90
 TQpVar.cxx:91
 TQpVar.cxx:92
 TQpVar.cxx:93
 TQpVar.cxx:94
 TQpVar.cxx:95
 TQpVar.cxx:96
 TQpVar.cxx:97
 TQpVar.cxx:98
 TQpVar.cxx:99
 TQpVar.cxx:100
 TQpVar.cxx:101
 TQpVar.cxx:102
 TQpVar.cxx:103
 TQpVar.cxx:104
 TQpVar.cxx:105
 TQpVar.cxx:106
 TQpVar.cxx:107
 TQpVar.cxx:108
 TQpVar.cxx:109
 TQpVar.cxx:110
 TQpVar.cxx:111
 TQpVar.cxx:112
 TQpVar.cxx:113
 TQpVar.cxx:114
 TQpVar.cxx:115
 TQpVar.cxx:116
 TQpVar.cxx:117
 TQpVar.cxx:118
 TQpVar.cxx:119
 TQpVar.cxx:120
 TQpVar.cxx:121
 TQpVar.cxx:122
 TQpVar.cxx:123
 TQpVar.cxx:124
 TQpVar.cxx:125
 TQpVar.cxx:126
 TQpVar.cxx:127
 TQpVar.cxx:128
 TQpVar.cxx:129
 TQpVar.cxx:130
 TQpVar.cxx:131
 TQpVar.cxx:132
 TQpVar.cxx:133
 TQpVar.cxx:134
 TQpVar.cxx:135
 TQpVar.cxx:136
 TQpVar.cxx:137
 TQpVar.cxx:138
 TQpVar.cxx:139
 TQpVar.cxx:140
 TQpVar.cxx:141
 TQpVar.cxx:142
 TQpVar.cxx:143
 TQpVar.cxx:144
 TQpVar.cxx:145
 TQpVar.cxx:146
 TQpVar.cxx:147
 TQpVar.cxx:148
 TQpVar.cxx:149
 TQpVar.cxx:150
 TQpVar.cxx:151
 TQpVar.cxx:152
 TQpVar.cxx:153
 TQpVar.cxx:154
 TQpVar.cxx:155
 TQpVar.cxx:156
 TQpVar.cxx:157
 TQpVar.cxx:158
 TQpVar.cxx:159
 TQpVar.cxx:160
 TQpVar.cxx:161
 TQpVar.cxx:162
 TQpVar.cxx:163
 TQpVar.cxx:164
 TQpVar.cxx:165
 TQpVar.cxx:166
 TQpVar.cxx:167
 TQpVar.cxx:168
 TQpVar.cxx:169
 TQpVar.cxx:170
 TQpVar.cxx:171
 TQpVar.cxx:172
 TQpVar.cxx:173
 TQpVar.cxx:174
 TQpVar.cxx:175
 TQpVar.cxx:176
 TQpVar.cxx:177
 TQpVar.cxx:178
 TQpVar.cxx:179
 TQpVar.cxx:180
 TQpVar.cxx:181
 TQpVar.cxx:182
 TQpVar.cxx:183
 TQpVar.cxx:184
 TQpVar.cxx:185
 TQpVar.cxx:186
 TQpVar.cxx:187
 TQpVar.cxx:188
 TQpVar.cxx:189
 TQpVar.cxx:190
 TQpVar.cxx:191
 TQpVar.cxx:192
 TQpVar.cxx:193
 TQpVar.cxx:194
 TQpVar.cxx:195
 TQpVar.cxx:196
 TQpVar.cxx:197
 TQpVar.cxx:198
 TQpVar.cxx:199
 TQpVar.cxx:200
 TQpVar.cxx:201
 TQpVar.cxx:202
 TQpVar.cxx:203
 TQpVar.cxx:204
 TQpVar.cxx:205
 TQpVar.cxx:206
 TQpVar.cxx:207
 TQpVar.cxx:208
 TQpVar.cxx:209
 TQpVar.cxx:210
 TQpVar.cxx:211
 TQpVar.cxx:212
 TQpVar.cxx:213
 TQpVar.cxx:214
 TQpVar.cxx:215
 TQpVar.cxx:216
 TQpVar.cxx:217
 TQpVar.cxx:218
 TQpVar.cxx:219
 TQpVar.cxx:220
 TQpVar.cxx:221
 TQpVar.cxx:222
 TQpVar.cxx:223
 TQpVar.cxx:224
 TQpVar.cxx:225
 TQpVar.cxx:226
 TQpVar.cxx:227
 TQpVar.cxx:228
 TQpVar.cxx:229
 TQpVar.cxx:230
 TQpVar.cxx:231
 TQpVar.cxx:232
 TQpVar.cxx:233
 TQpVar.cxx:234
 TQpVar.cxx:235
 TQpVar.cxx:236
 TQpVar.cxx:237
 TQpVar.cxx:238
 TQpVar.cxx:239
 TQpVar.cxx:240
 TQpVar.cxx:241
 TQpVar.cxx:242
 TQpVar.cxx:243
 TQpVar.cxx:244
 TQpVar.cxx:245
 TQpVar.cxx:246
 TQpVar.cxx:247
 TQpVar.cxx:248
 TQpVar.cxx:249
 TQpVar.cxx:250
 TQpVar.cxx:251
 TQpVar.cxx:252
 TQpVar.cxx:253
 TQpVar.cxx:254
 TQpVar.cxx:255
 TQpVar.cxx:256
 TQpVar.cxx:257
 TQpVar.cxx:258
 TQpVar.cxx:259
 TQpVar.cxx:260
 TQpVar.cxx:261
 TQpVar.cxx:262
 TQpVar.cxx:263
 TQpVar.cxx:264
 TQpVar.cxx:265
 TQpVar.cxx:266
 TQpVar.cxx:267
 TQpVar.cxx:268
 TQpVar.cxx:269
 TQpVar.cxx:270
 TQpVar.cxx:271
 TQpVar.cxx:272
 TQpVar.cxx:273
 TQpVar.cxx:274
 TQpVar.cxx:275
 TQpVar.cxx:276
 TQpVar.cxx:277
 TQpVar.cxx:278
 TQpVar.cxx:279
 TQpVar.cxx:280
 TQpVar.cxx:281
 TQpVar.cxx:282
 TQpVar.cxx:283
 TQpVar.cxx:284
 TQpVar.cxx:285
 TQpVar.cxx:286
 TQpVar.cxx:287
 TQpVar.cxx:288
 TQpVar.cxx:289
 TQpVar.cxx:290
 TQpVar.cxx:291
 TQpVar.cxx:292
 TQpVar.cxx:293
 TQpVar.cxx:294
 TQpVar.cxx:295
 TQpVar.cxx:296
 TQpVar.cxx:297
 TQpVar.cxx:298
 TQpVar.cxx:299
 TQpVar.cxx:300
 TQpVar.cxx:301
 TQpVar.cxx:302
 TQpVar.cxx:303
 TQpVar.cxx:304
 TQpVar.cxx:305
 TQpVar.cxx:306
 TQpVar.cxx:307
 TQpVar.cxx:308
 TQpVar.cxx:309
 TQpVar.cxx:310
 TQpVar.cxx:311
 TQpVar.cxx:312
 TQpVar.cxx:313
 TQpVar.cxx:314
 TQpVar.cxx:315
 TQpVar.cxx:316
 TQpVar.cxx:317
 TQpVar.cxx:318
 TQpVar.cxx:319
 TQpVar.cxx:320
 TQpVar.cxx:321
 TQpVar.cxx:322
 TQpVar.cxx:323
 TQpVar.cxx:324
 TQpVar.cxx:325
 TQpVar.cxx:326
 TQpVar.cxx:327
 TQpVar.cxx:328
 TQpVar.cxx:329
 TQpVar.cxx:330
 TQpVar.cxx:331
 TQpVar.cxx:332
 TQpVar.cxx:333
 TQpVar.cxx:334
 TQpVar.cxx:335
 TQpVar.cxx:336
 TQpVar.cxx:337
 TQpVar.cxx:338
 TQpVar.cxx:339
 TQpVar.cxx:340
 TQpVar.cxx:341
 TQpVar.cxx:342
 TQpVar.cxx:343
 TQpVar.cxx:344
 TQpVar.cxx:345
 TQpVar.cxx:346
 TQpVar.cxx:347
 TQpVar.cxx:348
 TQpVar.cxx:349
 TQpVar.cxx:350
 TQpVar.cxx:351
 TQpVar.cxx:352
 TQpVar.cxx:353
 TQpVar.cxx:354
 TQpVar.cxx:355
 TQpVar.cxx:356
 TQpVar.cxx:357
 TQpVar.cxx:358
 TQpVar.cxx:359
 TQpVar.cxx:360
 TQpVar.cxx:361
 TQpVar.cxx:362
 TQpVar.cxx:363
 TQpVar.cxx:364
 TQpVar.cxx:365
 TQpVar.cxx:366
 TQpVar.cxx:367
 TQpVar.cxx:368
 TQpVar.cxx:369
 TQpVar.cxx:370
 TQpVar.cxx:371
 TQpVar.cxx:372
 TQpVar.cxx:373
 TQpVar.cxx:374
 TQpVar.cxx:375
 TQpVar.cxx:376
 TQpVar.cxx:377
 TQpVar.cxx:378
 TQpVar.cxx:379
 TQpVar.cxx:380
 TQpVar.cxx:381
 TQpVar.cxx:382
 TQpVar.cxx:383
 TQpVar.cxx:384
 TQpVar.cxx:385
 TQpVar.cxx:386
 TQpVar.cxx:387
 TQpVar.cxx:388
 TQpVar.cxx:389
 TQpVar.cxx:390
 TQpVar.cxx:391
 TQpVar.cxx:392
 TQpVar.cxx:393
 TQpVar.cxx:394
 TQpVar.cxx:395
 TQpVar.cxx:396
 TQpVar.cxx:397
 TQpVar.cxx:398
 TQpVar.cxx:399
 TQpVar.cxx:400
 TQpVar.cxx:401
 TQpVar.cxx:402
 TQpVar.cxx:403
 TQpVar.cxx:404
 TQpVar.cxx:405
 TQpVar.cxx:406
 TQpVar.cxx:407
 TQpVar.cxx:408
 TQpVar.cxx:409
 TQpVar.cxx:410
 TQpVar.cxx:411
 TQpVar.cxx:412
 TQpVar.cxx:413
 TQpVar.cxx:414
 TQpVar.cxx:415
 TQpVar.cxx:416
 TQpVar.cxx:417
 TQpVar.cxx:418
 TQpVar.cxx:419
 TQpVar.cxx:420
 TQpVar.cxx:421
 TQpVar.cxx:422
 TQpVar.cxx:423
 TQpVar.cxx:424
 TQpVar.cxx:425
 TQpVar.cxx:426
 TQpVar.cxx:427
 TQpVar.cxx:428
 TQpVar.cxx:429
 TQpVar.cxx:430
 TQpVar.cxx:431
 TQpVar.cxx:432
 TQpVar.cxx:433
 TQpVar.cxx:434
 TQpVar.cxx:435
 TQpVar.cxx:436
 TQpVar.cxx:437
 TQpVar.cxx:438
 TQpVar.cxx:439
 TQpVar.cxx:440
 TQpVar.cxx:441
 TQpVar.cxx:442
 TQpVar.cxx:443
 TQpVar.cxx:444
 TQpVar.cxx:445
 TQpVar.cxx:446
 TQpVar.cxx:447
 TQpVar.cxx:448
 TQpVar.cxx:449
 TQpVar.cxx:450
 TQpVar.cxx:451
 TQpVar.cxx:452
 TQpVar.cxx:453
 TQpVar.cxx:454
 TQpVar.cxx:455
 TQpVar.cxx:456
 TQpVar.cxx:457
 TQpVar.cxx:458
 TQpVar.cxx:459
 TQpVar.cxx:460
 TQpVar.cxx:461
 TQpVar.cxx:462
 TQpVar.cxx:463
 TQpVar.cxx:464
 TQpVar.cxx:465
 TQpVar.cxx:466
 TQpVar.cxx:467
 TQpVar.cxx:468
 TQpVar.cxx:469
 TQpVar.cxx:470
 TQpVar.cxx:471
 TQpVar.cxx:472
 TQpVar.cxx:473
 TQpVar.cxx:474
 TQpVar.cxx:475
 TQpVar.cxx:476
 TQpVar.cxx:477
 TQpVar.cxx:478
 TQpVar.cxx:479
 TQpVar.cxx:480
 TQpVar.cxx:481
 TQpVar.cxx:482
 TQpVar.cxx:483
 TQpVar.cxx:484
 TQpVar.cxx:485
 TQpVar.cxx:486
 TQpVar.cxx:487
 TQpVar.cxx:488
 TQpVar.cxx:489
 TQpVar.cxx:490
 TQpVar.cxx:491
 TQpVar.cxx:492
 TQpVar.cxx:493
 TQpVar.cxx:494
 TQpVar.cxx:495
 TQpVar.cxx:496
 TQpVar.cxx:497
 TQpVar.cxx:498
 TQpVar.cxx:499
 TQpVar.cxx:500
 TQpVar.cxx:501
 TQpVar.cxx:502
 TQpVar.cxx:503
 TQpVar.cxx:504
 TQpVar.cxx:505
 TQpVar.cxx:506
 TQpVar.cxx:507
 TQpVar.cxx:508
 TQpVar.cxx:509
 TQpVar.cxx:510
 TQpVar.cxx:511
 TQpVar.cxx:512
 TQpVar.cxx:513
 TQpVar.cxx:514
 TQpVar.cxx:515
 TQpVar.cxx:516
 TQpVar.cxx:517
 TQpVar.cxx:518
 TQpVar.cxx:519
 TQpVar.cxx:520
 TQpVar.cxx:521
 TQpVar.cxx:522
 TQpVar.cxx:523
 TQpVar.cxx:524
 TQpVar.cxx:525
 TQpVar.cxx:526
 TQpVar.cxx:527
 TQpVar.cxx:528
 TQpVar.cxx:529
 TQpVar.cxx:530
 TQpVar.cxx:531
 TQpVar.cxx:532
 TQpVar.cxx:533
 TQpVar.cxx:534
 TQpVar.cxx:535
 TQpVar.cxx:536
 TQpVar.cxx:537
 TQpVar.cxx:538
 TQpVar.cxx:539
 TQpVar.cxx:540
 TQpVar.cxx:541
 TQpVar.cxx:542
 TQpVar.cxx:543
 TQpVar.cxx:544
 TQpVar.cxx:545
 TQpVar.cxx:546
 TQpVar.cxx:547
 TQpVar.cxx:548
 TQpVar.cxx:549
 TQpVar.cxx:550
 TQpVar.cxx:551
 TQpVar.cxx:552
 TQpVar.cxx:553
 TQpVar.cxx:554
 TQpVar.cxx:555
 TQpVar.cxx:556
 TQpVar.cxx:557
 TQpVar.cxx:558
 TQpVar.cxx:559
 TQpVar.cxx:560
 TQpVar.cxx:561
 TQpVar.cxx:562
 TQpVar.cxx:563
 TQpVar.cxx:564
 TQpVar.cxx:565
 TQpVar.cxx:566
 TQpVar.cxx:567
 TQpVar.cxx:568
 TQpVar.cxx:569
 TQpVar.cxx:570
 TQpVar.cxx:571
 TQpVar.cxx:572
 TQpVar.cxx:573
 TQpVar.cxx:574
 TQpVar.cxx:575
 TQpVar.cxx:576
 TQpVar.cxx:577
 TQpVar.cxx:578
 TQpVar.cxx:579
 TQpVar.cxx:580
 TQpVar.cxx:581
 TQpVar.cxx:582
 TQpVar.cxx:583
 TQpVar.cxx:584
 TQpVar.cxx:585
 TQpVar.cxx:586
 TQpVar.cxx:587
 TQpVar.cxx:588
 TQpVar.cxx:589
 TQpVar.cxx:590
 TQpVar.cxx:591
 TQpVar.cxx:592
 TQpVar.cxx:593
 TQpVar.cxx:594
 TQpVar.cxx:595
 TQpVar.cxx:596
 TQpVar.cxx:597
 TQpVar.cxx:598
 TQpVar.cxx:599
 TQpVar.cxx:600
 TQpVar.cxx:601
 TQpVar.cxx:602
 TQpVar.cxx:603
 TQpVar.cxx:604
 TQpVar.cxx:605
 TQpVar.cxx:606
 TQpVar.cxx:607
 TQpVar.cxx:608
 TQpVar.cxx:609
 TQpVar.cxx:610
 TQpVar.cxx:611
 TQpVar.cxx:612
 TQpVar.cxx:613
 TQpVar.cxx:614
 TQpVar.cxx:615
 TQpVar.cxx:616
 TQpVar.cxx:617
 TQpVar.cxx:618
 TQpVar.cxx:619
 TQpVar.cxx:620
 TQpVar.cxx:621
 TQpVar.cxx:622
 TQpVar.cxx:623
 TQpVar.cxx:624
 TQpVar.cxx:625
 TQpVar.cxx:626
 TQpVar.cxx:627
 TQpVar.cxx:628
 TQpVar.cxx:629
 TQpVar.cxx:630
 TQpVar.cxx:631
 TQpVar.cxx:632
 TQpVar.cxx:633
 TQpVar.cxx:634
 TQpVar.cxx:635
 TQpVar.cxx:636
 TQpVar.cxx:637
 TQpVar.cxx:638
 TQpVar.cxx:639
 TQpVar.cxx:640
 TQpVar.cxx:641
 TQpVar.cxx:642
 TQpVar.cxx:643
 TQpVar.cxx:644
 TQpVar.cxx:645
 TQpVar.cxx:646
 TQpVar.cxx:647
 TQpVar.cxx:648
 TQpVar.cxx:649
 TQpVar.cxx:650
 TQpVar.cxx:651
 TQpVar.cxx:652
 TQpVar.cxx:653
 TQpVar.cxx:654
 TQpVar.cxx:655
 TQpVar.cxx:656
 TQpVar.cxx:657
 TQpVar.cxx:658
 TQpVar.cxx:659
 TQpVar.cxx:660
 TQpVar.cxx:661
 TQpVar.cxx:662
 TQpVar.cxx:663
 TQpVar.cxx:664
 TQpVar.cxx:665
 TQpVar.cxx:666
 TQpVar.cxx:667
 TQpVar.cxx:668
 TQpVar.cxx:669
 TQpVar.cxx:670
 TQpVar.cxx:671
 TQpVar.cxx:672
 TQpVar.cxx:673
 TQpVar.cxx:674
 TQpVar.cxx:675
 TQpVar.cxx:676
 TQpVar.cxx:677
 TQpVar.cxx:678
 TQpVar.cxx:679
 TQpVar.cxx:680
 TQpVar.cxx:681
 TQpVar.cxx:682
 TQpVar.cxx:683
 TQpVar.cxx:684
 TQpVar.cxx:685
 TQpVar.cxx:686
 TQpVar.cxx:687
 TQpVar.cxx:688
 TQpVar.cxx:689
 TQpVar.cxx:690
 TQpVar.cxx:691
 TQpVar.cxx:692
 TQpVar.cxx:693
 TQpVar.cxx:694
 TQpVar.cxx:695
 TQpVar.cxx:696
 TQpVar.cxx:697
 TQpVar.cxx:698
 TQpVar.cxx:699
 TQpVar.cxx:700
 TQpVar.cxx:701
 TQpVar.cxx:702
 TQpVar.cxx:703
 TQpVar.cxx:704
 TQpVar.cxx:705
 TQpVar.cxx:706
 TQpVar.cxx:707
 TQpVar.cxx:708
 TQpVar.cxx:709
 TQpVar.cxx:710
 TQpVar.cxx:711
 TQpVar.cxx:712
 TQpVar.cxx:713
 TQpVar.cxx:714
 TQpVar.cxx:715
 TQpVar.cxx:716
 TQpVar.cxx:717
 TQpVar.cxx:718
 TQpVar.cxx:719
 TQpVar.cxx:720
 TQpVar.cxx:721
 TQpVar.cxx:722
 TQpVar.cxx:723
 TQpVar.cxx:724
 TQpVar.cxx:725
 TQpVar.cxx:726
 TQpVar.cxx:727
 TQpVar.cxx:728
 TQpVar.cxx:729
 TQpVar.cxx:730
 TQpVar.cxx:731
 TQpVar.cxx:732
 TQpVar.cxx:733
 TQpVar.cxx:734
 TQpVar.cxx:735
 TQpVar.cxx:736
 TQpVar.cxx:737
 TQpVar.cxx:738
 TQpVar.cxx:739
 TQpVar.cxx:740
 TQpVar.cxx:741
 TQpVar.cxx:742
 TQpVar.cxx:743
 TQpVar.cxx:744
 TQpVar.cxx:745
 TQpVar.cxx:746
 TQpVar.cxx:747
 TQpVar.cxx:748
 TQpVar.cxx:749
 TQpVar.cxx:750
 TQpVar.cxx:751
 TQpVar.cxx:752
 TQpVar.cxx:753
 TQpVar.cxx:754
 TQpVar.cxx:755
 TQpVar.cxx:756
 TQpVar.cxx:757
 TQpVar.cxx:758
 TQpVar.cxx:759
 TQpVar.cxx:760
 TQpVar.cxx:761
 TQpVar.cxx:762
 TQpVar.cxx:763
 TQpVar.cxx:764
 TQpVar.cxx:765
 TQpVar.cxx:766
 TQpVar.cxx:767
 TQpVar.cxx:768
 TQpVar.cxx:769
 TQpVar.cxx:770
 TQpVar.cxx:771
 TQpVar.cxx:772
 TQpVar.cxx:773
 TQpVar.cxx:774
 TQpVar.cxx:775
 TQpVar.cxx:776
 TQpVar.cxx:777
 TQpVar.cxx:778
 TQpVar.cxx:779
 TQpVar.cxx:780
 TQpVar.cxx:781
 TQpVar.cxx:782
 TQpVar.cxx:783
 TQpVar.cxx:784
 TQpVar.cxx:785
 TQpVar.cxx:786
 TQpVar.cxx:787
 TQpVar.cxx:788
 TQpVar.cxx:789
 TQpVar.cxx:790
 TQpVar.cxx:791
 TQpVar.cxx:792
 TQpVar.cxx:793
 TQpVar.cxx:794
 TQpVar.cxx:795
 TQpVar.cxx:796
 TQpVar.cxx:797
 TQpVar.cxx:798
 TQpVar.cxx:799
 TQpVar.cxx:800
 TQpVar.cxx:801
 TQpVar.cxx:802
 TQpVar.cxx:803
 TQpVar.cxx:804
 TQpVar.cxx:805
 TQpVar.cxx:806
 TQpVar.cxx:807
 TQpVar.cxx:808
 TQpVar.cxx:809