outil/src/ot_doubleprecision.cpp

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

#include <math.h>
#include <iomanip>
#include "ot_doubleprecision.h"


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


 #pragma package(smart_init)

double2::double2():x(0.),dx(1e-12)
{
}
double2::double2(double val):x(val),dx(1e-12*fabs(val))
{
}
double2::double2(double2 &mdd):x(mdd.x),dx(mdd.dx)
{
}
double2::double2(const double2& mdd):x(mdd.x),dx(mdd.dx)
{
}
double2::~double2()
{
}


double2& double2::operator=(const double2& val)
{
x=val.x;
dx=val.dx;
return *this;
}

int double2::operator==(double2& val)
{
int rep=0;
if ((val.x>=x-dx/2.) && (val.x<=x+dx/2.) )
if ((x>=val.x-val.dx/2.) && (x<=val.x+val.dx/2.) )
rep=1; else rep=0;
return rep;
}
int double2::operator!=(double2& val)
{
return !(*this==val);
}

int double2::operator<(double2& val)
{
if (x+dx/2.<val.x-val.dx/2.)
return 1;
else
return 0;
}

int double2::operator<=(double2& val)
{
if (x+dx/2.<val.x+val.dx/2.)
return 1;
else
return 0;
}

int double2::operator>(double2& val)
{
double a=x-dx/2.;
double b=val.x+val.dx/2.;
if (a>b)
return 1;
else
return 0;
}

int double2::operator>=(double2& val)
{
if (x-dx/2.>val.x-val.dx/2.)
return 1; else return 0;
}

double2 operator+(double2& val1,double2& val2)
{
double2 xx;
xx.x=val1.x+val2.x;
xx.dx=val1.dx+val2.dx;
return xx;
}

double2 operator+(const double2& val1,const double2& val2)
{
double2 xx;
xx.x=val1.x+val2.x;
xx.dx=val1.dx+val2.dx;
return xx;
}


double2 operator-(double2& val1,double2& val2)
{
double2 xx;
xx.x=val1.x-val2.x;
xx.dx=val1.dx+val2.dx;
return xx;
} 

double2 operator-(const double2& val1,const double2& val2)
{
double2 xx;
xx.x=val1.x-val2.x;
xx.dx=val1.dx+val2.dx;
return xx;
}


double2 operator*(double2& val1,double2& val2)
{
double2 xx;
xx.x=val1.x*val2.x;
xx.dx=fabs(val1.x)*val2.dx+fabs(val2.x)*val1.dx;
return xx;
}

double2 operator*(const double2& val1,const double2& val2)
{
double2 xx;
xx.x=val1.x*val2.x;
xx.dx=fabs(val1.x)*val2.dx+fabs(val2.x)*val1.dx;
return xx;
}


double2 operator/(double2& val1,double2& val2)
{
double2 xx;
xx.x=val1.x/val2.x;
xx.dx=fabs(1./val2.x)*val1.dx+fabs(val1.x/val2.x/val2.x)*val2.dx;
return xx;
}

double2 operator/(const double2& val1,const double2& val2)
{
double2 xx;
xx.x=val1.x/val2.x;
xx.dx=fabs(1./val2.x)*val1.dx+fabs(val1.x/val2.x/val2.x)*val2.dx;
return xx;
}


double2 operator^(double2& val1,double n)
{
double2 xx;
xx.x=pow(val1.x,n);
if(val1.x)
xx.dx=n*pow(val1.x,n-1)*val1.dx;
else xx.dx=val1.dx;
return xx;
}

double2 operator^(const double2& val1,const double n)
{
double2 xx;
xx.x=pow(val1.x,n);
if(val1.x)
xx.dx=n*pow(val1.x,n-1)*val1.dx;
else xx.dx=val1.dx;
return xx;
}

std::ostream& operator <<(std::ostream& os,const double2& m)
{
os<<m.x<<setw(15);//<<m.dx;
return os;
}

double2 cos(double2& val)
{
double2 xx;
xx.x=cos(val.x);
xx.dx=fabs(sin(val.x))*val.dx;
return xx;
}


double2 cos(const double2& val)
{
double2 xx;
xx.x=cos(val.x);
xx.dx=fabs(sin(val.x))*val.dx;
return xx;
}


double2 acos(double2& val)
{
double2 xx;
double2 zero=0.;
double2 un=1. ;
xx.x=acos(val.x);

zero.dx=val.dx;
//if(val==un) return zero;
//if(val!=un)
xx.dx=fabs(-1./sqrt(1-val.x*val.x))*val.dx;
return xx;
}

double2 acos(const double2& val)
{
double2 xx;
double2 zero(0);
double2 un(1);

xx.x=acos(val.x);

zero.dx=val.dx;
//if(val==un) return zero;
//if(val!=un)
xx.dx=fabs(-1./sqrt(1-val.x*val.x))*val.dx;
return xx;
}


double2 sin(double2& val)
{
double2 xx;
xx.x=sin(val.x);
xx.dx=fabs(cos(val.x))*val.dx;
return xx;
}


double2 double2::get_fabs()
{
double2 zro=0.0;
double2 tmp=*this;
if (tmp<zro)  return zro-tmp;
else return tmp;
}


double2 sin(const double2& val)
{
double2 xx;
xx.x=sin(val.x);
xx.dx=fabs(cos(val.x))*val.dx;
return xx;
}


double2 asin(double2& val)
{
double2 xx;
xx.x=asin(val.x);
xx.dx=fabs(1./sqrt(1-val.x*val.x))*val.dx;
return xx;
}


double2 asin(const double2& val)
{
double2 xx;
xx.x=asin(val.x);
xx.dx=fabs(1./sqrt(1-val.x*val.x))*val.dx;
return xx;
}

double2 tan(double2& val)
{
double2 xx;
xx.x=tan(val.x);
xx.dx=fabs(1+tan(val.x)*tan(val.x))*val.dx;
return xx;
}

double2 tan(const double2& val)
{
double2 xx;
xx.x=tan(val.x);
xx.dx=fabs(1+tan(val.x)*tan(val.x))*val.dx;
return xx;
}

double2 atan(double2& val)
{
double2 xx;
xx.x=atan(val.x);
xx.dx=fabs(1./(1+val.x*val.x))*val.dx;
return xx;
}


double2 atan(const double2& val)
{
double2 xx;
xx.x=atan(val.x);
xx.dx=fabs(1./(1+val.x*val.x))*val.dx;
return xx;
}


double2 sqrt(double2&val)
{
double2 xx;
xx.x=sqrt(val.x);
xx.dx=fabs(1./(2*sqrt(val.x)))*val.dx;
return xx;

}
double2 sqrt(const double2&val)
{
double2 xx;
xx.x=sqrt(val.x);
xx.dx=fabs(1./(2*sqrt(val.x)))*val.dx;
return xx;

}


double double2::get_x()
 {
  return x;
 }


double double2::get_dx()
{
 return dx;
}


void double2:: set_dx(double ddx)
{
dx=ddx;
}
void double2::set_x(double xx)
{
x=xx;
}


int operator==(const double2& val1,const double2& val2)
{
return val1==val2;
}


Revision:	69
Committed:	Thu Mar 27 13:20:26 2008 UTC (17 years, 1 month ago) by souaissa
Original Path:	*magic/lib/outil/outil/src/ot_doubleprecision.cpp*
File size:	5362 byte(s)
Log Message:	Mise à jour des classes de la vectorisation et des calsses: ot_mathematique,ot_tenseur,ot_doubleprecision dans outil
#	User	Rev	Content
1	francois	17	#include "gestionversion.h"
2			//---------------------------------------------------------------------------
3			#pragma hdrstop
4
5			#include <math.h>
6	francois	26	#include <iomanip>
7	francois	17	#include "ot_doubleprecision.h"
8
9	francois	26
10	francois	17	//---------------------------------------------------------------------------
11
12
13			#pragma package(smart_init)
14
15			double2::double2():x(0.),dx(1e-12)
16			{
17			}
18			double2::double2(double val):x(val),dx(1e-12*fabs(val))
19			{
20			}
21			double2::double2(double2 &mdd):x(mdd.x),dx(mdd.dx)
22			{
23			}
24			double2::double2(const double2& mdd):x(mdd.x),dx(mdd.dx)
25			{
26			}
27			double2::~double2()
28			{
29			}
30
31
32			double2& double2::operator=(const double2& val)
33			{
34			x=val.x;
35			dx=val.dx;
36			return *this;
37			}
38
39			int double2::operator==(double2& val)
40			{
41			int rep=0;
42			if ((val.x>=x-dx/2.) && (val.x<=x+dx/2.) )
43			if ((x>=val.x-val.dx/2.) && (x<=val.x+val.dx/2.) )
44			rep=1; else rep=0;
45			return rep;
46			}
47	souaissa	58	int double2::operator!=(double2& val)
48			{
49			return !(*this==val);
50			}
51	francois	17
52			int double2::operator<(double2& val)
53			{
54			if (x+dx/2.<val.x-val.dx/2.)
55			return 1;
56			else
57			return 0;
58			}
59
60			int double2::operator<=(double2& val)
61			{
62			if (x+dx/2.<val.x+val.dx/2.)
63			return 1;
64			else
65			return 0;
66			}
67
68			int double2::operator>(double2& val)
69			{
70			double a=x-dx/2.;
71			double b=val.x+val.dx/2.;
72			if (a>b)
73			return 1;
74			else
75			return 0;
76			}
77
78			int double2::operator>=(double2& val)
79			{
80			if (x-dx/2.>val.x-val.dx/2.)
81			return 1; else return 0;
82			}
83
84			double2 operator+(double2& val1,double2& val2)
85			{
86			double2 xx;
87			xx.x=val1.x+val2.x;
88			xx.dx=val1.dx+val2.dx;
89			return xx;
90			}
91
92			double2 operator+(const double2& val1,const double2& val2)
93			{
94			double2 xx;
95			xx.x=val1.x+val2.x;
96			xx.dx=val1.dx+val2.dx;
97			return xx;
98			}
99
100
101			double2 operator-(double2& val1,double2& val2)
102			{
103			double2 xx;
104			xx.x=val1.x-val2.x;
105			xx.dx=val1.dx+val2.dx;
106			return xx;
107			}
108
109			double2 operator-(const double2& val1,const double2& val2)
110			{
111			double2 xx;
112			xx.x=val1.x-val2.x;
113			xx.dx=val1.dx+val2.dx;
114			return xx;
115			}
116
117
118			double2 operator*(double2& val1,double2& val2)
119			{
120			double2 xx;
121			xx.x=val1.x*val2.x;
122			xx.dx=fabs(val1.x)val2.dx+fabs(val2.x)val1.dx;
123			return xx;
124			}
125
126			double2 operator*(const double2& val1,const double2& val2)
127			{
128			double2 xx;
129			xx.x=val1.x*val2.x;
130			xx.dx=fabs(val1.x)val2.dx+fabs(val2.x)val1.dx;
131			return xx;
132			}
133
134
135			double2 operator/(double2& val1,double2& val2)
136			{
137			double2 xx;
138			xx.x=val1.x/val2.x;
139			xx.dx=fabs(1./val2.x)val1.dx+fabs(val1.x/val2.x/val2.x)val2.dx;
140			return xx;
141			}
142
143			double2 operator/(const double2& val1,const double2& val2)
144			{
145			double2 xx;
146			xx.x=val1.x/val2.x;
147			xx.dx=fabs(1./val2.x)val1.dx+fabs(val1.x/val2.x/val2.x)val2.dx;
148			return xx;
149			}
150
151
152	francois	26	double2 operator^(double2& val1,double n)
153	francois	17	{
154			double2 xx;
155			xx.x=pow(val1.x,n);
156			if(val1.x)
157			xx.dx=npow(val1.x,n-1)val1.dx;
158			else xx.dx=val1.dx;
159			return xx;
160			}
161
162	francois	26	double2 operator^(const double2& val1,const double n)
163	francois	17	{
164			double2 xx;
165			xx.x=pow(val1.x,n);
166			if(val1.x)
167			xx.dx=npow(val1.x,n-1)val1.dx;
168			else xx.dx=val1.dx;
169			return xx;
170			}
171
172			std::ostream& operator <<(std::ostream& os,const double2& m)
173			{
174	souaissa	58	os<<m.x<<setw(15);//<<m.dx;
175	francois	17	return os;
176			}
177
178			double2 cos(double2& val)
179			{
180			double2 xx;
181			xx.x=cos(val.x);
182			xx.dx=fabs(sin(val.x))*val.dx;
183			return xx;
184			}
185
186
187			double2 cos(const double2& val)
188			{
189			double2 xx;
190			xx.x=cos(val.x);
191			xx.dx=fabs(sin(val.x))*val.dx;
192			return xx;
193			}
194
195
196			double2 acos(double2& val)
197			{
198			double2 xx;
199	souaissa	58	double2 zero=0.;
200			double2 un=1. ;
201	francois	17	xx.x=acos(val.x);
202	souaissa	58
203			zero.dx=val.dx;
204			//if(val==un) return zero;
205			//if(val!=un)
206	francois	17	xx.dx=fabs(-1./sqrt(1-val.xval.x))val.dx;
207			return xx;
208			}
209
210			double2 acos(const double2& val)
211			{
212			double2 xx;
213	souaissa	58	double2 zero(0);
214			double2 un(1);
215
216	francois	17	xx.x=acos(val.x);
217	souaissa	58
218			zero.dx=val.dx;
219			//if(val==un) return zero;
220			//if(val!=un)
221	francois	17	xx.dx=fabs(-1./sqrt(1-val.xval.x))val.dx;
222			return xx;
223			}
224
225
226			double2 sin(double2& val)
227			{
228			double2 xx;
229			xx.x=sin(val.x);
230			xx.dx=fabs(cos(val.x))*val.dx;
231			return xx;
232			}
233
234
235	souaissa	69	double2 double2::get_fabs()
236	francois	17	{
237	souaissa	69	double2 zro=0.0;
238			double2 tmp=*this;
239			if (tmp<zro) return zro-tmp;
240			else return tmp;
241	francois	17	}
242
243
244
245			double2 sin(const double2& val)
246			{
247			double2 xx;
248			xx.x=sin(val.x);
249			xx.dx=fabs(cos(val.x))*val.dx;
250			return xx;
251			}
252
253
254
255
256			double2 asin(double2& val)
257			{
258			double2 xx;
259			xx.x=asin(val.x);
260			xx.dx=fabs(1./sqrt(1-val.xval.x))val.dx;
261			return xx;
262			}
263
264
265			double2 asin(const double2& val)
266			{
267			double2 xx;
268			xx.x=asin(val.x);
269			xx.dx=fabs(1./sqrt(1-val.xval.x))val.dx;
270			return xx;
271			}
272
273			double2 tan(double2& val)
274			{
275			double2 xx;
276			xx.x=tan(val.x);
277			xx.dx=fabs(1+tan(val.x)tan(val.x))val.dx;
278			return xx;
279			}
280
281			double2 tan(const double2& val)
282			{
283			double2 xx;
284			xx.x=tan(val.x);
285			xx.dx=fabs(1+tan(val.x)tan(val.x))val.dx;
286			return xx;
287			}
288
289			double2 atan(double2& val)
290			{
291			double2 xx;
292			xx.x=atan(val.x);
293			xx.dx=fabs(1./(1+val.xval.x))val.dx;
294			return xx;
295			}
296
297
298			double2 atan(const double2& val)
299			{
300			double2 xx;
301			xx.x=atan(val.x);
302			xx.dx=fabs(1./(1+val.xval.x))val.dx;
303			return xx;
304			}
305
306
307	souaissa	69	double2 sqrt(double2&val)
308			{
309			double2 xx;
310			xx.x=sqrt(val.x);
311			xx.dx=fabs(1./(2sqrt(val.x)))val.dx;
312			return xx;
313	francois	17
314	souaissa	69	}
315			double2 sqrt(const double2&val)
316			{
317			double2 xx;
318			xx.x=sqrt(val.x);
319			xx.dx=fabs(1./(2sqrt(val.x)))val.dx;
320			return xx;
321
322			}
323
324
325			double double2::get_x()
326	francois	17	{
327			return x;
328			}
329
330
331	souaissa	69	double double2::get_dx()
332			{
333			return dx;
334			}
335	francois	17
336
337
338	souaissa	69	void double2:: set_dx(double ddx)
339			{
340			dx=ddx;
341			}
342			void double2::set_x(double xx)
343			{
344			x=xx;
345			}
346	francois	17
347
348	souaissa	69	int operator==(const double2& val1,const double2& val2)
349			{
350			return val1==val2;
351			}
352	francois	17
353
354	souaissa	69