solveur/src/sl_vecteur.cpp

#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(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;
   for(int i=0; i<dim; i++)
   vect[i] = v.vect[i];
   }
   return (*this);
   }


   // Permet l'acc�s au �l�ments d'un vecteur
   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;
   }

   //Retourne la position de l'�l�ment directement superieur � x
   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;
   }
   }


   // Ici sont d�finies les operations �l�mentaires sur les vecteurs
   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;
   }
   // Fin des operations �l�mentaires sur les matrices
  
   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:	161
Committed:	Thu Sep 18 16:04:06 2008 UTC (16 years, 7 months ago) by souaissa
Original Path:	*magic/lib/solveur/solveur/src/sl_vecteur.cpp*
File size:	4935 byte(s)
Log Message:	mise a jour du solveur
#	User	Rev	Content
1	souaissa	161	#include "gestionversion.h"
2			//---------------------------------------------------------------------------
3
4			#include <assert.h>
5			#include <iostream.h>
6
7			#include "sl_vecteur.h"
8			# include <iomanip>
9
10			#pragma hdrstop
11
12
13			//---------------------------------------------------------------------------
14			#pragma package(smart_init)
15
16
17
18
19			vecteur::vecteur(int n){
20			dim = n;
21			vect = new double[dim];
22			for(int i=0;i<dim;i++) vect[i]=0.;
23
24			}
25
26
27			vecteur::vecteur(vecteur &v){
28			dim = v.dim;
29			vect = new double[dim];
30			for(int i=0; i<dim; i++)
31			vect[i] = v.vect[i];
32			}
33
34
35			vecteur::~vecteur(){
36			delete []vect;
37			}
38
39
40			vecteur & vecteur::operator =(const vecteur& v)
41			{
42			if(this==&v) return *this;
43			else {
44
45			delete [] this;
46			dim = v.dim;
47			for(int i=0; i<dim; i++)
48			vect[i] = v.vect[i];
49			}
50			return (*this);
51			}
52
53
54
55			// Permet l'acc�s au �l�ments d'un vecteur
56			double & vecteur::operator [] (int i) const{
57			assert(i<dim && i>=0);
58
59			return vect[i];
60			}
61
62			double vecteur::norme_12(int un_ou_deux)
63			{
64			double norme = 0.0;
65			switch (un_ou_deux)
66			{
67			case 1:
68			{
69			for(int i=0; i<dim; i++)
70			norme +=fabs( vect[i]);
71			}
72			case 2:
73			{
74
75			for(int i=0; i<dim; i++)
76			norme += vect[i]*vect[i];
77			}
78			}
79			return sqrt(norme);
80			}
81
82
83			int vecteur::getDim() const{
84			return dim;
85			}
86
87
88			void vecteur::setDim(int n)
89			{
90			dim = n;
91			}
92
93
94
95			int vecteur::position(double x)
96			{
97			for(int i=0; i<dim; i++)
98			if(vect[i] == x)
99			return i;
100
101			return -1;
102			}
103
104			//Retourne la position de l'�l�ment directement superieur � x
105			int vecteur::positionDuSuivant(double x)
106			{
107			this->trier();
108			if( x >= vect[0] && x <= vect[dim-1] ) //Si x est inclus dans le tableau
109			{
110			int i = 0;
111			while(x < vect[i])
112			i++;
113
114			return i;
115			}
116			else
117			return -1;
118			}
119
120
121			// Trie le vecteur
122			void vecteur::trier()
123			{
124			double temp;
125
126			for(int i=0; i < dim-1; i++)
127			for(int j=i+1; j < dim; j++)
128			if (vect[i] > vect[j])
129			{
130			temp = vect[i];
131			vect[i] = vect[j];
132			vect[j] = temp;
133			}
134			}
135
136
137			// Ici sont d�finies les operations �l�mentaires sur les vecteurs
138			vecteur operator+(const vecteur& U, const vecteur& V)
139			{
140			if(U.getDim() != V.getDim() )
141			throw ErreurVecteur(1);
142
143			int n = U.getDim();
144			vecteur tmp(n);
145
146			for (int i=0; i<n; i++)
147			tmp[i] = U[i] + V[i];
148
149			return tmp;
150			}
151
152			vecteur operator-(const vecteur& U, const vecteur& V)
153			{
154			if(U.getDim() != V.getDim() )
155			throw ErreurVecteur(1);
156
157			int n = U.getDim();
158			vecteur tmp(n);
159			for (int i=0; i<n; i++)
160			tmp[i] = U[i] - V[i];
161
162			return tmp;
163			}
164
165
166			double operator*(const vecteur& U, const vecteur& V)
167			{
168			if(U.getDim() != V.getDim() )
169			throw ErreurVecteur(1);
170
171			int n = U.getDim();
172			double tmp = 0.0;
173
174			for(int i=0; i<n; i++)
175			tmp += U[i] * V[i];
176
177			return tmp;
178			}
179
180			vecteur operator*(double nb , const vecteur& U )
181			{
182			int n = U.getDim();
183			vecteur tmp(n);
184
185			for (int i=0; i<n; i++)
186			tmp[i] = U[i] * nb;
187
188			return tmp;
189			}
190
191			vecteur operator*(const vecteur& U, double nb )
192			{
193			int n = U.getDim();
194			vecteur tmp(n);
195
196			for (int i=0; i<n; i++)
197			tmp[i] = U[i] * nb;
198
199			return tmp;
200			}
201
202			vecteur & vecteur::operator+=(const vecteur& U)
203			{
204			(this) = (this)+U;
205
206			return (*this);
207			}
208
209			vecteur & vecteur::operator-=(const vecteur& U)
210			{
211			(this) = (this)-U;
212
213			return (*this);
214			}
215
216
217
218			vecteur & vecteur::operator*=(double nb)
219			{
220			(this) = (this) * nb;
221
222			return (*this);
223			}
224
225			vecteur operator/(vecteur U, double nb)
226			{
227			if(nb == 0)
228			throw ErreurVecteur(2);
229
230			int n = U.getDim();
231			vecteur tmp = U;
232
233			for(int i=0; i<n; i++)
234			tmp[i] /= nb;
235
236			return tmp;
237			}
238			// Fin des operations �l�mentaires sur les matrices
239
240			ostream & operator<<(ostream& out, const vecteur& U)
241			{
242
243			out<<"["<<setw(11);
244			for(int i=0;i<U.dim;i++)
245			{
246			out<<setw(10)<<U[i]<<setw(10);
247			}
248			out<<"]"<<endl;
249			return out;
250
251			}
252
253
254
255
256
257
258
259			ErreurVecteur::ErreurVecteur(int i)
260			{
261			switch(i)
262			{
263			case 0 :
264			message = "DSL Vous avez depassez les bornes du vecteur !!!";
265			break;
266			case 1:
267			message = "DSL Vos vecteurs n'ont pas la meme dimension !!!";
268			break;
269			case 2:
270			message = "DSL Vous ne pouvez pas divizer le vecteur par zero !!!";
271			break;
272			}
273			}
274
275			ErreurVecteur::~ErreurVecteur()
276			{
277
278			}
279
280			char * ErreurVecteur::leMessage()
281			{
282			return message;
283			}
284
285
286			ostream & operator<<(ostream &out, ErreurVecteur erreur)
287			{
288			out << erreur.message<<endl;
289
290			return out;
291			}
292