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))
{
if (dx==0.0) dx=1e-12;
}
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)
{
int rep=0;
if ((val1.x>=val2.x-val2.dx/2.) && (val1.x<=val2.x+val2.dx/2.) )
if ((val2.x>=val1.x-val1.dx/2.) && (val2.x<=val1.x+val1.dx/2.) )
rep=1; else rep=0;
return rep;
}


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