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