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