ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/REPOS_ERICCA/magic/lib/outil/src/ot_mathematique.cpp
Revision: 997
Committed: Tue Dec 18 15:59:49 2018 UTC (6 years, 5 months ago) by couturad
File size: 44412 byte(s)
Log Message:
MICROSTRUCTURE: ajout d'un outil pour reduire le nombre de colonnes d'un histogramme 

File Contents

# User Rev Content
1 francois 283 //------------------------------------------------------------
2     //------------------------------------------------------------
3     // MAGiC
4     // Jean Christophe Cuilli�re et Vincent FRANCOIS
5     // D�partement de G�nie M�canique - UQTR
6     //------------------------------------------------------------
7     // Le projet MAGIC est un projet de recherche du d�partement
8     // de g�nie m�canique de l'Universit� du Qu�bec �
9     // Trois Rivi�res
10     // Les librairies ne peuvent �tre utilis�es sans l'accord
11     // des auteurs (contact : francois@uqtr.ca)
12     //------------------------------------------------------------
13     //------------------------------------------------------------
14     //
15     // ot_mathematique.cpp
16     //
17     //------------------------------------------------------------
18     //------------------------------------------------------------
19     // COPYRIGHT 2000
20     // Version du 02/03/2006 � 11H23
21     //------------------------------------------------------------
22     //------------------------------------------------------------
23    
24    
25     #include "gestionversion.h"
26     #include <iomanip>
27     #include <math.h>
28     #include <string.h>
29     #include <assert.h>
30     #include <algorithm>
31 couturad 926 #include <fstream>
32 francois 283 #include "ot_mathematique.h"
33    
34    
35 couturad 926 OT_HISTOGRAMME::OT_HISTOGRAMME(void)
36     {
37     m_i_min=0;
38     m_i_max=0;
39     m_init=false;
40     m_largeur_colonne=0;
41     }
42 couturad 919
43     OT_HISTOGRAMME::OT_HISTOGRAMME(double largeur_colonne):m_largeur_colonne(largeur_colonne)
44     {
45     m_i_min=0;
46     m_i_max=0;
47     m_init=false;
48     }
49    
50 couturad 968 OT_HISTOGRAMME::OT_HISTOGRAMME(OT_HISTOGRAMME& mdd)
51 couturad 926 {
52     m_largeur_colonne=mdd.m_largeur_colonne;
53     m_i_min=mdd.m_i_min;
54     m_i_max=mdd.m_i_max;
55     m_init=mdd.m_init;
56 couturad 968 m_map_colonne=mdd.m_map_colonne;
57 couturad 926 }
58    
59 couturad 997 OT_HISTOGRAMME::OT_HISTOGRAMME(double largeur_colonne, OT_HISTOGRAMME& mdd):m_largeur_colonne(largeur_colonne)
60     {
61     m_i_min=0;
62     m_i_max=0;
63     m_init=false;
64     std::map<long,double>::iterator it;
65     double val;
66     double borne_min;
67     double borne_max;
68     int ret=mdd.get_premiere_valeur(it,val,borne_min,borne_max);
69     while(ret!=0)
70     {
71     ajouter_valeur(borne_min,val);
72     ret=mdd.get_suivante_valeur(it,val,borne_min,borne_max);
73     }
74     }
75    
76    
77 couturad 919 OT_HISTOGRAMME::~OT_HISTOGRAMME(void)
78     {
79     m_map_colonne.clear();
80     }
81    
82 couturad 926 void OT_HISTOGRAMME::fixe_largeur_colonne(double largeur_colonne)
83     {
84     m_largeur_colonne=largeur_colonne;
85     }
86    
87     double OT_HISTOGRAMME::get_largeur_colonne(void)
88     {
89     return m_largeur_colonne;
90     }
91    
92 couturad 919 void OT_HISTOGRAMME::ajouter_valeur(double x,double val)
93     {
94     long i = (long)(x/m_largeur_colonne);
95     ajouter_valeur(i,val);
96     }
97    
98     void OT_HISTOGRAMME::ajouter_valeur(long int i, double val)
99     {
100 couturad 926 if(!m_init)
101 couturad 919 {
102     m_i_min=i;
103     m_i_max=i;
104     m_map_colonne.insert(std::pair<long,double>(i,val));
105     m_init=true;
106     }
107     else if(i>m_i_max)
108     {
109 couturad 968 // for(long j=i-1;j>m_i_max;j--)
110     // m_map_colonne.insert(std::pair<long,double>(j,0.0));
111 couturad 919 m_i_max=i;
112     m_map_colonne.insert(std::pair<long,double>(i,val));
113     }
114     else if(i<m_i_min)
115     {
116 couturad 968 // for(long j=i+1;j<m_i_min;j++)
117     // m_map_colonne.insert(std::pair<long,double>(j,0.0));
118 couturad 919 m_i_min=i;
119     m_map_colonne.insert(std::pair<long,double>(i,val));
120     }
121     else
122     {
123 couturad 968 std::map<long,double>::iterator it;
124     it=m_map_colonne.find(i);
125     if(it==m_map_colonne.end())
126     {
127     m_map_colonne.insert(std::pair<long,double>(i,val));
128     }
129     else it->second+=val;
130 couturad 919 }
131     }
132    
133 couturad 968 int OT_HISTOGRAMME::get_valeur(double x, double& val)
134 couturad 919 {
135     long i = (long)(x/m_largeur_colonne);
136 couturad 968 return get_valeur(i,val);
137     }
138    
139     int OT_HISTOGRAMME::get_valeur(long i, double& val)
140     {
141 couturad 919 std::map<long,double>::iterator it;
142     it=m_map_colonne.find(i);
143     if(it==m_map_colonne.end())
144     {
145 couturad 968 return 0;
146 couturad 919 }
147 couturad 968 val=it->second;
148     return 1;
149 couturad 919 }
150    
151 couturad 968
152 couturad 926 int OT_HISTOGRAMME::get_premiere_valeur(std::map< long, double >::iterator& it,double &valeur)
153 couturad 919 {
154     it=m_map_colonne.begin();
155 couturad 926 if(it==m_map_colonne.end()) return 0;
156 couturad 919 valeur = it->second;
157 couturad 926 return 1;
158     }
159    
160     int OT_HISTOGRAMME::get_suivante_valeur(std::map< long, double >::iterator& it,double &valeur)
161     {
162     it++;
163     if(it==m_map_colonne.end()) return 0;
164     valeur = it->second;
165     return 1;
166     }
167    
168     int OT_HISTOGRAMME::get_premiere_valeur(std::map< long, double >::iterator& it,double &valeur,double &borne_min,double &borne_max)
169     {
170     it=m_map_colonne.begin();
171     if(it==m_map_colonne.end()) return 0;
172     valeur = it->second;
173 couturad 919 borne_min=(it->first)*m_largeur_colonne;
174 couturad 926 borne_max=(it->first)*m_largeur_colonne+m_largeur_colonne;
175     return 1;
176 couturad 919 }
177    
178 couturad 926 int OT_HISTOGRAMME::get_suivante_valeur(std::map< long, double >::iterator& it,double &valeur,double &borne_min,double &borne_max)
179 couturad 919 {
180     it++;
181 couturad 926 if(it==m_map_colonne.end()) return 0;
182 couturad 919 valeur = it->second;
183     borne_min=(it->first)*m_largeur_colonne;
184 couturad 926 borne_max=(it->first)*m_largeur_colonne+m_largeur_colonne;
185     return 1;
186 couturad 919 }
187    
188 couturad 926 int OT_HISTOGRAMME::get_premiere_valeur(std::map< long, double >::iterator& it, double &valeur, long int& i)
189     {
190     it=m_map_colonne.begin();
191     if(it==m_map_colonne.end()) return 0;
192     valeur = it->second;
193     i = it->first;
194     return 1;
195     }
196    
197     int OT_HISTOGRAMME::get_suivante_valeur(std::map< long, double >::iterator& it, double &valeur, long int& i)
198     {
199     it++;
200     if(it==m_map_colonne.end()) return 0;
201     valeur = it->second;
202     i = it->first;
203     return 1;
204     }
205    
206 couturad 919 long int OT_HISTOGRAMME::get_nb_colonne(void)
207     {
208     return m_map_colonne.size();
209     }
210    
211     double OT_HISTOGRAMME::get_x_min(void)
212     {
213     return m_i_min*m_largeur_colonne;
214     }
215    
216     double OT_HISTOGRAMME::get_x_max(void)
217     {
218 couturad 926 return m_i_max*m_largeur_colonne+m_largeur_colonne;
219 couturad 919 }
220    
221 couturad 926 OT_HISTOGRAMME& OT_HISTOGRAMME::operator=(OT_HISTOGRAMME& mdd)
222     {
223     m_largeur_colonne=mdd.m_largeur_colonne;
224     m_i_min=mdd.m_i_min;
225     m_i_max=mdd.m_i_max;
226     m_init=mdd.m_init;
227     m_map_colonne=mdd.m_map_colonne;
228     }
229 couturad 919
230 couturad 966 OT_HISTOGRAMME & OT_HISTOGRAMME::operator=(const OT_HISTOGRAMME& mdd)
231     {
232     m_largeur_colonne=mdd.m_largeur_colonne;
233     m_i_min=mdd.m_i_min;
234     m_i_max=mdd.m_i_max;
235     m_init=mdd.m_init;
236     m_map_colonne=mdd.m_map_colonne;
237     }
238    
239    
240 couturad 951 void OT_HISTOGRAMME::enregistrer_bin(std::ofstream& ofstr)
241 couturad 926 {
242     ofstr.write((char*)&m_init,sizeof(bool));
243     ofstr.write((char*)&m_i_min,sizeof(long));
244     ofstr.write((char*)&m_i_max,sizeof(long));
245     ofstr.write((char*)&m_largeur_colonne,sizeof(double));
246     long nb_colonne = get_nb_colonne();
247     ofstr.write((char*)&nb_colonne,sizeof(long));
248     std::map<long,double>::iterator it;
249     for(it=m_map_colonne.begin();it!=m_map_colonne.end();it++)
250     {
251     long i = it->first;
252     ofstr.write((char*)&i,sizeof(long));
253     double val = it->second;
254     ofstr.write((char*)&val,sizeof(double));
255     }
256     }
257    
258 couturad 951 void OT_HISTOGRAMME::ouvrir_bin(std::ifstream& ifstr)
259 couturad 926 {
260     ifstr.read((char*)&m_init,sizeof(bool));
261     ifstr.read((char*)&m_i_min,sizeof(long));
262     ifstr.read((char*)&m_i_max,sizeof(long));
263     ifstr.read((char*)&m_largeur_colonne,sizeof(double));
264     long nb_colonne;
265     ifstr.read((char*)&nb_colonne,sizeof(long));
266     for(long j=0;j<nb_colonne;j++)
267     {
268     long k;
269     ifstr.read((char*)&k,sizeof(long));
270     double val;
271     ifstr.read((char*)&val,sizeof(double));
272     ajouter_valeur(k,val);
273     }
274     }
275    
276 couturad 997 void OT_HISTOGRAMME::ouvrir_txt(char* nom_fichier)
277     {
278     FILE* in=fopen(nom_fichier,"rt");
279     char ligne[1000];
280     char *res=fgets(ligne,1000,in);
281     res=fgets(ligne,1000,in);
282     double xmin,xmax,xmilieu,val;
283     while(!feof(in))
284     {
285     sscanf(ligne,"%lf %lf %lf %lf",&xmin,&xmax,&xmilieu,&val);
286     if(m_init==false)
287     {
288     m_largeur_colonne=fabs(xmax-xmin);
289     }
290     ajouter_valeur(xmin,val);
291     res=fgets(ligne,1000,in);
292     }
293     }
294    
295 couturad 951 void OT_HISTOGRAMME::exporter(std::ofstream& ofstrm)
296 couturad 926 {
297     ofstrm << "x_min x_max x_milieu valeur" << std::endl;
298     std::map<long,double>::iterator it_his;
299     double val;
300     double borne_min,borne_max;
301     int k=get_premiere_valeur(it_his,val,borne_min,borne_max);
302     while(k!=0)
303     {
304     double borne_mid = borne_min+m_largeur_colonne/2.;
305     ofstrm << borne_min << " " << borne_max << " " << borne_mid << " " << val << std::endl;
306     k=get_suivante_valeur(it_his,val,borne_min,borne_max);
307     }
308     }
309    
310    
311 couturad 906 OT_QUATERNION::OT_QUATERNION(void)
312     {
313     valeur[0]=0;
314     valeur[1]=0;
315     valeur[2]=0;
316     valeur[3]=0;
317     }
318 francois 283
319 couturad 906 OT_QUATERNION::OT_QUATERNION(double x, double y, double z, double w)
320     {
321     valeur[0]=x;
322     valeur[1]=y;
323     valeur[2]=z;
324     valeur[3]=w;
325     }
326    
327     OT_QUATERNION::OT_QUATERNION(OT_QUATERNION& mdd)
328     {
329     valeur[0]=mdd.valeur[0];
330     valeur[1]=mdd.valeur[1];
331     valeur[2]=mdd.valeur[2];
332     valeur[3]=mdd.valeur[3];
333     }
334    
335     double OT_QUATERNION::get_x(void)
336     {
337     return valeur[0];
338     }
339    
340     void OT_QUATERNION::change_x(double x)
341     {
342     valeur[0]=x;
343     }
344    
345     double OT_QUATERNION::get_y(void)
346     {
347     return valeur[1];
348     }
349    
350     void OT_QUATERNION::change_y(double y)
351     {
352     valeur[1]=y;
353     }
354    
355     double OT_QUATERNION::get_z(void)
356     {
357     return valeur[2];
358     }
359    
360     void OT_QUATERNION::change_z(double z)
361     {
362     valeur[2]=z;
363     }
364    
365     double OT_QUATERNION::get_w(void)
366     {
367     return valeur[3];
368     }
369    
370     void OT_QUATERNION::change_w(double w)
371     {
372     valeur[3]=w;
373     }
374    
375     OT_QUATERNION& OT_QUATERNION::operator=(OT_QUATERNION& mdd)
376     {
377     valeur[0]=mdd.valeur[0];
378     valeur[1]=mdd.valeur[1];
379     valeur[2]=mdd.valeur[2];
380     valeur[3]=mdd.valeur[3];
381     return *this;
382     }
383    
384    
385 francois 283 OT_VECTEUR_3D::OT_VECTEUR_3D(double x,double y,double z)
386 foucault 27 {
387 francois 283 valeur[0]=x;
388     valeur[1]=y;
389     valeur[2]=z;
390 foucault 27 }
391 francois 249
392    
393 francois 283 OT_VECTEUR_3D::OT_VECTEUR_3D(double *xyz)
394     {
395     valeur[0]=xyz[0];
396     valeur[1]=xyz[1];
397     valeur[2]=xyz[2];
398     }
399 francois 249
400 francois 283 OT_VECTEUR_3D::OT_VECTEUR_3D(double *xyz1,double *xyz2)
401     {
402     valeur[0]=xyz2[0]-xyz1[0];
403     valeur[1]=xyz2[1]-xyz1[1];
404     valeur[2]=xyz2[2]-xyz1[2];
405     }
406 souaissa 69
407 francois 283 OT_VECTEUR_3D::OT_VECTEUR_3D(const OT_VECTEUR_3D& mdd)
408     {
409     valeur[0]=mdd.valeur[0];
410     valeur[1]=mdd.valeur[1];
411     valeur[2]=mdd.valeur[2];
412     }
413    
414     OT_VECTEUR_3D::OT_VECTEUR_3D(void)
415     {
416     valeur[0]=0.;
417     valeur[1]=0.;
418     valeur[2]=0.;
419     }
420    
421     double OT_VECTEUR_3D::get_x(void) const
422     {
423     return valeur[0];
424     }
425    
426    
427     double OT_VECTEUR_3D::get_y(void) const
428     {
429     return valeur[1];
430     }
431    
432    
433     double OT_VECTEUR_3D::get_z(void) const
434     {
435     return valeur[2];
436     }
437    
438     void OT_VECTEUR_3D::change_x(double x)
439     {
440     valeur[0]=x;
441     }
442    
443     void OT_VECTEUR_3D::change_y(double y)
444     {
445     valeur[1]=y;
446     }
447    
448     void OT_VECTEUR_3D::change_z(double z)
449     {
450     valeur[2]=z;
451     }
452    
453     double* OT_VECTEUR_3D::get_xyz(void)
454     {
455     return valeur;
456     }
457    
458     OT_VECTEUR_3D::operator const double* () const
459     {
460     return valeur;
461     }
462    
463     OT_VECTEUR_3D::operator double* ()
464     {
465     return valeur;
466     }
467    
468     double OT_VECTEUR_3D::operator[] (int i) const
469     {
470     return valeur[i];
471     }
472    
473     double & OT_VECTEUR_3D::operator[] (int i)
474     {
475     return valeur[i];
476     }
477    
478     double OT_VECTEUR_3D::operator() (int i) const
479     {
480     return valeur[i];
481     }
482     double & OT_VECTEUR_3D::operator() (int i)
483     {
484     return valeur[i];
485     }
486    
487     double OT_VECTEUR_3D::get_longueur(void) const
488     {
489     return sqrt(valeur[0]*valeur[0]+valeur[1]*valeur[1]+valeur[2]*valeur[2]);
490     }
491    
492     double OT_VECTEUR_3D::get_longueur2(void) const
493     {
494     return (valeur[0]*valeur[0]+valeur[1]*valeur[1]+valeur[2]*valeur[2]);
495     }
496    
497    
498     void OT_VECTEUR_3D::norme(void)
499     {
500     double longueur=get_longueur();
501     if (longueur != 0)
502     {
503     valeur[0]=valeur[0]/longueur;
504     valeur[2]=valeur[2]/longueur;
505     valeur[1]=valeur[1]/longueur;
506     }
507     }
508    
509     OT_VECTEUR_3D OT_VECTEUR_3D::gram_shmidt(const OT_VECTEUR_3D& vint)
510     {
511     OT_VECTEUR_3D v(0.,0.,0.);
512     double alpha=(*this)*vint;
513     v= *this-alpha*vint;
514     return v;
515     }
516    
517     OT_VECTEUR_3D OT_VECTEUR_3D::unite(int i)
518     {
519     OT_VECTEUR_3D v(0.,0.,0.);
520     v[i]=1.;
521     return v;
522     }
523    
524    
525     int OT_VECTEUR_3D::compare_valeur (const OT_VECTEUR_3D& mdd) const
526     {
527     return memcmp(valeur, mdd.valeur, 3*sizeof(double));
528     }
529    
530     bool OT_VECTEUR_3D::operator== (const OT_VECTEUR_3D& mdd) const
531     {
532     return compare_valeur(mdd) == 0;
533     }
534    
535     bool OT_VECTEUR_3D::operator!= (const OT_VECTEUR_3D& mdd) const
536     {
537     return compare_valeur(mdd) != 0;
538     }
539    
540     bool OT_VECTEUR_3D::operator< (const OT_VECTEUR_3D& mdd) const
541     {
542     return compare_valeur(mdd) < 0;
543     }
544    
545     bool OT_VECTEUR_3D::operator<= (const OT_VECTEUR_3D& mdd) const
546     {
547     return compare_valeur(mdd) <= 0;
548     }
549    
550     bool OT_VECTEUR_3D::operator> (const OT_VECTEUR_3D& mdd) const
551     {
552     return compare_valeur(mdd) > 0;
553     }
554    
555     bool OT_VECTEUR_3D::operator>= (const OT_VECTEUR_3D& mdd) const
556     {
557     return compare_valeur(mdd) >= 0;
558     }
559    
560     std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3D & __vec)
561     {
562     __os << "{ "<< __vec[0]<<", "<<__vec[1]<<", "<<__vec[2]<<"}, ";
563     return __os;
564     }
565    
566     OT_VECTEUR_3D operator/ (const OT_VECTEUR_3D& mdd1, double diviseur)
567     {
568     OT_VECTEUR_3D kQuot;
569    
570     if ( diviseur != (double)0.0 )
571     {
572     double facteur = ((double)1.0)/diviseur;
573     kQuot.valeur[0] = facteur*mdd1.valeur[0];
574     kQuot.valeur[1] = facteur*mdd1.valeur[1];
575     kQuot.valeur[2] = facteur*mdd1.valeur[2];
576     }
577     else
578     {
579     kQuot.valeur[0] = 1E300;
580     kQuot.valeur[1] = 1E300;
581     kQuot.valeur[2] = 1E300;
582     }
583    
584     return kQuot;
585     }
586    
587     OT_VECTEUR_3D operator- (const OT_VECTEUR_3D& mdd1)
588     {
589     return OT_VECTEUR_3D(
590     -mdd1.valeur[0],
591     -mdd1.valeur[1],
592     -mdd1.valeur[2]);
593     }
594    
595     double operator*(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2)
596     {
597     double tmp;
598     tmp=mdd1.valeur[0]*mdd2.valeur[0]+mdd1.valeur[1]*mdd2.valeur[1]+mdd1.valeur[2]*mdd2.valeur[2];
599     return tmp;
600     }
601    
602     OT_VECTEUR_3D operator*(double mdd1,const OT_VECTEUR_3D& mdd2)
603     {
604     OT_VECTEUR_3D tmp;
605     tmp.valeur[0]=mdd1*mdd2.valeur[0];
606     tmp.valeur[1]=mdd1*mdd2.valeur[1];
607     tmp.valeur[2]=mdd1*mdd2.valeur[2];
608     return tmp;
609     }
610    
611     OT_VECTEUR_3D& OT_VECTEUR_3D::operator+= (const OT_VECTEUR_3D& mdd)
612     {
613     valeur[0] += mdd.valeur[0];
614     valeur[1] += mdd.valeur[1];
615     valeur[2] += mdd.valeur[2];
616     return *this;
617     }
618     OT_VECTEUR_3D& OT_VECTEUR_3D::operator-= (const OT_VECTEUR_3D& mdd)
619     {
620     valeur[0] -= mdd.valeur[0];
621     valeur[1] -= mdd.valeur[1];
622     valeur[2] -= mdd.valeur[2];
623     return *this;
624     }
625     OT_VECTEUR_3D& OT_VECTEUR_3D::operator*= (double facteur)
626     {
627     valeur[0] *= facteur;
628     valeur[1] *= facteur;
629     valeur[2] *= facteur;
630     return *this;
631     }
632     OT_VECTEUR_3D& OT_VECTEUR_3D::operator/= (double diviseur)
633     {
634     if ( diviseur != (double)0.0 )
635     {
636     double facteur = ((double)1.0)/diviseur;
637     valeur[0] *= facteur;
638     valeur[1] *= facteur;
639     valeur[2] *= facteur;
640     }
641     else
642     {
643     valeur[0] = 1E300;
644     valeur[1] = 1E300;
645     valeur[2] = 1E300;
646     }
647    
648     return *this;
649     }
650    
651     OT_VECTEUR_3D operator&(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2)
652     {
653     OT_VECTEUR_3D tmp;
654     tmp.valeur[0]=mdd1.valeur[1]*mdd2.valeur[2]-mdd1.valeur[2]*mdd2.valeur[1];
655     tmp.valeur[1]=mdd1.valeur[2]*mdd2.valeur[0]-mdd1.valeur[0]*mdd2.valeur[2];
656     tmp.valeur[2]=mdd1.valeur[0]*mdd2.valeur[1]-mdd1.valeur[1]*mdd2.valeur[0];
657     return tmp;
658     }
659    
660     double OT_VECTEUR_3D::diff(void)
661     {
662     return 0.33333333333333*(fabs(valeur[0])+fabs(valeur[1])+fabs(valeur[2]));
663     }
664    
665    
666     OT_MATRICE_3D::OT_MATRICE_3D(OT_VECTEUR_3D& colonne1,OT_VECTEUR_3D& colonne2,OT_VECTEUR_3D& colonne3)
667     {
668     vec[0]=colonne1;
669     vec[1]=colonne2;
670     vec[2]=colonne3;
671     }
672    
673     OT_MATRICE_3D::OT_MATRICE_3D(const OT_MATRICE_3D& mdd)
674     {
675     vec[0]=mdd.vec[0];
676     vec[1]=mdd.vec[1];
677     vec[2]=mdd.vec[2];
678     }
679    
680     OT_MATRICE_3D::OT_MATRICE_3D(void)
681     {
682     for (int i=0;i<3;i++)
683     {
684     for (int j=0;j<3;j++)
685     {
686     vec[i][j]=0.;
687     }
688    
689     }
690    
691     }
692     std::ostream & operator << ( std::ostream & __os, const OT_MATRICE_3D & __mat)
693     {
694    
695     __os << "{ ";
696     for (unsigned i=0; i<3; i++)
697     {
698     __os << "[ "<< __mat(i,0)<<" ]\t [ "<<__mat(i,1) <<" ]\t [ "<<__mat(i,2);
699     if (i+1 < 3)
700     __os << std::endl << " ";
701     }
702     __os << " }" << std::endl;
703     return __os;
704     }
705    
706     OT_VECTEUR_3D & OT_MATRICE_3D::operator [](int i)
707     {
708     return vec[i];
709     }
710    
711     OT_MATRICE_3D::OT_MATRICE_3D(double* t)
712     {
713     for (int i=0;i<3;i++)
714     {
715     for (int j=0;j<3;j++)
716     {
717     vec[i][j]=t[i*3+j];
718     }
719    
720     }
721     }
722    
723     double OT_MATRICE_3D::valeur(int iLigne, int iCol) const
724     {
725     return vec[iCol][iLigne];
726     }
727     double & OT_MATRICE_3D::valeur(int iLigne, int iCol)
728     {
729     return vec[iCol][iLigne];
730     }
731     double OT_MATRICE_3D::operator() (int iLigne, int iCol) const
732     {
733     return vec[iCol][iLigne];
734     }
735     double & OT_MATRICE_3D::operator() (int iLigne, int iCol)
736     {
737     return vec[iCol][iLigne];
738     }
739     double OT_MATRICE_3D::get_determinant()
740     {
741     double coFacteur0 = valeur(1,1)*valeur(2,2) - valeur(1,2)*valeur(2,1);
742     double coFacteur1 = valeur(1,2)*valeur(2,0) - valeur(1,0)*valeur(2,2);
743     double coFacteur2 = valeur(1,0)*valeur(2,1) - valeur(1,1)*valeur(2,0);
744     double determinant = valeur(0,0)*coFacteur0 + valeur(0,1)*coFacteur1 + valeur(0,2)*coFacteur2;
745     return determinant;
746     }
747     void OT_MATRICE_3D::identite(void)
748     {
749     for (unsigned i = 0; i<3; i++)
750     for (unsigned j = 0; j < 3; j++)
751     vec[i][j] = (i==j) ? 1.0 : 0.0 ;
752     }
753    
754     void OT_MATRICE_3D::transpose(OT_MATRICE_3D& res) const
755     {
756     for (unsigned i = 0; i<3; i++)
757     for (unsigned j = 0; j < 3; j++)
758     res.vec[i][j] = vec[j][i];
759     }
760    
761     OT_MATRICE_3D OT_MATRICE_3D::transpose() const
762     {
763     OT_MATRICE_3D temp;
764     for (unsigned i = 0; i<3; i++)
765     for (unsigned j = 0; j < 3; j++)
766     temp.valeur(i,j) =valeur(j,i);
767    
768     return temp;
769     }
770    
771     OT_MATRICE_3D OT_MATRICE_3D::inverse () const
772     {
773     // Invert a 3x3 using cofactors. This is faster than using a generic
774     // Gaussian elimination because of the loop overhead of such a method.
775    
776     OT_MATRICE_3D matInverse;
777    
778     matInverse.valeur(0,0) = valeur(1,1)*valeur(2,2) - valeur(1,2)*valeur(2,1);
779     matInverse.valeur(0,1) = valeur(0,2)*valeur(2,1) - valeur(0,1)*valeur(2,2);
780     matInverse.valeur(0,2) = valeur(0,1)*valeur(1,2) - valeur(0,2)*valeur(1,1);
781     matInverse.valeur(1,0) = valeur(1,2)*valeur(2,0) - valeur(1,0)*valeur(2,2);
782     matInverse.valeur(1,1) = valeur(0,0)*valeur(2,2) - valeur(0,2)*valeur(2,0);
783     matInverse.valeur(1,2) = valeur(0,2)*valeur(1,0) - valeur(0,0)*valeur(1,2);
784     matInverse.valeur(2,0) = valeur(1,0)*valeur(2,1) - valeur(1,1)*valeur(2,0);
785     matInverse.valeur(2,1) = valeur(0,1)*valeur(2,0) - valeur(0,0)*valeur(2,1);
786     matInverse.valeur(2,2) = valeur(0,0)*valeur(1,1) - valeur(0,1)*valeur(1,0);
787    
788     double det = valeur(0,0)*matInverse(0,0) + valeur(0,1)*matInverse(1,0)+
789     valeur(0,2)*matInverse(2,0);
790    
791     if ( fabs(det) <= 1E-100 )
792     {
793     matInverse.identite();
794     return matInverse;
795     }
796    
797     double invDet = 1/det;
798    
799     for (int i=0; i<3; i++)
800     for (int j=0; j<3; j++)
801     matInverse.vec[i][j] *= invDet;
802    
803     return matInverse;
804     }
805    
806     void OT_MATRICE_3D::change_vecteur1(OT_VECTEUR_3D v)
807     {
808     vec[0]=v;
809     }
810     void OT_MATRICE_3D::change_vecteur2(OT_VECTEUR_3D v)
811     {
812     vec[1]=v;
813     }
814     void OT_MATRICE_3D::change_vecteur3(OT_VECTEUR_3D v)
815     {
816     vec[2]=v;
817     }
818     OT_VECTEUR_3D& OT_MATRICE_3D::get_vecteur1(void)
819     {
820     return vec[0];
821     }
822     OT_VECTEUR_3D& OT_MATRICE_3D::get_vecteur2(void)
823     {
824     return vec[1];
825     }
826     OT_VECTEUR_3D& OT_MATRICE_3D::get_vecteur3(void)
827     {
828     return vec[2];
829     }
830    
831    
832    
833     OT_MATRICE_3D operator+(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2)
834     {
835     OT_MATRICE_3D tmp;
836     for (int i=0;i<3;i++) {
837     for (int j=0;j<3;j++) tmp(i,j)= mdd1(i,j)+mdd2(i,j);
838     }
839     return tmp;
840     }
841    
842    
843     OT_VECTEUR_3D operator*(const OT_MATRICE_3D& mdd1,const OT_VECTEUR_3D& mdd2)
844     {
845     OT_VECTEUR_3D tmp;
846     tmp(0)=mdd1(0,0)*mdd2(0)+mdd1(0,1)*mdd2(1)+mdd1(0,2)*mdd2(2);
847     tmp(1)=mdd1(1,0)*mdd2(0)+mdd1(1,1)*mdd2(1)+mdd1(1,2)*mdd2(2);
848     tmp(2)=mdd1(2,0)*mdd2(0)+mdd1(2,1)*mdd2(1)+mdd1(2,2)*mdd2(2);
849     return tmp;
850     }
851    
852     OT_VECTEUR_3D operator+(const OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2)
853     {
854     OT_VECTEUR_3D tmp;
855     tmp(0)=mdd1(0)+mdd2(0);
856     tmp(1)=mdd1(1)+mdd2(1);
857     tmp(2)=mdd1(2)+mdd2(2);
858     return tmp;
859     }
860    
861     OT_VECTEUR_3D operator-(const class OT_VECTEUR_3D& mdd1,const OT_VECTEUR_3D& mdd2)
862     {
863     OT_VECTEUR_3D tmp;
864     tmp.valeur[0]=mdd1.valeur[0]-mdd2.valeur[0];
865     tmp.valeur[1]=mdd1.valeur[1]-mdd2.valeur[1];
866     tmp.valeur[2]=mdd1.valeur[2]-mdd2.valeur[2];
867     return tmp;
868     }
869    
870     OT_MATRICE_3D operator*(const OT_MATRICE_3D& mdd1,const OT_MATRICE_3D& mdd2)
871     {
872     OT_MATRICE_3D tmp;
873     for (int i=0; i<3; i++)
874     for (int j=0; j<3; j++)
875     {
876     tmp(i,j) = 0;
877     for (int k=0; k<3; k++)
878     tmp(i,j) += mdd1(i,k)*mdd2(k,j);
879     }
880     return tmp;
881     }
882    
883     #ifdef ot_vecteur_4d
884     OT_VECTEUR_4D::OT_VECTEUR_4D (double v[4])
885     {
886     for (int i=0; i<4; i++)
887     valeur[i]=v[i];
888     }
889    
890     OT_VECTEUR_4D::OT_VECTEUR_4D (double x, double y, double z, double w)
891     {
892     valeur[0] = x;
893     valeur[1] = y;
894     valeur[2] = z;
895     valeur[3] = w;
896     }
897    
898     OT_VECTEUR_4D::OT_VECTEUR_4D (const OT_VECTEUR_4D & v)
899     {
900     for (int i=0; i<4; i++)
901     valeur[i]=v[i];
902     }
903    
904    
905     double & OT_VECTEUR_4D::operator()(int i)
906     {
907     return valeur[i];
908     }
909    
910     double OT_VECTEUR_4D::operator()(int i) const
911     {
912     return valeur[i];
913     }
914    
915     double & OT_VECTEUR_4D::operator[](int i)
916     {
917     return valeur[i];
918     }
919    
920     double OT_VECTEUR_4D::operator[](int i) const
921     {
922     return valeur[i];
923     }
924    
925     OT_VECTEUR_4D::operator const double* () const
926     {
927     return valeur;
928     }
929    
930     OT_VECTEUR_4D::operator double* ()
931     {
932     return valeur;
933     }
934    
935     double OT_VECTEUR_4D::get_x(void) const
936     {
937     return valeur[0];
938     }
939     double & OT_VECTEUR_4D::x(void)
940     {
941     return valeur[0];
942     }
943     double OT_VECTEUR_4D::get_y(void) const
944     {
945     return valeur[1];
946     }
947     double & OT_VECTEUR_4D::y(void)
948     {
949     return valeur[1];
950     }
951     double OT_VECTEUR_4D::get_z(void) const
952     {
953     return valeur[2];
954     }
955     double & OT_VECTEUR_4D::z(void)
956     {
957     return valeur[2];
958     }
959     double OT_VECTEUR_4D::get_w(void) const
960     {
961     return valeur[3];
962     }
963     double & OT_VECTEUR_4D::w(void)
964     {
965     return valeur[3];
966     }
967     void OT_VECTEUR_4D::change_x(double x)
968     {
969     valeur[0] = x;
970     }
971     void OT_VECTEUR_4D::change_y(double y)
972     {
973     valeur[1] = y;
974     }
975     void OT_VECTEUR_4D::change_z(double z)
976     {
977     valeur[2] = z;
978     }
979     void OT_VECTEUR_4D::change_w(double w)
980     {
981     valeur[3] = w;
982     }
983     double* OT_VECTEUR_4D::get_xyzw(void)
984     {
985     return valeur;
986     }
987    
988     OT_VECTEUR_4D OT_VECTEUR_4D::operator+ (const OT_VECTEUR_4D & a)
989     {
990     return OT_VECTEUR_4D(
991     a(0)+valeur[0],a(1)+valeur[1],a(2)+valeur[2],a(3)+valeur[3]
992     );
993     }
994    
995     OT_VECTEUR_4D OT_VECTEUR_4D::operator- (const OT_VECTEUR_4D & a)
996     {
997     return OT_VECTEUR_4D(
998     valeur[0]-a(0),valeur[1]-a(1),valeur[2]-a(2),valeur[3]-a(3)
999     );
1000     }
1001    
1002     OT_VECTEUR_4D operator* (const OT_VECTEUR_4D & rkV, const double a)
1003     {
1004     return OT_VECTEUR_4D(
1005     a*rkV[0],a*rkV[1],a*rkV[2],a*rkV[3]
1006     );
1007     }
1008     OT_VECTEUR_4D operator* (const double a, const OT_VECTEUR_4D & rkV)
1009     {
1010     return OT_VECTEUR_4D(
1011     a*rkV[0],a*rkV[1],a*rkV[2],a*rkV[3]
1012     );
1013     }
1014    
1015     OT_VECTEUR_4D operator/ (const OT_VECTEUR_4D & rkV, const double a)
1016     {
1017     double inv = 1/a;
1018     return OT_VECTEUR_4D(
1019     inv*rkV[0],inv*rkV[1],inv*rkV[2],inv*rkV[3]
1020     );
1021     }
1022    
1023    
1024     OT_VECTEUR_4D operator/ (const double a, const OT_VECTEUR_4D & rkV)
1025     {
1026     double inv = 1/a;
1027     return OT_VECTEUR_4D(
1028     inv*rkV[0],inv*rkV[1],inv*rkV[2],inv*rkV[3]
1029     );
1030     }
1031    
1032     double OT_VECTEUR_4D::operator* (const OT_VECTEUR_4D & a)
1033     {
1034     return a[0]*valeur[0]+a[1]*valeur[1]+a[2]*valeur[2]+a[3]*valeur[3];
1035     }
1036    
1037    
1038     OT_VECTEUR_4D& OT_VECTEUR_4D::operator+= (const OT_VECTEUR_4D& rkV)
1039     {
1040     valeur[0] += rkV.valeur[0];
1041     valeur[1] += rkV.valeur[1];
1042     valeur[2] += rkV.valeur[2];
1043     valeur[3] += rkV.valeur[3];
1044     return *this;
1045     }
1046    
1047     OT_VECTEUR_4D& OT_VECTEUR_4D::operator-= (const OT_VECTEUR_4D& rkV)
1048     {
1049     valeur[0] -= rkV.valeur[0];
1050     valeur[1] -= rkV.valeur[1];
1051     valeur[2] -= rkV.valeur[2];
1052     valeur[3] -= rkV.valeur[3];
1053     return *this;
1054     }
1055     OT_VECTEUR_4D& OT_VECTEUR_4D::operator*= (double fScalar)
1056     {
1057     valeur[0] *= fScalar;
1058     valeur[1] *= fScalar;
1059     valeur[2] *= fScalar;
1060     valeur[3] *= fScalar;
1061     return *this;
1062     }
1063     OT_VECTEUR_4D& OT_VECTEUR_4D::operator/= (double fScalar)
1064     {
1065     double a = 1/fScalar;
1066     valeur[0] *= a;
1067     valeur[1] *= a;
1068     valeur[2] *= a;
1069     valeur[3] *= a;
1070     return *this;
1071     }
1072     OT_VECTEUR_4D &OT_VECTEUR_4D::operator= (double a)
1073     {
1074     valeur[0]=valeur[1]=valeur[2]=valeur[3]=a;
1075     return *this;
1076     }
1077    
1078     std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4D & __vec)
1079     {
1080     __os << "{ "<< __vec[0]<<", "<<__vec[1]<<", "<<__vec[2]<<", "<<__vec[3]<<"}, ";
1081     return __os;
1082     }
1083     #endif // ot_vecteur_4d
1084    
1085    
1086    
1087     // ot_vecteur_3d
1088    
1089    
1090    
1091     OT_VECTEUR_3DD::OT_VECTEUR_3DD (double2 v[3])
1092     {
1093     for (int i=0; i<3; i++)
1094     valeur[i]=v[i];
1095     }
1096    
1097     OT_VECTEUR_3DD::OT_VECTEUR_3DD (double2 x, double2 y, double2 z)
1098     {
1099     valeur[0] = x;
1100     valeur[1] = y;
1101     valeur[2] = z;
1102     }
1103    
1104 francois 550 OT_VECTEUR_3DD::OT_VECTEUR_3DD(double2 *xyz1,double2 *xyz2)
1105     {
1106     valeur[0]=xyz2[0]-xyz1[0];
1107     valeur[1]=xyz2[1]-xyz1[1];
1108     valeur[2]=xyz2[2]-xyz1[2];
1109     }
1110    
1111 francois 283 OT_VECTEUR_3DD::OT_VECTEUR_3DD (const OT_VECTEUR_3DD & v)
1112     {
1113     for (int i=0; i<3; i++)
1114     valeur[i]=v[i];
1115     }
1116    
1117    
1118     double2 & OT_VECTEUR_3DD::operator()(int i)
1119     {
1120     return valeur[i];
1121     }
1122    
1123     double2 OT_VECTEUR_3DD::operator()(int i) const
1124     {
1125     return valeur[i];
1126     }
1127    
1128     double2 & OT_VECTEUR_3DD::operator[](int i)
1129     {
1130     return valeur[i];
1131     }
1132    
1133     double2 OT_VECTEUR_3DD::operator[](int i) const
1134     {
1135     return valeur[i];
1136     }
1137    
1138     OT_VECTEUR_3DD::operator const double2* () const
1139     {
1140     return valeur;
1141     }
1142    
1143     OT_VECTEUR_3DD::operator double2* ()
1144     {
1145     return valeur;
1146     }
1147    
1148     OT_VECTEUR_3DD& OT_VECTEUR_3DD::operator =(const OT_VECTEUR_3DD& v3d)
1149     {
1150     if (this==&v3d) return *this;
1151     valeur [0]=v3d.get_x();
1152     valeur [1]=v3d.get_y();
1153     valeur [2]=v3d.get_z();
1154     return *this;
1155     }
1156     double2 OT_VECTEUR_3DD::norme()
1157     {
1158     double2 nor= valeur [0]*valeur [0]+valeur [1]*valeur [1]+valeur [2]*valeur [2];
1159     nor=sqrt(nor);
1160     return nor;
1161     }
1162     OT_VECTEUR_3DD OT_VECTEUR_3DD::vecteur_norme()
1163     {
1164     OT_VECTEUR_3DD nor;
1165     double2 zero=0.;
1166     double2 norme= this->norme() ;
1167     nor=(*this)*(1./norme);
1168     return nor;
1169     }
1170 francois 550 double2 OT_VECTEUR_3DD::get_longueur(void)
1171     {
1172     return sqrt(valeur[0]*valeur[0]+valeur[1]*valeur[1]+valeur[2]*valeur[2]);
1173     }
1174 francois 283
1175 francois 550 double2 OT_VECTEUR_3DD::get_longueur2(void)
1176     {
1177     return (valeur[0]*valeur[0]+valeur[1]*valeur[1]+valeur[2]*valeur[2]);
1178     }
1179    
1180 francois 283 double2 OT_VECTEUR_3DD::get_x(void) const
1181     {
1182     return valeur[0];
1183     }
1184     double2 & OT_VECTEUR_3DD::x(void)
1185     {
1186     return valeur[0];
1187     }
1188     double2 OT_VECTEUR_3DD::get_y(void) const
1189     {
1190     return valeur[1];
1191     }
1192     double2 & OT_VECTEUR_3DD::y(void)
1193     {
1194     return valeur[1];
1195     }
1196     double2 OT_VECTEUR_3DD::get_z(void) const
1197     {
1198     return valeur[2];
1199     }
1200     double2 & OT_VECTEUR_3DD::z(void)
1201     {
1202     return valeur[2];
1203     }
1204     void OT_VECTEUR_3DD::change_x(double2 x)
1205     {
1206     valeur[0] = x;
1207     }
1208     void OT_VECTEUR_3DD::change_y(double2 y)
1209     {
1210     valeur[1] = y;
1211     }
1212     void OT_VECTEUR_3DD::change_z(double2 z)
1213     {
1214     valeur[2] = z;
1215     }
1216     double2* OT_VECTEUR_3DD::get_xyz(void)
1217     {
1218     return valeur;
1219     }
1220    
1221     OT_VECTEUR_3DD OT_VECTEUR_3DD::operator+ (const OT_VECTEUR_3DD & a)
1222     {
1223     return OT_VECTEUR_3DD(
1224     a(0)+valeur[0],a(1)+valeur[1],a(2)+valeur[2]);
1225     }
1226    
1227     OT_VECTEUR_3DD OT_VECTEUR_3DD::operator- (const OT_VECTEUR_3DD & a)
1228     {
1229     return OT_VECTEUR_3DD(
1230     valeur[0]-a(0),valeur[1]-a(1),valeur[2]-a(2));
1231     }
1232    
1233     OT_VECTEUR_3DD operator* (const OT_VECTEUR_3DD & rkV, const double2 a)
1234     {
1235     return OT_VECTEUR_3DD(
1236     a*rkV[0],a*rkV[1],a*rkV[2]);
1237     }
1238     OT_VECTEUR_3DD operator* (const double2 a, const OT_VECTEUR_3DD & rkV)
1239     {
1240     return OT_VECTEUR_3DD(
1241     a*rkV[0],a*rkV[1],a*rkV[2]);
1242     }
1243    
1244     OT_VECTEUR_3DD operator/ (const OT_VECTEUR_3DD & rkV, const double2 a)
1245     {
1246     double2 inv = 1/a;
1247     return OT_VECTEUR_3DD(
1248     inv*rkV[0],inv*rkV[1],inv*rkV[2]);
1249     }
1250    
1251    
1252     OT_VECTEUR_3DD operator/ (const double2 a, const OT_VECTEUR_3DD & rkV)
1253     {
1254     double2 inv = 1/a;
1255     return OT_VECTEUR_3DD(
1256     inv*rkV[0],inv*rkV[1],inv*rkV[2]);
1257     }
1258     OT_VECTEUR_3DD OT_VECTEUR_3DD::operator&(const OT_VECTEUR_3DD& v2)
1259     {
1260     OT_VECTEUR_3DD tmp;
1261     tmp[0]= valeur[1]*v2[2]-valeur[2]*v2[1];
1262     tmp[1]= valeur[2]*v2[0]-valeur[0]*v2[2];
1263     tmp[2]= valeur[0]*v2[1]-valeur[1]*v2[0];
1264     return tmp;
1265     }
1266     double2 OT_VECTEUR_3DD::operator* (const OT_VECTEUR_3DD & a)
1267     {
1268     return a[0]*valeur[0]+a[1]*valeur[1]+a[2]*valeur[2];
1269     }
1270    
1271    
1272     OT_VECTEUR_3DD& OT_VECTEUR_3DD::operator+= (const OT_VECTEUR_3DD& rkV)
1273     {
1274     valeur[0] = valeur[0] +rkV.valeur[0];
1275     valeur[1] = valeur[1] +rkV.valeur[1];
1276     valeur[2] = valeur[2] +rkV.valeur[2];
1277     return *this;
1278     }
1279    
1280     OT_VECTEUR_3DD& OT_VECTEUR_3DD::operator-= (const OT_VECTEUR_3DD& rkV)
1281     {
1282     valeur[0] = valeur[0] -rkV.valeur[0];
1283     valeur[1] = valeur[1] -rkV.valeur[1];
1284     valeur[2] = valeur[2] -rkV.valeur[2];
1285     return *this;
1286     }
1287     OT_VECTEUR_3DD& OT_VECTEUR_3DD::operator*= (double2 fScalar)
1288     {
1289     valeur[0] =valeur[0] * fScalar;
1290     valeur[1] =valeur[1] * fScalar;
1291     valeur[2] =valeur[2] * fScalar;
1292     return *this;
1293     }
1294     OT_VECTEUR_3DD& OT_VECTEUR_3DD::operator/= (double2 fScalar)
1295     {
1296     double2 a = 1/fScalar;
1297     valeur[0] =valeur[0] * a;
1298     valeur[1] =valeur[1] * a;
1299     valeur[2] =valeur[2] * a;
1300     return *this;
1301     }
1302    
1303    
1304     std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_3DD & __vec)
1305     {
1306 couturad 951 __os << "[ "<<std::setw(20)<< __vec[0]<<std::setw(4)<<", "<<std::setw(20)<<__vec[1]<<", "<<std::setw(20)<<__vec[2]<<std::setw(4)<<", "<<std::setw(20)<<"] ";
1307 francois 283 return __os;
1308     }
1309    
1310     int OT_VECTEUR_3DD::compare_valeur (const OT_VECTEUR_3DD& mdd) const
1311     {
1312     if (valeur[0]==mdd.valeur[0]&&valeur[1]==mdd.valeur[1] &&valeur[2]==mdd.valeur[2])
1313     return 1;
1314     else return 0;
1315    
1316     }
1317    
1318     bool OT_VECTEUR_3DD::operator==(const OT_VECTEUR_3DD& mdd) const
1319     {
1320     return compare_valeur(mdd);
1321     }
1322    
1323    
1324    
1325    
1326    
1327    
1328    
1329    
1330    
1331    
1332     OT_VECTEUR_4DD::OT_VECTEUR_4DD (double2 v[4])
1333     {
1334     for (int i=0; i<4; i++)
1335     valeur[i]=v[i];
1336     }
1337    
1338     OT_VECTEUR_4DD::OT_VECTEUR_4DD (double2 x, double2 y, double2 z, double2 w)
1339     {
1340     valeur[0] = x;
1341     valeur[1] = y;
1342     valeur[2] = z;
1343     valeur[3] = w;
1344     }
1345    
1346     OT_VECTEUR_4DD::OT_VECTEUR_4DD (const OT_VECTEUR_4DD & v)
1347     {
1348     for (int i=0; i<4; i++)
1349     valeur[i]=v[i];
1350     }
1351    
1352    
1353     double2 & OT_VECTEUR_4DD::operator()(int i)
1354     {
1355     return valeur[i];
1356     }
1357    
1358     double2 OT_VECTEUR_4DD::operator()(int i) const
1359     {
1360     return valeur[i];
1361     }
1362    
1363     double2 & OT_VECTEUR_4DD::operator[](int i)
1364     {
1365     return valeur[i];
1366     }
1367    
1368     double2 OT_VECTEUR_4DD::operator[](int i) const
1369     {
1370     return valeur[i];
1371     }
1372    
1373     OT_VECTEUR_4DD::operator const double2* () const
1374     {
1375     return valeur;
1376     }
1377    
1378     OT_VECTEUR_4DD::operator double2* ()
1379     {
1380     return valeur;
1381     }
1382    
1383     OT_VECTEUR_4DD& OT_VECTEUR_4DD::operator =(const OT_VECTEUR_4DD& v4d)
1384     {
1385     if (this==&v4d) return *this;
1386     valeur [0]=v4d.get_x();
1387     valeur [1]=v4d.get_y();
1388     valeur [2]=v4d.get_z();
1389     valeur [3]=v4d.get_w();
1390     return *this;
1391     }
1392     double2 OT_VECTEUR_4DD::norme()
1393     {
1394     double2 nor= valeur [0]*valeur [0]+valeur [1]*valeur [1]+valeur [2]*valeur [2]+valeur [3]*valeur [3];
1395     nor=nor^0.5;
1396     return nor;
1397     }
1398     OT_VECTEUR_4DD OT_VECTEUR_4DD::vecteur_norme()
1399     {
1400     OT_VECTEUR_4DD nor;
1401     double2 zero=0.;
1402     double2 norme= this->norme() ;
1403     assert(norme!=zero) ;
1404     nor=(*this)*(1./norme);
1405     return nor;
1406     }
1407    
1408 francois 363 OT_VECTEUR_4DD OT_VECTEUR_4DD::vecteur_norme_3d()
1409     {
1410     double2 norme= valeur [0]*valeur [0]+valeur [1]*valeur [1]+valeur [2]*valeur [2];
1411     norme=norme^0.5;
1412     OT_VECTEUR_4DD nor;
1413     double2 zero=0.;
1414     assert(norme!=zero) ;
1415     nor.change_x(valeur[0]/norme);
1416     nor.change_y(valeur[1]/norme);
1417     nor.change_z(valeur[2]/norme);
1418     nor.change_w(valeur[3]);
1419     return nor;
1420     }
1421 francois 283 double2 OT_VECTEUR_4DD::get_x(void) const
1422     {
1423     return valeur[0];
1424     }
1425     double2 & OT_VECTEUR_4DD::x(void)
1426     {
1427     return valeur[0];
1428     }
1429     double2 OT_VECTEUR_4DD::get_y(void) const
1430     {
1431     return valeur[1];
1432     }
1433     double2 & OT_VECTEUR_4DD::y(void)
1434     {
1435     return valeur[1];
1436     }
1437     double2 OT_VECTEUR_4DD::get_z(void) const
1438     {
1439     return valeur[2];
1440     }
1441     double2 & OT_VECTEUR_4DD::z(void)
1442     {
1443     return valeur[2];
1444     }
1445     double2 OT_VECTEUR_4DD::get_w(void) const
1446     {
1447     return valeur[3];
1448     }
1449     double2 & OT_VECTEUR_4DD::w(void)
1450     {
1451     return valeur[3];
1452     }
1453     void OT_VECTEUR_4DD::change_x(double2 x)
1454     {
1455     valeur[0] = x;
1456     }
1457     void OT_VECTEUR_4DD::change_y(double2 y)
1458     {
1459     valeur[1] = y;
1460     }
1461     void OT_VECTEUR_4DD::change_z(double2 z)
1462     {
1463     valeur[2] = z;
1464     }
1465     void OT_VECTEUR_4DD::change_w(double2 w)
1466     {
1467     valeur[3] = w;
1468     }
1469     double2* OT_VECTEUR_4DD::get_xyzw(void)
1470     {
1471     return valeur;
1472     }
1473    
1474     OT_VECTEUR_4DD OT_VECTEUR_4DD::operator+ (const OT_VECTEUR_4DD & a)
1475     {
1476     return OT_VECTEUR_4DD(
1477     a(0)+valeur[0],a(1)+valeur[1],a(2)+valeur[2],a(3)+valeur[3]
1478     );
1479     }
1480    
1481     OT_VECTEUR_4DD OT_VECTEUR_4DD::operator- (const OT_VECTEUR_4DD & a)
1482     {
1483     return OT_VECTEUR_4DD(
1484     valeur[0]-a(0),valeur[1]-a(1),valeur[2]-a(2),valeur[3]-a(3)
1485     );
1486     }
1487    
1488     OT_VECTEUR_4DD operator* (const OT_VECTEUR_4DD & rkV, const double2 a)
1489     {
1490     return OT_VECTEUR_4DD(
1491     a*rkV[0],a*rkV[1],a*rkV[2],a*rkV[3]
1492     );
1493     }
1494     OT_VECTEUR_4DD operator* (const double2 a, const OT_VECTEUR_4DD & rkV)
1495     {
1496     return OT_VECTEUR_4DD(
1497     a*rkV[0],a*rkV[1],a*rkV[2],a*rkV[3]
1498     );
1499     }
1500    
1501     OT_VECTEUR_4DD operator/ (const OT_VECTEUR_4DD & rkV, const double2 a)
1502     {
1503     double2 inv = 1/a;
1504     return OT_VECTEUR_4DD(
1505     inv*rkV[0],inv*rkV[1],inv*rkV[2],inv*rkV[3]
1506     );
1507     }
1508    
1509    
1510     OT_VECTEUR_4DD operator/ (const double2 a, const OT_VECTEUR_4DD & rkV)
1511     {
1512     double2 inv = 1/a;
1513     return OT_VECTEUR_4DD(
1514     inv*rkV[0],inv*rkV[1],inv*rkV[2],inv*rkV[3]
1515     );
1516     }
1517     OT_VECTEUR_4DD OT_VECTEUR_4DD::operator^(const OT_VECTEUR_4DD& v2)
1518     {
1519     OT_VECTEUR_4DD tmp;
1520     tmp[0]= valeur[1]*v2[2]-valeur[2]*v2[1];
1521     tmp[1]= valeur[2]*v2[0]-valeur[0]*v2[2];
1522     tmp[2]= valeur[0]*v2[1]-valeur[1]*v2[0];
1523     tmp[3]= 0;
1524     //tmp[3]= valeur[1]*v2[2]-valeur[2]*v2[1];
1525     return tmp;
1526     }
1527     double2 OT_VECTEUR_4DD::operator* (const OT_VECTEUR_4DD & a)
1528     {
1529     return a[0]*valeur[0]+a[1]*valeur[1]+a[2]*valeur[2]+a[3]*valeur[3];
1530     }
1531    
1532    
1533     OT_VECTEUR_4DD& OT_VECTEUR_4DD::operator+= (const OT_VECTEUR_4DD& rkV)
1534     {
1535     valeur[0] = valeur[0] +rkV.valeur[0];
1536     valeur[1] = valeur[1] +rkV.valeur[1];
1537     valeur[2] = valeur[2] +rkV.valeur[2];
1538     valeur[3] = valeur[3] +rkV.valeur[3];
1539     return *this;
1540     }
1541    
1542     OT_VECTEUR_4DD& OT_VECTEUR_4DD::operator-= (const OT_VECTEUR_4DD& rkV)
1543     {
1544     valeur[0] = valeur[0] -rkV.valeur[0];
1545     valeur[1] = valeur[1] -rkV.valeur[1];
1546     valeur[2] = valeur[2] -rkV.valeur[2];
1547     valeur[3] = valeur[3] -rkV.valeur[3];
1548     return *this;
1549     }
1550     OT_VECTEUR_4DD& OT_VECTEUR_4DD::operator*= (double2 fScalar)
1551     {
1552     valeur[0] =valeur[0] * fScalar;
1553     valeur[1] =valeur[1] * fScalar;
1554     valeur[2] =valeur[2] * fScalar;
1555     valeur[3] =valeur[3] * fScalar;
1556     return *this;
1557     }
1558     OT_VECTEUR_4DD& OT_VECTEUR_4DD::operator/= (double2 fScalar)
1559     {
1560     double2 a = 1/fScalar;
1561     valeur[0] =valeur[0] * a;
1562     valeur[1] =valeur[1] * a;
1563     valeur[2] =valeur[2] * a;
1564     valeur[3] =valeur[3] * a;
1565     return *this;
1566     }
1567    
1568    
1569     std::ostream & operator << ( std::ostream & __os, const OT_VECTEUR_4DD & __vec)
1570     {
1571 couturad 951 __os << "[ "<<std::setw(20)<< __vec[0]<<std::setw(4)<<", "<<std::setw(20)<<__vec[1]<<", "<<std::setw(20)<<__vec[2]<<std::setw(4)<<", "<<std::setw(20)<<__vec[3]<<std::setw(4)<<"] ";
1572 francois 283 return __os;
1573     }
1574    
1575     int OT_VECTEUR_4DD::compare_valeur (const OT_VECTEUR_4DD& mdd) const
1576     {
1577     if (valeur[0]==mdd.valeur[0]&&valeur[1]==mdd.valeur[1] &&valeur[2]==mdd.valeur[2]&&valeur[3]==mdd.valeur[3])
1578     return 1;
1579     else return 0;
1580    
1581     }
1582    
1583     bool OT_VECTEUR_4DD::operator==(const OT_VECTEUR_4DD& mdd) const
1584     {
1585     return compare_valeur(mdd);
1586     }
1587    
1588    
1589    
1590 francois 743 bool OT_VECTEUR_4DD::est_nul(void)
1591     {
1592     double2 ZERO(0.);
1593     if (valeur[0]==ZERO&&valeur[1]==ZERO &&valeur[2]==ZERO&&valeur[3]==ZERO)
1594     return true;
1595     return false;
1596     }
1597 francois 283
1598 francois 743 bool OT_VECTEUR_4DD::est_nul_3d(void)
1599     {
1600     double2 ZERO(0.);
1601     if (valeur[0]==ZERO&&valeur[1]==ZERO &&valeur[2]==ZERO)
1602     return true;
1603     return false;
1604     }
1605 francois 283
1606    
1607    
1608    
1609    
1610    
1611    
1612    
1613    
1614    
1615    
1616 francois 743
1617 francois 283 int OPERATEUR::egal(double a,double b,double eps)
1618     {
1619     double res=fabs(a-b);
1620     if (res<eps) return(1);
1621     return(0);
1622     }
1623    
1624 couturad 906 int OPERATEUR::egal(double* xyz1, double* xyz2, double eps)
1625     {
1626     if(fabs(xyz1[0]-xyz2[0])<eps)
1627     if(fabs(xyz1[1]-xyz2[1])<eps)
1628     if(fabs(xyz1[2]-xyz2[2])<eps)
1629     return 1;
1630     return 0;
1631     }
1632 francois 283
1633 couturad 906
1634    
1635 francois 283 double OPERATEUR::qualite_triangle(double* noeud1,double* noeud2,double* noeud3)
1636     {
1637     OT_VECTEUR_3D vec12(noeud1,noeud2);
1638     OT_VECTEUR_3D vec13(noeud1,noeud3);
1639     OT_VECTEUR_3D vec23(noeud2,noeud3);
1640     double d12=vec12.get_longueur();
1641     double d13=vec13.get_longueur();
1642     double d23=vec23.get_longueur();
1643 couturad 951 double dmax=std::max(d12,d13);
1644     dmax=std::max(dmax,d23);
1645 francois 283 double p=0.5*(d12+d13+d23);
1646     double crit=(p-d12)*(p-d13)*(p-d23)/p;
1647     if (crit<0) crit=0.;
1648     crit=sqrt(crit);
1649     crit=crit/dmax;
1650     crit=crit*3.4641101614;
1651     return crit;
1652     }
1653    
1654     void OPERATEUR::doubleto2int(double val,int& val1,int& val2)
1655     {
1656     int *p=(int*)(&(val));
1657     val1=(*p);
1658     val2=(*(p+1));
1659     }
1660    
1661     double OPERATEUR::qualite_tetra(double* noeud1,double* noeud2,double* noeud3,double *noeud4)
1662     {
1663     OT_VECTEUR_3D ab(noeud1,noeud2);
1664     OT_VECTEUR_3D ac(noeud1,noeud3);
1665     OT_VECTEUR_3D cb(noeud3,noeud2);
1666     OT_VECTEUR_3D db(noeud4,noeud2);
1667     OT_VECTEUR_3D da(noeud4,noeud1);
1668     OT_VECTEUR_3D dc(noeud4,noeud3);
1669     double dab=ab.get_longueur();
1670     double dac=ac.get_longueur();
1671     double dcb=cb.get_longueur();
1672     double ddb=db.get_longueur();
1673     double dda=da.get_longueur();
1674     double ddc=dc.get_longueur();
1675    
1676 couturad 951 double dmax=std::max(dab,dac);
1677     dmax=std::max(dmax,dcb);
1678     dmax=std::max(dmax,ddb);
1679     dmax=std::max(dmax,dda);
1680     dmax=std::max(dmax,ddc);
1681 francois 283
1682     OT_VECTEUR_3D pvec=ab&ac;
1683     double vol=pvec*da;
1684     if (vol>0.) return 0.;
1685     vol=fabs(vol);
1686     double som=pvec.get_longueur()/2.;
1687     pvec=ab&da;
1688     som=som+pvec.get_longueur()/2.;
1689     pvec=ac&dc;
1690     som=som+pvec.get_longueur()/2.;
1691     pvec=cb&db;
1692     som=som+pvec.get_longueur()/2.;
1693     double crit=vol/som/dmax/0.408249;
1694     return crit;
1695     }
1696    
1697 francois 418 int OPERATEUR::estdansletetra(double *xyz1,double *xyz2,double *xyz3,double *xyz4,double x,double y, double z)
1698     {
1699     OT_VECTEUR_3D v1(xyz2[0]-xyz1[0],xyz2[1]-xyz1[1],xyz2[2]-xyz1[2]);
1700     OT_VECTEUR_3D v2(xyz3[0]-xyz1[0],xyz3[1]-xyz1[1],xyz3[2]-xyz1[2]);
1701     OT_VECTEUR_3D v3(xyz4[0]-xyz1[0],xyz4[1]-xyz1[1],xyz4[2]-xyz1[2]);
1702     OT_VECTEUR_3D v4(x-xyz1[0],y-xyz1[1],z-xyz1[2]);
1703     OT_MATRICE_3D mat(v1,v2,v3);
1704     OT_MATRICE_3D mat1(v4,v2,v3);
1705     OT_MATRICE_3D mat2(v1,v4,v3);
1706     OT_MATRICE_3D mat3(v1,v2,v4);
1707     double det=mat.get_determinant();
1708     double xsi=mat1.get_determinant()/det;
1709     double eta=mat2.get_determinant()/det;
1710     double dseta=mat3.get_determinant()/det;
1711     int reponse1=1;
1712     int reponse2=1;
1713     double eps=0.0000001;
1714     if (xsi<-eps) reponse1=0;
1715     if (eta<-eps) reponse1=0;
1716     if (dseta<-eps) reponse1=0;
1717     if (xsi+eta+dseta>1.+eps) reponse1=0;
1718     if (xsi<eps) reponse2=0;
1719     if (eta<eps) reponse2=0;
1720     if (dseta<eps) reponse2=0;
1721     if (xsi+eta+dseta>1.-eps) reponse2=0;
1722     int face1=0,face2=0,face3=0,face4=0;
1723     if ((reponse1==1) && (reponse2==0))
1724     {
1725     if (dseta<eps) face1=1;
1726     if (eta<eps) face2=1;
1727     if (xsi<eps) face3=1;
1728     if (xsi+eta+dseta>1.-eps) face4=1;
1729     }
1730     return reponse1+2*reponse2+4*face1+8*face2+16*face3+32*face4;
1731     }
1732 francois 283
1733    
1734 francois 418
1735    
1736     int OPERATEUR::projeteestdansletriangle(double *xyz1,double *xyz2,double *xyz3,double x,double y, double z)
1737     {
1738     OT_VECTEUR_3D vec1(xyz1,xyz2);
1739     OT_VECTEUR_3D vec2(xyz1,xyz3);
1740     OT_VECTEUR_3D n=vec1&vec2;
1741     n.norme();
1742     double d=-(n.get_x()*xyz1[0]+n.get_y()*xyz1[1]+n.get_z()*xyz1[2]);
1743     double t=-(n.get_x()*x+n.get_y()*y+n.get_z()*z+d);
1744     double xx=x+t*n.get_x();
1745     double yy=y+t*n.get_y();
1746     double zz=z+t*n.get_z();
1747     return estdansletriangle(xyz1,xyz2,xyz3,xx,yy,zz);
1748     }
1749    
1750    
1751     int OPERATEUR::estdansletriangle(double *xyz1,double *xyz2,double *xyz3,double x,double y, double z)
1752     {
1753     OT_VECTEUR_3D vec1(xyz1,xyz2);
1754     OT_VECTEUR_3D vec2(xyz1,xyz3);
1755     OT_VECTEUR_3D vecb(x-xyz1[0],y-xyz1[1],z-xyz1[2]);
1756     OT_MATRICE_3D m(vec1,vec2,vecb);
1757     double det=m.get_determinant();
1758     double eps=1e-10*((vec1&vec2)*(vec1&vec2));
1759     if (fabs(det)>eps) return 0;
1760     double ab[3]={vec1.get_x(),vec1.get_y(),vec1.get_z()};
1761     double ac[3]={vec2.get_x(),vec2.get_y(),vec2.get_z()};
1762     double b[3]={vecb.get_x(),vecb.get_y(),vecb.get_z()};
1763     det=ab[0]*ac[1]-ab[1]*ac[0];
1764     int n1,n2;
1765     if (fabs(det)>eps)
1766     {
1767     n1=0;
1768     n2=1;
1769     }
1770     else
1771     {
1772     det=ab[0]*ac[2]-ab[2]*ac[0];
1773     if (fabs(det)>eps)
1774     {
1775     n1=0;
1776     n2=2;
1777     }
1778     else
1779     {
1780     det=ab[1]*ac[2]-ab[2]*ac[1];
1781     n1=1;
1782     n2=2;
1783     }
1784     }
1785     double xsi=(b[n1]*ac[n2]-b[n2]*ac[n1])/det;
1786     double eta=(ab[n1]*b[n2]-ab[n2]*b[n1])/det;
1787     int reponse1=1;
1788     int reponse2=1;
1789     eps=0.0000001;
1790     if (xsi<-eps) reponse1=0;
1791     if (eta<-eps) reponse1=0;
1792     if (xsi+eta>1.+eps) reponse1=0;
1793     if (xsi<eps) reponse2=0;
1794     if (eta<eps) reponse2=0;
1795     if (xsi+eta>1.-eps) reponse2=0;
1796     int arete1=0,arete2=0,arete3=0;
1797     if ((reponse1==1) && (reponse2==0))
1798     {
1799     if (eta<eps) arete1=1;
1800     if (xsi<eps) arete3=1;
1801     if (xsi+eta>1.-eps) arete2=1;
1802     }
1803     return reponse1+2*reponse2+4*arete1+8*arete2+16*arete3;
1804     }
1805    
1806    
1807    
1808    
1809     int OPERATEUR::compare_etat_tetra(int etat,int valeur)
1810     {
1811     int faceinte=etat&1;
1812     int inte=(etat&2)>>1;
1813     int face1=(etat&4)>>2;
1814     int face2=(etat&8)>>3;
1815     int face3=(etat&16)>>4;
1816     int face4=(etat&32)>>5;
1817     if ((faceinte==1) && (valeur==INTERIEUR)) return 1;
1818     if ((inte==1) && (valeur==INTERIEUR)) return 1;
1819     if (/*(face==0) && */(inte==1) && (valeur==STRICTINTERIEUR)) return 1;
1820     if ((faceinte==1) && (inte==0) && (valeur==SUR_FACE)) return 1;
1821     if ((face1==1) && (valeur==FACE1)) return 1;
1822     if ((face2==1) && (valeur==FACE2)) return 1;
1823     if ((face3==1) && (valeur==FACE3)) return 1;
1824     if ((face4==1) && (valeur==FACE4)) return 1;
1825     if ((face1==1) && (face2==1) && (valeur==ARETE1)) return 1;
1826     if ((face1==1) && (face3==1) && (valeur==ARETE2)) return 1;
1827     if ((face2==1) && (face3==1) && (valeur==ARETE3)) return 1;
1828     if ((face1==1) && (face4==1) && (valeur==ARETE4)) return 1;
1829     if ((face2==1) && (face4==1) && (valeur==ARETE5)) return 1;
1830     if ((face3==1) && (face4==1) && (valeur==ARETE6)) return 1;
1831     if ((face1==1) && (face2==1) && (face3==1) && (valeur==SOMMET1)) return 1;
1832     if ((face1==1) && (face2==1) && (face4==1) && (valeur==SOMMET2)) return 1;
1833     if ((face1==1) && (face3==1) && (face4==1) && (valeur==SOMMET3)) return 1;
1834     if ((face2==1) && (face3==1) && (face4==1) && (valeur==SOMMET4)) return 1;
1835     return 0;
1836     }
1837    
1838     int OPERATEUR::compare_etat_triangle(int etat,int valeur)
1839     {
1840     int areteinte=etat&1;
1841     int inte=(etat&2)>>1;
1842     int arete1=(etat&4)>>2;
1843     int arete2=(etat&8)>>3;
1844     int arete3=(etat&16)>>4;
1845     if ((areteinte==1) && (valeur==INTERIEUR)) return 1;
1846     if ((inte==1) && (valeur==INTERIEUR)) return 1;
1847     if ((inte==1) && (valeur==STRICTINTERIEUR)) return 1;
1848     if ((areteinte==1) && (inte==0) && (valeur==SUR_ARETE)) return 1;
1849     if ((arete1==1) && (valeur==ARETE1)) return 1;
1850     if ((arete2==1) && (valeur==ARETE2)) return 1;
1851     if ((arete3==1) && (valeur==ARETE3)) return 1;
1852     if ((arete1==1) && (arete2==1) && (valeur==SOMMET2)) return 1;
1853     if ((arete2==1) && (arete3==1) && (valeur==SOMMET3)) return 1;
1854     if ((arete3==1) && (arete1==1) && (valeur==SOMMET1)) return 1;
1855     return 0;
1856     }
1857    
1858 couturad 926 double OPERATEUR::taille_tetra(double* noeud1, double* noeud2, double* noeud3, double* noeud4)
1859     {
1860     OT_VECTEUR_3D ab(noeud1,noeud2);
1861     OT_VECTEUR_3D ac(noeud1,noeud3);
1862     OT_VECTEUR_3D cb(noeud3,noeud2);
1863     OT_VECTEUR_3D db(noeud4,noeud2);
1864     OT_VECTEUR_3D da(noeud4,noeud1);
1865     OT_VECTEUR_3D dc(noeud4,noeud3);
1866     double dab=ab.get_longueur();
1867     double dac=ac.get_longueur();
1868     double dcb=cb.get_longueur();
1869     double ddb=db.get_longueur();
1870     double dda=da.get_longueur();
1871     double ddc=dc.get_longueur();
1872 couturad 951 double dmax=std::max(dab,dac);
1873     dmax=std::max(dmax,dcb);
1874     dmax=std::max(dmax,ddb);
1875     dmax=std::max(dmax,dda);
1876     dmax=std::max(dmax,ddc);
1877 couturad 926 return dmax;
1878     }
1879 francois 418
1880 couturad 926 double OPERATEUR::taille_triangle(double* noeud1, double* noeud2, double* noeud3)
1881     {
1882     OT_VECTEUR_3D vec12(noeud1,noeud2);
1883     OT_VECTEUR_3D vec13(noeud1,noeud3);
1884     OT_VECTEUR_3D vec23(noeud2,noeud3);
1885     double d12=vec12.get_longueur();
1886     double d13=vec13.get_longueur();
1887     double d23=vec23.get_longueur();
1888 couturad 951 double dmax=std::max(d12,d13);
1889     dmax=std::max(dmax,d23);
1890 couturad 926 return dmax;
1891     }
1892    
1893    
1894 francois 283 template <int N> DOUBLEN<N>::DOUBLEN()
1895     {
1896     tab[0]=-1;
1897     }
1898    
1899     template <int N> DOUBLEN<N>::DOUBLEN(DOUBLEN& mdd)
1900     {
1901     for (int i=0;i<N;i++)
1902     tab[i]=mdd.tab[i];
1903     }
1904    
1905     template <int N> DOUBLEN<N>::DOUBLEN(double *v)
1906     {
1907     for (int i=0;i<N;i++)
1908     tab[i]=v[i];
1909     }
1910    
1911     template <int N> DOUBLEN<N>::~DOUBLEN()
1912     {
1913     }
1914    
1915     template <int N> double DOUBLEN<N>::get_valeur(int num)
1916     {
1917     return tab[num];
1918     }
1919    
1920     template <int N> void DOUBLEN<N>::change_valeur(int num,double val)
1921     {
1922     tab[num]=val;
1923     }
1924    
1925     template <int N> DOUBLEN<N> & DOUBLEN<N>::operator=(DOUBLEN<N> & mdd)
1926     {
1927     for (int i=0;i<N;i++)
1928     tab[i]=mdd.tab[i];
1929     return *this;
1930     }
1931    
1932     template <int N> DOUBLEN<N> & DOUBLEN<N>::operator=(const DOUBLEN<N> & mdd)
1933     {
1934     for (int i=0;i<N;i++)
1935     tab[i]=mdd.tab[i];
1936     return *this;
1937     }
1938    
1939    
1940     #ifdef BORLANDCPP
1941     // instanciation pour Windows (Borland c++)
1942     template class __export DOUBLEN<1>;
1943     template class __export DOUBLEN<4>;
1944     template class __export DOUBLEN<10>;
1945     #else
1946     #ifdef GCC
1947     // instanciation pour Unix (g++)
1948     template class DOUBLEN<1>;
1949     template class DOUBLEN<4>;
1950     template class DOUBLEN<10>;
1951     #else
1952     // instanciation pour Windows (Visual Studio)
1953     #endif
1954     #endif
1955    
1956