outil/src/ot_tenseur.cpp

//---------------------------------------------------------------------------
#include "gestionversion.h"

#pragma hdrstop

#include "ot_tenseur.h"

#include <iomanip>
#include <conio.h>
#include <stdio.h>
#include <assert>
//---------------------------------------------------------------------------

#pragma package(smart_init)


template <class T1, int Dim>
OT_TNS<T1,Dim>::OT_TNS()
{
Dim_Spce=Dim;
 Dim_t1=0;
 Dim_t2=0;
 t=NULL;
}

template <class T1, int Dim>
OT_TNS<T1,Dim>::OT_TNS(vector<T1>&v1,vector<T1>&v2)
{

Dim_Spce=Dim;
 Dim_t1=v1.size()/Dim_Spce;
 Dim_t2=v2.size()/Dim_Spce;

int Dim_t=Dim_t1*Dim_t2;
t=new T1[Dim_t];
T1* ei=new T1[Dim_Spce];
T1* ej=new T1[Dim_Spce];

   for(int i=0;i<Dim_t1;i++)
    {
     for(int r=0;r<Dim_Spce;r++)    ei[r]=v1[i*Dim_Spce+r];
         for(int j=0;j<Dim_t2;j++)
            {
            for(int s=0;s<Dim_Spce;s++)   ej[s]=v2[j*Dim_Spce+s] ;
             t[i*Dim_t2+j]=0;
                 for(int k=0;k<Dim_Spce;k++){
                     t[i*Dim_t2+j]=t[i*Dim_t2+j]+ei[k]*ej[k];
                     }

            }

      }
delete [] ei;
delete [] ej;

}

template <class T1,int Dim>
OT_TNS<T1,Dim>::OT_TNS(vector<T1>& v1)
{
Dim_Spce=Dim;
int taille_v= v1.size();
Dim_t1=taille_v/Dim_Spce;
Dim_t2=Dim_t1;
int Dim_t=Dim_t1*Dim_t2;
t=new T1[Dim_t];
T1* ei=new T1[Dim_Spce];
T1* ej=new T1[Dim_Spce];

   for(int i=0;i<Dim_t1;i++)
    {
     for(int r=0;r<Dim_Spce;r++)    ei[r]=v1[i*Dim_Spce+r];
         for(int j=0;j<Dim_t2;j++)
            {
            for(int s=0;s<Dim_Spce;s++)   ej[s]=v1[j*Dim_Spce+s] ;
             t[i*Dim_t2+j]=0;
                 for(int k=0;k<Dim_Spce;k++)
                     t[i*Dim_t2+j]=t[i*Dim_t2+j]+ei[k]*ej[k];

            }

      }
delete [] ei;
delete [] ej;
}

template <class T1, int Dim>
OT_TNS<T1,Dim>::OT_TNS(int taille,T1* tab)
{
Dim_Spce=Dim;
 Dim_t1=taille/Dim;
 Dim_t2=Dim_t1;
int Dim_t=Dim_t1*Dim_t2;
t=new T1[Dim_t];
T1* ei=new T1[Dim_Spce];
T1* ej=new T1[Dim_Spce];

   for(int i=0;i<Dim_t1;i++)
    {
     for(int r=0;r<Dim_Spce;r++)    ei[r]=tab[i*Dim_Spce+r];
         for(int j=0;j<Dim_t2;j++)
            {
            for(int s=0;s<Dim_Spce;s++)   ej[s]=tab[j*Dim_Spce+s] ;
             t[i*Dim_t2+j]=0;
                 for(int k=0;k<Dim_Spce;k++)
                     t[i*Dim_t2+j]=t[i*Dim_t2+j]+ei[k]*ej[k];

            }

      }
delete [] ei;
delete [] ej;


}

template <class T1,int Dim>
OT_TNS<T1,Dim>::OT_TNS(int taille1,int taille2,T1* tab1,T1* tab2)
{
Dim_Spce=Dim;
 Dim_t1=taille1/Dim;
 Dim_t2=taille2/Dim;
int Dim_t=Dim_t1*Dim_t2;
t=new T1[Dim_t];
T1* ei=new T1[Dim_Spce];
T1* ej=new T1[Dim_Spce];

   for(int i=0;i<Dim_t1;i++)
    {
     for(int r=0;r<Dim_Spce;r++)    ei[r]=tab1[i*Dim_Spce+r];
         for(int j=0;j<Dim_t2;j++)
            {
            for(int s=0;s<Dim_Spce;s++)   ej[s]=tab2[j*Dim_Spce+s] ;
             t[i*Dim_t2+j]=0;
                 for(int k=0;k<Dim_Spce;k++)
                     t[i*Dim_t2+j]=t[i*Dim_t2+j]+ei[k]*ej[k];

            }

      }
delete [] ei;
delete [] ej;


}

template <class T1,int Dim>
OT_TNS<T1,Dim>::~OT_TNS()
{
if(this!=NULL) delete [] t;
Dim_Spce=0;
Dim_t1=0;
Dim_t2=0;
}

template <class T1,int Dim>
OT_TNS<T1,Dim>::OT_TNS(const OT_TNS<T1,Dim>& ot)
{


Dim_Spce=ot.Dim_Spce;
Dim_t1=ot.Dim_t1;
Dim_t2=ot.Dim_t2;

t=new T1[Dim_t1*Dim_t2];
for(int i=0;i<Dim_t1*Dim_t2;i++)
t[i]= ot.t[i] ;

}

template <class T1,int Dim>
OT_TNS<T1,Dim>& OT_TNS<T1,Dim>:: operator =(const OT_TNS<T1,Dim>& ot)
{
 Dim_Spce=ot.Dim_Spce;
 if(this==&ot) return *this;
 else
  {
   delete [] t;
   Dim_Spce=ot.Dim_Spce;
   Dim_t1=ot.Dim_t1;
   Dim_t2=ot.Dim_t2;
   t=new T1[Dim_t1*Dim_t2];
     for(int i=0;i<Dim_t1*Dim_t2;i++)
       t[i]=ot.t[i];
  }
 return *this;
}


template <class T1,int Dim>
vector<T1> OT_TNS<T1,Dim>:: operator[](int i)
{
assert(i<Dim_t1);
vector<T1> r(Dim_t2);
       for(int j=0;j<Dim_t2;j++)
            {
            r[j]=t[i*Dim_t2+j];
            }


return r;

}


   /*
int operator==(const OT_TNS<double,3>& t1,const OT_TNS<double,3>&t2)
{
if(t1.nb_lgns()!=t2.nb_lgns()||t1.nb_cols()!=t2.nb_cols()) return 0;
else {
  for(int i=0;i<t1.nb_lgns();i++)
    {
     for(int j=0;j<t1.nb_cols();j++)
       {
      if(t1(i,j)!=t2(i,j)) return 0;
       }

    }
     }
return 1;
}
 
int operator==(const OT_TNS<double2,3>& t1,const OT_TNS<double2,3>&t2)
{
if(t1.nb_lgns()!=t2.nb_lgns()||t1.nb_cols()!=t2.nb_cols()) return 0;
else {
  for(int i=0;i<t1.nb_lgns();i++)
    {
     for(int j=0;j<t1.nb_cols();j++)
       {
      if(!(t1(i,j)==t2(i,j))) return 0;
       }

    }
     }
return 1;
}   */

template <class T1,int Dim>
T1&OT_TNS<T1,Dim>:: operator()(int i,int j)
{
assert(i<Dim_t1&&j<Dim_t2);
return t[i*Dim_t2+j] ;
}
template <class T1,int Dim>
T1&OT_TNS<T1,Dim>:: operator()(int i,int j)const
{
assert(i<Dim_t1&&j<Dim_t2);
return t[i*Dim_t2+j] ;
}


template <class T1,int Dim>
int OT_TNS<T1,Dim>:: nb_lgns()const
{
return Dim_t1;
}


template <class T1,int Dim>
int OT_TNS<T1,Dim>:: nb_cols()const
{
return Dim_t2;
}

template <class T1,int Dim>
int OT_TNS<T1,Dim>:: get_spcedim()const
{
return Dim_Spce;
}


template <class T1,int Dim>
int OT_TNS<T1,Dim>:: is_equivalent_at(const OT_TNS<double2,Dim>& tns)
 {
vector<int> check;

 for(int i=0;i<tns.nb_lgns();i++)
  {

//  bool verif=false;
  vector<T1> lig1;
  for(int ix1=0;ix1<Dim_t2;ix1++) lig1.insert(lig1.end(),t[i*Dim_t2+ix1]);
  for(int j=0;j<Dim_t2;j++)
    {
     int p=-1;
    if(!existe(check,j,p))
     {
    vector<int>trouve;
    vector<double2>valeur;
    vector<double2> lig2;
    for(int ix2=0;ix2<Dim_t2;ix2++) lig2.insert(lig2.end(),tns(j,ix2));
          for(int r=0;r<Dim_t2;r++)
           {
            double2 val=fabs(lig1[r]);
            val.set_dx(0.01);
            int indx1=-1;
            int indx2=-1;

            for(int s=0;s<Dim_t2;s++)
             {  int pos1;
                double2 vall=fabs(lig2[s]);
                vall.set_dx(0.01);
                if (val==vall&&!existe(trouve,s,indx1))//&&!existe(valeur,vall,pos1))
                  {
                  trouve.insert(trouve.end(),s);
                  valeur.insert(valeur.end(),val);
                  break;
                  }

             }

           }
    int t_trouve=trouve.size();
    if (t_trouve==Dim_t2)
     {
     check.insert(check.end(),j);
     break;

     }
      
    }
    }
continue;
 }
int t_chek=check.size();
if (t_chek==Dim_t1)return 1;
else return 0;

 }

template <class T1,int Dim>
int OT_TNS<T1,Dim> ::existe(const vector<int>& vct,int val,int& idx)
{
for(int i=0;i<vct.size();i++)
    {
    int x=vct[i];

    if(x==val){
       idx=i; return 1;

      }
    }
 idx=-1;
return 0;
}
template <class T1,int Dim>
int OT_TNS<T1,Dim> :: existe(const vector<double2>& vct,double2 val,int& idx)
{
  val= fabs(val);
  for(int i=0;i<vct.size();i++)
    {
    double2 x=fabs(vct[i]);
    if(x==val){
       idx=i; return 1;  }
    }
 idx=-1;
return 0;
}

template <class T1,int Dim>
int OT_TNS<T1,Dim>:: existe(const vector<double>& vct,double val,int& idx)
{

  if(val<0)   val=-val;
  for(int i=0;i<vct.size();i++)
    {
    double x=vct[i];
    if(x<0)   val=-val;
    if(x==val){
       idx=i; return 1;  }
    }
 idx=-1;
return 0;
}
           /*
std::ostream& operator<<(std::ostream& os,const OT_TNS<double,3>& tns)
{
   for(int i=0;i<tns.nb_lgns();i++) {
      for(int j=0;j<tns.nb_cols();j++) {
        //  T1 val=tns(i,j);
          os<<setw(5)<<tns(i,j);
          }
       os<<endl;
       }
       return os;
}

std::ostream& operator<<(std::ostream& os,const OT_TNS<double2,3>& tns)
{
   for(int i=0;i<tns.nb_lgns();i++) {
      for(int j=0;j<tns.nb_cols();j++) {
        //  T1 val=tns(i,j);
          os<<setw(5)<<tns(i,j);
          }
       os<<endl;
       }
       return os;
}
        */


Revision:	58
Committed:	Fri Sep 28 21:00:16 2007 UTC (17 years, 7 months ago) by souaissa
Original Path:	*magic/lib/outil/outil/src/ot_tenseur.cpp*
File size:	8212 byte(s)
Log Message:	vectorisation de geometrie pour comparaison
#	User	Rev	Content
1	souaissa	58	//---------------------------------------------------------------------------
2	francois	17	#include "gestionversion.h"
3
4			#pragma hdrstop
5	souaissa	58
6	francois	17	#include "ot_tenseur.h"
7	souaissa	58
8			#include <iomanip>
9			#include <conio.h>
10			#include <stdio.h>
11			#include <assert>
12	francois	17	//---------------------------------------------------------------------------
13	souaissa	58
14	francois	17	#pragma package(smart_init)
15
16
17
18	souaissa	58	template <class T1, int Dim>
19			OT_TNS<T1,Dim>::OT_TNS()
20			{
21			Dim_Spce=Dim;
22			Dim_t1=0;
23			Dim_t2=0;
24			t=NULL;
25			}
26	francois	17
27	souaissa	58	template <class T1, int Dim>
28			OT_TNS<T1,Dim>::OT_TNS(vector<T1>&v1,vector<T1>&v2)
29			{
30	francois	17
31	souaissa	58	Dim_Spce=Dim;
32			Dim_t1=v1.size()/Dim_Spce;
33			Dim_t2=v2.size()/Dim_Spce;
34	francois	17
35	souaissa	58	int Dim_t=Dim_t1*Dim_t2;
36			t=new T1[Dim_t];
37			T1* ei=new T1[Dim_Spce];
38			T1* ej=new T1[Dim_Spce];
39	francois	17
40	souaissa	58	for(int i=0;i<Dim_t1;i++)
41			{
42			for(int r=0;r<Dim_Spce;r++) ei[r]=v1[i*Dim_Spce+r];
43			for(int j=0;j<Dim_t2;j++)
44			{
45			for(int s=0;s<Dim_Spce;s++) ej[s]=v2[j*Dim_Spce+s] ;
46			t[i*Dim_t2+j]=0;
47			for(int k=0;k<Dim_Spce;k++){
48			t[iDim_t2+j]=t[iDim_t2+j]+ei[k]*ej[k];
49			}
50
51			}
52
53			}
54			delete [] ei;
55			delete [] ej;
56
57			}
58
59			template <class T1,int Dim>
60			OT_TNS<T1,Dim>::OT_TNS(vector<T1>& v1)
61	francois	17	{
62	souaissa	58	Dim_Spce=Dim;
63			int taille_v= v1.size();
64			Dim_t1=taille_v/Dim_Spce;
65			Dim_t2=Dim_t1;
66			int Dim_t=Dim_t1*Dim_t2;
67			t=new T1[Dim_t];
68			T1* ei=new T1[Dim_Spce];
69			T1* ej=new T1[Dim_Spce];
70	francois	17
71	souaissa	58	for(int i=0;i<Dim_t1;i++)
72			{
73			for(int r=0;r<Dim_Spce;r++) ei[r]=v1[i*Dim_Spce+r];
74			for(int j=0;j<Dim_t2;j++)
75			{
76			for(int s=0;s<Dim_Spce;s++) ej[s]=v1[j*Dim_Spce+s] ;
77			t[i*Dim_t2+j]=0;
78			for(int k=0;k<Dim_Spce;k++)
79			t[iDim_t2+j]=t[iDim_t2+j]+ei[k]*ej[k];
80	francois	17
81	souaissa	58	}
82	francois	17
83	souaissa	58	}
84			delete [] ei;
85			delete [] ej;
86			}
87	francois	17
88	souaissa	58	template <class T1, int Dim>
89			OT_TNS<T1,Dim>::OT_TNS(int taille,T1* tab)
90	francois	17	{
91	souaissa	58	Dim_Spce=Dim;
92			Dim_t1=taille/Dim;
93			Dim_t2=Dim_t1;
94			int Dim_t=Dim_t1*Dim_t2;
95			t=new T1[Dim_t];
96			T1* ei=new T1[Dim_Spce];
97			T1* ej=new T1[Dim_Spce];
98	francois	17
99	souaissa	58	for(int i=0;i<Dim_t1;i++)
100			{
101			for(int r=0;r<Dim_Spce;r++) ei[r]=tab[i*Dim_Spce+r];
102			for(int j=0;j<Dim_t2;j++)
103			{
104			for(int s=0;s<Dim_Spce;s++) ej[s]=tab[j*Dim_Spce+s] ;
105			t[i*Dim_t2+j]=0;
106			for(int k=0;k<Dim_Spce;k++)
107			t[iDim_t2+j]=t[iDim_t2+j]+ei[k]*ej[k];
108	francois	17
109	souaissa	58	}
110	francois	17
111	souaissa	58	}
112			delete [] ei;
113			delete [] ej;
114	francois	17
115
116	souaissa	58
117	francois	17	}
118
119	souaissa	58	template <class T1,int Dim>
120			OT_TNS<T1,Dim>::OT_TNS(int taille1,int taille2,T1* tab1,T1* tab2)
121			{
122			Dim_Spce=Dim;
123			Dim_t1=taille1/Dim;
124			Dim_t2=taille2/Dim;
125			int Dim_t=Dim_t1*Dim_t2;
126			t=new T1[Dim_t];
127			T1* ei=new T1[Dim_Spce];
128			T1* ej=new T1[Dim_Spce];
129	francois	17
130	souaissa	58	for(int i=0;i<Dim_t1;i++)
131			{
132			for(int r=0;r<Dim_Spce;r++) ei[r]=tab1[i*Dim_Spce+r];
133			for(int j=0;j<Dim_t2;j++)
134			{
135			for(int s=0;s<Dim_Spce;s++) ej[s]=tab2[j*Dim_Spce+s] ;
136			t[i*Dim_t2+j]=0;
137			for(int k=0;k<Dim_Spce;k++)
138			t[iDim_t2+j]=t[iDim_t2+j]+ei[k]*ej[k];
139	francois	17
140	souaissa	58	}
141	francois	17
142	souaissa	58	}
143			delete [] ei;
144			delete [] ej;
145	francois	17
146
147	souaissa	58	}
148	francois	17
149	souaissa	58	template <class T1,int Dim>
150			OT_TNS<T1,Dim>::~OT_TNS()
151			{
152			if(this!=NULL) delete [] t;
153			Dim_Spce=0;
154			Dim_t1=0;
155			Dim_t2=0;
156			}
157	francois	17
158	souaissa	58	template <class T1,int Dim>
159			OT_TNS<T1,Dim>::OT_TNS(const OT_TNS<T1,Dim>& ot)
160			{
161	francois	17
162
163	souaissa	58	Dim_Spce=ot.Dim_Spce;
164			Dim_t1=ot.Dim_t1;
165			Dim_t2=ot.Dim_t2;
166	francois	17
167	souaissa	58	t=new T1[Dim_t1*Dim_t2];
168			for(int i=0;i<Dim_t1*Dim_t2;i++)
169			t[i]= ot.t[i] ;
170	francois	17
171	souaissa	58	}
172	francois	17
173	souaissa	58	template <class T1,int Dim>
174			OT_TNS<T1,Dim>& OT_TNS<T1,Dim>:: operator =(const OT_TNS<T1,Dim>& ot)
175	francois	17	{
176	souaissa	58	Dim_Spce=ot.Dim_Spce;
177			if(this==&ot) return *this;
178			else
179			{
180			delete [] t;
181			Dim_Spce=ot.Dim_Spce;
182			Dim_t1=ot.Dim_t1;
183			Dim_t2=ot.Dim_t2;
184			t=new T1[Dim_t1*Dim_t2];
185			for(int i=0;i<Dim_t1*Dim_t2;i++)
186			t[i]=ot.t[i];
187			}
188			return *this;
189	francois	17	}
190
191	souaissa	58
192
193			template <class T1,int Dim>
194			vector<T1> OT_TNS<T1,Dim>:: operator[](int i)
195	francois	17	{
196	souaissa	58	assert(i<Dim_t1);
197			vector<T1> r(Dim_t2);
198			for(int j=0;j<Dim_t2;j++)
199			{
200			r[j]=t[i*Dim_t2+j];
201			}
202
203
204			return r;
205
206	francois	17	}
207
208
209	souaissa	58	/*
210			int operator==(const OT_TNS<double,3>& t1,const OT_TNS<double,3>&t2)
211	francois	17	{
212	souaissa	58	if(t1.nb_lgns()!=t2.nb_lgns()\|\|t1.nb_cols()!=t2.nb_cols()) return 0;
213			else {
214			for(int i=0;i<t1.nb_lgns();i++)
215			{
216			for(int j=0;j<t1.nb_cols();j++)
217			{
218			if(t1(i,j)!=t2(i,j)) return 0;
219			}
220	francois	17
221	souaissa	58	}
222			}
223			return 1;
224			}
225	francois	17
226	souaissa	58	int operator==(const OT_TNS<double2,3>& t1,const OT_TNS<double2,3>&t2)
227			{
228			if(t1.nb_lgns()!=t2.nb_lgns()\|\|t1.nb_cols()!=t2.nb_cols()) return 0;
229			else {
230			for(int i=0;i<t1.nb_lgns();i++)
231			{
232			for(int j=0;j<t1.nb_cols();j++)
233			{
234			if(!(t1(i,j)==t2(i,j))) return 0;
235			}
236	francois	17
237	souaissa	58	}
238			}
239			return 1;
240			} */
241	francois	17
242	souaissa	58	template <class T1,int Dim>
243			T1&OT_TNS<T1,Dim>:: operator()(int i,int j)
244			{
245			assert(i<Dim_t1&&j<Dim_t2);
246			return t[i*Dim_t2+j] ;
247			}
248			template <class T1,int Dim>
249			T1&OT_TNS<T1,Dim>:: operator()(int i,int j)const
250			{
251			assert(i<Dim_t1&&j<Dim_t2);
252			return t[i*Dim_t2+j] ;
253			}
254	francois	17
255
256	souaissa	58	template <class T1,int Dim>
257			int OT_TNS<T1,Dim>:: nb_lgns()const
258			{
259			return Dim_t1;
260			}
261	francois	17
262	souaissa	58
263			template <class T1,int Dim>
264			int OT_TNS<T1,Dim>:: nb_cols()const
265	francois	17	{
266	souaissa	58	return Dim_t2;
267	francois	17	}
268
269	souaissa	58	template <class T1,int Dim>
270			int OT_TNS<T1,Dim>:: get_spcedim()const
271			{
272			return Dim_Spce;
273			}
274	francois	17
275
276	souaissa	58
277
278			template <class T1,int Dim>
279			int OT_TNS<T1,Dim>:: is_equivalent_at(const OT_TNS<double2,Dim>& tns)
280			{
281			vector<int> check;
282
283			for(int i=0;i<tns.nb_lgns();i++)
284			{
285
286			// bool verif=false;
287			vector<T1> lig1;
288			for(int ix1=0;ix1<Dim_t2;ix1++) lig1.insert(lig1.end(),t[i*Dim_t2+ix1]);
289			for(int j=0;j<Dim_t2;j++)
290	francois	17	{
291	souaissa	58	int p=-1;
292			if(!existe(check,j,p))
293			{
294			vector<int>trouve;
295			vector<double2>valeur;
296			vector<double2> lig2;
297			for(int ix2=0;ix2<Dim_t2;ix2++) lig2.insert(lig2.end(),tns(j,ix2));
298			for(int r=0;r<Dim_t2;r++)
299			{
300			double2 val=fabs(lig1[r]);
301			val.set_dx(0.01);
302			int indx1=-1;
303			int indx2=-1;
304	francois	17
305	souaissa	58	for(int s=0;s<Dim_t2;s++)
306			{ int pos1;
307			double2 vall=fabs(lig2[s]);
308			vall.set_dx(0.01);
309			if (val==vall&&!existe(trouve,s,indx1))//&&!existe(valeur,vall,pos1))
310			{
311			trouve.insert(trouve.end(),s);
312			valeur.insert(valeur.end(),val);
313			break;
314			}
315
316			}
317
318			}
319			int t_trouve=trouve.size();
320			if (t_trouve==Dim_t2)
321			{
322			check.insert(check.end(),j);
323			break;
324
325	francois	17	}
326	souaissa	58
327			}
328			}
329			continue;
330			}
331			int t_chek=check.size();
332			if (t_chek==Dim_t1)return 1;
333			else return 0;
334	francois	17
335	souaissa	58	}
336
337			template <class T1,int Dim>
338			int OT_TNS<T1,Dim> ::existe(const vector<int>& vct,int val,int& idx)
339			{
340			for(int i=0;i<vct.size();i++)
341			{
342			int x=vct[i];
343
344			if(x==val){
345			idx=i; return 1;
346
347			}
348			}
349			idx=-1;
350			return 0;
351	francois	17	}
352	souaissa	58	template <class T1,int Dim>
353			int OT_TNS<T1,Dim> :: existe(const vector<double2>& vct,double2 val,int& idx)
354			{
355			val= fabs(val);
356			for(int i=0;i<vct.size();i++)
357			{
358			double2 x=fabs(vct[i]);
359			if(x==val){
360			idx=i; return 1; }
361			}
362			idx=-1;
363			return 0;
364			}
365	francois	17
366	souaissa	58	template <class T1,int Dim>
367			int OT_TNS<T1,Dim>:: existe(const vector<double>& vct,double val,int& idx)
368			{
369	francois	17
370	souaissa	58	if(val<0) val=-val;
371			for(int i=0;i<vct.size();i++)
372			{
373			double x=vct[i];
374			if(x<0) val=-val;
375			if(x==val){
376			idx=i; return 1; }
377			}
378			idx=-1;
379			return 0;
380			}
381			/*
382			std::ostream& operator<<(std::ostream& os,const OT_TNS<double,3>& tns)
383	francois	17	{
384	souaissa	58	for(int i=0;i<tns.nb_lgns();i++) {
385			for(int j=0;j<tns.nb_cols();j++) {
386			// T1 val=tns(i,j);
387			os<<setw(5)<<tns(i,j);
388			}
389			os<<endl;
390			}
391			return os;
392			}
393	francois	17
394	souaissa	58	std::ostream& operator<<(std::ostream& os,const OT_TNS<double2,3>& tns)
395			{
396			for(int i=0;i<tns.nb_lgns();i++) {
397			for(int j=0;j<tns.nb_cols();j++) {
398			// T1 val=tns(i,j);
399			os<<setw(5)<<tns(i,j);
400			}
401			os<<endl;
402			}
403			return os;
404			}
405			*/
406	francois	17
407
408
409
410
411	souaissa	58
412
413
414
415
416
417
418
419
420
421
422
423