solveur/src/vecteur.cpp

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


#pragma hdrstop

#include "vecteur.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)
#include<assert.h>
#include <math.h>


void Vecteur::alloc(int rows)
{
        NbRows = rows;
        Data = new double[NbRows];
        assert(Data);
}

void Vecteur::free()
{
        if(Data) delete[] Data;
        Data=NULL;
}

void Vecteur::copy(const Vecteur& x)
{
        for(int i=0;i<NbRows;i++)
        {
                Data[i]=x.Data[i];
        }
}

 void Vecteur::fill(const double& a)
{
        for(int i=0;i<NbRows;i++)
        {
                Data[i]=a;
        }
}

 Vecteur::Vecteur()
{
        NbRows = 0;
        Data = NULL;
}

Vecteur::Get_size()const
{
return NbRows;
}

 void  Vecteur:: resize(int new_size)
{
if (Data==NULL)
  {
  NbRows=new_size;
  Data =new double[NbRows];
  }
else
{
 delete [] Data;
 NbRows=new_size;
 Data=new double[NbRows];
 }
}

 Vecteur::Vecteur(int rows)
{
        alloc(rows);
        fill(0.0);
}

 Vecteur::Vecteur(const double& val,int rows)
{
        alloc(rows);
        fill(val);
}

 Vecteur::~Vecteur()
{
        free();
}

 Vecteur::Vecteur(const Vecteur& x)
{
        alloc(x.NbRows);
        copy(x);
}

 int Vecteur::Get_Size()const
{
        return NbRows;
}

double& Vecteur::operator[](int i)
{
        return Data[i];
}

double& Vecteur::operator()(int i)
{
        return Data[i];
}

 const double& Vecteur::operator[](int i)const
{
        return Data[i];
}

 const double& Vecteur::operator()(int i)const
{
        return Data[i];
}

  Vecteur& Vecteur::operator=(const Vecteur& x)
{
        if(this==&x) return *this;
        if(NbRows!=x.NbRows)
        {
                free();
                alloc(x.NbRows);
        }
        copy(x);
        return *this;
}

  Vecteur& Vecteur::operator+=(const Vecteur& x)
{
        assert (NbRows==x.NbRows) ;

        for(int i=0;i<NbRows;i++)
        {
                Data[i]+=x.Data[i];
        }
        return *this;
}

  Vecteur& Vecteur::operator-=(const Vecteur& x)
{
        assert (NbRows== x.NbRows) ;

        for(int i=0;i<NbRows;i++)
        {
                Data[i]-=x.Data[i];
        }
        return *this;
}

  Vecteur& Vecteur::operator*=(const double& a)
{
        for(int i=0;i<NbRows;i++)
        {
                Data[i]*=a;
        }
        return *this;
}

  Vecteur& Vecteur::operator/=(const double& a)
{
        for(int i=0;i<NbRows;i++)
        {
                Data[i]/=a;
        }
        return *this;
}


Vecteur operator-(const Vecteur& x)
{
        Vecteur z(x.Get_Size());

        for(int i=0;i<x.Get_Size();i++)
        {
                z[i]=-x[i];
        }
        return z;
}


Vecteur operator+(const Vecteur& x, const Vecteur& y)
{
        assert (x.Get_size()== y.Get_size()) ;

        Vecteur z(x.NbRows);

        for(int i=0;i<x.NbRows;i++)
        {
                z.Data[i]=x.Data[i]+y.Data[i];
        }
        return z;
}

Vecteur operator-(const Vecteur& x, const Vecteur& y)
{
        assert (x.Get_size()== y.Get_size()) ;
        Vecteur z(x.NbRows);

        for(int i=0;i<x.NbRows;i++)
        {
                z.Data[i]=x.Data[i]-y.Data[i];
        }
        return z;
}

Vecteur operator*(const Vecteur& x, const double& a)
{
        Vecteur z(x.NbRows);

        for(int i=0;i<x.NbRows;i++)
        {
                z.Data[i]=x.Data[i]*a;
        }
        return z;
}

Vecteur operator*(const double& a, const Vecteur& x)
{
        Vecteur z(x.NbRows);

        for(int i=0;i<x.NbRows;i++)
        {
                z.Data[i]=x.Data[i]*a;
        }
        return z;
}

Vecteur operator/(const Vecteur& x, const double& a)
{
        Vecteur z(x.NbRows);

        for(int i=0;i<x.NbRows;i++)
        {
                z.Data[i]=x.Data[i]/a;
        }
        return z;
}

double operator*(const Vecteur& x, const Vecteur& y)
{
        double sum(0.0);
        for(int i=0;i<x.NbRows;i++)
        {
                sum+=x.Data[i]*y.Data[i];
        }
        return sum;
}


 void Vecteur:: affiche()
{
        cout << "[";
        for(int i=0; i<NbRows; ++i) {
                        cout << "[" << Data[i] << "]";
                if(NbRows-i-1) cout << "\n ";
        }
        cout << "]\n";


}


double Vecteur::Get_NormeUn()
{
double sum=(0);
 for(int i=0;i<NbRows;i++)
   {
   sum+=fabs(Data[i]);
   }
return sum;
}

double Vecteur::Get_NormeDeux()
{
double norm2=*this**this;
return  sqrt(norm2);
}

double Vecteur::norm_Scal()
{
double sum=0.;
for(int i=0;i<NbRows;i++)
{
sum=sum+fabs(Data[i]);
}
return sum;
}


Revision:	253
Committed:	Tue Jul 13 19:40:46 2010 UTC (14 years, 10 months ago) by francois
File size:	4131 byte(s)
Log Message:	changement de hiearchie et utilisation de ccmake + mise a jour
#	User	Rev	Content
1	souaissa	108	#include "gestionversion.h"
2			//---------------------------------------------------------------------------
3
4
5			#pragma hdrstop
6
7			#include "vecteur.h"
8
9			//---------------------------------------------------------------------------
10
11			#pragma package(smart_init)
12			#include<assert.h>
13			#include <math.h>
14
15
16
17
18			void Vecteur::alloc(int rows)
19			{
20			NbRows = rows;
21			Data = new double[NbRows];
22			assert(Data);
23			}
24
25			void Vecteur::free()
26			{
27			if(Data) delete[] Data;
28			Data=NULL;
29			}
30
31			void Vecteur::copy(const Vecteur& x)
32			{
33			for(int i=0;i<NbRows;i++)
34			{
35			Data[i]=x.Data[i];
36			}
37			}
38
39			void Vecteur::fill(const double& a)
40			{
41			for(int i=0;i<NbRows;i++)
42			{
43			Data[i]=a;
44			}
45			}
46
47			Vecteur::Vecteur()
48			{
49			NbRows = 0;
50			Data = NULL;
51			}
52
53			Vecteur::Get_size()const
54			{
55			return NbRows;
56			}
57
58			void Vecteur:: resize(int new_size)
59			{
60			if (Data==NULL)
61			{
62			NbRows=new_size;
63			Data =new double[NbRows];
64			}
65			else
66			{
67			delete [] Data;
68			NbRows=new_size;
69			Data=new double[NbRows];
70			}
71			}
72
73			Vecteur::Vecteur(int rows)
74			{
75			alloc(rows);
76			fill(0.0);
77			}
78
79			Vecteur::Vecteur(const double& val,int rows)
80			{
81			alloc(rows);
82			fill(val);
83			}
84
85			Vecteur::~Vecteur()
86			{
87			free();
88			}
89
90			Vecteur::Vecteur(const Vecteur& x)
91			{
92			alloc(x.NbRows);
93			copy(x);
94			}
95
96			int Vecteur::Get_Size()const
97			{
98			return NbRows;
99			}
100
101			double& Vecteur::operator[](int i)
102			{
103			return Data[i];
104			}
105
106			double& Vecteur::operator()(int i)
107			{
108			return Data[i];
109			}
110
111			const double& Vecteur::operator[](int i)const
112			{
113			return Data[i];
114			}
115
116			const double& Vecteur::operator()(int i)const
117			{
118			return Data[i];
119			}
120
121			Vecteur& Vecteur::operator=(const Vecteur& x)
122			{
123			if(this==&x) return *this;
124			if(NbRows!=x.NbRows)
125			{
126			free();
127			alloc(x.NbRows);
128			}
129			copy(x);
130			return *this;
131			}
132
133			Vecteur& Vecteur::operator+=(const Vecteur& x)
134			{
135			assert (NbRows==x.NbRows) ;
136
137			for(int i=0;i<NbRows;i++)
138			{
139			Data[i]+=x.Data[i];
140			}
141			return *this;
142			}
143
144			Vecteur& Vecteur::operator-=(const Vecteur& x)
145			{
146			assert (NbRows== x.NbRows) ;
147
148			for(int i=0;i<NbRows;i++)
149			{
150			Data[i]-=x.Data[i];
151			}
152			return *this;
153			}
154
155			Vecteur& Vecteur::operator*=(const double& a)
156			{
157			for(int i=0;i<NbRows;i++)
158			{
159			Data[i]*=a;
160			}
161			return *this;
162			}
163
164			Vecteur& Vecteur::operator/=(const double& a)
165			{
166			for(int i=0;i<NbRows;i++)
167			{
168			Data[i]/=a;
169			}
170			return *this;
171			}
172
173
174			Vecteur operator-(const Vecteur& x)
175			{
176			Vecteur z(x.Get_Size());
177
178			for(int i=0;i<x.Get_Size();i++)
179			{
180			z[i]=-x[i];
181			}
182			return z;
183			}
184
185
186
187			Vecteur operator+(const Vecteur& x, const Vecteur& y)
188			{
189			assert (x.Get_size()== y.Get_size()) ;
190
191			Vecteur z(x.NbRows);
192
193			for(int i=0;i<x.NbRows;i++)
194			{
195			z.Data[i]=x.Data[i]+y.Data[i];
196			}
197			return z;
198			}
199
200			Vecteur operator-(const Vecteur& x, const Vecteur& y)
201			{
202			assert (x.Get_size()== y.Get_size()) ;
203			Vecteur z(x.NbRows);
204
205			for(int i=0;i<x.NbRows;i++)
206			{
207			z.Data[i]=x.Data[i]-y.Data[i];
208			}
209			return z;
210			}
211
212			Vecteur operator*(const Vecteur& x, const double& a)
213			{
214			Vecteur z(x.NbRows);
215
216			for(int i=0;i<x.NbRows;i++)
217			{
218			z.Data[i]=x.Data[i]*a;
219			}
220			return z;
221			}
222
223			Vecteur operator*(const double& a, const Vecteur& x)
224			{
225			Vecteur z(x.NbRows);
226
227			for(int i=0;i<x.NbRows;i++)
228			{
229			z.Data[i]=x.Data[i]*a;
230			}
231			return z;
232			}
233
234			Vecteur operator/(const Vecteur& x, const double& a)
235			{
236			Vecteur z(x.NbRows);
237
238			for(int i=0;i<x.NbRows;i++)
239			{
240			z.Data[i]=x.Data[i]/a;
241			}
242			return z;
243			}
244
245			double operator*(const Vecteur& x, const Vecteur& y)
246			{
247			double sum(0.0);
248			for(int i=0;i<x.NbRows;i++)
249			{
250			sum+=x.Data[i]*y.Data[i];
251			}
252			return sum;
253			}
254
255
256			void Vecteur:: affiche()
257			{
258			cout << "[";
259			for(int i=0; i<NbRows; ++i) {
260			cout << "[" << Data[i] << "]";
261			if(NbRows-i-1) cout << "\n ";
262			}
263			cout << "]\n";
264
265
266			}
267
268
269
270			double Vecteur::Get_NormeUn()
271			{
272			double sum=(0);
273			for(int i=0;i<NbRows;i++)
274			{
275			sum+=fabs(Data[i]);
276			}
277			return sum;
278			}
279
280			double Vecteur::Get_NormeDeux()
281			{
282			double norm2=this*this;
283			return sqrt(norm2);
284			}
285
286			double Vecteur::norm_Scal()
287			{
288			double sum=0.;
289			for(int i=0;i<NbRows;i++)
290			{
291			sum=sum+fabs(Data[i]);
292			}
293			return sum;
294			}
295
296
297
298