Index: /trunk/SophyaProg/Tests/sphg0.cc
===================================================================
--- /trunk/SophyaProg/Tests/sphg0.cc	(revision 491)
+++ /trunk/SophyaProg/Tests/sphg0.cc	(revision 491)
@@ -0,0 +1,20 @@
+#include <iostream.h>
+#include "spheregorski.h"
+
+
+int main() 
+{
+  double teta,phi;
+  //  PeidaInit();
+  int  m=32;
+  SphereGorski<double> sph(m);
+  for (int j=0;j<sph.NbPixels();j++) 
+    {
+      sph.PixThetaPhi(j,teta,phi);
+      sph(j)= 0.2* cos(3.*teta)*sin(8*phi);
+    }
+  // Projection  dans une image
+
+  cout <<  " ===== Fin de test0 ======== " << endl;
+  return 0;
+}
Index: /trunk/SophyaProg/Tests/tnt.cc
===================================================================
--- /trunk/SophyaProg/Tests/tnt.cc	(revision 490)
+++ /trunk/SophyaProg/Tests/tnt.cc	(revision 491)
@@ -30,5 +30,9 @@
 
 printf("Ecriture NTuple ds nt.ppf ... \n");
-nt1.Write("nt.ppf");
+{
+// nt1.Write("nt.ppf");  c'etait du PEIDA
+POutPersist s("nt.ppf");
+s << nt1 ;
+}
 
 printf("Lecture NTuple (nt2) ds nt.ppf ... \n");
@@ -42,5 +46,10 @@
 printf("ReLecture NTuple (nt1) ds nt.ppf ... \n");
 
-nt1.Read("nt.ppf");
+{
+//  nt1.Read("nt.ppf");   c'etait du PEIDA !
+PInPersist s("nt.ppf");
+s >> nt1;
+}
+
 nt1.Show(cout);
 nt1.Print(0, 5);
@@ -48,7 +57,12 @@
 nt1.Print(94, 5);
 
-printf("Creation/Lecture Lecture NTuple (nt1) ds nt.ppf ... \n");
+printf("Creation/Lecture Lecture NTuple (nt3) ds nt.ppf ... \n");
 NTuple nt3;
-nt3.Read("nt.ppf");
+{
+//  nt3.Read("nt.ppf");   c'etait du PEIDA !
+PInPersist s("nt.ppf");
+s >> nt3;
+}
+
 nt3.Show(cout);
 nt3.Print(0, 5);
Index: /trunk/SophyaProg/Tests/tstndblk.cc
===================================================================
--- /trunk/SophyaProg/Tests/tstndblk.cc	(revision 491)
+++ /trunk/SophyaProg/Tests/tstndblk.cc	(revision 491)
@@ -0,0 +1,158 @@
+#include "machdefs.h"
+#include <iostream.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include "outilsinit.h"
+#include "pexceptions.h"
+#include "ndatablock.h"
+
+using namespace PlanckDPC;
+
+////////////////////////////////////////////////////////////////////////////////////////
+int main(int narg,char *arg[])
+{
+PeidaInit();
+float x1[5] = {1.,2.,3.,4.,5.};
+float x2[5] = {10.,20.,30.,40.,50.};
+float x3[5] = {100.,200.,300.,400.,500.};
+
+{  // Pour voir explicitement le travail du destructeur
+
+//-----------------------------------------------------
+cout<<endl<<"Createur par defaut Va"<<endl;
+NDataBlock<int_4> V1; V1.Print(1,99);
+TRY {
+  cout<<endl<<"...Createur par copie V2e(V1)"<<endl;
+  NDataBlock<int_4> V2e(V1);
+} CATCHALL {
+  cout<<"...Exception catched"<<endl;
+} ENDTRY
+
+//-----------------------------------------------------
+cout<<endl<<"Createur A1(3)"<<endl;
+NDataBlock<float> A1(3);
+cout<<endl<<"Createur B1(5)"<<endl;
+NDataBlock<float> B1(5);
+A1.FillFrom(5,x1); A1.Print(0,999);
+B1.FillFrom(5,x1); B1.Print(0,999);
+
+cout<<endl<<"Createur A2(3)"<<endl;
+NDataBlock<float> A2(3);
+A2.FillFrom(5,x2); A2.Print(0,999);
+cout<<endl<<"Createur B2(5)"<<endl;
+NDataBlock<float> B2(5);
+B2.FillFrom(5,x2); B2.Print(0,999);
+
+cout<<endl<<"Createur A3(3)"<<endl;
+NDataBlock<float> A3(3);
+A3.FillFrom(5,x3); A3.Print(0,999);
+cout<<endl<<"Createur B3(5)"<<endl;
+NDataBlock<float> B3(5);
+B3.FillFrom(5,x3); B3.Print(0,999);
+
+//-----------------------------------------------------
+cout<<endl<<"Createur par copie AA1(A1)"<<endl;
+NDataBlock<float> AA1(A1);
+
+cout<<endl<<"Createur par copie BB1(B1)"<<endl;
+NDataBlock<float> BB1(B1);
+
+{cout<<endl<<"Createur par copie {BBB1(B1)}"<<endl;
+NDataBlock<float> BBB1(B1);}
+
+{cout<<endl<<"Createur avec bridge {Abr(5,x3,new Bridge)}"<<endl;
+NDataBlock<float> Abr(5,x3,new Bridge);
+Abr.Print(0,999);
+cout<<"x3 existe encore: "<<x3[0]<<",...,"<<x3[4]<<endl;}
+
+{cout<<endl<<"Createur avec bridge {Abr(5,dum,NULL)}"<<endl;
+float *dum = new float[10];
+for(int i=0;i<10;i++) dum[i] = 1000.+i;
+NDataBlock<float> Abr(10,dum);
+Abr.Print(0,999);}
+
+//-----------------------------------------------------
+cout<<endl<<endl;
+NDataBlock<float> AC(3);
+AC.Reset();
+cout<<endl<<"AC=2"<<endl;
+AC = 2; AC.Print(0,999);
+AC.Reset();
+cout<<endl<<"AC=A1"<<endl;
+AC = A1; AC.Print(0,999);
+
+//-----------------------------------------------------
+cout<<endl<<endl;
+AC.Reset();
+cout<<endl<<"AC+=2"<<endl;
+AC += 2; AC.Print(0,999);
+cout<<endl<<"AC+=2+3"<<endl;
+AC += 2+3; AC.Print(0,999);
+cout<<endl<<"AC+=3"<<endl;
+AC += 3; AC.Print(0,999);
+cout<<endl<<"AC-=3"<<endl;
+AC -= 3; AC.Print(0,999);
+cout<<endl<<"AC*=10"<<endl;
+AC *= 10; AC.Print(0,999);
+cout<<endl<<"AC/=10"<<endl;
+AC /= 10; AC.Print(0,999);
+
+//-----------------------------------------------------
+cout<<endl<<endl;
+AC.Reset(1000);
+cout<<endl<<"AC+=A1"<<endl;
+AC += A1; AC.Print(0,999);
+cout<<endl<<"AC-=A1"<<endl;
+AC.Reset(1000);
+AC -= A1; AC.Print(0,999);
+cout<<endl<<"AC*=A1"<<endl;
+AC.Reset(1000);
+AC *= A1; AC.Print(0,999);
+cout<<endl<<"AC/=A1"<<endl;
+AC.Reset(1000);
+AC /= A1; AC.Print(0,999);
+
+//-----------------------------------------------------
+cout<<endl<<endl;
+cout<<endl<<"AC=A1+2"<<endl;
+AC = A1+2.f; AC.Print(0,999);
+cout<<endl<<"AC=2+A1"<<endl;
+AC = 2.f+A1; AC.Print(0,999);
+cout<<endl<<"AC=A1*2"<<endl;
+AC = A1*2.f; AC.Print(0,999);
+cout<<endl<<"AC=2*A1"<<endl;
+AC = 2.f*A1; AC.Print(0,999);
+cout<<endl<<"AC=A1-2"<<endl;
+AC = A1-2.f; AC.Print(0,999);
+cout<<endl<<"AC=2-A1"<<endl;
+AC = 2.f-A1; AC.Print(0,999);
+cout<<endl<<"AC=A1/2"<<endl;
+AC = A1/2.f; AC.Print(0,999);
+cout<<endl<<"AC=2/A1"<<endl;
+AC = 2.f/A1; AC.Print(0,999);
+
+//-----------------------------------------------------
+cout<<endl<<endl;
+cout<<endl<<"AC=A1+A2"<<endl;
+AC = A1 + A2; AC.Print(0,999);
+cout<<endl<<"AC=A2-A1"<<endl;
+AC = A2 - A1; AC.Print(0,999);
+cout<<endl<<"AC=A1*A2"<<endl;
+AC = A1 * A2; AC.Print(0,999);
+cout<<endl<<"AC=A2/A1"<<endl;
+AC = A2 / A1; AC.Print(0,999);
+
+//-----------------------------------------------------
+cout<<endl<<endl;
+cout<<endl<<"AC=A1+A2+A3"<<" "<<&A1<<","<<&A2<<","<<&A3<<endl;
+AC = A1 + A2 + A3; AC.Print(0,999);
+
+
+cout<<"\n\n\n"<<endl;
+}  // Pour voir explicitement le travail du destructeur
+cout<<"Fin du Job"<<endl;
+
+exit(0);
+}
Index: /trunk/SophyaProg/Tests/tsttmat.cc
===================================================================
--- /trunk/SophyaProg/Tests/tsttmat.cc	(revision 491)
+++ /trunk/SophyaProg/Tests/tsttmat.cc	(revision 491)
@@ -0,0 +1,226 @@
+#include "machdefs.h"
+#include <iostream.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include "outilsinit.h"
+#include "pexceptions.h"
+#include "matrix.h"
+#include "tmatrix.h"
+#include "nbrandom.h"
+
+using namespace PlanckDPC;
+
+////////////////////////////////////////////////////////////////////////////////////////
+int main(int narg,char *arg[])
+{
+PeidaInit();
+r_8 v[3][4] = {{1,2,3,4},{4,5,6,5},{7,8,9,10}};
+
+{
+
+TMatrix<r_8> A(2,3);
+{for(int i=0;i<2;i++) for(int j=0;j<3;j++) A(i,j) = v[i][j];}
+cout<<"A:"<<endl<<A;
+
+{
+cout << " Test ecriture PPersist TMatrix " << endl; 
+FIO_TMatrix<r_8> ftm(A);
+ftm.Write("tmtx.ppf");
+}
+{
+cout << " Test lecture PPersist TMatrix " << endl; 
+FIO_TMatrix<r_8> ftm("tmtx.ppf");
+cout<<"Alue:"<<(TMatrix<r_8>)ftm<<endl;
+}
+
+cout<<"Matrices B(2,3)"<<endl;
+TMatrix<r_8> B(3,2);
+{for(int i=0;i<3;i++) for(int j=0;j<2;j++) B(i,j) = v[i][j];}
+cout<<"B:"<<endl<<B;
+
+cout<<"Matrices C(3,3)"<<endl;
+TMatrix<r_8> C(3,3);
+{for(int i=0;i<3;i++) for(int j=0;j<3;j++) C(i,j) = v[i][j];}
+cout<<"C:"<<endl<<C;
+
+cout<<"Matrices D(2,2)"<<endl;
+TMatrix<r_8> D(2,2);
+{for(int i=0;i<2;i++) for(int j=0;j<2;j++) D(i,j) = v[i][j];}
+cout<<"D:"<<endl<<D;
+
+cout<<"Matrices E(3,4)"<<endl;
+TMatrix<r_8> E(3,4);
+{for(int i=0;i<3;i++) for(int j=0;j<4;j++) E(i,j) = v[i][j];}
+cout<<"E:"<<endl<<E;
+
+//-----------------------------------------------
+cout<<endl<<"Matrices AA(A)"<<endl;
+TMatrix<r_8> AA(A);
+cout<<"AA:"<<endl<<AA;
+
+//-----------------------------------------------
+cout<<endl<<"Matrices AA2; AA2=A;"<<endl;
+TMatrix<r_8> AA2; AA2=A;
+cout<<"AA2:"<<endl<<AA2;
+
+//-----------------------------------------------
+cout<<endl<<"Matrices AAA.Clone(A)"<<endl;
+TMatrix<r_8> AAA; AAA.Clone(A);
+cout<<"AAA:"<<endl<<AAA;
+cout<<endl<<"Matrices BBB.Clone(B)"<<endl;
+TMatrix<r_8> BBB; BBB.Clone(B);
+cout<<"BBB:"<<endl<<BBB;
+cout<<"Matrices CCC.Clone(C)"<<endl;
+TMatrix<r_8> CCC; CCC.Clone(C);
+cout<<"CCC:"<<endl<<CCC;
+
+//-----------------------------------------------
+cout<<endl<<"Matrices I(5,5)=1.234"<<endl;
+TMatrix<r_8> I(5,5); I = 5;
+cout<<"I:"<<endl<<I;
+
+//-----------------------------------------------
+cout<<endl<<"Matrices AAA+=1"<<endl;
+AAA += 1;
+cout<<"AAA:"<<endl<<AAA;
+cout<<"Matrices AAA-=1"<<endl;
+AAA -= 1;
+cout<<"AAA:"<<endl<<AAA;
+cout<<"Matrices AAA*=10"<<endl;
+AAA *= 10;
+cout<<"AAA:"<<endl<<AAA;
+cout<<"Matrices AAA/=10"<<endl;
+AAA /= 10;
+cout<<"AAA:"<<endl<<AAA;
+
+//-----------------------------------------------
+cout<<endl<<"Matrices AAA+=A"<<endl;
+AAA += A;
+cout<<"AAA:"<<endl<<AAA;
+cout<<"Matrices AAA-=A"<<endl;
+AAA -= A;
+cout<<"AAA:"<<endl<<AAA;
+
+//-----------------------------------------------
+cout<<endl<<"Matrices AAA=A"<<endl;
+AAA = A;
+cout<<"AAA:"<<endl<<AAA;
+cout<<endl<<"Matrices BBB=B"<<endl;
+BBB = B;
+cout<<"BBB:"<<endl<<BBB;
+
+//---------------------------------------------
+TMatrix<r_8> a(A,false);
+cout<<endl<<"Matrices AAA*=C"<<endl;
+{for(int i=0;i<AAA.NRows();i++) for(int j=0;j<C.NCols();j++)
+  {a(i,j) = 0; for(int k=0;k<AAA.NCols();k++) a(i,j) += AAA(i,k)*C(k,j);}}
+AAA *= C;
+cout<<"AAA:"<<endl<<AAA;
+cout<<"a:"<<endl<<a;
+TMatrix<r_8> b(B,false);
+cout<<"Matrices BBB*=D"<<endl;
+{for(int i=0;i<BBB.NRows();i++) for(int j=0;j<D.NCols();j++)
+  {b(i,j) = 0; for(int k=0;k<BBB.NCols();k++) b(i,j) += BBB(i,k)*D(k,j);}}
+BBB *= D;
+cout<<"B:"<<endl<<BBB;
+cout<<"b:"<<endl<<b;
+
+//-----------------------------------------------
+AA.Clone(A);
+cout<<endl<<"Matrices AA = AA + 10"<<endl;
+AA = AA + 10.; cout<<"AA"<<endl<<AA;
+cout<<endl<<"Matrices AA = AA - 10"<<endl;
+AA = AA - 10.; cout<<"AA"<<endl<<AA;
+cout<<endl<<"Matrices AA = 10 - AA"<<endl;
+AA = 10. - AA; cout<<"AA"<<endl<<AA;
+cout<<endl<<"Matrices AA = AA - 10"<<endl;
+AA = AA - 10.; cout<<"AA"<<endl<<AA;
+cout<<endl<<"Matrices AA = -1 * AA"<<endl;
+AA = -1. * AA; cout<<"AA"<<endl<<AA;
+cout<<endl<<"Matrices AA = 10 * AA"<<endl;
+AA = 10. * AA; cout<<"AA"<<endl<<AA;
+cout<<endl<<"Matrices AA = AA * 10"<<endl;
+AA = AA * 10.; cout<<"AA"<<endl<<AA;
+cout<<endl<<"Matrices AA = AA / 100"<<endl;
+AA = AA / 100.; cout<<"AA"<<endl<<AA;
+
+//-----------------------------------------------
+TMatrix<r_8> R;
+AA.Clone(A); AA += 10.; AAA.Clone(A); AAA += 100.;
+cout<<endl<<"Matrices R = A + AA"<<endl;
+R = A + AA; cout<<"R"<<endl<<R;
+cout<<endl<<"Matrices R = AA - A"<<endl;
+R = AA - A; cout<<"R"<<endl<<R;
+cout<<endl<<"Matrices R = A + AA + AAA"<<endl;
+R = A + AA + AAA; cout<<"R"<<endl<<R;
+cout<<endl<<"Matrices R = A + 100 + 2*A"<<endl;
+R = A + 100. + 2.*A; cout<<"R"<<endl<<R;
+
+//-----------------------------------------------
+TMatrix<r_8> RR(2,4);
+{for(int i=0;i<A.NRows();i++) for(int j=0;j<E.NCols();j++)
+  {RR(i,j) = 0; for(int k=0;k<A.NCols();k++) RR(i,j) += A(i,k)*E(k,j);}}
+cout<<endl<<"Matrices R = A * E"<<endl;
+R = A * E;
+cout<<"R"<<endl<<R; cout<<"RR"<<endl<<RR;
+
+//-----------------------------------------------
+cout<<endl<<"Matrices A = A.Transpose 2x"<<endl;
+cout<<"A"<<endl<<A;
+A = A.Transpose(); cout<<"trA"<<endl<<A;
+A = A.Transpose(); cout<<"trtrA"<<endl<<A;
+cout<<endl<<"Matrices AT = A.Transpose()  2x"<<endl;
+TMatrix<r_8> AT;
+AT = A.Transpose(); cout<<"AT"<<endl<<AT;
+AT = AT.Transpose(); cout<<"trAT"<<endl<<AT;
+
+//-----------------------------------------------
+cout<<endl<<"Test Inversion avec couplage a M=Matrix(C)"<<endl;
+TMatrix<r_8> X(10,10);
+{for(int i=0;i<10;i++) for(int j=0;j<10;j++)
+  {X(i,j) = drand01(); if(drand01()>0.8) X(i,j) += 1.e+15*drand01();}}
+cout<<"TMatrix X"<<endl<<X;
+{
+Matrix M(X); cout<<"Matrix M"<<endl<<M<<endl;
+Matrix MI = M.Inverse(); cout<<"MI"<<endl<<MI;
+MI *= M; cout<<"MI*M"<<endl<<MI;
+r_8 xmin=-1.;
+for(int i=0;i<10;i++) for(int j=0;j<10;j++)
+   if(i!=j && fabs(MI(i,j))>xmin) xmin=fabs(MI(i,j));
+cout<<"Biggest off diagonal identity matrix element is "<<xmin<<endl;
+} // destruction de M,MI
+cout<<"TMatrix X"<<endl<<X;
+
+//-----------------------------------------------
+{
+cout<<endl<<"Test Inversion directe"<<endl;
+cout<<"TMatrix X"<<endl<<X;
+TMatrix<r_8> Xinv;
+Xinv = X.Inverse();
+cout<<"TMatrix Xinv"<<endl<<Xinv;
+Xinv *= X;
+cout<<"Xinv *= X"<<endl<<Xinv;
+r_8 xmin=-1.;
+for(int i=0;i<10;i++) for(int j=0;j<10;j++)
+   if(i!=j && fabs(Xinv(i,j))>xmin) xmin=fabs(Xinv(i,j));
+cout<<"Biggest off diagonal identity matrix element is "<<xmin<<endl;
+cout<<"TMatrix X"<<endl<<X;
+}
+
+//-----------------------------------------------
+cout<<endl<<"Test liens TMatrix L avec Matrix MI"<<endl;
+Matrix MI(10,5);
+{for(int i=0;i<10;i++) for(int j=0;j<5;j++) MI(i,j) = 1000*i+j;}
+cout<<"MI"<<endl<<MI;
+{
+TMatrix<r_8> L(MI.NRows(),MI.NCol(),MI.Data(),new Bridge);
+cout<<"L"<<endl<<L;
+L *= 100.; cout<<"L*=100."<<endl<<L;
+} // destruction de L
+cout<<"MI(4,4)="<<MI(4,4)<<endl;
+
+} // destruction de toutes les matrices
+exit(0);
+}
Index: /trunk/SophyaProg/Tests/tsttvec.cc
===================================================================
--- /trunk/SophyaProg/Tests/tsttvec.cc	(revision 491)
+++ /trunk/SophyaProg/Tests/tsttvec.cc	(revision 491)
@@ -0,0 +1,113 @@
+#include "machdefs.h"
+#include <iostream.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include "outilsinit.h"
+#include "pexceptions.h"
+#include "cvector.h"
+#include "tvector.h"
+#include "nbrandom.h"
+
+using namespace PlanckDPC;
+
+////////////////////////////////////////////////////////////////////////////////////////
+int main(int narg,char *arg[])
+{
+PeidaInit();
+r_8 v[10] = {1,2,3,4,5,6,7,8,9,10};
+{
+cout<<"TVector(10)"<<endl;
+TVector<r_8> v1(10);
+{for(int i=0;i<10;i++) v1(i)=100+i;}
+cout<<"nel="<<v1.NElts()<<endl<<v1;
+
+{
+cout << " Test ecriture PPersist TVector " << endl; 
+FIO_TVector<r_8> ftv(v1);
+ftv.Write("tvec.ppf");
+}
+{
+cout << " Test lecture PPersist TVector " << endl; 
+FIO_TVector<r_8> ftv("tvec.ppf");
+cout<<"Vlue:"<<(TVector<r_8>)ftv<<endl;
+}
+
+
+cout<<"TVector(10,v,br)"<<endl;
+TVector<r_8> v2(10,v,new Bridge); cout<<v2;
+
+cout<<"TVector()"<<endl;
+TVector<r_8> v3; cout<<v3;
+
+cout<<"v3 = v1"<<endl;
+v3 = v1; cout<<v3;
+
+cout<<"v3 = 123456"<<endl;
+v3 = 123456.; cout<<v3;
+
+cout<<"ps = v1 * v2"<<endl;
+r_8 ps = v1 * v2; cout<<"ps="<<ps<<endl;
+
+cout<<"v2 = 10.*v1"<<endl;
+v2 = 10.*v1; cout<<v2;
+cout<<"v2 = v2*0.1"<<endl;
+v2 = v2*0.1; cout<<v2;
+
+cout<<"v2 = v1/10."<<endl;
+v2 = v1/10.; cout<<v2;
+cout<<"v2 = v2/0.1"<<endl;
+v2 = v2/0.1; cout<<v2;
+
+cout<<"v2 = 10.+v1"<<endl;
+v2 = 10.+v1; cout<<v2;
+cout<<"v2 = v2-10."<<endl;
+v2 = v2-10.; cout<<v2;
+
+cout<<"v2 = 10.-v1"<<endl;
+v2 = 10.-v1; cout<<v2;
+cout<<"v2 = (-1.)*v2+10."<<endl;
+v2 = (-1.)*v2+10.; cout<<v2;
+
+cout<<"v2 += 10."<<endl;
+v2 += 10.; cout<<v2;
+cout<<"v2 -= 10."<<endl;
+v2 -= 10.; cout<<v2;
+cout<<"v2 *= 10."<<endl;
+v2 *= 10.; cout<<v2;
+cout<<"v2 /= 10."<<endl;
+v2 /= 10.; cout<<v2;
+
+cout<<"v3.ReSize(4)"<<endl;
+v3.ReSize(4);
+{for(int i=0;i<4;i++) v3(i)=i+1;} cout<<v3;
+TMatrix<r_8> M(2,4);
+{for(int i=0;i<8;i++) M[i]=i+1;} cout<<M;
+TVector<r_8> v4(10);
+v4 = M*v3; cout<<v4;
+
+cout<<"LinSolve(A,B,X)"<<endl;
+TMatrix<r_8> A(5,5);
+TVector<r_8> B(5);
+{for(int i=0;i<25;i++) {A[i]=drand01(); if(i<5) B(i)=drand01();}}
+TVector<r_8> X;
+X = B;
+cout<<"A = "<<A; cout<<"B = "<<B;
+r_8 d=0.;
+d = LinSolve(A,B,X);
+cout<<"d="<<d<<endl; cout<<"X = "<<X;
+X = A*X; cout<<"A*X = "<<X;
+X -= B; cout<<"B-X = "<<X;
+cout<<"LinSolveInPlace(A,B)"<<endl;
+X = B;
+d = LinSolveInPlace(A,X);
+cout<<"d="<<d<<endl; cout<<"X = "<<X;
+
+cout<<"Conversion en ancien Vector"<<endl;
+Vector Vold(v1);
+cout<<"Vold = "<<Vold;
+
+} // destruction de toutes les vecteurs
+exit(0);
+}
