outil/src/ot_doubleprecision.cpp

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