Index: trunk/SophyaLib/TArray/tvector.cc
===================================================================
--- trunk/SophyaLib/TArray/tvector.cc	(revision 762)
+++ trunk/SophyaLib/TArray/tvector.cc	(revision 804)
@@ -1,188 +1,132 @@
-// $Id: tvector.cc,v 1.1.1.1 2000-03-02 16:48:24 ansari Exp $
+// $Id: tvector.cc,v 1.2 2000-04-03 17:35:59 ansari Exp $
 //                         C.Magneville          04/99
 #include "machdefs.h"
-#include <stdio.h>
 #include <stdlib.h>
-#include <iostream.h>
-#include <complex>
 #include "pexceptions.h"
 #include "tvector.h"
-#include "objfio.h"
+
+////////////////////////////////////////////////////////////////
+//**** Createur, Destructeur
 
 template <class T>
-TVector<T>::TVector(uint_4 n)
-// Constructeur d'un vecteur de "n" elements
-: TMatrix<T>(n,1)
+TVector<T>::TVector()
+  : TMatrix<T>()
 {
 }
 
 template <class T>
-TVector<T>::TVector(uint_4 n, T* values,Bridge* br)
-// Construit un vecteur de n elements. On fournit
-// le tableau des valeurs et eventuellement un Bridge.
-: TMatrix<T>(n,1,values,br)
+TVector<T>::TVector(uint_4 n, short lcv, short mm)
+// Constructeur 
+  : TMatrix<T>((lcv == ColumnVector) ? n : 1,(lcv == ColumnVector) ? 1 : 0, mm)
+{
+  if (lcv == ColumnVector) veceli_ = marowi_;
+  else veceli_ = macoli_;
+}
+
+
+template <class T>
+TVector<T>::TVector(const TVector<T>& a)
+// Constructeur par copie (partage si "a" temporaire).
+  : TMatrix<T>(a)
 {
 }
 
 template <class T>
-TVector<T>::TVector(const TVector<T>& v)
-// Constructeur par copie (partage si "v" temporaire).
-: TMatrix<T>(v)
+TVector<T>::TVector(const TVector<T>& a, bool share)
+// Constructeur par copie avec possibilite de forcer le partage ou non.
+: TMatrix<T>(a, share)
 {
 }
 
 template <class T>
-TVector<T>::TVector(const TVector<T>& v,bool share)
-// Constructeur par copie avec possibilite de forcer le partage ou non.
-: TMatrix<T>(v,share)
+TVector<T>::TVector(const TArray<T>& a)
+: TMatrix<T>(a)
 {
 }
 
+
 template <class T>
-TVector<T>::TVector(const TMatrix<T>& a)
-// Constructeur a partir d'une matrice "a" de dimension (n,1)
-: TMatrix<T>(a)
+TVector<T>::TVector(const TArray<T>& a, bool share, short lcv, short mm )
+: TMatrix<T>(a, share, mm)
 {
-if(a.NCols() != 1)
-  throw(SzMismatchError("TVector(const TMatrix<T>& a) size mismatch, ncol!=1"));
+  if (lcv == SameTypeVector) veceli_ = a.VectKA();
+  else {
+    if (lcv == ColumnVector) veceli_ = marowi_;
+    else veceli_ = macoli_;
+  }
+}
+
+template <class T>
+TVector<T>::~TVector()
+// Destructeur
+{
+
+}
+
+template <class T>
+void TVector<T>::ReSize(uint_4 n, short lcv)
+{
+  if( n == 0 ) 
+    throw(SzMismatchError("TVector::ReSize() n = 0 "));
+  uint_4 r,c;
+  if (lcv == SameTypeVector)  lcv = GetVectorType();
+  if (lcv == ColumnVector) { r = n;  c = 1; }
+  else { c = n; r = 1; }
+  TMatrix<T>::ReSize(r,c);
+}
+
+template <class T>
+void TVector<T>::Realloc(uint_4 n, short lcv, bool force)
+{
+  if( n == 0 ) 
+    throw(SzMismatchError("TVector::Realloc() n = 0 "));
+  uint_4 r,c;
+  if (lcv == SameTypeVector)  lcv = GetVectorType();
+  if (lcv == ColumnVector) { r = n;  c = 1; }
+  else { c = n; r = 1; }
+  TMatrix<T>::Realloc(r,c,SameMemoryMapping,force);
+}
+
+// $CHECK$ Reza 03/2000  Doit-on declarer cette methode const ?
+template <class T>
+TVector<T> TVector<T>::operator () (Range relt) const
+{
+  Range rr, cr;
+  if (GetVectorType() == ColumnVector )  rr = relt; 
+  else cr = relt;
+  TMatrix<T> const & mtx = (*this);
+  TVector sv( mtx(rr, cr) , true, GetVectorType(), GetMemoryMapping() );
+  sv.SetTemp(true);
+  return(sv);  
+}
+
+template <class T>
+T TVector<T>::Norm2() const
+{
+  T ret = 0;
+  for(uint_8 k=0; k<Size(); k++)   ret += (*this)(k)*(*this)(k);
+  return ret;
 }
 
 
-///////////////////////////////////////////////////////////
-// --------------------------------------------------------
-//   Les objets delegues pour la gestion de persistance 
-// --------------------------------------------------------
-///////////////////////////////////////////////////////////
-
-template <class T>
-FIO_TVector<T>::FIO_TVector()
-{
-dobj=new TVector<T>;
-ownobj=true;
-}
-
-template <class T>
-FIO_TVector<T>::FIO_TVector(string const & filename) 
-{
-dobj=new TVector<T>;
-ownobj=true; 
-Read(filename);
-}
-
-template <class T>
-FIO_TVector<T>::FIO_TVector(const TVector<T> & obj) 
-{ 
-dobj = new TVector<T>(obj);
-ownobj=true; 
-}
-
-template <class T>
-FIO_TVector<T>::FIO_TVector(TVector<T> * obj) 
-{ 
-dobj = obj;
-ownobj=false; 
-}
-
-template <class T>
-FIO_TVector<T>::~FIO_TVector()
-{
-if (ownobj && dobj) delete dobj;
-}
-
-template <class T>
-AnyDataObj* FIO_TVector<T>::DataObj()
-{
-return(dobj);
-}
-
-template <class T>
-void FIO_TVector<T>::SetDataObj(AnyDataObj & o)
-{
-TVector<T> * po = dynamic_cast< TVector<T> * >(&o);
-if (po == NULL) return;
-if (ownobj && dobj) delete dobj;
-dobj = po; ownobj = false;
-} 
-
-template <class T>
-void FIO_TVector<T>::ReadSelf(PInPersist& is)
-{
-// On lit les 3 premiers uint_4
-//  0: Numero de version,  1 : NRows=NElts,  2 : NCol=1
-uint_4 itab[3];
-is.Get(itab,3);
-if (dobj == NULL) dobj = new TVector<T>(itab[1]);
-else dobj->ReSize(itab[1]);
-// On lit le NDataBlock
-FIO_NDataBlock<T> fio_nd(&dobj->DataBlock());
-fio_nd.Read(is);
-}
-
-template <class T>
-void FIO_TVector<T>::WriteSelf(POutPersist& os) const
-{
-if (dobj == NULL)   return;
-//  On ecrit 3 uint_4 .... 
-//  0: Numero de version,  1 : NRows=NElts,  2 : NCol=1
-uint_4 itab[3];
- itab[0] = 1;  // Numero de version a 1
-itab[1] = dobj->NElts();
-itab[2] = 1;
-os.Put(itab,3);
-// On ecrit le NDataBlock
-FIO_NDataBlock<T> fio_nd(&dobj->DataBlock());
-fio_nd.Write(os);
-}
-
 ///////////////////////////////////////////////////////////////
 #ifdef __CXX_PRAGMA_TEMPLATES__
-#pragma define_template TVector<uint_1>
 #pragma define_template TVector<uint_2>
-#pragma define_template TVector<int_2>
 #pragma define_template TVector<int_4>
 #pragma define_template TVector<int_8>
-#pragma define_template TVector<uint_4>
-#pragma define_template TVector<uint_8>
 #pragma define_template TVector<r_4>
 #pragma define_template TVector<r_8>
 #pragma define_template TVector< complex<r_4> > 
 #pragma define_template TVector< complex<r_8> > 
-// Instances des delegues FileIO (PPersist)
-#pragma define_template FIO_TVector<uint_1>
-#pragma define_template FIO_TVector<uint_2>
-#pragma define_template FIO_TVector<int_2>
-#pragma define_template FIO_TVector<int_4>
-#pragma define_template FIO_TVector<int_8>
-#pragma define_template FIO_TVector<uint_4>
-#pragma define_template FIO_TVector<uint_8>
-#pragma define_template FIO_TVector<r_8>
-#pragma define_template FIO_TVector<r_4>
-#pragma define_template FIO_TVector< complex<r_4> >
-#pragma define_template FIO_TVector< complex<r_8> >
 #endif
 
 #if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
-template class TVector<uint_1>;
 template class TVector<uint_2>;
-template class TVector<int_2>;
 template class TVector<int_4>;
 template class TVector<int_8>;
-template class TVector<uint_4>;
-template class TVector<uint_8>;
 template class TVector<r_4>;
 template class TVector<r_8>;
 template class TVector< complex<r_4> >;
 template class TVector< complex<r_8> >;
-// Instances des delegues FileIO (PPersist)
-template class FIO_TVector<uint_1>;
-template class FIO_TVector<uint_2>;
-template class FIO_TVector<int_2>;
-template class FIO_TVector<int_4>;
-template class FIO_TVector<int_8>;
-template class FIO_TVector<uint_4>;
-template class FIO_TVector<uint_8>;
-template class FIO_TVector<r_8>;
-template class FIO_TVector<r_4>;
-template class FIO_TVector< complex<r_4> >;
-template class FIO_TVector< complex<r_8> >;
 #endif
+
