solveur/src/sl_vecteur.cpp

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       sl_vecteur.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:57 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "gestionversion.h"

   #include <assert.h>
   #include <iostream.h>

   #include "sl_vecteur.h"
# include <iomanip>

#pragma hdrstop


#pragma package(smart_init)


 vecteur::vecteur(int n){
   dim = n;
   vect = new double[dim];
   for(int i=0;i<dim;i++) vect[i]=0.;

  }

  vecteur::vecteur(double* v,int n)
  {
   dim = n;
   vect = new double[dim];
   for(int i=0;i<dim;i++) vect[i]=v[i];

  }
   vecteur::vecteur(vecteur &v){
   dim = v.dim;
   vect = new double[dim];
   for(int i=0; i<dim; i++)
   vect[i] = v.vect[i];
   }


   vecteur::~vecteur(){
   delete []vect;
   }
  

   vecteur & vecteur::operator =(const vecteur& v)
   {
   if(this==&v) return *this;
   else {
   
   delete  this;
   dim = v.dim;
   vect= new double[dim];

   for(int i=0; i<dim; i++)
   vect[i] = v.vect[i];
   }
   return (*this);
   }


   double & vecteur::operator [] (int i) const{
   assert(i<dim && i>=0);

   return vect[i];
   }


   double vecteur::norme_12(int un_ou_deux)
   {
    double norme = 0.0;
    switch (un_ou_deux)
     {
      case 1:
      {
      for(int i=0; i<dim; i++)
      norme +=fabs( vect[i]);
      }
      case 2:
      {

      for(int i=0; i<dim; i++)
      norme += vect[i]*vect[i];
      }
     }
   return sqrt(norme);
   }


   int vecteur::getDim() const{
   return dim;
   }
  

   void vecteur::setDim(int n)
   {
   dim = n;
   }
  
  
   int vecteur::position(double x)
   {
   for(int i=0; i<dim; i++)
   if(vect[i] == x)
   return i;
  
   return -1;
   }

   int vecteur::positionDuSuivant(double x)
   {
   this->trier();
   if( x >= vect[0] && x <= vect[dim-1] ) //Si x est inclus dans le tableau
   {
   int i = 0;
   while(x < vect[i])
   i++;
  
   return i;
   }
   else
   return -1;
   }
  
  
   // Trie le vecteur
   void vecteur::trier()
   {
   double temp;

   for(int i=0; i < dim-1; i++)
   for(int j=i+1; j < dim; j++)
   if (vect[i] > vect[j])
   {
   temp = vect[i];
   vect[i] = vect[j];
   vect[j] = temp;
   }
   }


   vecteur operator+(const vecteur& U, const vecteur& V)
   {
   if(U.getDim() != V.getDim() )
   throw ErreurVecteur(1);
  
   int n = U.getDim();
   vecteur tmp(n);
  
   for (int i=0; i<n; i++)
   tmp[i] = U[i] + V[i];
  
   return tmp;
   }
  
   vecteur operator-(const vecteur& U, const vecteur& V)
   {
   if(U.getDim() != V.getDim() )
   throw ErreurVecteur(1);

   int n = U.getDim();
   vecteur tmp(n);
   for (int i=0; i<n; i++)
   tmp[i] = U[i] - V[i];
  
   return tmp;
   }
  
  
   double operator*(const vecteur& U, const vecteur& V)
   {
   if(U.getDim() != V.getDim() )
   throw ErreurVecteur(1);
  
   int n = U.getDim();
   double tmp = 0.0;
  
   for(int i=0; i<n; i++)
   tmp += U[i] * V[i];
  
   return tmp;
   }
  
   vecteur operator*(double nb , const vecteur& U )
   {
   int n = U.getDim();
   vecteur tmp(n);
  
   for (int i=0; i<n; i++)
   tmp[i] = U[i] * nb;
  
   return tmp;
   }
  
   vecteur operator*(const vecteur& U, double nb )
   {
   int n = U.getDim();
   vecteur tmp(n);
  
   for (int i=0; i<n; i++)
   tmp[i] = U[i] * nb;
  
   return tmp;
   }
  
   vecteur & vecteur::operator+=(const vecteur& U)
   {
   (*this) = (*this)+U;
  
   return (*this);
   }
  
   vecteur & vecteur::operator-=(const vecteur& U)
   {
   (*this) = (*this)-U;

   return (*this);
   }
  
  
   vecteur & vecteur::operator*=(double nb)
   {
   (*this) = (*this) * nb;
  
   return (*this);
   }
  
   vecteur operator/(vecteur U, double nb)
   {
   if(nb == 0)
   throw ErreurVecteur(2);
  
   int n = U.getDim();
   vecteur tmp = U;
  
   for(int i=0; i<n; i++)
   tmp[i] /= nb;
  
   return tmp;
   }
  
   ostream & operator<<(ostream& out, const vecteur& U)
   {

   out<<"["<<setw(11);
   for(int i=0;i<U.dim;i++)
   {
   out<<setw(10)<<U[i]<<setw(10);
   }
   out<<"]"<<endl;
   return out;

   }


   ErreurVecteur::ErreurVecteur(int i)
   {
   switch(i)
   {
   case 0 :
   message = "DSL Vous avez depassez les bornes du vecteur !!!";
   break;
   case 1:
   message = "DSL Vos vecteurs n'ont pas la meme dimension !!!";
   break;
   case 2:
   message = "DSL Vous ne pouvez pas divizer le vecteur par zero !!!";
   break;
   }
   }

   ErreurVecteur::~ErreurVecteur()
   {

   }

   char * ErreurVecteur::leMessage()
   {
   return message;
   }


   ostream & operator<<(ostream &out, ErreurVecteur erreur)
   {
   out << erreur.message<<endl;

   return out;
   }

Revision:	1158
Committed:	Thu Jun 13 22:18:49 2024 UTC (11 months ago) by francois
File size:	5767 byte(s)
Log Message:	compatibilité Ubuntu 22.04 Suppression des refeences à Windows Ajout d'une banière
#	User	Rev	Content
1	francois	1158	//####//------------------------------------------------------------
2			//####//------------------------------------------------------------
3			//####// MAGiC
4			//####// Jean Christophe Cuilliere et Vincent FRANCOIS
5			//####// Departement de Genie Mecanique - UQTR
6			//####//------------------------------------------------------------
7			//####// MAGIC est un projet de recherche de l equipe ERICCA
8			//####// du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
9			//####// http://www.uqtr.ca/ericca
10			//####// http://www.uqtr.ca/
11			//####//------------------------------------------------------------
12			//####//------------------------------------------------------------
13			//####//
14			//####// sl_vecteur.cpp
15			//####//
16			//####//------------------------------------------------------------
17			//####//------------------------------------------------------------
18			//####// COPYRIGHT 2000-2024
19			//####// jeu 13 jun 2024 11:58:57 EDT
20			//####//------------------------------------------------------------
21			//####//------------------------------------------------------------
22	souaissa	161	#include "gestionversion.h"
23
24			#include <assert.h>
25			#include <iostream.h>
26
27			#include "sl_vecteur.h"
28			# include <iomanip>
29
30			#pragma hdrstop
31
32
33			#pragma package(smart_init)
34
35
36
37
38			vecteur::vecteur(int n){
39			dim = n;
40			vect = new double[dim];
41			for(int i=0;i<dim;i++) vect[i]=0.;
42
43			}
44
45	souaissa	166	vecteur::vecteur(double* v,int n)
46			{
47			dim = n;
48			vect = new double[dim];
49			for(int i=0;i<dim;i++) vect[i]=v[i];
50
51			}
52	souaissa	161	vecteur::vecteur(vecteur &v){
53			dim = v.dim;
54			vect = new double[dim];
55			for(int i=0; i<dim; i++)
56			vect[i] = v.vect[i];
57			}
58
59
60			vecteur::~vecteur(){
61			delete []vect;
62			}
63
64
65			vecteur & vecteur::operator =(const vecteur& v)
66			{
67			if(this==&v) return *this;
68			else {
69
70	souaissa	166	delete this;
71	souaissa	161	dim = v.dim;
72	souaissa	166	vect= new double[dim];
73
74	souaissa	161	for(int i=0; i<dim; i++)
75			vect[i] = v.vect[i];
76			}
77			return (*this);
78			}
79
80
81
82			double & vecteur::operator [] (int i) const{
83			assert(i<dim && i>=0);
84
85			return vect[i];
86			}
87	souaissa	166
88
89	souaissa	161	double vecteur::norme_12(int un_ou_deux)
90			{
91			double norme = 0.0;
92			switch (un_ou_deux)
93			{
94			case 1:
95			{
96			for(int i=0; i<dim; i++)
97			norme +=fabs( vect[i]);
98			}
99			case 2:
100			{
101
102			for(int i=0; i<dim; i++)
103			norme += vect[i]*vect[i];
104			}
105			}
106			return sqrt(norme);
107			}
108
109
110			int vecteur::getDim() const{
111			return dim;
112			}
113
114
115			void vecteur::setDim(int n)
116			{
117			dim = n;
118			}
119
120
121
122			int vecteur::position(double x)
123			{
124			for(int i=0; i<dim; i++)
125			if(vect[i] == x)
126			return i;
127
128			return -1;
129			}
130
131			int vecteur::positionDuSuivant(double x)
132			{
133			this->trier();
134			if( x >= vect[0] && x <= vect[dim-1] ) //Si x est inclus dans le tableau
135			{
136			int i = 0;
137			while(x < vect[i])
138			i++;
139
140			return i;
141			}
142			else
143			return -1;
144			}
145
146
147			// Trie le vecteur
148			void vecteur::trier()
149			{
150			double temp;
151
152			for(int i=0; i < dim-1; i++)
153			for(int j=i+1; j < dim; j++)
154			if (vect[i] > vect[j])
155			{
156			temp = vect[i];
157			vect[i] = vect[j];
158			vect[j] = temp;
159			}
160			}
161
162
163			vecteur operator+(const vecteur& U, const vecteur& V)
164			{
165			if(U.getDim() != V.getDim() )
166			throw ErreurVecteur(1);
167
168			int n = U.getDim();
169			vecteur tmp(n);
170
171			for (int i=0; i<n; i++)
172			tmp[i] = U[i] + V[i];
173
174			return tmp;
175			}
176
177			vecteur operator-(const vecteur& U, const vecteur& V)
178			{
179			if(U.getDim() != V.getDim() )
180			throw ErreurVecteur(1);
181
182			int n = U.getDim();
183			vecteur tmp(n);
184			for (int i=0; i<n; i++)
185			tmp[i] = U[i] - V[i];
186
187			return tmp;
188			}
189
190
191			double operator*(const vecteur& U, const vecteur& V)
192			{
193			if(U.getDim() != V.getDim() )
194			throw ErreurVecteur(1);
195
196			int n = U.getDim();
197			double tmp = 0.0;
198
199			for(int i=0; i<n; i++)
200			tmp += U[i] * V[i];
201
202			return tmp;
203			}
204
205			vecteur operator*(double nb , const vecteur& U )
206			{
207			int n = U.getDim();
208			vecteur tmp(n);
209
210			for (int i=0; i<n; i++)
211			tmp[i] = U[i] * nb;
212
213			return tmp;
214			}
215
216			vecteur operator*(const vecteur& U, double nb )
217			{
218			int n = U.getDim();
219			vecteur tmp(n);
220
221			for (int i=0; i<n; i++)
222			tmp[i] = U[i] * nb;
223
224			return tmp;
225			}
226
227			vecteur & vecteur::operator+=(const vecteur& U)
228			{
229			(this) = (this)+U;
230
231			return (*this);
232			}
233
234			vecteur & vecteur::operator-=(const vecteur& U)
235			{
236			(this) = (this)-U;
237
238			return (*this);
239			}
240
241
242
243			vecteur & vecteur::operator*=(double nb)
244			{
245			(this) = (this) * nb;
246
247			return (*this);
248			}
249
250			vecteur operator/(vecteur U, double nb)
251			{
252			if(nb == 0)
253			throw ErreurVecteur(2);
254
255			int n = U.getDim();
256			vecteur tmp = U;
257
258			for(int i=0; i<n; i++)
259			tmp[i] /= nb;
260
261			return tmp;
262			}
263
264			ostream & operator<<(ostream& out, const vecteur& U)
265			{
266
267			out<<"["<<setw(11);
268			for(int i=0;i<U.dim;i++)
269			{
270			out<<setw(10)<<U[i]<<setw(10);
271			}
272			out<<"]"<<endl;
273			return out;
274
275			}
276
277
278
279
280
281
282
283			ErreurVecteur::ErreurVecteur(int i)
284			{
285			switch(i)
286			{
287			case 0 :
288			message = "DSL Vous avez depassez les bornes du vecteur !!!";
289			break;
290			case 1:
291			message = "DSL Vos vecteurs n'ont pas la meme dimension !!!";
292			break;
293			case 2:
294			message = "DSL Vous ne pouvez pas divizer le vecteur par zero !!!";
295			break;
296			}
297			}
298
299			ErreurVecteur::~ErreurVecteur()
300			{
301
302			}
303
304			char * ErreurVecteur::leMessage()
305			{
306			return message;
307			}
308
309
310			ostream & operator<<(ostream &out, ErreurVecteur erreur)
311			{
312			out << erreur.message<<endl;
313
314			return out;
315			}
316