outil/src/ot_tenseur.cpp

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

#pragma hdrstop
#include <assert.h>
#include "ot_tenseur.h"
#include "tpl_liste_entite.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)


OT_TENSEUR::OT_TENSEUR()
 {
  nb_lignes=0;
  nb_colonnes=0;
  nb_ref=0;
  tenseur=NULL;
  ref=NULL;
 }

OT_TENSEUR::OT_TENSEUR(int p,int q)
 {
  nb_lignes=p;
  nb_colonnes=q;
  nb_ref=4*p;
  tenseur=NULL;
  ref=NULL;
 }

OT_TENSEUR::OT_TENSEUR(vector<double2>& vect)
 {
  nb_ref=vect.size();
  nb_lignes=1/4.*nb_ref;
  nb_colonnes=nb_lignes;
 
  tenseur=new double2[nb_lignes*nb_colonnes];
  ref=new double2[nb_ref];
  for(int i=0;i<nb_ref;i++)  ref[i]=vect[i];

  for(int i=0;i<nb_lignes;i++){
  
  double2 x1=vect[4*i];
  double2 y1=vect[4*i+1];
  double2 z1=vect[4*i+2];
  double2 w1=vect[4*i+3];
  
   for(int j=0;j<nb_colonnes;j++){
   
      double2 x2=vect[4*j];
      double2 y2=vect[4*j+1];
      double2 z2=vect[4*j+2];
      double2 w2=vect[4*j+3];
      tenseur[i*nb_colonnes+j]=x1*x2+y1*y2+z1*z2+w1*w2;
     //tenseur[i*nb_colonnes+j]=vect[4*i]*vect[4*j]+vect[4*i+1]*vect[4*j+1]+vect[4*i+2]*vect[4*j+2]+vect[4*i+3]*vect[4*j+3];
   }
  }
 
  
 }


OT_TENSEUR::OT_TENSEUR(int p,int q,double2* tab)
{
  nb_lignes=p;
  nb_colonnes=q;
  nb_ref=4*p;
  tenseur=new double2[nb_lignes*nb_colonnes];
  ref=new double2[nb_ref];
  for(int i=0;i<nb_ref;i++)  ref[i]=tab[i];

  for(int i=0;i<nb_lignes;i++){
   for(int j=0;j<nb_colonnes;j++){
   tenseur[i*nb_colonnes+j]=tab[4*i]*tab[4*j]+tab[4*i+1]*tab[4*j+1]+tab[4*i+2]*tab[4*j+2]+tab[4*i+3]*tab[4*j+3];
   }
  }
} 


OT_TENSEUR::OT_TENSEUR(const OT_TENSEUR& mdd)
 {
nb_lignes=mdd.nb_lignes;
nb_colonnes=mdd.nb_colonnes;
nb_ref=mdd.nb_ref;
tenseur=new double2[nb_lignes*nb_colonnes];
ref=new double2[nb_ref];
for(int i=0;i<nb_ref;i++) ref[i]=mdd.ref[i];

for(int i=0;i<nb_lignes*nb_colonnes;i++) 
  tenseur[i]=mdd.tenseur[i] ;
 
 }
 
OT_TENSEUR::~OT_TENSEUR()
{
if(tenseur){
  delete [] tenseur;
  delete [] ref; }
} 
 

OT_TENSEUR& OT_TENSEUR::operator=(const OT_TENSEUR& m)
 {
 if(this == &m)
  return *this;

   if(tenseur)
     {
     delete [] tenseur;
     delete [] ref;
     }
   nb_lignes=m.nb_lignes;
   nb_colonnes=m.nb_colonnes;
   nb_ref=m.nb_ref;
   tenseur=new double2 [nb_lignes*nb_colonnes];
   ref=new double2[m.nb_ref];
   
   for(int i=0;i<nb_ref;i++) ref[i]= m.ref[i];
   
     for(int i=0;i<nb_lignes*nb_colonnes;i++)
       {
       tenseur[i]=m.tenseur[i];
       }
  return *this;
 }


double2 OT_TENSEUR::operator() (int r, int s) const
{
 return tenseur[r*nb_colonnes+s] ;
}

double2& OT_TENSEUR::operator() (int r, int s)
 {
  return tenseur[r*nb_colonnes+s];
 }


int OT_TENSEUR:: get_nb_lignes()
 {
return nb_lignes;
 }

int OT_TENSEUR:: get_nb_colonnes()
 {
 return nb_colonnes;
 }

int OT_TENSEUR:: get_nb_ref()
 {
 return nb_ref;
 }

  
void OT_TENSEUR:: extraire_ligne(int idx,double2* ligne)
{
 for(int j=0;j<nb_colonnes;j++)
   ligne[j]=tenseur[idx*nb_colonnes+j]; 
}

void OT_TENSEUR:: extraire_colonne(int idx,double2* colonne)
{
 for(int i=0;i<nb_lignes;i++)
   colonne[i]=tenseur[i*nb_colonnes+idx]; 
}


OT_TENSEUR OT_TENSEUR::extraire_sous_tenseur(int i1,int i2,int j1,int j2)
{

assert(i1<i2&&j1<j2) ;
int nb_lgne=i2-i1+1;
int nb_colone=j2-j1+1; 
OT_TENSEUR res(nb_lgne,nb_colone);
int*lst1=new int[nb_lgne+nb_colone] ;

for(int i=0;i<nb_lgne;i++)
 {
  lst1[i]=i1+i;
 
 }
for(int i=nb_lgne;i<nb_lgne+nb_lgne;i++)
 {
  lst1[i]=j1+i;

 }

 int N=nb_lgne+nb_lgne;
 
 for(int i=0;i<N;i++)
  {
  int pd,pp,i; /* place d�finitive, plus petit */
  int tampon;
  for(pd=0;pd<N-1;pd++)
   {
    pp=pd;
    for(i=pp+1;i<N;i++) if(lst1[i]<lst1[pp])pp=i;
     tampon=lst1[pp];
     lst1[pp]=lst1[pd];
     lst1[pd]=tampon;
   }

 }

TPL_LISTE_ENTITE<int> lst;
lst.ajouter(lst1[0]);

for(int i=0;i<N;i++)
{
 if(!lst.est_dans_la_liste(lst1[i]))
   lst.ajouter(lst1[i]);
   
}

res.nb_ref=4*lst.get_nb();

res.ref=new double2[res.nb_ref];

  for(int i=0;i<lst.get_nb();i++)
    {
    res.ref[4*i]=ref[4*lst.get(i)];
    res.ref[4*i+1]=ref[4*lst.get(i)+1];
    res.ref[4*i+2]=ref[4*lst.get(i)+2];
    res.ref[4*i+3]=ref[4*lst.get(i)+3];
    }
    
res.tenseur=new double2[nb_lgne*nb_colone];

for(int i=0;i<nb_lgne;i++){
        for(int j=0;j<nb_colone;j++){
         double2 val=tenseur[(i+i1)*nb_colonnes+j+j1];
         res.tenseur[i*res.nb_colonnes+j]=val;
        }
     }
delete [] lst1;

     return res;
}


int OT_TENSEUR ::trouver_le_terme(int num_lign,double2 term)
{

int trouve=0;
TPL_LISTE_ENTITE<int> indx;

for(int i=0;i<nb_colonnes; i++)
 {
 double2 val=tenseur[num_lign*nb_colonnes+i];
 if(term==val)
   {
    trouve++;
   indx.ajouter(i);
   }


 }

return trouve;

}           
Revision:	17
Committed:	Fri Jun 15 21:55:53 2007 UTC (17 years, 11 months ago) by francois
Original Path:	*magic/lib/outil/outil/src/ot_tenseur.cpp*
File size:	5060 byte(s)
Log Message:	ajout de routine de calcul de tenseur et ajout de la double precision
#	User	Rev	Content
1	francois	17	#include "gestionversion.h"
2			//---------------------------------------------------------------------------
3
4			#pragma hdrstop
5			#include <assert.h>
6			#include "ot_tenseur.h"
7			#include "tpl_liste_entite.h"
8			//---------------------------------------------------------------------------
9			#pragma package(smart_init)
10
11
12			OT_TENSEUR::OT_TENSEUR()
13			{
14			nb_lignes=0;
15			nb_colonnes=0;
16			nb_ref=0;
17			tenseur=NULL;
18			ref=NULL;
19			}
20
21			OT_TENSEUR::OT_TENSEUR(int p,int q)
22			{
23			nb_lignes=p;
24			nb_colonnes=q;
25			nb_ref=4*p;
26			tenseur=NULL;
27			ref=NULL;
28			}
29
30			OT_TENSEUR::OT_TENSEUR(vector<double2>& vect)
31			{
32			nb_ref=vect.size();
33			nb_lignes=1/4.*nb_ref;
34			nb_colonnes=nb_lignes;
35
36			tenseur=new double2[nb_lignes*nb_colonnes];
37			ref=new double2[nb_ref];
38			for(int i=0;i<nb_ref;i++) ref[i]=vect[i];
39
40			for(int i=0;i<nb_lignes;i++){
41
42			double2 x1=vect[4*i];
43			double2 y1=vect[4*i+1];
44			double2 z1=vect[4*i+2];
45			double2 w1=vect[4*i+3];
46
47			for(int j=0;j<nb_colonnes;j++){
48
49			double2 x2=vect[4*j];
50			double2 y2=vect[4*j+1];
51			double2 z2=vect[4*j+2];
52			double2 w2=vect[4*j+3];
53			tenseur[inb_colonnes+j]=x1x2+y1y2+z1z2+w1*w2;
54			//tenseur[inb_colonnes+j]=vect[4i]vect[4j]+vect[4i+1]vect[4j+1]+vect[4i+2]vect[4j+2]+vect[4i+3]vect[4*j+3];
55			}
56			}
57
58
59			}
60
61
62			OT_TENSEUR::OT_TENSEUR(int p,int q,double2* tab)
63			{
64			nb_lignes=p;
65			nb_colonnes=q;
66			nb_ref=4*p;
67			tenseur=new double2[nb_lignes*nb_colonnes];
68			ref=new double2[nb_ref];
69			for(int i=0;i<nb_ref;i++) ref[i]=tab[i];
70
71			for(int i=0;i<nb_lignes;i++){
72			for(int j=0;j<nb_colonnes;j++){
73			tenseur[inb_colonnes+j]=tab[4i]tab[4j]+tab[4i+1]tab[4j+1]+tab[4i+2]tab[4j+2]+tab[4i+3]tab[4*j+3];
74			}
75			}
76			}
77
78
79			OT_TENSEUR::OT_TENSEUR(const OT_TENSEUR& mdd)
80			{
81			nb_lignes=mdd.nb_lignes;
82			nb_colonnes=mdd.nb_colonnes;
83			nb_ref=mdd.nb_ref;
84			tenseur=new double2[nb_lignes*nb_colonnes];
85			ref=new double2[nb_ref];
86			for(int i=0;i<nb_ref;i++) ref[i]=mdd.ref[i];
87
88			for(int i=0;i<nb_lignes*nb_colonnes;i++)
89			tenseur[i]=mdd.tenseur[i] ;
90
91			}
92
93			OT_TENSEUR::~OT_TENSEUR()
94			{
95			if(tenseur){
96			delete [] tenseur;
97			delete [] ref; }
98			}
99
100
101			OT_TENSEUR& OT_TENSEUR::operator=(const OT_TENSEUR& m)
102			{
103			if(this == &m)
104			return *this;
105
106			if(tenseur)
107			{
108			delete [] tenseur;
109			delete [] ref;
110			}
111			nb_lignes=m.nb_lignes;
112			nb_colonnes=m.nb_colonnes;
113			nb_ref=m.nb_ref;
114			tenseur=new double2 [nb_lignes*nb_colonnes];
115			ref=new double2[m.nb_ref];
116
117			for(int i=0;i<nb_ref;i++) ref[i]= m.ref[i];
118
119			for(int i=0;i<nb_lignes*nb_colonnes;i++)
120			{
121			tenseur[i]=m.tenseur[i];
122			}
123			return *this;
124			}
125
126
127
128			double2 OT_TENSEUR::operator() (int r, int s) const
129			{
130			return tenseur[r*nb_colonnes+s] ;
131			}
132
133			double2& OT_TENSEUR::operator() (int r, int s)
134			{
135			return tenseur[r*nb_colonnes+s];
136			}
137
138
139
140
141
142
143
144
145			int OT_TENSEUR:: get_nb_lignes()
146			{
147			return nb_lignes;
148			}
149
150			int OT_TENSEUR:: get_nb_colonnes()
151			{
152			return nb_colonnes;
153			}
154
155			int OT_TENSEUR:: get_nb_ref()
156			{
157			return nb_ref;
158			}
159
160
161
162
163			void OT_TENSEUR:: extraire_ligne(int idx,double2* ligne)
164			{
165			for(int j=0;j<nb_colonnes;j++)
166			ligne[j]=tenseur[idx*nb_colonnes+j];
167			}
168
169			void OT_TENSEUR:: extraire_colonne(int idx,double2* colonne)
170			{
171			for(int i=0;i<nb_lignes;i++)
172			colonne[i]=tenseur[i*nb_colonnes+idx];
173			}
174
175
176			OT_TENSEUR OT_TENSEUR::extraire_sous_tenseur(int i1,int i2,int j1,int j2)
177			{
178
179			assert(i1<i2&&j1<j2) ;
180			int nb_lgne=i2-i1+1;
181			int nb_colone=j2-j1+1;
182			OT_TENSEUR res(nb_lgne,nb_colone);
183			int*lst1=new int[nb_lgne+nb_colone] ;
184
185			for(int i=0;i<nb_lgne;i++)
186			{
187			lst1[i]=i1+i;
188
189			}
190			for(int i=nb_lgne;i<nb_lgne+nb_lgne;i++)
191			{
192			lst1[i]=j1+i;
193
194			}
195
196			int N=nb_lgne+nb_lgne;
197
198			for(int i=0;i<N;i++)
199			{
200			int pd,pp,i; /* place d�finitive, plus petit */
201			int tampon;
202			for(pd=0;pd<N-1;pd++)
203			{
204			pp=pd;
205			for(i=pp+1;i<N;i++) if(lst1[i]<lst1[pp])pp=i;
206			tampon=lst1[pp];
207			lst1[pp]=lst1[pd];
208			lst1[pd]=tampon;
209			}
210
211			}
212
213			TPL_LISTE_ENTITE<int> lst;
214			lst.ajouter(lst1[0]);
215
216			for(int i=0;i<N;i++)
217			{
218			if(!lst.est_dans_la_liste(lst1[i]))
219			lst.ajouter(lst1[i]);
220
221			}
222
223			res.nb_ref=4*lst.get_nb();
224
225			res.ref=new double2[res.nb_ref];
226
227			for(int i=0;i<lst.get_nb();i++)
228			{
229			res.ref[4i]=ref[4lst.get(i)];
230			res.ref[4i+1]=ref[4lst.get(i)+1];
231			res.ref[4i+2]=ref[4lst.get(i)+2];
232			res.ref[4i+3]=ref[4lst.get(i)+3];
233			}
234
235			res.tenseur=new double2[nb_lgne*nb_colone];
236
237			for(int i=0;i<nb_lgne;i++){
238			for(int j=0;j<nb_colone;j++){
239			double2 val=tenseur[(i+i1)*nb_colonnes+j+j1];
240			res.tenseur[i*res.nb_colonnes+j]=val;
241			}
242			}
243			delete [] lst1;
244
245			return res;
246			}
247
248
249			int OT_TENSEUR ::trouver_le_terme(int num_lign,double2 term)
250			{
251
252			int trouve=0;
253			TPL_LISTE_ENTITE<int> indx;
254
255			for(int i=0;i<nb_colonnes; i++)
256			{
257			double2 val=tenseur[num_lign*nb_colonnes+i];
258			if(term==val)
259			{
260			trouve++;
261			indx.ajouter(i);
262			}
263
264
265			}
266
267			return trouve;
268
269			}