outil/src/ot_doubleprecision.cpp

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

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


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

double double2::EPS_RELATIF=1e-8;

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