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(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);
   }


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