Changeset 508 in Sophya for trunk


Ignore:
Timestamp:
Oct 25, 1999, 12:36:22 PM (26 years ago)
Author:
ansari
Message:

Vector/Matrix OVector/OMatrix cmv 25/10/99

Location:
trunk/SophyaLib
Files:
34 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/NTools/cvector.cc

    r307 r508  
    66
    77//++
    8 // Class        Vector
     8// Class        OVector
    99// Lib  Outils++
    1010// include      cvector.h
    … …  
    1616//++
    1717// Links        Parents
    18 // Matrix
     18// OMatrix
    1919//--
    2020
    … …  
    2424
    2525//++
    26 Vector::Vector(int n)
     26OVector::OVector(int n)
    2727//
    2828//      Constructeur, n = nombre d'éléments.
    2929//--
    30 : Matrix(n, 1)
     30: OMatrix(n, 1)
    3131{END_CONSTRUCTOR}
    3232
    3333
    3434//++
    35 Vector::Vector(int n, double* values)
     35OVector::OVector(int n, double* values)
    3636//
    3737//      Constructeur, à partir des valeurs. Pas d'allocation.
    3838//--
    39 : Matrix(n, 1, values)
     39: OMatrix(n, 1, values)
    4040{END_CONSTRUCTOR}
    4141
    4242
    4343//++
    44 Vector::Vector(const Vector& v)
     44OVector::OVector(const OVector& v)
    4545//
    4646//      Constructeur par copie.
    4747//--
    48 : Matrix(v)
     48: OMatrix(v)
    4949{END_CONSTRUCTOR}
    5050
    5151
    5252//++
    53 Vector::Vector(const Matrix& a)
     53OVector::OVector(const OMatrix& a)
    5454//
    5555//      Constructeur par "copie" à partir d'une matrice, qui doit avoir une seule colonne.
    … …  
    5858//      sizeMismatchErr    si la matrice a plus d'une colonne
    5959//--
    60 : Matrix(a.nr,1)      // Matrix(a) ne marche pas, pourquoi ???? bug gcc ???
     60: OMatrix(a.nr,1)      // OMatrix(a) ne marche pas, pourquoi ???? bug gcc ???
    6161{
    6262  if (a.nc != 1) THROW(sizeMismatchErr);
    … …  
    6666
    6767//++
    68 Vector::Vector(const TVector<r_8>& v)
     68OVector::OVector(const TVector<r_8>& v)
    6969//
    7070//      Constructeur par "copie" a partir d'un TVector<r_8>.
    7171//      Attention, les donnees sont partagees.
    7272//--
    73 : Matrix(v)
     73: OMatrix(v)
    7474{
    7575}
    … …  
    8787
    8888//++
    89 Vector& Vector::operator = (double x)
     89OVector& OVector::operator = (double x)
    9090//
    9191//      Affectation à partir d'un scalaire. Tous les éléments prennent cette valeur.
    … …  
    9898
    9999//++
    100 double operator* (const Vector& v1, const Vector& v2)
     100double operator* (const OVector& v1, const OVector& v2)
    101101//
    102102//      Produit scalaire entre deux vecteurs.
    … …  
    117117
    118118//++
    119 // Vector operator* (const Vector& v, double b)
     119// OVector operator* (const OVector& v, double b)
    120120//      multiplication par un scalaire.
    121121//--
    122122
    123123//++
    124 // Vector operator* (const Matrix& a, const Vector& b)
     124// OVector operator* (const OMatrix& a, const OVector& b)
    125125//      produit matrice*vecteur.
    126126//--
    … …  
    144144
    145145//++
    146 double LinSolveInPlace(Matrix& a, Vector& b)
     146double LinSolveInPlace(OMatrix& a, OVector& b)
    147147//
    148148//      Résolution du système A*C = B
    … …  
    152152  if (a.NCol() != a.NRows()) THROW(sizeMismatchErr);
    153153
    154   return Matrix::GausPiv(a,b);
    155 }
    156 
    157 
    158 //++
    159 double LinSolve(const Matrix& a, const Vector& b, Vector& c)
     154  return OMatrix::GausPiv(a,b);
     155}
     156
     157
     158//++
     159double LinSolve(const OMatrix& a, const OVector& b, OVector& c)
    160160//
    161161//      Résolution du système A*C = B, avec C retourné dans B
    … …  
    165165  if (a.NCol() != a.NRows()) THROW(sizeMismatchErr);
    166166  c = b;
    167   Matrix a1(a);
    168   return Matrix::GausPiv(a1,c);
     167  OMatrix a1(a);
     168  return OMatrix::GausPiv(a1,c);
    169169}
    170170
    171171//////////////////////////////////////////////////////////
    172172//++
    173 Vector Vector::FitResidus(GeneralFit& gfit,double xorg,double dx)
     173OVector OVector::FitResidus(GeneralFit& gfit,double xorg,double dx)
    174174//
    175175//      Retourne une classe contenant les residus du fit ``gfit''.
    … …  
    178178{
    179179if(NElts()<=0)
    180   throw(SzMismatchError("Vector::FitResidus: size mismatch\n"));
     180  throw(SzMismatchError("OVector::FitResidus: size mismatch\n"));
    181181GeneralFunction* f = gfit.GetFunction();
    182182if(f==NULL)
    183   throw(NullPtrError("Vector::FitResidus: NULL pointer\n"));
    184 Vector par = gfit.GetParm();
    185 Vector v(*this);
     183  throw(NullPtrError("OVector::FitResidus: NULL pointer\n"));
     184OVector par = gfit.GetParm();
     185OVector v(*this);
    186186for(int i=0;i<NElts();i++) {
    187187  double x = xorg+i*dx;
    … …  
    192192
    193193//++
    194 Vector Vector::FitFunction(GeneralFit& gfit,double xorg,double dx)
     194OVector OVector::FitFunction(GeneralFit& gfit,double xorg,double dx)
    195195//
    196196//      Retourne une classe contenant la fonction du fit ``gfit''.
    … …  
    199199{
    200200if(NElts()<=0)
    201   throw(SzMismatchError("Vector::FitResidus: size mismatch\n"));
     201  throw(SzMismatchError("OVector::FitResidus: size mismatch\n"));
    202202GeneralFunction* f = gfit.GetFunction();
    203203if(f==NULL)
    204   throw(NullPtrError("Vector::FitResidus: NULL pointer\n"));
    205 Vector par = gfit.GetParm();
    206 Vector v(*this);
     204  throw(NullPtrError("OVector::FitResidus: NULL pointer\n"));
     205OVector par = gfit.GetParm();
     206OVector v(*this);
    207207for(int i=0;i<NElts();i++) {
    208208  double x = xorg+i*dx;

  • trunk/SophyaLib/NTools/cvector.h

    r307 r508  
    1313// Vecteur colonne, en fait une matrice avec une seule colonne, pour faire
    1414// des operations matricielles.
    15 class Vector : public Matrix {
     15class OVector : public OMatrix {
    1616  friend class TVector<r_8>;
    1717public:
    1818  // Constructeur, n = nombre d'elements.
    19   EXPLICIT Vector(int n=1);
     19  EXPLICIT OVector(int n=1);
    2020  // Constructeur, a partir des valeurs. Pas d'allocation.
    21   Vector(int n, double* values);
     21  OVector(int n, double* values);
    2222  // Constructeur par copie
    23   Vector(const Vector& v);
     23  OVector(const OVector& v);
    2424  // Constructeur par "copie" a partir d'une matrice, qui doit avoir une colonne
    2525  // <thrown> sizeMismatchErr </thrown>
    26   Vector(const Matrix& a);
     26  OVector(const OMatrix& a);
    2727  // Constructeur par copie a partir d'un TVector<r_8>
    28   Vector(const TVector<r_8>& v);
     28  OVector(const TVector<r_8>& v);
    2929
    3030  // Construction automatique pour PPF
    … …  
    3232  enum {classId = ClassId_Vector};
    3333  int_4                 ClassId() const         { return classId; }
    34   static PPersist*      Create() {return new Vector(1);}
     34  static PPersist*      Create() {return new OVector(1);}
    3535  // </group>
    3636 
    … …  
    3939  void Realloc(int n, bool force=false);
    4040
    41   Vector& operator = (const Vector& v);
    42   Vector& operator = (double x);
     41  OVector& operator = (const OVector& v);
     42  OVector& operator = (double x);
    4343
    4444  // Acces aux elements
    … …  
    5050  // produit scalaire
    5151  // <group>
    52   friend double operator* (const Vector& v1, const Vector& v2);
    53   friend Vector operator* (const Vector& v, double b)
    54   {return Vector(((Matrix const&)v) * b);}
     52  friend double operator* (const OVector& v1, const OVector& v2);
     53  friend OVector operator* (const OVector& v, double b)
     54  {return OVector(((OMatrix const&)v) * b);}
    5555  // </group>
    5656  // produit matrice*vecteur
    57   friend Vector operator* (const Matrix& a, const Vector& b)
    58   {return Vector(a * ((Matrix const&) (b)));}
     57  friend OVector operator* (const OMatrix& a, const OVector& b)
     58  {return OVector(a * ((OMatrix const&) (b)));}
    5959
    6060  // Nombre de lignes du vecteur
    … …  
    6262
    6363  // Resolution du systeme A*C = B
    64   friend double LinSolve(const Matrix& a, const Vector& b, Vector& c);
     64  friend double LinSolve(const OMatrix& a, const OVector& b, OVector& c);
    6565 
    6666  // Resolution du systeme A*C = B, avec C retourne dans B
    67   friend double LinSolveInPlace(Matrix& a, Vector& b);
     67  friend double LinSolveInPlace(OMatrix& a, OVector& b);
    6868
    6969  // Residus et fonction fittees.
    70   Vector FitResidus(GeneralFit& gfit,double xorg=0.,double dx=1.);
    71   Vector FitFunction(GeneralFit& gfit,double xorg=0.,double dx=1.);
     70  OVector FitResidus(GeneralFit& gfit,double xorg=0.,double dx=1.);
     71  OVector FitFunction(GeneralFit& gfit,double xorg=0.,double dx=1.);
    7272
    7373};
    7474
    7575
    76 inline Vector& Vector::operator = (const Vector& v)
    77 { Matrix::operator =(v); return *this; }
     76inline OVector& OVector::operator = (const OVector& v)
     77{ OMatrix::operator =(v); return *this; }
    7878
    7979
    80 inline double const& Vector::operator()(int n) const
     80inline double const& OVector::operator()(int n) const
    8181{
    8282#ifdef RGCHECK
    … …  
    8787
    8888
    89 inline double& Vector::operator()(int n)
     89inline double& OVector::operator()(int n)
    9090{
    9191#ifdef RGCHECK
    … …  
    9595}
    9696
    97 inline void Vector::Realloc(int n, bool force)
    98 { Matrix::Realloc(n,1,force);}
     97inline void OVector::Realloc(int n, bool force)
     98{ OMatrix::Realloc(n,1,force);}
    9999
    100100

  • trunk/SophyaLib/NTools/difeq.cc

    r244 r508  
    106106//++
    107107DiffEqSolver&
    108 DiffEqSolver::StartV(Vector const& yi, double t)
     108DiffEqSolver::StartV(OVector const& yi, double t)
    109109//
    110110//      Spécifie le point de départ de l'intégration de l'équadif.
    … …  
    169169
    170170//++
    171 // virtual void DiffEqSolver::SolveArr(Matrix&  y, double* t, double tf, int n)=0
     171// virtual void DiffEqSolver::SolveArr(OMatrix&  y, double* t, double tf, int n)=0
    172172//      Lance la résolution de l'équadif, jusqu'à la valeur
    173173//      tf du temps. N valeurs intermédiaires sont retournées dans
    … …  
    189189//++
    190190void
    191 DiffEqSolver::SolveV(Vector& yf, double tf)
     191DiffEqSolver::SolveV(OVector& yf, double tf)
    192192//
    193193//      Lance la résolution de l'équadif, jusqu'à la valeur
    … …  
    201201{
    202202  double t;
    203   Matrix m(1, mFunc->NFuncReal());
     203  OMatrix m(1, mFunc->NFuncReal());
    204204  SolveArr(m, &t, tf, 1);
    205205  yf.Realloc(mFunc->NFunc());
    … …  
    219219  ASSERT(mFunc->NFunc() == 1);
    220220  double t;
    221   Matrix m(1,mFunc->NFuncReal());
     221  OMatrix m(1,mFunc->NFuncReal());
    222222  SolveArr(m, &t, tf, 1);
    223223  yf = m(0,0);
    … …  
    238238{
    239239  double t;
    240   Matrix m(1, mFunc->NFuncReal());
     240  OMatrix m(1, mFunc->NFuncReal());
    241241  SolveArr(m, &t, tf, 1);
    242242  for (int i=0; i<mFunc->NFunc(); i++)
    … …  
    258258{
    259259  ASSERT(mFunc->NFunc() == 1);
    260   Matrix m(n, mFunc->NFuncReal());
     260  OMatrix m(n, mFunc->NFuncReal());
    261261  SolveArr(m, t, tf, n);
    262262  for (int i=0; i<n; i++)
    … …  
    281281//--
    282282{
    283    Matrix m(n, mFunc->NFuncReal());
     283   OMatrix m(n, mFunc->NFuncReal());
    284284   SolveArr(m, t, tf, n);
    285285   for (int i=0; i<n; i++)
    … …  
    318318
    319319//++
    320 //  virtual void ComputeV(Vector& fpi, Vector const& fi)
     320//  virtual void ComputeV(OVector& fpi, OVector const& fi)
    321321//      Calcule les valeurs des dérivées fpi à partir des valeurs
    322322//      des fonctions fi. A redéfinir.
    … …  
    340340
    341341//++
    342 // virtual void AdjustStart(Vector& start, double tstart)
     342// virtual void AdjustStart(OVector& start, double tstart)
    343343//      Pour ajuster le vecteur de départ quand il y a des
    344344//      fonctions à usage interne...
    … …  
    405405
    406406void
    407 DiffEqFcnT1::ComputeV(Vector& fpi, Vector const& fi)
     407DiffEqFcnT1::ComputeV(OVector& fpi, OVector const& fi)
    408408{
    409409  fpi(0) = (*mFcn)(fi(0), fi(1));
    … …  
    412412
    413413void
    414 DiffEqFcnT1::AdjustStart(Vector& start, double tstart)
     414DiffEqFcnT1::AdjustStart(OVector& start, double tstart)
    415415{
    416416  start.Realloc(2);
    … …  
    446446
    447447void
    448 DiffEqFcn2::ComputeV(Vector& fpi, Vector const& fi)
     448DiffEqFcn2::ComputeV(OVector& fpi, OVector const& fi)
    449449{
    450450  fpi(0) = fi(1);
    … …  
    481481
    482482void
    483 DiffEqFcnT2::ComputeV(Vector& fpi, Vector const& fi)
     483DiffEqFcnT2::ComputeV(OVector& fpi, OVector const& fi)
    484484{
    485485  fpi(0) = fi(1);
    … …  
    489489
    490490void
    491 DiffEqFcnT2::AdjustStart(Vector& start, double tstart)
     491DiffEqFcnT2::AdjustStart(OVector& start, double tstart)
    492492{
    493493  start.Realloc(3);
    … …  
    505505//      un vecteur de dimension 3.
    506506//      On fournit une fonction de type
    507 //|     typedef void(*DIFEQFCNV)(Vector& y2, Vector const& y1,
    508 //|                              Vector const& y);
     507//|     typedef void(*DIFEQFCNV)(OVector& y2, OVector const& y1,
     508//|                              OVector const& y);
    509509//      qui retourne y'' en fonction de y' et y.
    510510//      Note : le système résolu est alors en fait
    … …  
    527527
    528528void
    529 DiffEqFcnV::ComputeV(Vector& fpi, Vector const& fi)
     529DiffEqFcnV::ComputeV(OVector& fpi, OVector const& fi)
    530530{
    531531  fpi(0) = fi(3);
    … …  
    582582
    583583void
    584 RK4DiffEq::SolveArr(Matrix& y, double* t, double tf, int n)
     584RK4DiffEq::SolveArr(OMatrix& y, double* t, double tf, int n)
    585585{
    586586  //TIMEF;
    … …  
    592592   double dx = (tf - mXStart)/(n*nStep);
    593593   
    594    Vector yt = mYStart;
     594   OVector yt = mYStart;
    595595
    596596   k1.Realloc(mFunc->NFuncReal());
    … …  
    610610
    611611void
    612 RK4DiffEq::RKStep(Vector& newY, Vector const& y0, double dt)
     612RK4DiffEq::RKStep(OVector& newY, OVector const& y0, double dt)
    613613{
    614614    mFunc->ComputeV(k1, y0);

  • trunk/SophyaLib/NTools/difeq.h

    r307 r508  
    2828 
    2929  // Calcule les valeurs des derivees fpi a partir des valeurs des fonctions fi
    30   virtual void ComputeV(Vector& fpi, Vector const& fi)
     30  virtual void ComputeV(OVector& fpi, OVector const& fi)
    3131       { Compute(fpi(0), fi(0)); }
    3232
    … …  
    4444  // Pour ajuster vecteur de depart quand il y a des fonctions a usage
    4545  // interne...
    46   virtual void AdjustStart(Vector& /*start*/, double /*tstart*/)
     46  virtual void AdjustStart(OVector& /*start*/, double /*tstart*/)
    4747    {}   
    4848protected:
    … …  
    8787  // Implementation de Compute qui va utiliser la fonction fournie
    8888  // au constructeur.
    89   virtual void ComputeV(Vector& fpi, Vector const& fi);
     89  virtual void ComputeV(OVector& fpi, OVector const& fi);
    9090
    9191  // Implementation de AdjustStart qui gere la fonction a usage interne.
    92   virtual void AdjustStart(Vector& start, double tstart);
     92  virtual void AdjustStart(OVector& start, double tstart);
    9393protected:
    9494  DIFEQFCNT1 mFcn;
    … …  
    102102  DiffEqFcn2(DIFEQFCN2);
    103103
    104   virtual void ComputeV(Vector& fpi, Vector const& fi);
     104  virtual void ComputeV(OVector& fpi, OVector const& fi);
    105105protected:
    106106  DIFEQFCN2 mFcn;
    … …  
    121121  // Implementation de Compute qui va utiliser la fonction fournie
    122122  // au constructeur.
    123   virtual void ComputeV(Vector& fpi, Vector const& fi);
     123  virtual void ComputeV(OVector& fpi, OVector const& fi);
    124124
    125125  // Implementation de AdjustStart qui gere la fonction a usage interne.
    126   virtual void AdjustStart(Vector& start, double tstart);
     126  virtual void AdjustStart(OVector& start, double tstart);
    127127protected:
    128128  DIFEQFCNT2 mFcn;
    … …  
    130130
    131131// Cas y'' = f(y',y) avec des 3-vecteurs
    132 typedef void(*DIFEQFCNV)(Vector&, Vector const&, Vector const&);
     132typedef void(*DIFEQFCNV)(OVector&, OVector const&, OVector const&);
    133133
    134134// <summary> y'' = f(y',y,t) </summary>
    135135// Cas y'' = f(y',y,t), on fournit la fonction f, sous la forme
    136 // double f(Vector), et ca construit la bonne DiffEqFunction
     136// double f(OVector), et ca construit la bonne DiffEqFunction
    137137class DiffEqFcnV : public DiffEqFunction {
    138138public:
    139   // Constructeur, on fournit une fonction (Vector)->double
     139  // Constructeur, on fournit une fonction (OVector)->double
    140140  // qui donne y'' en fonction du vecteur (t, y, y')
    141141  DiffEqFcnV(DIFEQFCNV);
    … …  
    143143  // Implementation de Compute qui va utiliser la fonction fournie
    144144  // au constructeur.
    145   virtual void ComputeV(Vector& fpi, Vector const& fi);
     145  virtual void ComputeV(OVector& fpi, OVector const& fi);
    146146protected:
    147147  DIFEQFCNV mFcn;
    148   Vector tmp1, tmp2, tmp3;
     148  OVector tmp1, tmp2, tmp3;
    149149};
    150150
    … …  
    176176  // Change les conditions initiales. Notation chainee possible.
    177177  // <group>
    178   DiffEqSolver& StartV(Vector const& yi, double t);
     178  DiffEqSolver& StartV(OVector const& yi, double t);
    179179  // si NFunc == 1
    180180  DiffEqSolver& Start1(double        yi, double t);
    … …  
    184184  // Lance la resolution, avec ou sans conservation de n valeurs intermediaires
    185185  // <group>
    186   virtual void SolveV(Vector& yf, double tf);
     186  virtual void SolveV(OVector& yf, double tf);
    187187  // si NFunc == 1
    188188  virtual void Solve1(double& yf, double tf); 
    189189  virtual void Solve(double* yf, double tf);
    190   virtual void SolveArr(Matrix&  y, double* t, double tf, int n)=0;
     190  virtual void SolveArr(OMatrix&  y, double* t, double tf, int n)=0;
    191191  // si NFunc == 1
    192192  virtual void SolveArr1(double*  y, double* t, double tf, int n);   
    … …  
    198198  bool mOwnFunc;
    199199
    200   Vector  mYStart;
     200  OVector  mYStart;
    201201  double  mXStart;
    202202  double  mStep;
    … …  
    215215
    216216  // Implementation de RK4
    217   virtual void SolveArr(Matrix& y, double* t, double tf, int n);
     217  virtual void SolveArr(OMatrix& y, double* t, double tf, int n);
    218218
    219219protected:
    220220  // Un pas RK4
    221   void RKStep(Vector& newY, Vector const& y0, double dt);
     221  void RKStep(OVector& newY, OVector const& y0, double dt);
    222222  // Vecteurs utilises en interne, pour ne pas les reallouer.
    223   Vector k1, k2, k3, k4;
     223  OVector k1, k2, k3, k4;
    224224};
    225225

  • trunk/SophyaLib/NTools/fftserver.cc

    r467 r508  
    156156}
    157157
    158 void FFTServer::fftf(Vector& in, Vector& out)
     158void FFTServer::fftf(OVector& in, OVector& out)
    159159{
    160160  int l = in.NElts();
    161 /* ----- Si c'etait un Vector<float> on aurait ecrit comme ca
    162    Pour le moment Vector est double, on passe donc par un tableau
     161/* ----- Si c'etait un OVector<float> on aurait ecrit comme ca
     162   Pour le moment OVector est double, on passe donc par un tableau
    163163   intermediare
    164164// La transformee sur le tableau de flaot se fait en place,
    … …  
    175175}
    176176
    177 void FFTServer::fftb(Vector& in, Vector& out)
     177void FFTServer::fftb(OVector& in, OVector& out)
    178178{
    179179  int l = in.NElts();
    180 /* ----- Si c'etait un Vector<float> on aurait ecrit comme ca
    181    Pour le moment Vector est double, on passe donc par un tableau
     180/* ----- Si c'etait un OVector<float> on aurait ecrit comme ca
     181   Pour le moment OVector est double, on passe donc par un tableau
    182182   intermediare
    183183// La transformee sur le tableau de flaot se fait en place,

  • trunk/SophyaLib/NTools/fftserver.h

    r467 r508  
    1717  virtual void fftf(int l, complex<double>* inout);
    1818  virtual void fftb(int l, complex<double>* inout);
    19   virtual void fftf(Vector& in, Vector& out);
    20   virtual void fftb(Vector& in, Vector& out);
     19  virtual void fftf(OVector& in, OVector& out);
     20  virtual void fftb(OVector& in, OVector& out);
    2121
    2222 protected:
    … …  
    9494  \param inout input array /output backward FFT(original array destroyed)
    9595*/
    96 /*!\fn  virtual void FFTServer::fftf(Vector& in, Vector& out)
     96/*!\fn  virtual void FFTServer::fftf(OVector& in, OVector& out)
    9797  \param in input array
    9898  \param out forward FFT
    9999*/
    100 /*! \fn virtual void FFTServer::fftb(Vector& in, Vector& out)
     100/*! \fn virtual void FFTServer::fftb(OVector& in, OVector& out)
    101101  \param in input array
    102102  \param out backward FFT

  • trunk/SophyaLib/NTools/generaldata.cc

    r490 r508  
    748748if(varx<0 || varx>=mNVar) return -2.;
    749749if(mNDataGood<=0) return -4.;
    750 Vector x(mNDataGood);
    751 Vector y(mNDataGood);
    752 Vector ey2(1);
     750OVector x(mNDataGood);
     751OVector y(mNDataGood);
     752OVector ey2(1);
    753753if(ey) ey2.Realloc(mNDataGood,true);
    754754int ntest = 0;
    … …  
    763763double res = 0.;
    764764if(ey) {
    765   Vector errcoef(1);
     765  OVector errcoef(1);
    766766  res = pol.Fit(x,y,ey2,degre,errcoef);
    767767} else {
    … …  
    797797if(vary<0 || vary>=mNVar || vary==varx) return -3.;
    798798if(mNDataGood<=0) return -4.;
    799 Vector x(mNDataGood);
    800 Vector y(mNDataGood);
    801 Vector z(mNDataGood);
    802 Vector ez2(1);
     799OVector x(mNDataGood);
     800OVector y(mNDataGood);
     801OVector z(mNDataGood);
     802OVector ez2(1);
    803803if(ez) ez2.Realloc(mNDataGood,true);
    804804int ntest = 0;
    … …  
    814814double res = 0.;
    815815if(ez) {
    816   Vector errcoef(1);
     816  OVector errcoef(1);
    817817  if(degre2>0) res = pol.Fit(x,y,z,ez2,degre1,degre2,errcoef);
    818818  else         res = pol.Fit(x,y,z,ez2,degre1,errcoef);

  • trunk/SophyaLib/NTools/generalfit.cc

    r490 r508  
    874874
    875875//++
    876 Vector GeneralFit::GetParm()
     876OVector GeneralFit::GetParm()
    877877//
    878878//      Retourne les valeurs des parametres dans un vecteur.
    … …  
    10961096{
    10971097 volatile double oldChi2;
    1098  Matrix COVAR(mNPar,mNPar);
    1099  Vector DA(mNPar);
    1100  Vector dparam(mNPar);
    1101  Vector paramTry(mNPar);
    1102  Vector param_tr(mNPar);
    1103  Vector paramTry_tr(mNPar);
    1104  Vector step_tr(mNPar);
     1098 OMatrix COVAR(mNPar,mNPar);
     1099 OVector DA(mNPar);
     1100 OVector dparam(mNPar);
     1101 OVector paramTry(mNPar);
     1102 OVector param_tr(mNPar);
     1103 OVector paramTry_tr(mNPar);
     1104 OVector step_tr(mNPar);
    11051105 nStop = nStopL = nStep = 0;
    11061106 Chi2 = oldChi2 = 0.;
    … …  
    15151515
    15161516//////////////////////////////////////////////////////////////////////
    1517 void GeneralFit::write_in_step(double ci2,Vector& par)
     1517void GeneralFit::write_in_step(double ci2,OVector& par)
    15181518{
    15191519if(FileStep==NULL) return;
    … …  
    15241524
    15251525//////////////////////////////////////////////////////////////////////
    1526 void GeneralFit::TryFunc(Vector& par,Vector& par_tr)
     1526void GeneralFit::TryFunc(OVector& par,OVector& par_tr)
    15271527{
    15281528  BETA_Try = 0;
    15291529  ATGA_Try = 0;
    15301530  Chi2  = 0;
    1531   Vector deriv(mNPar);
    1532   Vector derivtr(mNPar);
     1531  OVector deriv(mNPar);
     1532  OVector derivtr(mNPar);
    15331533  double result;
    15341534
    … …  
    15641564
    15651565//////////////////////////////////////////////////////////////////////
    1566 void GeneralFit::TryXi2(Vector& par,Vector& par_tr)
     1566void GeneralFit::TryXi2(OVector& par,OVector& par_tr)
    15671567{
    15681568  double c, *parloc;
    … …  
    16641664
    16651665//////////////////////////////////////////////////////////////////////
    1666 Vector GeneralFit::p_vers_tr(Vector const& p)
    1667 {
    1668  Vector tr(p);
     1666OVector GeneralFit::p_vers_tr(OVector const& p)
     1667{
     1668 OVector tr(p);
    16691669 for(int i=0;i<mNPar;i++) {
    16701670   if( fixParam[i] || ! boundParam[i] ) continue;
    … …  
    16751675
    16761676//////////////////////////////////////////////////////////////////////
    1677 void GeneralFit::p_vers_tr(Vector const& p,Vector& tr)
     1677void GeneralFit::p_vers_tr(OVector const& p,OVector& tr)
    16781678{
    16791679 for(int i=0;i<mNPar;i++) {
    … …  
    16951695
    16961696//////////////////////////////////////////////////////////////////////
    1697 Vector GeneralFit::tr_vers_p(Vector const& tr)
    1698 {
    1699  Vector p(tr);
     1697OVector GeneralFit::tr_vers_p(OVector const& tr)
     1698{
     1699 OVector p(tr);
    17001700 for(int i=0;i<mNPar;i++) {
    17011701   if( fixParam[i] || ! boundParam[i] ) continue;
    … …  
    17061706
    17071707//////////////////////////////////////////////////////////////////////
    1708 void GeneralFit::tr_vers_p(Vector const& tr,Vector& p)
     1708void GeneralFit::tr_vers_p(OVector const& tr,OVector& p)
    17091709{
    17101710 for(int i=0;i<mNPar;i++) {
    … …  
    17271727
    17281728//////////////////////////////////////////////////////////////////////
    1729 Vector GeneralFit::dp_vers_dtr(Vector const& dp,Vector const& tr)
    1730 {
    1731  Vector dtr(dp);
     1729OVector GeneralFit::dp_vers_dtr(OVector const& dp,OVector const& tr)
     1730{
     1731 OVector dtr(dp);
    17321732 for(int i=0;i<mNPar;i++) {
    17331733   if( fixParam[i] || ! boundParam[i] ) continue;
    … …  
    17381738
    17391739//////////////////////////////////////////////////////////////////////
    1740 void GeneralFit::dp_vers_dtr(Vector const& dp,Vector const& tr,Vector& dtr)
     1740void GeneralFit::dp_vers_dtr(OVector const& dp,OVector const& tr,OVector& dtr)
    17411741{
    17421742 for(int i=0;i<mNPar;i++) {
    … …  
    17591759
    17601760//////////////////////////////////////////////////////////////////////
    1761 Vector GeneralFit::dtr_vers_dp(Vector const& dtr,Vector const& tr)
    1762 {
    1763  Vector dp(dtr);
     1761OVector GeneralFit::dtr_vers_dp(OVector const& dtr,OVector const& tr)
     1762{
     1763 OVector dp(dtr);
    17641764 for(int i=0;i<mNPar;i++) {
    17651765   if( fixParam[i] || ! boundParam[i] ) continue;
    … …  
    17711771//////////////////////////////////////////////////////////////////////
    17721772// inline fonction pour aller + vite dans le try()
    1773 //void GeneralFit::dtr_vers_dp(Vector const& dtr,Vector const& tr,Vector& dp)
    1774 
    1775 //////////////////////////////////////////////////////////////////////
    1776 int GeneralFit::put_in_limits_for_deriv(Vector const& p,Vector& dp,double dist)
     1773//void GeneralFit::dtr_vers_dp(OVector const& dtr,OVector const& tr,OVector& dp)
     1774
     1775//////////////////////////////////////////////////////////////////////
     1776int GeneralFit::put_in_limits_for_deriv(OVector const& p,OVector& dp,double dist)
    17771777// 1-/ Redefinit dp pour qu'il soit superieur a minStepDeriv
    17781778// 2-/ Redefinit dp pour que p+/-dp reste dans les limites (parametre borne)

  • trunk/SophyaLib/NTools/generalfit.h

    r307 r508  
    124124
    125125  double          GetParm(int);
    126   Vector          GetParm();
     126  OVector          GetParm();
    127127  double          GetParmErr(int);
    128128  double          GetCoVar(int,int);
    … …  
    168168  GeneralFitData*   mData;
    169169
    170   Vector          Param;
    171   Vector          errParam;
    172   Vector          stepParam;
    173   Vector          minParam;
    174   Vector          maxParam;
    175   Vector          minStepDeriv;
    176   Vector          Eps;
     170  OVector          Param;
     171  OVector          errParam;
     172  OVector          stepParam;
     173  OVector          minParam;
     174  OVector          maxParam;
     175  OVector          minStepDeriv;
     176  OVector          Eps;
    177177  unsigned short int* fixParam;
    178178  unsigned short int* boundParam;
    … …  
    188188  FILE            *FileStep;
    189189 
    190   Matrix          ATGA;
    191   Vector          BETA;
    192   Matrix          ATGA_Try;
    193   Vector          BETA_Try;
    194   Vector          C;
    195   Vector          D;
     190  OMatrix          ATGA;
     191  OVector          BETA;
     192  OMatrix          ATGA_Try;
     193  OVector          BETA_Try;
     194  OVector          C;
     195  OVector          D;
    196196 
    197197  double          Chi2;
    … …  
    202202 
    203203  // Fonctions privees
    204   void       write_in_step(double ci2,Vector& par);
     204  void       write_in_step(double ci2,OVector& par);
    205205  void       General_Init(void);
    206   void       TryFunc(Vector& par,Vector& par_tr);
    207   void       TryXi2(Vector& par,Vector& par_tr);
     206  void       TryFunc(OVector& par,OVector& par_tr);
     207  void       TryXi2(OVector& par,OVector& par_tr);
    208208  void       CheckSanity();
    209209  void       Set_Bound_C_D(int i);
    210210  void       Set_Bound_C_D();
    211211  double     p_vers_tr(int i,double p);
    212   Vector     p_vers_tr(Vector const& p);
    213   void       p_vers_tr(Vector const& p,Vector& tr);
     212  OVector     p_vers_tr(OVector const& p);
     213  void       p_vers_tr(OVector const& p,OVector& tr);
    214214  double     tr_vers_p(int i,double tr);
    215   Vector     tr_vers_p(Vector const& tr);
    216   void       tr_vers_p(Vector const& tr,Vector& p);
     215  OVector     tr_vers_p(OVector const& tr);
     216  void       tr_vers_p(OVector const& tr,OVector& p);
    217217  double     c_dp_vers_dtr(int i,double tr);
    218   Vector       dp_vers_dtr(Vector const& dp,Vector const& tr);
    219   void         dp_vers_dtr(Vector const& dp,Vector const& tr,Vector& dtr);
     218  OVector       dp_vers_dtr(OVector const& dp,OVector const& tr);
     219  void         dp_vers_dtr(OVector const& dp,OVector const& tr,OVector& dtr);
    220220  double     c_dtr_vers_dp(int i,double tr);
    221   Vector       dtr_vers_dp(Vector const& dtr,Vector const& tr);
    222   int        put_in_limits_for_deriv(Vector const& p,Vector& dp,double dist=0.66);
    223   inline void dtr_vers_dp(Vector const& dtr,Vector const& tr,Vector& dp)
     221  OVector       dtr_vers_dp(OVector const& dtr,OVector const& tr);
     222  int        put_in_limits_for_deriv(OVector const& p,OVector& dp,double dist=0.66);
     223  inline void dtr_vers_dp(OVector const& dtr,OVector const& tr,OVector& dp)
    224224              {  for(int i=0;i<mNPar;i++)
    225225                   { if( fixParam[i] ) continue;

  • trunk/SophyaLib/NTools/hisprof.cc

    r490 r508  
    260260//--
    261261//++
    262 // inline void GetMean(Vector& v)
     262// inline void GetMean(OVector& v)
    263263//      Retourne le contenu de la moyenne dans le vecteur v
    264264//--
    265265//++
    266 // inline void GetError2(Vector& v)
     266// inline void GetError2(OVector& v)
    267267//      Retourne le contenu au carre de la dispersion/erreur dans le vecteur v
    268268//--

  • trunk/SophyaLib/NTools/hisprof.h

    r490 r508  
    2929  // Acces a l information
    3030  inline Histo GetHisto() {if(!Ok) UpdateHisto(); return (Histo) *this;}
    31   inline void GetMean(Vector& v) {if(!Ok) UpdateHisto(); Histo::GetValue(v);}
    32   inline void GetError2(Vector& v) {if(!Ok) UpdateHisto(); Histo::GetError2(v);}
     31  inline void GetMean(OVector& v) {if(!Ok) UpdateHisto(); Histo::GetValue(v);}
     32  inline void GetError2(OVector& v) {if(!Ok) UpdateHisto(); Histo::GetError2(v);}
    3333  inline float operator()(int i) const {if(!Ok) UpdateHisto(); return data[i];}
    3434  inline float Error2(int i) const {if(!Ok) UpdateHisto(); return (float) err2[i];}

  • trunk/SophyaLib/NTools/histos.cc

    r490 r508  
    11//
    2 // $Id: histos.cc,v 1.4 1999-10-21 15:25:45 ansari Exp $
     2// $Id: histos.cc,v 1.5 1999-10-25 10:36:07 ansari Exp $
    33//
    44
    … …  
    404404/********* Methode *********/
    405405//++
    406 void Histo::GetAbsc(Vector &v)
     406void Histo::GetAbsc(OVector &v)
    407407//
    408408//      Remplissage d'un tableau avec la valeur des abscisses
    … …  
    415415
    416416//++
    417 void Histo::GetValue(Vector &v)
     417void Histo::GetValue(OVector &v)
    418418//
    419419//      Remplissage d'un tableau avec la valeur du contenu
    … …  
    426426
    427427//++
    428 void Histo::GetError2(Vector &v)
     428void Histo::GetError2(OVector &v)
    429429//
    430430//      Remplissage d'un tableau avec la valeur des erreurs au carre
    … …  
    438438
    439439//++
    440 void Histo::GetError(Vector &v)
     440void Histo::GetError(OVector &v)
    441441//
    442442//      Remplissage d'un tableau avec la valeur des erreurs
    … …  
    451451/********* Methode *********/
    452452//++
    453 void Histo::PutValue(Vector &v, int ierr)
     453void Histo::PutValue(OVector &v, int ierr)
    454454//
    455455//      Remplissage du contenu de l'histo avec les valeurs d'un vecteur
    … …  
    465465
    466466//++
    467 void Histo::PutValueAdd(Vector &v, int ierr)
     467void Histo::PutValueAdd(OVector &v, int ierr)
    468468//
    469469//      Addition du contenu de l'histo avec les valeurs d'un vecteur
    … …  
    479479
    480480//++
    481 void Histo::PutError2(Vector &v)
     481void Histo::PutError2(OVector &v)
    482482//
    483483//      Remplissage des erreurs au carre de l'histo avec les valeurs d'un vecteur
    … …  
    491491
    492492//++
    493 void Histo::PutError2Add(Vector &v)
     493void Histo::PutError2Add(OVector &v)
    494494//
    495495//      Addition des erreurs au carre de l'histo avec les valeurs d'un vecteur
    … …  
    503503
    504504//++
    505 void Histo::PutError(Vector &v)
     505void Histo::PutError(OVector &v)
    506506//
    507507//      Remplissage des erreurs de l'histo avec les valeurs d'un vecteur
    … …  
    11211121  }
    11221122
    1123   Vector xFit(nLowHigh);
    1124   Vector yFit(nLowHigh);
    1125   Vector e2Fit(nLowHigh);
    1126   Vector errcoef(1);
     1123  OVector xFit(nLowHigh);
     1124  OVector yFit(nLowHigh);
     1125  OVector e2Fit(nLowHigh);
     1126  OVector errcoef(1);
    11271127  int ii = 0;
    11281128  for (int j=iLow; j<=iHigh; j++) {
    … …  
    14441444if(f==NULL)
    14451445  throw(NullPtrError("Histo::FitResidus: NULL pointer\n"));
    1446 Vector par = gfit.GetParm();
     1446OVector par = gfit.GetParm();
    14471447Histo h(*this);
    14481448for(int i=0;i<NBins();i++) {
    … …  
    14641464if(f==NULL)
    14651465  throw(NullPtrError("Histo::FitFunction: NULL pointer\n"));
    1466 Vector par = gfit.GetParm();
     1466OVector par = gfit.GetParm();
    14671467Histo h(*this);
    14681468for(int i=0;i<NBins();i++) {

  • trunk/SophyaLib/NTools/histos.h

    r490 r508  
    11// This may look like C code, but it is really -*- C++ -*-
    22//
    3 // $Id: histos.h,v 1.3 1999-10-21 15:25:47 ansari Exp $
     3// $Id: histos.h,v 1.4 1999-10-25 10:36:07 ansari Exp $
    44//
    55
    … …  
    6666
    6767  // get/put dans/depuis un vector
    68   void GetAbsc(Vector& v);
    69   void GetValue(Vector& v);
    70   void GetError2(Vector& v);
    71   void GetError(Vector& v);
    72   void PutValue(Vector& v, int ierr=0);
    73   void PutValueAdd(Vector &v, int ierr=0);
    74   void PutError2(Vector& v);
    75   void PutError2Add(Vector& v);
    76   void PutError(Vector& v);
     68  void GetAbsc(OVector& v);
     69  void GetValue(OVector& v);
     70  void GetError2(OVector& v);
     71  void GetError(OVector& v);
     72  void PutValue(OVector& v, int ierr=0);
     73  void PutValueAdd(OVector &v, int ierr=0);
     74  void PutError2(OVector& v);
     75  void PutError2Add(OVector& v);
     76  void PutError(OVector& v);
    7777
    7878  // INLINES

  • trunk/SophyaLib/NTools/histos2.cc

    r490 r508  
    603603///////////////////////////////////////////////////////////////////
    604604//++
    605 void Histo2D::GetXCoor(Vector &v)
     605void Histo2D::GetXCoor(OVector &v)
    606606//
    607607//      Remplissage d'un tableau avec les valeurs des abscisses.
    … …  
    615615
    616616//++
    617 void Histo2D::GetYCoor(Vector &v)
     617void Histo2D::GetYCoor(OVector &v)
    618618//
    619619//      Remplissage d'un tableau avec les valeurs des ordonnees.
    … …  
    644644
    645645//++
    646 void Histo2D::GetValue(Matrix &v)
     646void Histo2D::GetValue(OMatrix &v)
    647647//
    648648//      Remplissage d'un tableau avec les valeurs du contenu.
    … …  
    656656
    657657//++
    658 void Histo2D::GetError2(Matrix &v)
     658void Histo2D::GetError2(OMatrix &v)
    659659//
    660660//      Remplissage d'un tableau avec les valeurs du carre des erreurs.
    … …  
    670670
    671671//++
    672 void Histo2D::GetError(Matrix &v)
     672void Histo2D::GetError(OMatrix &v)
    673673//
    674674//      Remplissage d'un tableau avec les valeurs des erreurs.
    … …  
    685685///////////////////////////////////////////////////////////////////
    686686//++
    687 void Histo2D::PutValue(Matrix &v, int ierr)
     687void Histo2D::PutValue(OMatrix &v, int ierr)
    688688//
    689689//      Remplissage du contenu de l'histo avec les valeurs d'un tableau.
    … …  
    700700
    701701//++
    702 void Histo2D::PutValueAdd(Matrix &v, int ierr)
     702void Histo2D::PutValueAdd(OMatrix &v, int ierr)
    703703//
    704704//      Addition du contenu de l'histo avec les valeurs d'un tableau.
    … …  
    715715
    716716//++
    717 void Histo2D::PutError2(Matrix &v)
     717void Histo2D::PutError2(OMatrix &v)
    718718//
    719719//      Remplissage des erreurs au carre de l'histo
    … …  
    729729
    730730//++
    731 void Histo2D::PutError2Add(Matrix &v)
     731void Histo2D::PutError2Add(OMatrix &v)
    732732//
    733733//      Addition des erreurs au carre de l'histo
    … …  
    744744
    745745//++
    746 void Histo2D::PutError(Matrix &v)
     746void Histo2D::PutError(OMatrix &v)
    747747//
    748748//      Remplissage des erreurs de l'histo avec les valeurs d'un tableau.
    … …  
    11051105if(f==NULL)
    11061106  throw(NullPtrError("Histo2D::FitResidus: NULL pointer\n"));
    1107 Vector par = gfit.GetParm();
     1107OVector par = gfit.GetParm();
    11081108Histo2D h2(*this);
    11091109for(int i=0;i<NBinX();i++) for(int j=0;j<NBinY();j++) {
    … …  
    11271127if(f==NULL)
    11281128  throw(NullPtrError("Histo2D::FitFunction: NULL pointer\n"));
    1129 Vector par = gfit.GetParm();
     1129OVector par = gfit.GetParm();
    11301130Histo2D h2(*this);
    11311131for(int i=0;i<NBinX();i++) for(int j=0;j<NBinY();j++) {

  • trunk/SophyaLib/NTools/histos2.h

    r490 r508  
    6363
    6464  // get/put dans/depuis une matrice / vector
    65   void GetXCoor(Vector& v);
    66   void GetValue(Matrix &v);
    67   void GetYCoor(Vector& v);
    68   void GetError2(Matrix& v);
    69   void GetError(Matrix& v);
    70   void PutValue(Matrix& v, int ierr=0);
    71   void PutValueAdd(Matrix& v, int ierr=0);
    72   void PutError2(Matrix& v);
    73   void PutError2Add(Matrix& v);
    74   void PutError(Matrix& v);
     65  void GetXCoor(OVector& v);
     66  void GetValue(OMatrix &v);
     67  void GetYCoor(OVector& v);
     68  void GetError2(OMatrix& v);
     69  void GetError(OMatrix& v);
     70  void PutValue(OMatrix& v, int ierr=0);
     71  void PutValueAdd(OMatrix& v, int ierr=0);
     72  void PutError2(OMatrix& v);
     73  void PutError2Add(OMatrix& v);
     74  void PutError(OMatrix& v);
    7575
    7676  // INLINES

  • trunk/SophyaLib/NTools/linfit.cc

    r244 r508  
    55#include "cvector.h"
    66
    7 double LinFit(const Vector& x, const Vector& y, int nf, double (*f)(int, double),
    8            Vector& c)
     7double LinFit(const OVector& x, const OVector& y, int nf, double (*f)(int, double),
     8           OVector& c)
    99{
    1010  int n = x.NElts();
    1111  if (n != y.NElts()) THROW(sizeMismatchErr);
    1212 
    13   Matrix fx(nf, n);
     13  OMatrix fx(nf, n);
    1414  for (int i=0; i<nf; i++)
    1515    for (int j=0; j<n; j++)
    … …  
    2121
    2222
    23 double LinFit(const Matrix& fx, const Vector& y, Vector& c)
     23double LinFit(const OMatrix& fx, const OVector& y, OVector& c)
    2424{
    2525  int n = y.NElts();
    … …  
    2828  int nf = fx.NRows();
    2929
    30   Matrix a(nf,nf);
     30  OMatrix a(nf,nf);
    3131
    3232  for (int j=0; j<nf; j++)
    … …  
    3636  c = fx * y;
    3737
    38   if (Matrix::GausPiv(a,c) == 0) THROW(singMatxErr);
     38  if (OMatrix::GausPiv(a,c) == 0) THROW(singMatxErr);
    3939
    4040  double xi2 = 0;
    … …  
    5252
    5353
    54 double LinFit(const Vector& x, const Vector& y, const Vector& errY2, int nf,
    55            double (*f)(int, double), Vector& c, Vector& errC)
     54double LinFit(const OVector& x, const OVector& y, const OVector& errY2, int nf,
     55           double (*f)(int, double), OVector& c, OVector& errC)
    5656{
    5757  int n = x.NElts();
    5858  if (n != y.NElts()) THROW(sizeMismatchErr);
    5959 
    60   Matrix fx(nf, n);
     60  OMatrix fx(nf, n);
    6161  for (int i=0; i<nf; i++)
    6262    for (int j=0; j<n; j++)
    … …  
    6767
    6868
    69 double LinFit(const Matrix& fx, const Vector& y, const Vector& errY2,
    70            Vector& c, Vector& errC)
     69double LinFit(const OMatrix& fx, const OVector& y, const OVector& errY2,
     70           OVector& c, OVector& errC)
    7171{
    7272  int n = y.NElts();
    … …  
    7676  int nf = fx.NRows();
    7777
    78   Matrix a(nf,nf);
     78  OMatrix a(nf,nf);
    7979
    8080  c.Realloc(nf);
    … …  
    8989    }
    9090 
    91   Matrix d(nf,nf+1);
     91  OMatrix d(nf,nf+1);
    9292  for (int k=0; k<nf; k++) {
    9393    double x=0;
    … …  
    9999  }
    100100
    101   if (Matrix::GausPiv(a,d) == 0) THROW(singMatxErr);
     101  if (OMatrix::GausPiv(a,d) == 0) THROW(singMatxErr);
    102102
    103103  for (int l=0; l<nf; l++) {

  • trunk/SophyaLib/NTools/linfit.h

    r494 r508  
    11// This may look like C code, but it is really -*- C++ -*-
    22//
    3 // $Id: linfit.h,v 1.2 1999-10-21 18:45:46 ansari Exp $
     3// $Id: linfit.h,v 1.3 1999-10-25 10:36:08 ansari Exp $
    44//
    55
    … …  
    1010
    1111#include "machdefs.h"
    12 class Matrix;
    13 class Vector;
     12class OMatrix;
     13class OVector;
    1414
    15 double LinFit(const Vector& x, const Vector& y, int nf,
    16            double (*f)(int, double), Vector& c);
     15double LinFit(const OVector& x, const OVector& y, int nf,
     16           double (*f)(int, double), OVector& c);
    1717// fit lineaire des y en tant que somme de c(i)f(i,x), i=0..nf-1;
    1818
    1919
    20 double LinFit(const Matrix& fx, const Vector& y, Vector& c);
     20double LinFit(const OMatrix& fx, const OVector& y, OVector& c);
    2121// fit lineaire des y en tant que somme de c(i)f(i,x), i=0..nf-1,
    2222// la matrice fx contient les valeurs des f:
    … …  
    2424                     
    2525
    26 double LinFit(const Vector& x, const Vector& y, const Vector& errY2, int nf,
    27            double (*f)(int, double), Vector& c, Vector& errC);
     26double LinFit(const OVector& x, const OVector& y, const OVector& errY2, int nf,
     27           double (*f)(int, double), OVector& c, OVector& errC);
    2828// fit lineaire des y en tant que somme de c(i)f(i,x), i=0..nf-1,
    2929// errY2 contient les carres des erreurs sur les Y.
    … …  
    3131
    3232
    33 double LinFit(const Matrix& fx, const Vector& y, const Vector& errY2,
    34            Vector& c, Vector& errC);
     33double LinFit(const OMatrix& fx, const OVector& y, const OVector& errY2,
     34           OVector& c, OVector& errC);
    3535// fit lineaire des y en tant que somme de c(i)f(i,x), i=0..nf-1,
    3636// la matrice fx contient les valeurs des f:

  • trunk/SophyaLib/NTools/matrix.cc

    r490 r508  
    1 // $Id: matrix.cc,v 1.5 1999-10-21 15:25:49 ansari Exp $
     1// $Id: matrix.cc,v 1.6 1999-10-25 10:36:09 ansari Exp $
    22
    33#include "machdefs.h"
    … …  
    2626
    2727//++
    28 // Class        Matrix
     28// Class        OMatrix
    2929// Lib  Outils++
    3030// include      matrix.h
    … …  
    3838
    3939//++
    40 Matrix::Matrix()
     40OMatrix::OMatrix()
    4141//
    4242//      Construit une matrice 1x1 (pour ppersist).
    … …  
    5050
    5151//++
    52 Matrix::Matrix(int r, int c)
     52OMatrix::OMatrix(int r, int c)
    5353//
    5454//      Construit une matrice de r lignes et c colonnes.
    … …  
    6262
    6363//++
    64 Matrix::Matrix(int r, int c, double* values)
     64OMatrix::OMatrix(int r, int c, double* values)
    6565//
    6666//      Construit une matrice de r lignes et c colonnes. On fournit
    … …  
    7373
    7474//++
    75 Matrix::Matrix(const Matrix& a)
     75OMatrix::OMatrix(const OMatrix& a)
    7676//
    7777//      Constructeur par copie.
    … …  
    8585
    8686//++
    87 Matrix::Matrix(const TMatrix<r_8>& a)
     87OMatrix::OMatrix(const TMatrix<r_8>& a)
    8888//
    8989//      Constructeur par copie a partir d'une TMatrix<r_8>.
    … …  
    9999
    100100
    101 Matrix::~Matrix()
     101OMatrix::~OMatrix()
    102102{
    103103  DBASSERT(ndata == nr*nc);
    … …  
    111111
    112112//++
    113 void Matrix::Zero()
     113void OMatrix::Zero()
    114114//
    115115//      Remise à zero de tous les éléments
    … …  
    121121
    122122//++
    123 void Matrix::Realloc(int r, int c, bool force)
     123void OMatrix::Realloc(int r, int c, bool force)
    124124//
    125125//      Change la taille de la matrice. Réallocation physique seulement si
    … …  
    145145
    146146//++
    147 Matrix& Matrix::operator = (const Matrix& a)
     147OMatrix& OMatrix::operator = (const OMatrix& a)
    148148//
    149149//      Opérateur d'affectation.
    … …  
    158158
    159159//++
    160 Matrix& Matrix::operator = (double x)
     160OMatrix& OMatrix::operator = (double x)
    161161//
    162162//      Opérateur d'affectation depuis scalaire : identité * scalaire.
    … …  
    176176
    177177//++
    178 ostream& operator << (ostream& s, const Matrix& a)
     178ostream& operator << (ostream& s, const OMatrix& a)
    179179//
    180180//      Impression
    … …  
    194194
    195195//++
    196 Matrix& Matrix::operator *= (double b)
     196OMatrix& OMatrix::operator *= (double b)
    197197//
    198198//--
    … …  
    208208
    209209//++
    210 Matrix& Matrix::operator += (double b)
     210OMatrix& OMatrix::operator += (double b)
    211211//
    212212//--
    … …  
    222222
    223223//++
    224 Matrix& Matrix::operator -= (double b)
     224OMatrix& OMatrix::operator -= (double b)
    225225//
    226226//--
    … …  
    236236
    237237//++
    238 Matrix& Matrix::operator /= (double b)
     238OMatrix& OMatrix::operator /= (double b)
    239239//
    240240//--
    … …  
    251251
    252252//++
    253 Matrix operator * (const Matrix& a, double b)
    254 //
    255 //--
    256 {
    257   Matrix result(a);
     253OMatrix operator * (const OMatrix& a, double b)
     254//
     255//--
     256{
     257  OMatrix result(a);
    258258  return (result *= b);
    259259}
    260260
    261261//++
    262 Matrix operator * (double b, const Matrix& a)
    263 //
    264 //--
    265 {
    266   Matrix result(a);
     262OMatrix operator * (double b, const OMatrix& a)
     263//
     264//--
     265{
     266  OMatrix result(a);
    267267  return (result *= b);
    268268}
    269269
    270270//++
    271 Matrix operator + (const Matrix& a, double b)
    272 //
    273 //--
    274 {
    275   Matrix result(a);
     271OMatrix operator + (const OMatrix& a, double b)
     272//
     273//--
     274{
     275  OMatrix result(a);
    276276  return (result += b);
    277277}
    278278
    279279//++
    280 Matrix operator + (double b, const Matrix& a)
    281 //
    282 //--
    283 {
    284   Matrix result(a);
     280OMatrix operator + (double b, const OMatrix& a)
     281//
     282//--
     283{
     284  OMatrix result(a);
    285285  return (result += b);
    286286}
    287287
    288288//++
    289 Matrix operator - (const Matrix& a, double b)
    290 //
    291 //--
    292 {
    293   Matrix result(a);
     289OMatrix operator - (const OMatrix& a, double b)
     290//
     291//--
     292{
     293  OMatrix result(a);
    294294  return (result -= b);
    295295}
    296296
    297297//++
    298 Matrix operator - (double b, const Matrix& a)
    299 //
    300 //--
    301 {
    302   Matrix result(a);
     298OMatrix operator - (double b, const OMatrix& a)
     299//
     300//--
     301{
     302  OMatrix result(a);
    303303  result *= -1;
    304304  return (result += b);
    … …  
    306306
    307307//++
    308 Matrix operator / (const Matrix& a, double b)
    309 //
    310 //--
    311 {
    312   Matrix result(a);
     308OMatrix operator / (const OMatrix& a, double b)
     309//
     310//--
     311{
     312  OMatrix result(a);
    313313  return (result /= b);
    314314}
    315315
    316316//++
    317 Matrix operator * (const Matrix& a, int b)
    318 //
    319 //--
    320 {
    321   Matrix result(a);
     317OMatrix operator * (const OMatrix& a, int b)
     318//
     319//--
     320{
     321  OMatrix result(a);
    322322  return (result *= b);
    323323}
    324324
    325325//++
    326 Matrix operator * (int b, const Matrix& a)
    327 //
    328 //--
    329 {
    330   Matrix result(a);
     326OMatrix operator * (int b, const OMatrix& a)
     327//
     328//--
     329{
     330  OMatrix result(a);
    331331  return (result *= b);
    332332}
    333333
    334334//++
    335 Matrix operator + (const Matrix& a, int b)
    336 //
    337 //--
    338 {
    339   Matrix result(a);
     335OMatrix operator + (const OMatrix& a, int b)
     336//
     337//--
     338{
     339  OMatrix result(a);
    340340  return (result += b);
    341341}
    342342
    343343//++
    344 Matrix operator + (int b, const Matrix& a)
    345 //
    346 //--
    347 {
    348   Matrix result(a);
     344OMatrix operator + (int b, const OMatrix& a)
     345//
     346//--
     347{
     348  OMatrix result(a);
    349349  return (result += b);
    350350}
    351351
    352352//++
    353 Matrix operator - (const Matrix& a, int b)
    354 //
    355 //--
    356 {
    357   Matrix result(a);
     353OMatrix operator - (const OMatrix& a, int b)
     354//
     355//--
     356{
     357  OMatrix result(a);
    358358  return (result -= b);
    359359}
    360360
    361361//++
    362 Matrix operator - (int b, const Matrix& a)
    363 //
    364 //--
    365 {
    366   Matrix result(a);
     362OMatrix operator - (int b, const OMatrix& a)
     363//
     364//--
     365{
     366  OMatrix result(a);
    367367  result *= -1;
    368368  return (result += b);
    … …  
    370370
    371371//++
    372 Matrix operator / (const Matrix& a, int b)
    373 //
    374 //--
    375 {
    376   Matrix result(a);
     372OMatrix operator / (const OMatrix& a, int b)
     373//
     374//--
     375{
     376  OMatrix result(a);
    377377  return (result /= b);
    378378}
    … …  
    382382
    383383//++
    384 Matrix& Matrix::operator += (const Matrix& a)
     384OMatrix& OMatrix::operator += (const OMatrix& a)
    385385//
    386386//--
    … …  
    399399
    400400//++
    401 Matrix& Matrix::operator -= (const Matrix& a)
     401OMatrix& OMatrix::operator -= (const OMatrix& a)
    402402//
    403403//--
    … …  
    417417
    418418//++
    419 Matrix& Matrix::operator *= (const Matrix& a)
     419OMatrix& OMatrix::operator *= (const OMatrix& a)
    420420//
    421421//--
    … …  
    448448
    449449//++
    450 Matrix operator + (const Matrix& a, const Matrix& b)
     450OMatrix operator + (const OMatrix& a, const OMatrix& b)
    451451//
    452452//--
    … …  
    454454  if (b.nc != a.nc || b.nr != a.nr) THROW(sizeMismatchErr);
    455455
    456   Matrix c(a);
     456  OMatrix c(a);
    457457  return (c += b);
    458458}
    459459
    460460//++
    461 Matrix operator - (const Matrix& a, const Matrix& b)
     461OMatrix operator - (const OMatrix& a, const OMatrix& b)
    462462//
    463463//--
    … …  
    465465  if (b.nc != a.nc || b.nr != a.nr) THROW(sizeMismatchErr);
    466466
    467   Matrix c(a);
     467  OMatrix c(a);
    468468  return (c -= b);
    469469}
    … …  
    471471#if 0
    472472
    473 Matrix operator * (const Matrix& a, const Matrix& b)
     473OMatrix operator * (const OMatrix& a, const OMatrix& b)
    474474{
    475475  if (a.nc != b.nr) THROW(sizeMismatchErr);
    476476
    477   Matrix c(a.nr, b.nc);
     477  OMatrix c(a.nr, b.nc);
    478478
    479479  double* pc = c.data;
    … …  
    505505
    506506//++
    507 Matrix operator * (const Matrix& a, const Matrix& b)
     507OMatrix operator * (const OMatrix& a, const OMatrix& b)
    508508//
    509509//--
    … …  
    511511  if (a.nc != b.nr) THROW(sizeMismatchErr);
    512512
    513   Matrix c(a.nr, b.nc);
     513  OMatrix c(a.nr, b.nc);
    514514
    515515  for (int rc = 0; rc < c.nr; rc++)
    … …  
    527527
    528528//++
    529 Matrix Matrix::Transpose() const
     529OMatrix OMatrix::Transpose() const
    530530//
    531531//      Retourne la transposée.
    … …  
    536536{
    537537#if !HAS_NAMED_RETURN
    538 Matrix a(nc,nr);
     538OMatrix a(nc,nr);
    539539#endif
    540540  for (int i=0; i<nr; i++)
    … …  
    548548
    549549//++
    550 Matrix Matrix::Inverse() const
     550OMatrix OMatrix::Inverse() const
    551551//
    552552//      Retourne la matrice inverse.
    … …  
    559559{
    560560#if !HAS_NAMED_RETURN
    561 Matrix b(nc,nr);
    562 #endif
    563   Matrix a(*this);
     561OMatrix b(nc,nr);
     562#endif
     563  OMatrix a(*this);
    564564  b = 1.0;
    565   if (fabs(Matrix::GausPiv(a,b)) < 1.e-50) THROW(singMatxErr);
     565  if (fabs(OMatrix::GausPiv(a,b)) < 1.e-50) THROW(singMatxErr);
    566566#if !HAS_NAMED_RETURN
    567567return b;
    … …  
    570570
    571571
    572 void Matrix::WriteSelf(POutPersist& s) const
     572void OMatrix::WriteSelf(POutPersist& s) const
    573573{
    574574  ASSERT(ndata == nr*nc);
    … …  
    577577}
    578578
    579 void Matrix::ReadSelf(PInPersist& s)
     579void OMatrix::ReadSelf(PInPersist& s)
    580580{
    581581  int_4 r,c;
    … …  
    587587
    588588
    589 MatrixRC::MatrixRC()
     589OMatrixRC::OMatrixRC()
    590590: matrix(0), data(0), index(0), step(0)
    591591{}
    592592
    593 MatrixRC::MatrixRC(Matrix& m, RCKind rckind, int ind)
     593OMatrixRC::OMatrixRC(OMatrix& m, RCKind rckind, int ind)
    594594: matrix(&m), data(Org(m,rckind,ind)),
    595595  index(ind), step(Step(m,rckind)), kind(rckind)
    … …  
    599599
    600600
    601 int MatrixRC::Next()
     601int OMatrixRC::Next()
    602602{
    603603  if (!matrix) return -1;             // Failure ?
    … …  
    621621
    622622
    623 int MatrixRC::Prev()
     623int OMatrixRC::Prev()
    624624{
    625625  if (!matrix) return -1;             // Failure ?
    … …  
    638638
    639639
    640 int MatrixRC::SetCol(int c)
     640int OMatrixRC::SetCol(int c)
    641641{
    642642  if (!matrix) return -1;             // Failure ?
    … …  
    650650
    651651
    652 int MatrixRC::SetRow(int r)
     652int OMatrixRC::SetRow(int r)
    653653{
    654654  if (!matrix) return -1;             // Failure ?
    … …  
    662662
    663663
    664 int MatrixRC::SetDiag()
     664int OMatrixRC::SetDiag()
    665665{
    666666  if (!matrix) return -1;             // Failure ?
    … …  
    674674
    675675
    676 MatrixRC& MatrixRC::operator = (const MatrixRC& rc)
     676OMatrixRC& OMatrixRC::operator = (const OMatrixRC& rc)
    677677{
    678678  matrix = rc.matrix;
    … …  
    684684}
    685685
    686 //MatrixRC::operator Vector() const
    687 Vector MatrixRC::GetVect() const
     686//OMatrixRC::operator OVector() const
     687OVector OMatrixRC::GetVect() const
    688688#if HAS_NAMED_RETURN
    689689return v(NElts())
    … …  
    691691{
    692692#if !HAS_NAMED_RETURN
    693   Vector v(NElts());
     693  OVector v(NElts());
    694694#endif
    695695  int n = NElts();
    … …  
    702702
    703703
    704 MatrixRC& MatrixRC::operator += (const MatrixRC& rc)
     704OMatrixRC& OMatrixRC::operator += (const OMatrixRC& rc)
    705705{
    706706  int n = NElts();
    … …  
    716716
    717717
    718 MatrixRC& MatrixRC::operator -= (const MatrixRC& rc)
     718OMatrixRC& OMatrixRC::operator -= (const OMatrixRC& rc)
    719719{
    720720  int n = NElts();
    … …  
    729729
    730730
    731 MatrixRC& MatrixRC::operator *= (double x)
     731OMatrixRC& OMatrixRC::operator *= (double x)
    732732{
    733733  int n = NElts();
    … …  
    740740
    741741
    742 MatrixRC& MatrixRC::operator /= (double x)
     742OMatrixRC& OMatrixRC::operator /= (double x)
    743743{
    744744  int n = NElts();
    … …  
    751751
    752752
    753 MatrixRC& MatrixRC::operator -= (double x)
     753OMatrixRC& OMatrixRC::operator -= (double x)
    754754{
    755755  int n = NElts();
    … …  
    762762
    763763
    764 MatrixRC& MatrixRC::operator += (double x)
     764OMatrixRC& OMatrixRC::operator += (double x)
    765765{
    766766  int n = NElts();
    … …  
    774774
    775775
    776 double operator * (const MatrixRC& a, const MatrixRC& b)
     776double operator * (const OMatrixRC& a, const OMatrixRC& b)
    777777{
    778778  int n = a.NElts();
    … …  
    786786
    787787
    788 MatrixRC& MatrixRC::LinComb(double a, double b, const MatrixRC& rc, int first)
     788OMatrixRC& OMatrixRC::LinComb(double a, double b, const OMatrixRC& rc, int first)
    789789{
    790790  int n = NElts();
    … …  
    799799
    800800
    801 MatrixRC& MatrixRC::LinComb(double b, const MatrixRC& rc, int first)
     801OMatrixRC& OMatrixRC::LinComb(double b, const OMatrixRC& rc, int first)
    802802{
    803803  int n = NElts();
    … …  
    813813
    814814
    815 MatrixRC Matrix::Row(int r) const
     815OMatrixRC OMatrix::Row(int r) const
    816816#if HAS_NAMED_RETURN
    817 return rc((Matrix&)*this, matrixRow, r)
     817return rc((OMatrix&)*this, matrixRow, r)
    818818#endif
    819819{
    820820#if !HAS_NAMED_RETURN
    821         MatrixRC rc((Matrix&)*this, matrixRow, r);
     821        OMatrixRC rc((OMatrix&)*this, matrixRow, r);
    822822        return rc;
    823823#endif
    … …  
    825825
    826826
    827 MatrixRC Matrix::Col(int c) const
     827OMatrixRC OMatrix::Col(int c) const
    828828#if HAS_NAMED_RETURN
    829 return rc((Matrix&)*this, matrixCol, c)
     829return rc((OMatrix&)*this, matrixCol, c)
    830830#endif
    831831{
    832832#if !HAS_NAMED_RETURN
    833         MatrixRC rc((Matrix&)*this, matrixCol, c);
     833        OMatrixRC rc((OMatrix&)*this, matrixCol, c);
    834834        return rc;
    835835#endif
    … …  
    837837
    838838
    839 MatrixRC Matrix::Diag() const
     839OMatrixRC OMatrix::Diag() const
    840840#if HAS_NAMED_RETURN
    841 return rc((Matrix&)*this, matrixDiag)
     841return rc((OMatrix&)*this, matrixDiag)
    842842#endif
    843843{
    844844#if !HAS_NAMED_RETURN
    845         MatrixRC rc((Matrix&)*this, matrixDiag);
     845        OMatrixRC rc((OMatrix&)*this, matrixDiag);
    846846        return rc;
    847847#endif
    … …  
    849849
    850850
    851 int MatrixRC::IMaxAbs(int first)
     851int OMatrixRC::IMaxAbs(int first)
    852852{
    853853  int n=NElts();
    … …  
    865865
    866866
    867 void MatrixRC::Swap(MatrixRC& rc1, MatrixRC& rc2)
     867void OMatrixRC::Swap(OMatrixRC& rc1, OMatrixRC& rc2)
    868868{
    869869  int n=rc1.NElts();
    … …  
    877877
    878878
    879 double Matrix::GausPiv(Matrix& a, Matrix& b)
     879double OMatrix::GausPiv(OMatrix& a, OMatrix& b)
    880880{
    881881  int n = a.NRows();
    … …  
    902902    double ld = a.NRows() * log(nrm);
    903903    if (ld <= LN_MINDOUBLE || ld >= LN_MAXDOUBLE) {
    904      // cerr << "Matrix warning, overflow for det" << endl;
     904     // cerr << "OMatrix warning, overflow for det" << endl;
    905905    } else {
    906906      det = exp(ld);
    … …  
    908908  }
    909909
    910   MatrixRC pivRowa(a,matrixRow);
    911   MatrixRC pivRowb(b,matrixRow);
     910  OMatrixRC pivRowa(a,matrixRow);
     911  OMatrixRC pivRowb(b,matrixRow);
    912912
    913913  for (int k=0; k<n-1; k++) {
    914914    int iPiv = a.Col(k).IMaxAbs(k);
    915915    if (iPiv != k) {
    916       MatrixRC aIPiv(a.Row(iPiv));
    917       MatrixRC aK(a.Row(k));
    918       MatrixRC::Swap(aIPiv,aK);
    919       MatrixRC bIPiv(b.Row(iPiv));
    920       MatrixRC bK(b.Row(k));
    921       MatrixRC::Swap(bIPiv,bK);
     916      OMatrixRC aIPiv(a.Row(iPiv));
     917      OMatrixRC aK(a.Row(k));
     918      OMatrixRC::Swap(aIPiv,aK);
     919      OMatrixRC bIPiv(b.Row(iPiv));
     920      OMatrixRC bK(b.Row(k));
     921      OMatrixRC::Swap(bIPiv,bK);
    922922    }
    923923    double pivot = a(k,k);
    … …  
    958958
    959959//++
    960 double Matrix::Norm1()
     960double OMatrix::Norm1()
    961961//
    962962//      Norme 1 : somme des valeurs absolues.
    … …  
    970970
    971971//++
    972 double Matrix::Norm2()
     972double OMatrix::Norm2()
    973973//
    974974//      Norme 2, euclidienne.
    … …  
    983983//////////////////////////////////////////////////////////
    984984//++
    985 Matrix Matrix::FitResidus(GeneralFit& gfit
     985OMatrix OMatrix::FitResidus(GeneralFit& gfit
    986986               ,double xorg,double yorg,double dx,double dy)
    987987//
    … …  
    992992{
    993993if(NCol()<=0||NRows()<=0)
    994   throw(SzMismatchError("Matrix::FitResidus: size mismatch\n"));
     994  throw(SzMismatchError("OMatrix::FitResidus: size mismatch\n"));
    995995GeneralFunction* f = gfit.GetFunction();
    996996if(f==NULL)
    997   throw(NullPtrError("Matrix::FitResidus: NULL pointer\n"));
    998 Vector par = gfit.GetParm();
    999 Matrix m(*this);
     997  throw(NullPtrError("OMatrix::FitResidus: NULL pointer\n"));
     998OVector par = gfit.GetParm();
     999OMatrix m(*this);
    10001000for(int i=0;i<NRows();i++) for(int j=0;j<NCol();j++) {
    10011001  double x[2] = {xorg+j*dx,yorg+i*dy};
    … …  
    10061006
    10071007//++
    1008 Matrix Matrix::FitFunction(GeneralFit& gfit
     1008OMatrix OMatrix::FitFunction(GeneralFit& gfit
    10091009               ,double xorg,double yorg,double dx,double dy)
    10101010//
    … …  
    10151015{
    10161016if(NCol()<=0||NRows()<=0)
    1017   throw(SzMismatchError("Matrix::FitFunction: size mismatch\n"));
     1017  throw(SzMismatchError("OMatrix::FitFunction: size mismatch\n"));
    10181018GeneralFunction* f = gfit.GetFunction();
    10191019if(f==NULL)
    1020   throw(NullPtrError("Matrix::FitFunction: NULL pointer\n"));
    1021 Vector par = gfit.GetParm();
    1022 Matrix m(*this);
     1020  throw(NullPtrError("OMatrix::FitFunction: NULL pointer\n"));
     1021OVector par = gfit.GetParm();
     1022OMatrix m(*this);
    10231023for(int i=0;i<NRows();i++) for(int j=0;j<NCol();j++) {
    10241024  double x[2] = {xorg+j*dx,yorg+i*dy};

  • trunk/SophyaLib/NTools/matrix.h

    r494 r508  
    1818// <summary> Operations matricielles </summary>
    1919// Operations matricielles, algebre lineaire...
    20 class Matrix : public PPersist, public AnyDataObj {
    21   friend class Vector;
    22   friend class MatrixRC;
     20class OMatrix : public PPersist, public AnyDataObj {
     21  friend class OVector;
     22  friend class OMatrixRC;
    2323  friend class TMatrix<r_8>;
    2424public:
    25   Matrix();
     25  OMatrix();
    2626  // Constructeur, matrice a zero
    27   Matrix(int r, int c);
     27  OMatrix(int r, int c);
    2828  // Constructeur avec des valeurs. Pas d'allocation, juste pointe.
    29   Matrix(int r, int c, double* values);
     29  OMatrix(int r, int c, double* values);
    3030  // Constructeur par copie
    31   Matrix(const Matrix& a);
     31  OMatrix(const OMatrix& a);
    3232  // Constructeur par copie a partir d'une TMatrix<r_8>
    33   Matrix(const TMatrix<r_8>& a);
     33  OMatrix(const TMatrix<r_8>& a);
    3434  // Destructeur
    35   virtual ~Matrix();
     35  virtual ~OMatrix();
    3636
    3737  // Construction automatique pour PPF
    … …  
    3939  enum {classId = ClassId_Matrix};
    4040  int_4                 ClassId() const         { return classId; }
    41   static PPersist*      Create() {return new Matrix(1,1);}
     41  static PPersist*      Create() {return new OMatrix(1,1);}
    4242  // </group>
    4343
    … …  
    4949
    5050  // Operateur d'affectation
    51   Matrix& operator = (const Matrix& a);
     51  OMatrix& operator = (const OMatrix& a);
    5252  // Affectation depuis scalaire : identite * scalaire
    53   Matrix& operator = (double x);
     53  OMatrix& operator = (double x);
    5454
    5555  // Impression
    56   friend ostream& operator << (ostream& s, const Matrix& a);
     56  friend ostream& operator << (ostream& s, const OMatrix& a);
    5757
    5858  // Acces aux elements
    … …  
    7474  // Operations matricielles avec scalaire, allocation d'une nouvelle matrice
    7575  // <group>
    76   friend Matrix operator * (const Matrix& a, double b);
    77   friend Matrix operator * (double b, const Matrix& a);
    78   friend Matrix operator + (const Matrix& a, double b);
    79   friend Matrix operator + (double b, const Matrix& a);
    80   friend Matrix operator - (const Matrix& a, double b);
    81   friend Matrix operator - (double b, const Matrix& a);
    82   friend Matrix operator / (const Matrix& a, double b);
     76  friend OMatrix operator * (const OMatrix& a, double b);
     77  friend OMatrix operator * (double b, const OMatrix& a);
     78  friend OMatrix operator + (const OMatrix& a, double b);
     79  friend OMatrix operator + (double b, const OMatrix& a);
     80  friend OMatrix operator - (const OMatrix& a, double b);
     81  friend OMatrix operator - (double b, const OMatrix& a);
     82  friend OMatrix operator / (const OMatrix& a, double b);
    8383  // </group>
    8484
    8585  // Operations matricielles avec scalaires entiers, pour eviter l'appel
    8686  // du constructeur de vecteur a partir d'un entier...
    87   // sinon v*2 = v * Vector(2), BUG !
    88   // <group>
    89   friend Matrix operator * (const Matrix& a, int b);
    90   friend Matrix operator * (int b, const Matrix& a);
    91   friend Matrix operator + (const Matrix& a, int b);
    92   friend Matrix operator + (int b, const Matrix& a);
    93   friend Matrix operator - (const Matrix& a, int b);
    94   friend Matrix operator - (int b, const Matrix& a);
    95   friend Matrix operator / (const Matrix& a, int b);
     87  // sinon v*2 = v * OVector(2), BUG !
     88  // <group>
     89  friend OMatrix operator * (const OMatrix& a, int b);
     90  friend OMatrix operator * (int b, const OMatrix& a);
     91  friend OMatrix operator + (const OMatrix& a, int b);
     92  friend OMatrix operator + (int b, const OMatrix& a);
     93  friend OMatrix operator - (const OMatrix& a, int b);
     94  friend OMatrix operator - (int b, const OMatrix& a);
     95  friend OMatrix operator / (const OMatrix& a, int b);
    9696  // </group>
    9797
    9898  // Operations matricielles "en place", avec scalaire
    9999  // <group>
    100   Matrix& operator *= (double b);
    101   Matrix& operator += (double b);
    102   Matrix& operator -= (double b);
    103   Matrix& operator /= (double b);
     100  OMatrix& operator *= (double b);
     101  OMatrix& operator += (double b);
     102  OMatrix& operator -= (double b);
     103  OMatrix& operator /= (double b);
    104104  // </group>
    105105
    106106  // Operations matricielles
    107107  // <group>
    108   friend Matrix operator * (const Matrix& a, const Matrix& b);
    109   friend Matrix operator + (const Matrix& a, const Matrix& b);
    110   friend Matrix operator - (const Matrix& a, const Matrix& b);
    111 
    112   Matrix& operator *= (const Matrix& a);
    113   Matrix& operator += (const Matrix& b);
    114   Matrix& operator -= (const Matrix& b);
     108  friend OMatrix operator * (const OMatrix& a, const OMatrix& b);
     109  friend OMatrix operator + (const OMatrix& a, const OMatrix& b);
     110  friend OMatrix operator - (const OMatrix& a, const OMatrix& b);
     111
     112  OMatrix& operator *= (const OMatrix& a);
     113  OMatrix& operator += (const OMatrix& b);
     114  OMatrix& operator -= (const OMatrix& b);
    115115  // </group>
    116116
    117117  // Matrice transposee
    118   Matrix Transpose() const;
     118  OMatrix Transpose() const;
    119119  // Matrice inverse
    120120  // <thrown> singMatxErr </thrown>
    121   Matrix Inverse() const;
     121  OMatrix Inverse() const;
    122122
    123123  // Nombre de lignes
    … …  
    134134  // Acces aux rangees et colonnes
    135135  // <group>
    136   MatrixRC Row(int r) const;
    137   MatrixRC Col(int c) const;
    138   MatrixRC Diag() const;
    139   // </group>
    140   /* Versions const ? Alors il faut constructeur const pour MatrixRC,    */
    141   /* mais MatrixRC contient un Matrix* qui detruit const....             */
     136  OMatrixRC Row(int r) const;
     137  OMatrixRC Col(int c) const;
     138  OMatrixRC Diag() const;
     139  // </group>
     140  /* Versions const ? Alors il faut constructeur const pour OMatrixRC,    */
     141  /* mais OMatrixRC contient un OMatrix* qui detruit const....             */
    142142  /* mais en eux-meme, ils ne modifient pas la matrice. Ils permettent   */
    143143  /* de le faire...                                                      */
    … …  
    145145  // Pivot de Gauss : diagonalise la matrice A, en effectuant les memes
    146146  // operations sur la matrice B
    147   static double GausPiv(Matrix& A, Matrix& B);
     147  static double GausPiv(OMatrix& A, OMatrix& B);
    148148
    149149  // Residus et fonction fittees.
    150   Matrix FitResidus(GeneralFit& gfit
     150  OMatrix FitResidus(GeneralFit& gfit
    151151            ,double xorg=0.,double yorg=0.,double dx=1.,double dy=1.);
    152   Matrix FitFunction(GeneralFit& gfit
     152  OMatrix FitFunction(GeneralFit& gfit
    153153            ,double xorg=0.,double yorg=0.,double dx=1.,double dy=1.);
    154154
    … …  
    163163
    164164
    165 inline r_8& Matrix::operator()(int r, int c)
     165inline r_8& OMatrix::operator()(int r, int c)
    166166{
    167167#ifdef RGCHECK
    … …  
    172172
    173173
    174 inline r_8 const& Matrix::operator()(int r, int c) const
     174inline r_8 const& OMatrix::operator()(int r, int c) const
    175175{
    176176#ifdef RGCHECK
    … …  
    186186// Permet d'acceder a une ligne ou colonne d'une matrice, en place, comme
    187187// avec un vecteur.
    188 class MatrixRC EXC_AWARE {
    189 friend class Vector;
    190 friend class Matrix;
     188class OMatrixRC EXC_AWARE {
     189friend class OVector;
     190friend class OMatrix;
    191191public:
    192   MatrixRC();
    193 
    194   virtual ~MatrixRC() {}
     192  OMatrixRC();
     193
     194  virtual ~OMatrixRC() {}
    195195
    196196  int Next();
    … …  
    200200  int SetDiag();
    201201
    202   static int Step(const Matrix& m, RCKind rckind);
    203   static double* Org(const Matrix&, RCKind rckind, int ind=0);
     202  static int Step(const OMatrix& m, RCKind rckind);
     203  static double* Org(const OMatrix&, RCKind rckind, int ind=0);
    204204
    205205  int NElts() const;
    … …  
    207207  r_8  operator()(int i) const;
    208208
    209   MatrixRC& operator = (const MatrixRC& rc);
    210   //operator Vector() const;
    211   Vector GetVect() const;
    212 
    213   MatrixRC& operator += (const MatrixRC& rc);
    214   MatrixRC& operator -= (const MatrixRC& rc);
    215 
    216   MatrixRC& operator *= (double x);
    217   MatrixRC& operator /= (double x);
    218   MatrixRC& operator -= (double x);
    219   MatrixRC& operator += (double x);
    220 
    221   friend double operator * (const MatrixRC& a, const MatrixRC& b);
    222 
    223   MatrixRC& LinComb(double a, double b, const MatrixRC& rc, int first=0);
    224   MatrixRC& LinComb(double b, const MatrixRC& rc, int first=0);
     209  OMatrixRC& operator = (const OMatrixRC& rc);
     210  //operator OVector() const;
     211  OVector GetVect() const;
     212
     213  OMatrixRC& operator += (const OMatrixRC& rc);
     214  OMatrixRC& operator -= (const OMatrixRC& rc);
     215
     216  OMatrixRC& operator *= (double x);
     217  OMatrixRC& operator /= (double x);
     218  OMatrixRC& operator -= (double x);
     219  OMatrixRC& operator += (double x);
     220
     221  friend double operator * (const OMatrixRC& a, const OMatrixRC& b);
     222
     223  OMatrixRC& LinComb(double a, double b, const OMatrixRC& rc, int first=0);
     224  OMatrixRC& LinComb(double b, const OMatrixRC& rc, int first=0);
    225225
    226226  int IMaxAbs(int first=0);
    227227
    228   static void Swap(MatrixRC& rc1, MatrixRC& rc2);
    229   // comme c'est symetrique, soit c'est static MatrixRC, soit static Matrix,
    230   // soit Matrix avec verification qu'on parle bien de la meme...
     228  static void Swap(OMatrixRC& rc1, OMatrixRC& rc2);
     229  // comme c'est symetrique, soit c'est static OMatrixRC, soit static OMatrix,
     230  // soit OMatrix avec verification qu'on parle bien de la meme...
    231231
    232232protected:
    233   MatrixRC(Matrix& m, RCKind kind, int index=0);
    234   Matrix* matrix;
     233  OMatrixRC(OMatrix& m, RCKind kind, int index=0);
     234  OMatrix* matrix;
    235235  r_8*    data;
    236236  int     index;
    … …  
    240240
    241241
    242 inline int MatrixRC::Step(const Matrix& m, RCKind rckind)
     242inline int OMatrixRC::Step(const OMatrix& m, RCKind rckind)
    243243{
    244244  switch (rckind)
    … …  
    255255
    256256
    257 inline double* MatrixRC::Org(const Matrix& m, RCKind rckind, int index)
     257inline double* OMatrixRC::Org(const OMatrix& m, RCKind rckind, int index)
    258258{
    259259  switch (rckind)
    … …  
    270270
    271271
    272 inline int MatrixRC::NElts() const
     272inline int OMatrixRC::NElts() const
    273273{
    274274  if (!matrix) return -1;             // Failure ?
    … …  
    287287
    288288
    289 inline  double& MatrixRC::operator()(int i)
     289inline  double& OMatrixRC::operator()(int i)
    290290{
    291291  return data[i*step];
    … …  
    293293
    294294
    295 inline  double MatrixRC::operator()(int i) const
     295inline  double OMatrixRC::operator()(int i) const
    296296{
    297297  return data[i*step];

  • trunk/SophyaLib/NTools/outilsinit.cc

    r490 r508  
    3232//   Enregistrement des classes PPersist du modules Outils++
    3333 
    34   PPRegister(Matrix);
    35   PPRegister(Vector);
     34  PPRegister(OMatrix);
     35  PPRegister(OVector);
    3636  PPRegister(Poly);
    3737  PPRegister(Poly2);
    … …  
    7373  PPRegister(ImageR4);
    7474
    75   //PPersistMgr::RegisterClass(Matrix::classId,  Matrix::Create);
     75  //PPersistMgr::RegisterClass(OMatrix::classId,  OMatrix::Create);
    7676
    7777  int pnice;

  • trunk/SophyaLib/NTools/pclassids.h

    r490 r508  
    2020   ClassId_DVList   = 0x0105,
    2121
    22    ClassId_PMatrixF = 0x0110,
    23    ClassId_PMatrixD = 0x0111,
    24    ClassId_PVectorF = 0x0112,
    25    ClassId_PVectorD = 0x0113,
     22   ClassId_POMatrixF = 0x0110,
     23   ClassId_POMatrixD = 0x0111,
     24   ClassId_POVectorF = 0x0112,
     25   ClassId_POVectorD = 0x0113,
    2626
    2727   ClassId_Histo1D  = 0x0201,

  • trunk/SophyaLib/NTools/poly.cc

    r490 r508  
    1313//++
    1414// Links        Parents
    15 // Vector
     15// OVector
    1616//--
    1717
    … …  
    2929
    3030Poly::Poly(int degre)
    31 : Vector(degre+1), dirty(0), deg(0)
     31: OVector(degre+1), dirty(0), deg(0)
    3232{
    3333  END_CONSTRUCTOR
    … …  
    9999
    100100//++
    101 int Poly::Roots(Vector& roots) const
     101int Poly::Roots(OVector& roots) const
    102102//
    103103//      Retourne dans roots les racines réelles, si on sait
    … …  
    167167{
    168168  if (this == &a) return *this;
    169   Vector::operator=(a);
     169  OVector::operator=(a);
    170170
    171171  UpdateDeg();
    … …  
    324324#endif
    325325
    326   Vector::ReadSelf(s);
     326  OVector::ReadSelf(s);
    327327
    328328#ifdef DEBUG
    … …  
    341341  ((Poly*)(this))->Realloc(deg, true);
    342342  s << deg;
    343   Vector::WriteSelf(s);
     343  OVector::WriteSelf(s);
    344344}
    345345
    … …  
    375375
    376376//++
    377 double Poly::Fit(Vector const& x, Vector const& y, int degre)
     377double Poly::Fit(OVector const& x, OVector const& y, int degre)
    378378//
    379379//      Ajustement polynomial par moindre carrés. Un polynôme de
    … …  
    387387  Realloc(degre);
    388388
    389   Matrix a(degre+1, n);
     389  OMatrix a(degre+1, n);
    390390
    391391  for (int c=0; c<n; c++) {
    … …  
    397397  }
    398398
    399   double rc = LinFit(a,y,(Vector&)*this);
     399  double rc = LinFit(a,y,(OVector&)*this);
    400400  UpdateDeg();
    401401  return rc;
    … …  
    403403
    404404//++
    405 double Poly::Fit(Vector const& x, Vector const& y, Vector const& erry2, int degre,
    406                  Vector& errCoef)
     405double Poly::Fit(OVector const& x, OVector const& y, OVector const& erry2, int degre,
     406                 OVector& errCoef)
    407407//
    408408//      Ajustement polynomial par moindre carrés. Un polynôme de
    … …  
    419419  errCoef.Realloc(degre+1);
    420420
    421   Matrix a(degre+1, n);
     421  OMatrix a(degre+1, n);
    422422
    423423  for (int c=0; c<n; c++) {
    … …  
    429429  }
    430430
    431   double rc = LinFit(a,y,erry2,(Vector&)*this,errCoef);
     431  double rc = LinFit(a,y,erry2,(OVector&)*this,errCoef);
    432432  UpdateDeg();
    433433  return rc;
    … …  
    482482//++
    483483// Links        Parents
    484 // Vector
     484// OVector
    485485//--
    486486
    … …  
    494494//      Crée un polynôme de degrés partiels degreX et degreY.
    495495//--
    496 :Vector((degreX+1)*(degreY+1)), dirty(0),
     496:OVector((degreX+1)*(degreY+1)), dirty(0),
    497497 maxDegX(degreX), maxDegY(degreY), degX(0), degY(0), deg(0)
    498498{
    … …  
    506506//      de deux polynômes à une variable, p2(x,y)=px(x)py(y)
    507507//--
    508 :Vector((polX.Degre()+1)*(polY.Degre()+1)), dirty(0),
     508:OVector((polX.Degre()+1)*(polY.Degre()+1)), dirty(0),
    509509 maxDegX(polX.Degre()), maxDegY(polY.Degre()),
    510510 degX(polX.Degre()), degY(polY.Degre()), deg(degX+degY)
    … …  
    521521//      Constructeur par copie.
    522522//--
    523 :Vector(a), dirty(a.dirty),
     523:OVector(a), dirty(a.dirty),
    524524 maxDegX(a.maxDegX), maxDegY(a.maxDegY),
    525525 degX(a.degX), degY(a.degY), deg(a.deg)
    … …  
    561561  UpdateDegIfDirty();
    562562  Poly2 tmp(*this);
    563   Vector::Realloc((degreX+1)*(degreY+1));
     563  OVector::Realloc((degreX+1)*(degreY+1));
    564564  Zero();
    565565  maxDegX = degreX;
    … …  
    631631
    632632//++
    633 double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
     633double Poly2::Fit(OVector const& x, OVector const& y, OVector const& z,
    634634                  int degreX, int degreY)
    635635//
    … …  
    643643  Realloc(degreX, degreY);
    644644
    645   Matrix a((degreX+1)*(degreY+1), n);
     645  OMatrix a((degreX+1)*(degreY+1), n);
    646646
    647647  for (int c=0; c<n; c++) {
    … …  
    657657  }
    658658
    659   double rc = LinFit(a,z,(Vector&)*this);
     659  double rc = LinFit(a,z,(OVector&)*this);
    660660  UpdateDeg();
    661661  return rc;
    … …  
    664664
    665665//++
    666 double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
    667                   Vector const& errz2, int degreX, int degreY,
    668                   Vector& errCoef)
     666double Poly2::Fit(OVector const& x, OVector const& y, OVector const& z,
     667                  OVector const& errz2, int degreX, int degreY,
     668                  OVector& errCoef)
    669669//
    670670//      Ajustement par moindre carrés z = P(x,y), degrés partiels imposés,
    … …  
    680680  errCoef.Realloc((degreX+1)*(degreY+1));
    681681
    682   Matrix a((degreX+1)*(degreY+1), n);
     682  OMatrix a((degreX+1)*(degreY+1), n);
    683683
    684684  for (int c=0; c<n; c++) {
    … …  
    694694  }
    695695
    696   double rc = LinFit(a,z,errz2,(Vector&)*this,errCoef);
     696  double rc = LinFit(a,z,errz2,(OVector&)*this,errCoef);
    697697  UpdateDeg();
    698698  return rc;
    … …  
    700700
    701701//++
    702 double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
     702double Poly2::Fit(OVector const& x, OVector const& y, OVector const& z,
    703703                  int degre)
    704704//
    … …  
    712712  Realloc(degre, degre);   // certains vaudront 0, impose.
    713713
    714   Matrix a((degre+1)*(degre+2)/2, n);
    715   Vector cf((degre+1)*(degre+2)/2);
     714  OMatrix a((degre+1)*(degre+2)/2, n);
     715  OVector cf((degre+1)*(degre+2)/2);
    716716#define C_INDEX(i,j) ((i) + (j)*(2*degre+3-(j))/2)
    717717
    … …  
    744744
    745745//++
    746 double Poly2::Fit(Vector const& x, Vector const& y, Vector const& z,
    747                   Vector const& errz2, int degre,
    748                   Vector& errCoef)
     746double Poly2::Fit(OVector const& x, OVector const& y, OVector const& z,
     747                  OVector const& errz2, int degre,
     748                  OVector& errCoef)
    749749//
    750750//      Ajustement par moindre carrés z = P(x,y), degré total imposé,
    … …  
    761761#define C_INDEX(i,j) ((i) + (j)*(2*degre+3-(j))/2)
    762762
    763   Matrix a((degre+1)*(degre+2)/2, n);
    764   Vector cf((degre+1)*(degre+2)/2);
    765   Vector ecf((degre+1)*(degre+2)/2);
     763  OMatrix a((degre+1)*(degre+2)/2, n);
     764  OVector cf((degre+1)*(degre+2)/2);
     765  OVector ecf((degre+1)*(degre+2)/2);
    766766
    767767  for (int c=0; c<n; c++) {
    … …  
    806806#endif
    807807
    808   Vector::ReadSelf(s);
     808  OVector::ReadSelf(s);
    809809
    810810#ifdef DEBUG
    … …  
    817817{
    818818  s << maxDegX << maxDegY;
    819   Vector::WriteSelf(s);
     819  OVector::WriteSelf(s);
    820820}
    821821

  • trunk/SophyaLib/NTools/poly.h

    r220 r508  
    11// This may look like C code, but it is really -*- C++ -*-
    22//
    3 // $Id: poly.h,v 1.1.1.1 1999-04-09 17:57:58 ansari Exp $
     3// $Id: poly.h,v 1.2 1999-10-25 10:36:11 ansari Exp $
    44//
    55
    … …  
    1616class Poly2;
    1717
    18 class Poly : public Vector {
     18class Poly : public OVector {
    1919public:
    2020  Poly(int degre = 0);
    … …  
    2626  inline int Degre() const {UpdateDegIfDirty(); return deg;}
    2727
    28   inline void Realloc(int n, bool force=false) {Vector::Realloc(n+1,force);}
     28  inline void Realloc(int n, bool force=false) {OVector::Realloc(n+1,force);}
    2929
    3030  inline double operator[](int i) const {return data[i];}
    … …  
    4141  // Derive le polynome dans un autre
    4242
    43   int    Roots(Vector& roots) const;
     43  int    Roots(OVector& roots) const;
    4444  // retourne les racines si on peut les calculer...
    4545
    … …  
    7272  friend ostream& operator << (ostream& s, const Poly& a);
    7373
    74   double Fit(Vector const& x, Vector const& y, int degre);
     74  double Fit(OVector const& x, OVector const& y, int degre);
    7575  // Fit d'un polynome de degre donne sur les x et y.
    7676
    77   double Fit(Vector const& x, Vector const& y, Vector const& erry2, int degre,
    78             Vector& errCoef);
     77  double Fit(OVector const& x, OVector const& y, OVector const& erry2, int degre,
     78            OVector& errCoef);
    7979  // En plus, on fournit les carres des erreurs sur y et on a les erreurs
    8080  // sur les coefficients dans un vecteur.
    … …  
    9090
    9191
    92 class Poly2 : public Vector {  // Ca pourrait etre une matrice mais
     92class Poly2 : public OVector {  // Ca pourrait etre une matrice mais
    9393                                  // la encore, un vecteur est utile pour les
    9494                                  // fits.
    … …  
    131131  // retourne le coefficient de degre (dx,dy)
    132132
    133   double Fit(Vector const& x, Vector const& y, Vector const& z,
     133  double Fit(OVector const& x, OVector const& y, OVector const& z,
    134134             int degreX, int degreY);
    135   double Fit(Vector const& x, Vector const& y, Vector const& z,
    136              Vector const& errz2, int degreX, int degreY,
    137              Vector& errCoef);
     135  double Fit(OVector const& x, OVector const& y, OVector const& z,
     136             OVector const& errz2, int degreX, int degreY,
     137             OVector& errCoef);
    138138  // degres partiels imposes. cf Poly::Fit sinon
    139139
    140140
    141   double Fit(Vector const& x, Vector const& y, Vector const& z,
     141  double Fit(OVector const& x, OVector const& y, OVector const& z,
    142142             int degre);
    143   double Fit(Vector const& x, Vector const& y, Vector const& z,
    144              Vector const& errz2, int degre,
    145              Vector& errCoef);
     143  double Fit(OVector const& x, OVector const& y, OVector const& z,
     144             OVector const& errz2, int degre,
     145             OVector& errCoef);
    146146  // degre total impose. cf Poly::Fit sinon
    147147

  • trunk/SophyaLib/NTools/rk4cdifeq.cc

    r244 r508  
    7474//++
    7575RK4CDiffEq& 
    76 RK4CDiffEq::AbsAccuracy(Vector const& vScal)
     76RK4CDiffEq::AbsAccuracy(OVector const& vScal)
    7777//
    7878//      On souhaite une précision absolue, et le vecteur vScal contient
    … …  
    118118
    119119void
    120 RK4CDiffEq::RKCStep(Vector& newY, Vector const& y0, Vector const& yScale,
     120RK4CDiffEq::RKCStep(OVector& newY, OVector const& y0, OVector const& yScale,
    121121               double dttry, double& dtdone, double& dtnext)
    122122{
    … …  
    155155
    156156void
    157 RK4CDiffEq::SolveArr(Matrix& y, double* t, double tf, int n)
     157RK4CDiffEq::SolveArr(OMatrix& y, double* t, double tf, int n)
    158158{
    159159  //TIMEF;
    … …  
    162162  double dxres = (tf - mXStart)/n;
    163163
    164   Vector yt = mYStart;
     164  OVector yt = mYStart;
    165165 
    166166  k1.Realloc(mFunc->NFuncReal());

  • trunk/SophyaLib/NTools/rk4cdifeq.h

    r220 r508  
    2020  // <group>
    2121  RK4CDiffEq& Accuracy(double);
    22   RK4CDiffEq& AbsAccuracy(Vector const& vScal);
     22  RK4CDiffEq& AbsAccuracy(OVector const& vScal);
    2323  RK4CDiffEq& AbsAccuracy(double scal);
    2424  RK4CDiffEq& RelAccuracy();
    … …  
    2626 
    2727  // Implementation RK4 adaptatif
    28   virtual void SolveArr(Matrix& y, double* t, double tf, int n);
     28  virtual void SolveArr(OMatrix& y, double* t, double tf, int n);
    2929
    3030protected:
    3131  // Un pas adaptatif
    32   void RKCStep(Vector& newY, Vector const& y0, Vector const& yScale,
     32  void RKCStep(OVector& newY, OVector const& y0, OVector const& yScale,
    3333               double dttry, double& dtdone, double& dtnext);
    3434
    3535  double eps;
    3636  bool   relAccuracy;
    37   Vector accScale;
    38   Vector yTemp; // Pour ne pas reallouer
    39   Vector ySave;
     37  OVector accScale;
     38  OVector yTemp; // Pour ne pas reallouer
     39  OVector ySave;
    4040};
    4141

  • trunk/SophyaLib/NTools/rzimage.cc

    r278 r508  
    55// LAL (Orsay) / IN2P3-CNRS  DAPNIA/SPP (Saclay) / CEA
    66
    7 //  $Id: rzimage.cc,v 1.4 1999-04-28 13:36:50 ansari Exp $
     7//  $Id: rzimage.cc,v 1.5 1999-10-25 10:36:12 ansari Exp $
    88
    99#include "machdefs.h"
    … …  
    765765GeneralFunction* f = gfit.GetFunction();
    766766if(f==NULL) return NULL;
    767 Vector par = gfit.GetParm();
     767OVector par = gfit.GetParm();
    768768RzImage* img = new RzImage(DataType((r_4)0.),XSize(),YSize());
    769769img->SetOrg(XOrg(),YOrg());
    … …  
    790790GeneralFunction* f = gfit.GetFunction();
    791791if(f==NULL) return NULL;
    792 Vector par = gfit.GetParm();
     792OVector par = gfit.GetParm();
    793793RzImage* img = new RzImage(DataType((r_4)0.),XSize(),YSize());
    794794img->SetOrg(XOrg(),YOrg());

  • trunk/SophyaLib/NTools/tmatrix.cc

    r501 r508  
    1 // $Id: tmatrix.cc,v 1.10 1999-10-23 10:21:23 ansari Exp $
     1// $Id: tmatrix.cc,v 1.11 1999-10-25 10:36:12 ansari Exp $
    22//                         C.Magneville          04/99
    33#include "machdefs.h"
    … …  
    284284TMatrix<r_8> b(mNc,mNr); TMatrix<r_8> a(*this); b = 1.;
    285285if(fabs(TMatrix<r_8>::GausPiv(a,b)) < 1.e-50)
    286   throw(MathExc("TMatrix Inverse() Singular Matrix"));
     286  throw(MathExc("TMatrix Inverse() Singular OMatrix"));
    287287return b;
    288288}

  • trunk/SophyaLib/NTools/tmatrix.h

    r502 r508  
    11// This may look like C code, but it is really -*- C++ -*-
    22//                         C.Magneville          04/99
    3 #ifndef TMATRIX_SEEN
    4 #define TMATRIX_SEEN
     3#ifndef TMatrix_SEEN
     4#define TMatrix_SEEN
    55
    66#include "machdefs.h"
    … …  
    179179
    180180////////////////////////////////////////////////////////////////
    181 // Typedef pour simplifier
    182 // typedef TMatrix<r_8> Matrix;
     181// Typedef pour simplifier et compatibilite Peida
     182typedef TMatrix<r_8> Matrix;
    183183
    184184/////////////////////////////////////////////////////////////////////////
    … …  
    314314inline T  TMatrixRC<T>::operator()(uint_4 i) const {return data[i*step];}
    315315
     316////////////////////////////////////////////////////////////////
     317// Typedef pour simplifier et compatibilite Peida
     318typedef TMatrixRC<r_8> MatrixRC;
     319
    316320} // Fin du namespace
    317321

  • trunk/SophyaLib/NTools/tvector.h

    r502 r508  
    11// This may look like C code, but it is really -*- C++ -*-
    22//                         C.Magneville          05/99
    3 #ifndef TVECTOR_SEEN
    4 #define TVECTOR_SEEN
     3#ifndef TVector_SEEN
     4#define TVector_SEEN
    55
    66#include "tmatrix.h"
    … …  
    7676}
    7777
    78 // Typedef pour simplifier
    79 // typedef TVector<r_8> Vector;
     78// Typedef pour simplifier et compatibilite Peida
     79typedef TVector<r_8> Vector;
    8080
    8181/////////////////////////////////////////////////////////////////////////

  • trunk/SophyaLib/Samba/anagen.cc

    r468 r508  
    3737    double phi0;
    3838    float theta;
    39     Vector phin, datan, phis, datas;
     39    OVector phin, datan, phis, datas;
    4040    map.GetThetaSlice(map.NbThetaSlices()-ith-1,theta,phis,datas);
    4141    map.GetThetaSlice(ith,theta,phin,datan);
    … …  
    7777
    7878
    79 void comp_phas2gen(int nsmax,int nlmax,int nmmax, Vector datain,
     79void comp_phas2gen(int nsmax,int nlmax,int nmmax, OVector datain,
    8080                int nph,vector< complex<double> >& dataout,double phi0){
    8181  /*=======================================================================
    … …  
    9292  //FFTVector outf=FFTServer::solve(inf,-1);
    9393  FFTServer fft;
    94   Vector outf;
     94  OVector outf;
    9595  //cout<<"in :"<<datain<<endl;
    9696  fft.fftb(datain,outf);

  • trunk/SophyaLib/Samba/anagen.h

    r468 r508  
    1010             vector< vector< complex<double> > >& alm, double cos_theta_cut);
    1111
    12 void comp_phas2gen(int nsmax,int nlmax,int nmmax, Vector datain,
     12void comp_phas2gen(int nsmax,int nlmax,int nmmax, OVector datain,
    1313                int nph,vector< complex<double> >& dataout,double phi0);
    1414

  • trunk/SophyaLib/Samba/syngen.cc

    r468 r508  
    4343    double phi0;
    4444    float theta,thetas;
    45     Vector phin, datan,phis,datas;
     45    OVector phin, datan,phis,datas;
    4646    map.GetThetaSlice(map.NbThetaSlices()-ith-1,thetas,phis,datas);
    4747    map.GetThetaSlice(ith,theta,phin,datan);
    … …  
    104104void syn_phasgen(const int nsmax,const int nlmax,const int nmmax,
    105105              const vector< complex<long double> >& datain,
    106               int nph, Vector& dataout, double phi0,
     106              int nph, OVector& dataout, double phi0,
    107107              vector< complex<long double> >& bw){
    108108

  • trunk/SophyaLib/Samba/syngen.h

    r468 r508  
    1818void syn_phasgen(const int nsmax,const int nlmax,const int nmmax,
    1919              const vector< complex<long double> >& datain,
    20               int nph, Vector& dataout, double phi0,
     20              int nph, OVector& dataout, double phi0,
    2121              vector< complex<long double> >& bw);
    2222

  • trunk/SophyaLib/Samba/utilgeom.cc

    r272 r508  
    9595}
    9696
    97 //Matrix vecTxMat(const Vector& v, const Matrix& M) {
     97//OMatrix vecTxMat(const OVector& v, const OMatrix& M) {
    9898 
Note: See TracChangeset for help on using the changeset viewer.