| 1 |
|
| 2 |
/* |
| 3 |
* Code and supporting documentation (c) Copyright 1990 1991 Tektronix, Inc. |
| 4 |
* All Rights Reserved |
| 5 |
* |
| 6 |
* This file is a component of an X Window System-specific implementation |
| 7 |
* of Xcms based on the TekColor Color Management System. Permission is |
| 8 |
* hereby granted to use, copy, modify, sell, and otherwise distribute this |
| 9 |
* software and its documentation for any purpose and without fee, provided |
| 10 |
* that this copyright, permission, and disclaimer notice is reproduced in |
| 11 |
* all copies of this software and in supporting documentation. TekColor |
| 12 |
* is a trademark of Tektronix, Inc. |
| 13 |
* |
| 14 |
* Tektronix makes no representation about the suitability of this software |
| 15 |
* for any purpose. It is provided "as is" and with all faults. |
| 16 |
* |
| 17 |
* TEKTRONIX DISCLAIMS ALL WARRANTIES APPLICABLE TO THIS SOFTWARE, |
| 18 |
* INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A |
| 19 |
* PARTICULAR PURPOSE. IN NO EVENT SHALL TEKTRONIX BE LIABLE FOR ANY |
| 20 |
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER |
| 21 |
* RESULTING FROM LOSS OF USE, DATA, OR PROFITS, WHETHER IN AN ACTION OF |
| 22 |
* CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| 23 |
* CONNECTION WITH THE USE OR THE PERFORMANCE OF THIS SOFTWARE. |
| 24 |
*/ |
| 25 |
|
| 26 |
/* |
| 27 |
* It should be pointed out that for simplicity's sake, the |
| 28 |
* environment parameters are defined as floating point constants, |
| 29 |
* rather than octal or hexadecimal initializations of allocated |
| 30 |
* storage areas. This means that the range of allowed numbers |
| 31 |
* may not exactly match the hardware's capabilities. For example, |
| 32 |
* if the maximum positive double precision floating point number |
| 33 |
* is EXACTLY 1.11...E100 and the constant "MAXDOUBLE is |
| 34 |
* defined to be 1.11E100 then the numbers between 1.11E100 and |
| 35 |
* 1.11...E100 are considered to be undefined. For most |
| 36 |
* applications, this will cause no problems. |
| 37 |
* |
| 38 |
* An alternate method is to allocate a global static "double" variable, |
| 39 |
* say "maxdouble", and use a union declaration and initialization |
| 40 |
* to initialize it with the proper bits for the EXACT maximum value. |
| 41 |
* This was not done because the only compilers available to the |
| 42 |
* author did not fully support union initialization features. |
| 43 |
* |
| 44 |
*/ |
| 45 |
|
| 46 |
#ifdef HAVE_CONFIG_H |
| 47 |
#include <config.h> |
| 48 |
#endif |
| 49 |
#include "Xcmsint.h" |
| 50 |
|
| 51 |
/* forward/static */ |
| 52 |
static double _XcmsModulo(double value, double base); |
| 53 |
static double _XcmsPolynomial( |
| 54 |
register int order, |
| 55 |
double const *coeffs, |
| 56 |
double x); |
| 57 |
static double |
| 58 |
_XcmsModuloF( |
| 59 |
double val, |
| 60 |
register double *dp); |
| 61 |
|
| 62 |
/* |
| 63 |
* DEFINES |
| 64 |
*/ |
| 65 |
#define XCMS_MAXERROR 0.000001 |
| 66 |
#define XCMS_MAXITER 10000 |
| 67 |
#define XCMS_PI 3.14159265358979323846264338327950 |
| 68 |
#define XCMS_TWOPI 6.28318530717958620 |
| 69 |
#define XCMS_HALFPI 1.57079632679489660 |
| 70 |
#define XCMS_FOURTHPI 0.785398163397448280 |
| 71 |
#define XCMS_SIXTHPI 0.523598775598298820 |
| 72 |
#define XCMS_RADIANS(d) ((d) * XCMS_PI / 180.0) |
| 73 |
#define XCMS_DEGREES(r) ((r) * 180.0 / XCMS_PI) |
| 74 |
#define XCMS_X6_UNDERFLOWS (4.209340e-52) /* X**6 almost underflows */ |
| 75 |
#define XCMS_X16_UNDERFLOWS (5.421010e-20) /* X**16 almost underflows*/ |
| 76 |
#define XCMS_CHAR_BIT 8 |
| 77 |
#define XCMS_LONG_MAX 0x7FFFFFFF |
| 78 |
#define XCMS_DEXPLEN 11 |
| 79 |
#define XCMS_NBITS(type) (XCMS_CHAR_BIT * (int)sizeof(type)) |
| 80 |
#define XCMS_FABS(x) ((x) < 0.0 ? -(x) : (x)) |
| 81 |
|
| 82 |
/* XCMS_DMAXPOWTWO - largest power of two exactly representable as a double */ |
| 83 |
#define XCMS_DMAXPOWTWO ((double)(XCMS_LONG_MAX) * \ |
| 84 |
(1L << ((XCMS_NBITS(double)-XCMS_DEXPLEN) - XCMS_NBITS(int) + 1))) |
| 85 |
|
| 86 |
/* |
| 87 |
* LOCAL VARIABLES |
| 88 |
*/ |
| 89 |
|
| 90 |
static double const cos_pcoeffs[] = { |
| 91 |
0.12905394659037374438e7, |
| 92 |
-0.37456703915723204710e6, |
| 93 |
0.13432300986539084285e5, |
| 94 |
-0.11231450823340933092e3 |
| 95 |
}; |
| 96 |
|
| 97 |
static double const cos_qcoeffs[] = { |
| 98 |
0.12905394659037373590e7, |
| 99 |
0.23467773107245835052e5, |
| 100 |
0.20969518196726306286e3, |
| 101 |
1.0 |
| 102 |
}; |
| 103 |
|
| 104 |
static double const sin_pcoeffs[] = { |
| 105 |
0.20664343336995858240e7, |
| 106 |
-0.18160398797407332550e6, |
| 107 |
0.35999306949636188317e4, |
| 108 |
-0.20107483294588615719e2 |
| 109 |
}; |
| 110 |
|
| 111 |
static double const sin_qcoeffs[] = { |
| 112 |
0.26310659102647698963e7, |
| 113 |
0.39270242774649000308e5, |
| 114 |
0.27811919481083844087e3, |
| 115 |
1.0 |
| 116 |
}; |
| 117 |
|
| 118 |
/* |
| 119 |
* |
| 120 |
* FUNCTION |
| 121 |
* |
| 122 |
* _XcmsCosine double precision cosine |
| 123 |
* |
| 124 |
* KEY WORDS |
| 125 |
* |
| 126 |
* cos |
| 127 |
* machine independent routines |
| 128 |
* trigonometric functions |
| 129 |
* math libraries |
| 130 |
* |
| 131 |
* DESCRIPTION |
| 132 |
* |
| 133 |
* Returns double precision cosine of double precision |
| 134 |
* floating point argument. |
| 135 |
* |
| 136 |
* USAGE |
| 137 |
* |
| 138 |
* double _XcmsCosine (x) |
| 139 |
* double x; |
| 140 |
* |
| 141 |
* REFERENCES |
| 142 |
* |
| 143 |
* Computer Approximations, J.F. Hart et al, John Wiley & Sons, |
| 144 |
* 1968, pp. 112-120. |
| 145 |
* |
| 146 |
* RESTRICTIONS |
| 147 |
* |
| 148 |
* The sin and cos routines are interactive in the sense that |
| 149 |
* in the process of reducing the argument to the range -PI/4 |
| 150 |
* to PI/4, each may call the other. Ultimately one or the |
| 151 |
* other uses a polynomial approximation on the reduced |
| 152 |
* argument. The sin approximation has a maximum relative error |
| 153 |
* of 10**(-17.59) and the cos approximation has a maximum |
| 154 |
* relative error of 10**(-16.18). |
| 155 |
* |
| 156 |
* These error bounds assume exact arithmetic |
| 157 |
* in the polynomial evaluation. Additional rounding and |
| 158 |
* truncation errors may occur as the argument is reduced |
| 159 |
* to the range over which the polynomial approximation |
| 160 |
* is valid, and as the polynomial is evaluated using |
| 161 |
* finite-precision arithmetic. |
| 162 |
* |
| 163 |
* PROGRAMMER |
| 164 |
* |
| 165 |
* Fred Fish |
| 166 |
* |
| 167 |
* INTERNALS |
| 168 |
* |
| 169 |
* Computes cos(x) from: |
| 170 |
* |
| 171 |
* (1) Reduce argument x to range -PI to PI. |
| 172 |
* |
| 173 |
* (2) If x > PI/2 then call cos recursively |
| 174 |
* using relation cos(x) = -cos(x - PI). |
| 175 |
* |
| 176 |
* (3) If x < -PI/2 then call cos recursively |
| 177 |
* using relation cos(x) = -cos(x + PI). |
| 178 |
* |
| 179 |
* (4) If x > PI/4 then call sin using |
| 180 |
* relation cos(x) = sin(PI/2 - x). |
| 181 |
* |
| 182 |
* (5) If x < -PI/4 then call cos using |
| 183 |
* relation cos(x) = sin(PI/2 + x). |
| 184 |
* |
| 185 |
* (6) If x would cause underflow in approx |
| 186 |
* evaluation arithmetic then return |
| 187 |
* sqrt(1.0 - x**2). |
| 188 |
* |
| 189 |
* (7) By now x has been reduced to range |
| 190 |
* -PI/4 to PI/4 and the approximation |
| 191 |
* from HART pg. 119 can be used: |
| 192 |
* |
| 193 |
* cos(x) = ( p(y) / q(y) ) |
| 194 |
* Where: |
| 195 |
* |
| 196 |
* y = x * (4/PI) |
| 197 |
* |
| 198 |
* p(y) = SUM [ Pj * (y**(2*j)) ] |
| 199 |
* over j = {0,1,2,3} |
| 200 |
* |
| 201 |
* q(y) = SUM [ Qj * (y**(2*j)) ] |
| 202 |
* over j = {0,1,2,3} |
| 203 |
* |
| 204 |
* P0 = 0.12905394659037374438571854e+7 |
| 205 |
* P1 = -0.3745670391572320471032359e+6 |
| 206 |
* P2 = 0.134323009865390842853673e+5 |
| 207 |
* P3 = -0.112314508233409330923e+3 |
| 208 |
* Q0 = 0.12905394659037373590295914e+7 |
| 209 |
* Q1 = 0.234677731072458350524124e+5 |
| 210 |
* Q2 = 0.2096951819672630628621e+3 |
| 211 |
* Q3 = 1.0000... |
| 212 |
* (coefficients from HART table #3843 pg 244) |
| 213 |
* |
| 214 |
* |
| 215 |
* **** NOTE **** The range reduction relations used in |
| 216 |
* this routine depend on the final approximation being valid |
| 217 |
* over the negative argument range in addition to the positive |
| 218 |
* argument range. The particular approximation chosen from |
| 219 |
* HART satisfies this requirement, although not explicitly |
| 220 |
* stated in the text. This may not be true of other |
| 221 |
* approximations given in the reference. |
| 222 |
* |
| 223 |
*/ |
| 224 |
|
| 225 |
double _XcmsCosine(double x) |
| 226 |
{ |
| 227 |
auto double y; |
| 228 |
auto double yt2; |
| 229 |
double retval; |
| 230 |
|
| 231 |
if (x < -XCMS_PI || x > XCMS_PI) { |
| 232 |
x = _XcmsModulo (x, XCMS_TWOPI); |
| 233 |
if (x > XCMS_PI) { |
| 234 |
x = x - XCMS_TWOPI; |
| 235 |
} else if (x < -XCMS_PI) { |
| 236 |
x = x + XCMS_TWOPI; |
| 237 |
} |
| 238 |
} |
| 239 |
if (x > XCMS_HALFPI) { |
| 240 |
retval = -(_XcmsCosine (x - XCMS_PI)); |
| 241 |
} else if (x < -XCMS_HALFPI) { |
| 242 |
retval = -(_XcmsCosine (x + XCMS_PI)); |
| 243 |
} else if (x > XCMS_FOURTHPI) { |
| 244 |
retval = _XcmsSine (XCMS_HALFPI - x); |
| 245 |
} else if (x < -XCMS_FOURTHPI) { |
| 246 |
retval = _XcmsSine (XCMS_HALFPI + x); |
| 247 |
} else if (x < XCMS_X6_UNDERFLOWS && x > -XCMS_X6_UNDERFLOWS) { |
| 248 |
retval = _XcmsSquareRoot (1.0 - (x * x)); |
| 249 |
} else { |
| 250 |
y = x / XCMS_FOURTHPI; |
| 251 |
yt2 = y * y; |
| 252 |
retval = _XcmsPolynomial (3, cos_pcoeffs, yt2) / _XcmsPolynomial (3, cos_qcoeffs, yt2); |
| 253 |
} |
| 254 |
return (retval); |
| 255 |
} |
| 256 |
|
| 257 |
|
| 258 |
/* |
| 259 |
* FUNCTION |
| 260 |
* |
| 261 |
* _XcmsModulo double precision modulo |
| 262 |
* |
| 263 |
* KEY WORDS |
| 264 |
* |
| 265 |
* _XcmsModulo |
| 266 |
* machine independent routines |
| 267 |
* math libraries |
| 268 |
* |
| 269 |
* DESCRIPTION |
| 270 |
* |
| 271 |
* Returns double precision modulo of two double |
| 272 |
* precision arguments. |
| 273 |
* |
| 274 |
* USAGE |
| 275 |
* |
| 276 |
* double _XcmsModulo (value, base) |
| 277 |
* double value; |
| 278 |
* double base; |
| 279 |
* |
| 280 |
* PROGRAMMER |
| 281 |
* |
| 282 |
* Fred Fish |
| 283 |
* |
| 284 |
*/ |
| 285 |
static double _XcmsModulo(double value, double base) |
| 286 |
{ |
| 287 |
auto double intpart; |
| 288 |
|
| 289 |
value /= base; |
| 290 |
value = _XcmsModuloF (value, &intpart); |
| 291 |
value *= base; |
| 292 |
return(value); |
| 293 |
} |
| 294 |
|
| 295 |
|
| 296 |
/* |
| 297 |
* frac = (double) _XcmsModuloF(double val, double *dp) |
| 298 |
* return fractional part of 'val' |
| 299 |
* set *dp to integer part of 'val' |
| 300 |
* |
| 301 |
* Note -> only compiled for the CA or KA. For the KB/MC, |
| 302 |
* "math.c" instantiates a copy of the inline function |
| 303 |
* defined in "math.h". |
| 304 |
*/ |
| 305 |
static double |
| 306 |
_XcmsModuloF( |
| 307 |
double val, |
| 308 |
register double *dp) |
| 309 |
{ |
| 310 |
register double abs; |
| 311 |
/* |
| 312 |
* Don't use a register for this. The extra precision this results |
| 313 |
* in on some systems causes problems. |
| 314 |
*/ |
| 315 |
double ip; |
| 316 |
|
| 317 |
/* should check for illegal values here - nan, inf, etc */ |
| 318 |
abs = XCMS_FABS(val); |
| 319 |
if (abs >= XCMS_DMAXPOWTWO) { |
| 320 |
ip = val; |
| 321 |
} else { |
| 322 |
ip = abs + XCMS_DMAXPOWTWO; /* dump fraction */ |
| 323 |
ip -= XCMS_DMAXPOWTWO; /* restore w/o frac */ |
| 324 |
if (ip > abs) /* if it rounds up */ |
| 325 |
ip -= 1.0; /* fix it */ |
| 326 |
ip = XCMS_FABS(ip); |
| 327 |
} |
| 328 |
*dp = ip; |
| 329 |
return (val - ip); /* signed fractional part */ |
| 330 |
} |
| 331 |
|
| 332 |
|
| 333 |
/* |
| 334 |
* FUNCTION |
| 335 |
* |
| 336 |
* _XcmsPolynomial double precision polynomial evaluation |
| 337 |
* |
| 338 |
* KEY WORDS |
| 339 |
* |
| 340 |
* poly |
| 341 |
* machine independent routines |
| 342 |
* math libraries |
| 343 |
* |
| 344 |
* DESCRIPTION |
| 345 |
* |
| 346 |
* Evaluates a polynomial and returns double precision |
| 347 |
* result. Is passed a the order of the polynomial, |
| 348 |
* a pointer to an array of double precision polynomial |
| 349 |
* coefficients (in ascending order), and the independent |
| 350 |
* variable. |
| 351 |
* |
| 352 |
* USAGE |
| 353 |
* |
| 354 |
* double _XcmsPolynomial (order, coeffs, x) |
| 355 |
* int order; |
| 356 |
* double *coeffs; |
| 357 |
* double x; |
| 358 |
* |
| 359 |
* PROGRAMMER |
| 360 |
* |
| 361 |
* Fred Fish |
| 362 |
* |
| 363 |
* INTERNALS |
| 364 |
* |
| 365 |
* Evalates the polynomial using recursion and the form: |
| 366 |
* |
| 367 |
* P(x) = P0 + x(P1 + x(P2 +...x(Pn))) |
| 368 |
* |
| 369 |
*/ |
| 370 |
|
| 371 |
static double _XcmsPolynomial( |
| 372 |
register int order, |
| 373 |
double const *coeffs, |
| 374 |
double x) |
| 375 |
{ |
| 376 |
auto double rtn_value; |
| 377 |
|
| 378 |
coeffs += order; |
| 379 |
rtn_value = *coeffs--; |
| 380 |
while(order-- > 0) |
| 381 |
rtn_value = *coeffs-- + (x * rtn_value); |
| 382 |
|
| 383 |
return(rtn_value); |
| 384 |
} |
| 385 |
|
| 386 |
|
| 387 |
/* |
| 388 |
* FUNCTION |
| 389 |
* |
| 390 |
* _XcmsSine double precision sine |
| 391 |
* |
| 392 |
* KEY WORDS |
| 393 |
* |
| 394 |
* sin |
| 395 |
* machine independent routines |
| 396 |
* trigonometric functions |
| 397 |
* math libraries |
| 398 |
* |
| 399 |
* DESCRIPTION |
| 400 |
* |
| 401 |
* Returns double precision sine of double precision |
| 402 |
* floating point argument. |
| 403 |
* |
| 404 |
* USAGE |
| 405 |
* |
| 406 |
* double _XcmsSine (x) |
| 407 |
* double x; |
| 408 |
* |
| 409 |
* REFERENCES |
| 410 |
* |
| 411 |
* Computer Approximations, J.F. Hart et al, John Wiley & Sons, |
| 412 |
* 1968, pp. 112-120. |
| 413 |
* |
| 414 |
* RESTRICTIONS |
| 415 |
* |
| 416 |
* The sin and cos routines are interactive in the sense that |
| 417 |
* in the process of reducing the argument to the range -PI/4 |
| 418 |
* to PI/4, each may call the other. Ultimately one or the |
| 419 |
* other uses a polynomial approximation on the reduced |
| 420 |
* argument. The sin approximation has a maximum relative error |
| 421 |
* of 10**(-17.59) and the cos approximation has a maximum |
| 422 |
* relative error of 10**(-16.18). |
| 423 |
* |
| 424 |
* These error bounds assume exact arithmetic |
| 425 |
* in the polynomial evaluation. Additional rounding and |
| 426 |
* truncation errors may occur as the argument is reduced |
| 427 |
* to the range over which the polynomial approximation |
| 428 |
* is valid, and as the polynomial is evaluated using |
| 429 |
* finite-precision arithmetic. |
| 430 |
* |
| 431 |
* PROGRAMMER |
| 432 |
* |
| 433 |
* Fred Fish |
| 434 |
* |
| 435 |
* INTERNALS |
| 436 |
* |
| 437 |
* Computes sin(x) from: |
| 438 |
* |
| 439 |
* (1) Reduce argument x to range -PI to PI. |
| 440 |
* |
| 441 |
* (2) If x > PI/2 then call sin recursively |
| 442 |
* using relation sin(x) = -sin(x - PI). |
| 443 |
* |
| 444 |
* (3) If x < -PI/2 then call sin recursively |
| 445 |
* using relation sin(x) = -sin(x + PI). |
| 446 |
* |
| 447 |
* (4) If x > PI/4 then call cos using |
| 448 |
* relation sin(x) = cos(PI/2 - x). |
| 449 |
* |
| 450 |
* (5) If x < -PI/4 then call cos using |
| 451 |
* relation sin(x) = -cos(PI/2 + x). |
| 452 |
* |
| 453 |
* (6) If x is small enough that polynomial |
| 454 |
* evaluation would cause underflow |
| 455 |
* then return x, since sin(x) |
| 456 |
* approaches x as x approaches zero. |
| 457 |
* |
| 458 |
* (7) By now x has been reduced to range |
| 459 |
* -PI/4 to PI/4 and the approximation |
| 460 |
* from HART pg. 118 can be used: |
| 461 |
* |
| 462 |
* sin(x) = y * ( p(y) / q(y) ) |
| 463 |
* Where: |
| 464 |
* |
| 465 |
* y = x * (4/PI) |
| 466 |
* |
| 467 |
* p(y) = SUM [ Pj * (y**(2*j)) ] |
| 468 |
* over j = {0,1,2,3} |
| 469 |
* |
| 470 |
* q(y) = SUM [ Qj * (y**(2*j)) ] |
| 471 |
* over j = {0,1,2,3} |
| 472 |
* |
| 473 |
* P0 = 0.206643433369958582409167054e+7 |
| 474 |
* P1 = -0.18160398797407332550219213e+6 |
| 475 |
* P2 = 0.359993069496361883172836e+4 |
| 476 |
* P3 = -0.2010748329458861571949e+2 |
| 477 |
* Q0 = 0.263106591026476989637710307e+7 |
| 478 |
* Q1 = 0.3927024277464900030883986e+5 |
| 479 |
* Q2 = 0.27811919481083844087953e+3 |
| 480 |
* Q3 = 1.0000... |
| 481 |
* (coefficients from HART table #3063 pg 234) |
| 482 |
* |
| 483 |
* |
| 484 |
* **** NOTE **** The range reduction relations used in |
| 485 |
* this routine depend on the final approximation being valid |
| 486 |
* over the negative argument range in addition to the positive |
| 487 |
* argument range. The particular approximation chosen from |
| 488 |
* HART satisfies this requirement, although not explicitly |
| 489 |
* stated in the text. This may not be true of other |
| 490 |
* approximations given in the reference. |
| 491 |
* |
| 492 |
*/ |
| 493 |
|
| 494 |
double |
| 495 |
_XcmsSine (double x) |
| 496 |
{ |
| 497 |
double y; |
| 498 |
double yt2; |
| 499 |
double retval; |
| 500 |
|
| 501 |
if (x < -XCMS_PI || x > XCMS_PI) { |
| 502 |
x = _XcmsModulo (x, XCMS_TWOPI); |
| 503 |
if (x > XCMS_PI) { |
| 504 |
x = x - XCMS_TWOPI; |
| 505 |
} else if (x < -XCMS_PI) { |
| 506 |
x = x + XCMS_TWOPI; |
| 507 |
} |
| 508 |
} |
| 509 |
if (x > XCMS_HALFPI) { |
| 510 |
retval = -(_XcmsSine (x - XCMS_PI)); |
| 511 |
} else if (x < -XCMS_HALFPI) { |
| 512 |
retval = -(_XcmsSine (x + XCMS_PI)); |
| 513 |
} else if (x > XCMS_FOURTHPI) { |
| 514 |
retval = _XcmsCosine (XCMS_HALFPI - x); |
| 515 |
} else if (x < -XCMS_FOURTHPI) { |
| 516 |
retval = -(_XcmsCosine (XCMS_HALFPI + x)); |
| 517 |
} else if (x < XCMS_X6_UNDERFLOWS && x > -XCMS_X6_UNDERFLOWS) { |
| 518 |
retval = x; |
| 519 |
} else { |
| 520 |
y = x / XCMS_FOURTHPI; |
| 521 |
yt2 = y * y; |
| 522 |
retval = y * (_XcmsPolynomial (3, sin_pcoeffs, yt2) / _XcmsPolynomial(3, sin_qcoeffs, yt2)); |
| 523 |
} |
| 524 |
return(retval); |
| 525 |
} |
| 526 |
|
| 527 |
|
| 528 |
/* |
| 529 |
* NAME |
| 530 |
* _XcmsArcTangent |
| 531 |
* |
| 532 |
* SYNOPSIS |
| 533 |
*/ |
| 534 |
double |
| 535 |
_XcmsArcTangent(double x) |
| 536 |
/* |
| 537 |
* DESCRIPTION |
| 538 |
* Computes the arctangent. |
| 539 |
* This is an implementation of the Gauss algorithm as |
| 540 |
* described in: |
| 541 |
* Forman S. Acton, Numerical Methods That Work, |
| 542 |
* New York, NY, Harper & Row, 1970. |
| 543 |
* |
| 544 |
* RETURNS |
| 545 |
* Returns the arctangent |
| 546 |
*/ |
| 547 |
{ |
| 548 |
double ai, a1 = 0.0, bi, b1 = 0.0, l, d; |
| 549 |
double maxerror; |
| 550 |
int i; |
| 551 |
|
| 552 |
if (x == 0.0) { |
| 553 |
return (0.0); |
| 554 |
} |
| 555 |
if (x < 1.0) { |
| 556 |
maxerror = x * XCMS_MAXERROR; |
| 557 |
} else { |
| 558 |
maxerror = XCMS_MAXERROR; |
| 559 |
} |
| 560 |
ai = _XcmsSquareRoot( 1.0 / (1.0 + (x * x)) ); |
| 561 |
bi = 1.0; |
| 562 |
for (i = 0; i < XCMS_MAXITER; i++) { |
| 563 |
a1 = (ai + bi) / 2.0; |
| 564 |
b1 = _XcmsSquareRoot((a1 * bi)); |
| 565 |
if (a1 == b1) |
| 566 |
break; |
| 567 |
d = XCMS_FABS(a1 - b1); |
| 568 |
if (d < maxerror) |
| 569 |
break; |
| 570 |
ai = a1; |
| 571 |
bi = b1; |
| 572 |
} |
| 573 |
|
| 574 |
l = ((a1 > b1) ? b1 : a1); |
| 575 |
|
| 576 |
a1 = _XcmsSquareRoot(1 + (x * x)); |
| 577 |
return (x / (a1 * l)); |
| 578 |
} |