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 ((*this<val) || (*this==val)) return 1;
    return 0;
    /*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 ((*this>val) || (*this==val)) return 1;
    return 0;
  /*    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:	551
Committed:	Fri Sep 26 19:32:11 2014 UTC (10 years, 7 months ago) by francois
File size:	6386 byte(s)
Log Message:	Preparation pour Mailleur3D apres une erreur
#	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	francois	551	if ((this<val) \|\| (this==val)) return 1;
67			return 0;
68			/*if (x+dx/2.<val.x+val.dx/2.)
69	francois	283	return 1;
70			else
71	francois	551	return 0;*/
72	francois	283	}
73
74			int double2::operator>(double2& val)
75			{
76			double a=x-dx/2.;
77			double b=val.x+val.dx/2.;
78			if (a>b)
79			return 1;
80			else
81			return 0;
82			}
83
84			int double2::operator>=(double2& val)
85			{
86	francois	551	if ((this>val) \|\| (this==val)) return 1;
87			return 0;
88			/* if (x-dx/2.>val.x-val.dx/2.)
89	francois	283	return 1;
90	francois	551	else return 0;*/
91
92	francois	283	}
93
94			double2 operator+(double2& val1,double2& val2)
95			{
96			double2 xx;
97			xx.x=val1.x+val2.x;
98			xx.dx=val1.dx+val2.dx;
99			return xx;
100			}
101
102			double2 operator+(const double2& val1,const 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
111			double2 operator-(double2& val1,double2& val2)
112			{
113			double2 xx;
114			xx.x=val1.x-val2.x;
115			xx.dx=val1.dx+val2.dx;
116			return xx;
117			}
118
119			double2 operator-(const double2& val1,const double2& val2)
120			{
121			double2 xx;
122			xx.x=val1.x-val2.x;
123			xx.dx=val1.dx+val2.dx;
124			return xx;
125			}
126
127
128			double2 operator*(double2& val1,double2& val2)
129			{
130			double2 xx;
131			xx.x=val1.x*val2.x;
132			xx.dx=fabs(val1.x)val2.dx+fabs(val2.x)val1.dx;
133			return xx;
134			}
135
136			double2 operator*(const double2& val1,const double2& val2)
137			{
138			double2 xx;
139			xx.x=val1.x*val2.x;
140			xx.dx=fabs(val1.x)val2.dx+fabs(val2.x)val1.dx;
141			return xx;
142			}
143
144
145			double2 operator/(double2& val1,double2& val2)
146			{
147			double2 xx;
148			xx.x=val1.x/val2.x;
149			xx.dx=fabs(1./val2.x)val1.dx+fabs(val1.x/val2.x/val2.x)val2.dx;
150			return xx;
151			}
152
153			double2 operator/(const double2& val1,const double2& val2)
154			{
155			double2 xx;
156			xx.x=val1.x/val2.x;
157			xx.dx=fabs(1./val2.x)val1.dx+fabs(val1.x/val2.x/val2.x)val2.dx;
158			return xx;
159			}
160
161
162			double2 operator^(double2& val1,double n)
163			{
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			double2 operator^(const double2& val1,const double n)
173			{
174			double2 xx;
175			xx.x=pow(val1.x,n);
176			if (val1.x)
177			xx.dx=npow(val1.x,n-1)val1.dx;
178			else xx.dx=val1.dx;
179			return xx;
180			}
181
182			std::ostream& operator <<(std::ostream& os,const double2& m)
183			{
184			os<<m.x<<setw(15);//<<m.dx;
185			return os;
186			}
187
188			double2 cos(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 cos(const double2& val)
198			{
199			double2 xx;
200			xx.x=cos(val.x);
201			xx.dx=fabs(sin(val.x))*val.dx;
202			return xx;
203			}
204
205
206			double2 acos(double2& val)
207			{
208			double2 xx;
209			double2 zero=0.;
210			double2 un=1. ;
211			xx.x=acos(val.x);
212
213			zero.dx=val.dx;
214			//if(val==un) return zero;
215			//if(val!=un)
216			xx.dx=fabs(-1./sqrt(1-val.xval.x))val.dx;
217			return xx;
218			}
219
220			double2 acos(const double2& val)
221			{
222			double2 xx;
223			double2 zero(0);
224			double2 un(1);
225
226			xx.x=acos(val.x);
227
228			zero.dx=val.dx;
229			//if(val==un) return zero;
230			//if(val!=un)
231			xx.dx=fabs(-1./sqrt(1-val.xval.x))val.dx;
232			return xx;
233			}
234
235
236			double2 sin(double2& val)
237			{
238			double2 xx;
239			xx.x=sin(val.x);
240			xx.dx=fabs(cos(val.x))*val.dx;
241			return xx;
242			}
243
244
245			double2 double2::get_fabs()
246			{
247			double2 zro=0.0;
248			double2 tmp=*this;
249			if (tmp.x<0) return zro-tmp;
250			else return tmp;
251			}
252
253			double2 f2abs(double2& val)
254			{
255			double2 xx;
256			xx.x=fabs(val.x);
257			xx.dx=val.dx;
258			return xx;
259			}
260
261			double2 f2abs(const double2& val)
262			{
263			double2 xx;
264			xx.x=fabs(val.x);
265			xx.dx=val.dx;
266			return xx;
267			}
268
269			double2 sin(const double2& val)
270			{
271			double2 xx;
272			xx.x=sin(val.x);
273			xx.dx=fabs(cos(val.x))*val.dx;
274			return xx;
275			}
276
277
278
279
280			double2 asin(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
289			double2 asin(const double2& val)
290			{
291			double2 xx;
292			xx.x=asin(val.x);
293			xx.dx=fabs(1./sqrt(1-val.xval.x))val.dx;
294			return xx;
295			}
296
297			double2 tan(double2& val)
298			{
299			double2 xx;
300			xx.x=tan(val.x);
301			xx.dx=fabs(1+tan(val.x)tan(val.x))val.dx;
302			return xx;
303			}
304
305			double2 tan(const double2& val)
306			{
307			double2 xx;
308			xx.x=tan(val.x);
309			xx.dx=fabs(1+tan(val.x)tan(val.x))val.dx;
310			return xx;
311			}
312
313			double2 atan(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			double2 atan(const double2& val)
323			{
324			double2 xx;
325			xx.x=atan(val.x);
326			xx.dx=fabs(1./(1+val.xval.x))val.dx;
327			return xx;
328			}
329
330
331			double2 sqrt(double2&val)
332			{
333	francois	550	double2 ZERO(0.);
334			if (val==ZERO) return ZERO;
335	francois	283	double2 xx;
336			xx.x=sqrt(val.x);
337			xx.dx=fabs(1./(2sqrt(val.x)))val.dx;
338			return xx;
339
340			}
341			double2 sqrt(const double2&val)
342			{
343	francois	550	double2 ZERO(0.);
344			if (val==ZERO) return ZERO;
345	francois	283	double2 xx;
346			xx.x=sqrt(val.x);
347			xx.dx=fabs(1./(2sqrt(val.x)))val.dx;
348			return xx;
349
350			}
351
352
353			double double2::get_x()
354			{
355			return x;
356			}
357
358
359			double double2::get_dx()
360			{
361			return dx;
362			}
363
364
365
366			void double2:: set_dx(double ddx)
367			{
368			dx=ddx;
369			}
370			void double2::set_x(double xx)
371			{
372			x=xx;
373			}
374
375
376			int operator==(const double2& val1,const double2& val2)
377			{
378			int rep=0;
379			if ((val1.x>=val2.x-val2.dx/2.) && (val1.x<=val2.x+val2.dx/2.) )
380			if ((val2.x>=val1.x-val1.dx/2.) && (val2.x<=val1.x+val1.dx/2.) )
381			rep=1;
382			else rep=0;
383			return rep;
384			}
385
386
387