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-8)
{
}
double2::double2(double val):x(val),dx(1e-8*fabs(val))
{
if (dx==0.0) dx=1e-8;
}
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.x<0)  return zro-tmp;
else return tmp;
}

double2 f2abs(double2& val)
{
double2 xx;
xx.x=fabs(val.x);
xx.dx=val.dx;
return xx;
}

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

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:	253
Committed:	Tue Jul 13 19:40:46 2010 UTC (14 years, 10 months ago) by francois
File size:	5734 byte(s)
Log Message:	changement de hiearchie et utilisation de ccmake + mise a jour
#	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	francois	77	double2::double2():x(0.),dx(1e-8)
16	francois	17	{
17			}
18	francois	77	double2::double2(double val):x(val),dx(1e-8*fabs(val))
19	francois	17	{
20	francois	77	if (dx==0.0) dx=1e-8;
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	souaissa	75	if (tmp.x<0) return zro-tmp;
241	souaissa	69	else return tmp;
242	francois	17	}
243
244	francois	249	double2 f2abs(double2& val)
245			{
246			double2 xx;
247			xx.x=fabs(val.x);
248			xx.dx=val.dx;
249			return xx;
250			}
251	francois	17
252	francois	249	double2 f2abs(const double2& val)
253			{
254			double2 xx;
255			xx.x=fabs(val.x);
256			xx.dx=val.dx;
257			return xx;
258			}
259	francois	17
260			double2 sin(const double2& val)
261			{
262			double2 xx;
263			xx.x=sin(val.x);
264			xx.dx=fabs(cos(val.x))*val.dx;
265			return xx;
266			}
267
268
269
270
271			double2 asin(double2& val)
272			{
273			double2 xx;
274			xx.x=asin(val.x);
275			xx.dx=fabs(1./sqrt(1-val.xval.x))val.dx;
276			return xx;
277			}
278
279
280			double2 asin(const double2& val)
281			{
282			double2 xx;
283			xx.x=asin(val.x);
284			xx.dx=fabs(1./sqrt(1-val.xval.x))val.dx;
285			return xx;
286			}
287
288			double2 tan(double2& val)
289			{
290			double2 xx;
291			xx.x=tan(val.x);
292			xx.dx=fabs(1+tan(val.x)tan(val.x))val.dx;
293			return xx;
294			}
295
296			double2 tan(const double2& val)
297			{
298			double2 xx;
299			xx.x=tan(val.x);
300			xx.dx=fabs(1+tan(val.x)tan(val.x))val.dx;
301			return xx;
302			}
303
304			double2 atan(double2& val)
305			{
306			double2 xx;
307			xx.x=atan(val.x);
308			xx.dx=fabs(1./(1+val.xval.x))val.dx;
309			return xx;
310			}
311
312
313			double2 atan(const double2& val)
314			{
315			double2 xx;
316			xx.x=atan(val.x);
317			xx.dx=fabs(1./(1+val.xval.x))val.dx;
318			return xx;
319			}
320
321
322	souaissa	69	double2 sqrt(double2&val)
323			{
324			double2 xx;
325			xx.x=sqrt(val.x);
326			xx.dx=fabs(1./(2sqrt(val.x)))val.dx;
327			return xx;
328	francois	17
329	souaissa	69	}
330			double2 sqrt(const double2&val)
331			{
332			double2 xx;
333			xx.x=sqrt(val.x);
334			xx.dx=fabs(1./(2sqrt(val.x)))val.dx;
335			return xx;
336
337			}
338
339
340			double double2::get_x()
341	francois	17	{
342			return x;
343			}
344
345
346	souaissa	69	double double2::get_dx()
347			{
348			return dx;
349			}
350	francois	17
351
352
353	souaissa	69	void double2:: set_dx(double ddx)
354			{
355			dx=ddx;
356			}
357			void double2::set_x(double xx)
358			{
359			x=xx;
360			}
361	francois	17
362
363	souaissa	69	int operator==(const double2& val1,const double2& val2)
364			{
365	souaissa	70	int rep=0;
366			if ((val1.x>=val2.x-val2.dx/2.) && (val1.x<=val2.x+val2.dx/2.) )
367			if ((val2.x>=val1.x-val1.dx/2.) && (val2.x<=val1.x+val1.dx/2.) )
368			rep=1; else rep=0;
369			return rep;
370	souaissa	69	}
371	francois	17
372
373	souaissa	69