← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/ecl/intrepid

« back to all changes in this revision

Viewing changes to src/gmp/mpfr/tests/thyperbolic.c

  • Committer: Bazaar Package Importer
  • Author(s): Peter Van Eynde
  • Date: 2006-05-17 02:46:26 UTC
  • Revision ID: james.westby@ubuntu.com-20060517024626-lljr08ftv9g9vefl
Tags: upstream-0.9h-20060510
Import upstream version 0.9h-20060510

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gmp/mpfr/tests/thyperbolic.c
 
1
/* Test file for hyperbolic function : mpfr_cosh, mpfr_sinh, mpfr_tanh, mpfr_acosh, mpfr_asinh, mpfr_atanh.
 
2
 
 
3
Copyright 2001, 2002 Free Software Foundation, Inc.
 
4
 
 
5
This file is part of the MPFR Library.
 
6
 
 
7
The MPFR Library is free software; you can redistribute it and/or modify
 
8
it under the terms of the GNU Lesser General Public License as published
 
9
by
 
10
the Free Software Foundation; either version 2.1 of the License, or (at youroption) any later version.
 
11
 
 
12
The MPFR Library is distributed in the hope that it will be useful, but
 
13
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITYor FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 
14
License for more details.
 
15
 
 
16
You should have received a copy of the GNU Lesser General Public License
 
17
along with the MPFR Library; see the file COPYING.LIB.  If not, write to
 
18
the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 
19
MA 02111-1307, USA. */
 
20
                   
 
21
#include <stdio.h>
 
22
#include "gmp.h"
 
23
#include "gmp-impl.h"
 
24
#include "mpfr.h"
 
25
#include "mpfr-impl.h"
 
26
 
 
27
 
 
28
int check_O _PROTO((void));
 
29
int check_NAN _PROTO((void));
 
30
int check_zero _PROTO((void));
 
31
int check_INF _PROTO((void));
 
32
 
 
33
 
 
34
 
 
35
int
 
36
check_NAN (void)
 
37
{
 
38
 
 
39
 mpfr_t t, ch,sh,th,ach,ash,ath;
 
40
 int tester;
 
41
 
 
42
 mpfr_init2(t,200);
 
43
 mpfr_init2(ch,200);
 
44
 mpfr_init2(sh,200);
 
45
 mpfr_init2(th,200);
 
46
 mpfr_init2(ach,200);
 
47
 mpfr_init2(ash,200);
 
48
 mpfr_init2(ath,200);
 
49
 
 
50
 MPFR_SET_NAN(t);
 
51
 
 
52
  /******cosh********/
 
53
 
 
54
  tester=mpfr_cosh(ch,t,GMP_RNDD);
 
55
  if (!MPFR_IS_NAN(ch) || tester!=0 )
 
56
  {
 
57
    printf("cosh NAN \n");
 
58
    mpfr_clear(t);
 
59
    mpfr_clear(ch);
 
60
    mpfr_clear(sh);
 
61
    mpfr_clear(th);
 
62
    mpfr_clear(ach);
 
63
    mpfr_clear(ash);
 
64
    mpfr_clear(ath);
 
65
    return(1);
 
66
  } 
 
67
 
 
68
  /******sinh********/
 
69
 
 
70
  tester=mpfr_sinh(sh,t,GMP_RNDD);
 
71
  if (!MPFR_IS_NAN(sh) || tester!=0 )
 
72
  {
 
73
    printf("sinh NAN \n");
 
74
    mpfr_clear(t);
 
75
    mpfr_clear(ch);
 
76
    mpfr_clear(sh);
 
77
    mpfr_clear(th);
 
78
    mpfr_clear(ach);
 
79
    mpfr_clear(ash);
 
80
    mpfr_clear(ath);
 
81
    return(1);
 
82
  } 
 
83
 
 
84
  /******tanh********/
 
85
 
 
86
  tester=mpfr_tanh(th,t,GMP_RNDD);
 
87
  if (!MPFR_IS_NAN(th) || tester!=0 )
 
88
  {
 
89
    printf("tanh NAN \n");
 
90
    mpfr_clear(t);
 
91
    mpfr_clear(ch);
 
92
    mpfr_clear(sh);
 
93
    mpfr_clear(th);
 
94
    mpfr_clear(ach);
 
95
    mpfr_clear(ash);
 
96
    mpfr_clear(ath);
 
97
    return(1);
 
98
  } 
 
99
 
 
100
  /******acosh********/
 
101
 
 
102
  tester=mpfr_acosh(ach,t,GMP_RNDD);
 
103
  if (!MPFR_IS_NAN(ach) || tester!=0 )
 
104
  {
 
105
    printf("acosh NAN \n");
 
106
    return(1);
 
107
  } 
 
108
 
 
109
  /******asinh********/
 
110
 
 
111
  tester=mpfr_asinh(ash,t,GMP_RNDD);
 
112
  if (!MPFR_IS_NAN(ash) || tester!=0 )
 
113
  {
 
114
    printf("asinh NAN \n");
 
115
    mpfr_clear(t);
 
116
    mpfr_clear(ch);
 
117
    mpfr_clear(sh);
 
118
    mpfr_clear(th);
 
119
    mpfr_clear(ach);
 
120
    mpfr_clear(ash);
 
121
    mpfr_clear(ath);
 
122
    return(1);
 
123
  } 
 
124
 
 
125
  /******atanh********/
 
126
 
 
127
  tester=mpfr_atanh(ath,t,GMP_RNDD);
 
128
  if (!MPFR_IS_NAN(ath) || tester!=0 )
 
129
  {
 
130
    printf("atanh NAN \n");
 
131
    mpfr_clear(t);
 
132
    mpfr_clear(ch);
 
133
    mpfr_clear(sh);
 
134
    mpfr_clear(th);
 
135
    mpfr_clear(ach);
 
136
    mpfr_clear(ash);
 
137
    mpfr_clear(ath);
 
138
    return(1);
 
139
  } 
 
140
 
 
141
  mpfr_clear(t);
 
142
  mpfr_clear(ch);
 
143
  mpfr_clear(sh);
 
144
  mpfr_clear(th);
 
145
  mpfr_clear(ach);
 
146
  mpfr_clear(ash);
 
147
  mpfr_clear(ath);
 
148
 
 
149
  return(0);
 
150
 
 
151
}
 
152
int
 
153
check_zero (void)
 
154
{
 
155
 
 
156
 mpfr_t t, ch,sh,th,ach,ash,ath;
 
157
 int tester;
 
158
 
 
159
 mpfr_init2(t,200);
 
160
 mpfr_init2(ch,200);
 
161
 mpfr_init2(sh,200);
 
162
 mpfr_init2(th,200);
 
163
 mpfr_init2(ach,200);
 
164
 mpfr_init2(ash,200);
 
165
 mpfr_init2(ath,200);
 
166
 
 
167
 
 
168
 mpfr_set_ui(t,0,GMP_RNDD);
 
169
 
 
170
  /******cosh********/
 
171
 
 
172
  tester=mpfr_cosh(ch,t,GMP_RNDD);
 
173
  if (!mpfr_cmp_ui(ch,1) || !tester )
 
174
  {
 
175
    printf("cosh(0) \n");
 
176
    mpfr_clear(t);
 
177
    mpfr_clear(ch);
 
178
    mpfr_clear(sh);
 
179
    mpfr_clear(th);
 
180
    mpfr_clear(ach);
 
181
    mpfr_clear(ash);
 
182
    mpfr_clear(ath);
 
183
    return(1);
 
184
  } 
 
185
 
 
186
  /******sinh********/
 
187
 
 
188
  tester=mpfr_sinh(sh,t,GMP_RNDD);
 
189
  if (!MPFR_IS_ZERO(sh) || !tester )
 
190
  {
 
191
    printf("sinh(0) \n");
 
192
    mpfr_clear(t);
 
193
    mpfr_clear(ch);
 
194
    mpfr_clear(sh);
 
195
    mpfr_clear(th);
 
196
    mpfr_clear(ach);
 
197
    mpfr_clear(ash);
 
198
    mpfr_clear(ath);
 
199
    return(1);
 
200
  } 
 
201
 
 
202
  /******tanh********/
 
203
 
 
204
  tester=mpfr_tanh(th,t,GMP_RNDD);
 
205
  if (!MPFR_IS_ZERO(th) || !tester )
 
206
  {
 
207
    printf("tanh(0) \n");
 
208
   mpfr_clear(t);
 
209
   mpfr_clear(ch);
 
210
   mpfr_clear(sh);
 
211
   mpfr_clear(th);
 
212
   mpfr_clear(ach);
 
213
   mpfr_clear(ash);
 
214
   mpfr_clear(ath);
 
215
   return(1);
 
216
  } 
 
217
 
 
218
  /******acosh********/
 
219
 
 
220
  tester=mpfr_acosh(ach,t,GMP_RNDD);
 
221
  if (!MPFR_IS_NAN(ach) || tester != -1 )
 
222
  {
 
223
    printf("acosh(0) \n");
 
224
    mpfr_clear(t);
 
225
    mpfr_clear(ch);
 
226
    mpfr_clear(sh);
 
227
    mpfr_clear(th);
 
228
    mpfr_clear(ach);
 
229
    mpfr_clear(ash);
 
230
    mpfr_clear(ath);
 
231
    return(1);
 
232
  } 
 
233
 
 
234
  /******asinh********/
 
235
 
 
236
  tester=mpfr_asinh(ash,t,GMP_RNDD);
 
237
  if (!MPFR_IS_ZERO(ash) || !tester )
 
238
  {
 
239
    printf("asinh(0) \n");
 
240
    mpfr_clear(t);
 
241
    mpfr_clear(ch);
 
242
    mpfr_clear(sh);
 
243
    mpfr_clear(th);
 
244
    mpfr_clear(ach);
 
245
    mpfr_clear(ash);
 
246
    mpfr_clear(ath);
 
247
    return(1);
 
248
  } 
 
249
 
 
250
  /******atanh********/
 
251
 
 
252
  tester=mpfr_atanh(ath,t,GMP_RNDD);
 
253
  if (!MPFR_IS_ZERO(ath) || !tester )
 
254
  {
 
255
    printf("atanh(0) \n");
 
256
    mpfr_clear(t);
 
257
    mpfr_clear(ch);
 
258
    mpfr_clear(sh);
 
259
    mpfr_clear(th);
 
260
    mpfr_clear(ach);
 
261
    mpfr_clear(ash);
 
262
    mpfr_clear(ath);
 
263
    return(1);
 
264
  } 
 
265
 
 
266
  mpfr_clear(t);
 
267
  mpfr_clear(ch);
 
268
  mpfr_clear(sh);
 
269
  mpfr_clear(th);
 
270
  mpfr_clear(ach);
 
271
  mpfr_clear(ash);
 
272
  mpfr_clear(ath);
 
273
 
 
274
  return(0);
 
275
 
 
276
}
 
277
 
 
278
int
 
279
check_INF (void)
 
280
{
 
281
 
 
282
 mpfr_t t, ch,sh,th,ach,ash,ath;
 
283
 int tester;
 
284
 
 
285
 
 
286
 mpfr_init2(t,200);
 
287
 mpfr_init2(ch,200);
 
288
 mpfr_init2(sh,200);
 
289
 mpfr_init2(th,200);
 
290
 mpfr_init2(ach,200);
 
291
 mpfr_init2(ash,200);
 
292
 mpfr_init2(ath,200);
 
293
 
 
294
 MPFR_CLEAR_NAN(t);
 
295
 MPFR_SET_INF(t);
 
296
 
 
297
 if(MPFR_SIGN(t)<0)
 
298
   MPFR_CHANGE_SIGN(t);
 
299
 
 
300
  /******cosh********/
 
301
 
 
302
  tester = mpfr_cosh(ch,t,GMP_RNDD);
 
303
  if (!MPFR_IS_INF(ch) || MPFR_SIGN(ch) < 0 || tester!=0 )
 
304
  {
 
305
    printf("cosh(INF) \n");
 
306
    mpfr_clear(t);
 
307
    mpfr_clear(ch);
 
308
    mpfr_clear(sh);
 
309
    mpfr_clear(th);
 
310
    mpfr_clear(ach);
 
311
    mpfr_clear(ash);
 
312
    mpfr_clear(ath);
 
313
    return(1);
 
314
  } 
 
315
 
 
316
  /******sinh********/
 
317
 
 
318
  tester=mpfr_sinh(sh,t,GMP_RNDD);
 
319
  if (!MPFR_IS_INF(sh) || MPFR_SIGN(sh) < 0  || tester!=0 )
 
320
  {
 
321
    printf("sinh(INF) \n");
 
322
    mpfr_clear(t);
 
323
    mpfr_clear(ch);
 
324
    mpfr_clear(sh);
 
325
    mpfr_clear(th);
 
326
    mpfr_clear(ach);
 
327
    mpfr_clear(ash);
 
328
    mpfr_clear(ath);
 
329
    return(1);
 
330
  } 
 
331
 
 
332
  /******tanh********/
 
333
 
 
334
  tester=mpfr_tanh(th,t,GMP_RNDD);
 
335
  if (mpfr_cmp_ui(th,1) != 0 || tester!=0 )
 
336
  {
 
337
    printf("tanh(INF) \n");
 
338
    mpfr_clear(t);
 
339
    mpfr_clear(ch);
 
340
    mpfr_clear(sh);
 
341
    mpfr_clear(th);
 
342
    mpfr_clear(ach);
 
343
    mpfr_clear(ash);
 
344
    mpfr_clear(ath);
 
345
    return(1);
 
346
  } 
 
347
 
 
348
  /******acosh********/
 
349
 
 
350
  tester=mpfr_acosh(ach,t,GMP_RNDD);
 
351
  if (!MPFR_IS_INF(ach) || MPFR_SIGN(ach) < 0  || tester!=0 )
 
352
  {
 
353
    printf("acosh(INF) \n");
 
354
    mpfr_clear(t);
 
355
    mpfr_clear(ch);
 
356
    mpfr_clear(sh);
 
357
    mpfr_clear(th);
 
358
    mpfr_clear(ach);
 
359
    mpfr_clear(ash);
 
360
    mpfr_clear(ath);
 
361
    return(1);
 
362
  } 
 
363
 
 
364
  /******asinh********/
 
365
 
 
366
  tester=mpfr_asinh(ash,t,GMP_RNDD);
 
367
  if (!MPFR_IS_INF(ash) || MPFR_SIGN(ash) < 0  || tester!=0 )
 
368
  {
 
369
    printf("asinh(INF) \n");
 
370
    mpfr_clear(t);
 
371
    mpfr_clear(ch);
 
372
    mpfr_clear(sh);
 
373
    mpfr_clear(th);
 
374
    mpfr_clear(ach);
 
375
    mpfr_clear(ash);
 
376
    mpfr_clear(ath);
 
377
    return(1);
 
378
  } 
 
379
 
 
380
  /******atanh********/
 
381
 
 
382
  tester=mpfr_atanh(ath,t,GMP_RNDD);  
 
383
  if (!MPFR_IS_INF(ath) || tester != 0)
 
384
  {
 
385
    printf("atanh(INF) \n");
 
386
    mpfr_clear(t);
 
387
    mpfr_clear(ch);
 
388
    mpfr_clear(sh);
 
389
    mpfr_clear(th);
 
390
    mpfr_clear(ach);
 
391
    mpfr_clear(ash);
 
392
    mpfr_clear(ath);
 
393
    return(1);
 
394
  } 
 
395
 
 
396
 MPFR_CHANGE_SIGN(t);
 
397
 
 
398
  /******cosh********/
 
399
 
 
400
  tester=mpfr_cosh(ch,t,GMP_RNDD);
 
401
  if (!MPFR_IS_INF(ch) || MPFR_SIGN(ch) < 0  || tester!=0 )
 
402
  {
 
403
    printf("cosh(-INF) \n");
 
404
    mpfr_clear(t);
 
405
    mpfr_clear(ch);
 
406
    mpfr_clear(sh);
 
407
    mpfr_clear(th);
 
408
    mpfr_clear(ach);
 
409
    mpfr_clear(ash);
 
410
    mpfr_clear(ath);
 
411
    return(1);
 
412
  } 
 
413
 
 
414
  /******sinh********/
 
415
 
 
416
  tester=mpfr_sinh(sh,t,GMP_RNDD);
 
417
  if (!MPFR_IS_INF(sh)  || MPFR_SIGN(sh) > 0 || tester!=0 )
 
418
  {
 
419
    printf("sinh(-INF) \n");
 
420
    mpfr_clear(t);
 
421
    mpfr_clear(ch);
 
422
    mpfr_clear(sh);
 
423
    mpfr_clear(th);
 
424
    mpfr_clear(ach);
 
425
    mpfr_clear(ash);
 
426
    mpfr_clear(ath);
 
427
    return(1);
 
428
  } 
 
429
 
 
430
  /******tanh********/
 
431
 
 
432
  tester=mpfr_tanh(th,t,GMP_RNDD);
 
433
  if (!mpfr_cmp_ui(th,-1) || tester!=0 )
 
434
  {
 
435
    printf("tanh(-INF) \n");
 
436
    mpfr_clear(t);
 
437
    mpfr_clear(ch);
 
438
    mpfr_clear(sh);
 
439
    mpfr_clear(th);
 
440
    mpfr_clear(ach);
 
441
    mpfr_clear(ash);
 
442
    mpfr_clear(ath);
 
443
    return(1);
 
444
  } 
 
445
 
 
446
  /******acosh********/
 
447
 
 
448
  tester=mpfr_acosh(ach,t,GMP_RNDD);
 
449
  if (!MPFR_IS_INF(ach) || MPFR_SIGN(ach) < 0  || tester!=0 )
 
450
  {
 
451
    printf("acosh(-INF) \n");
 
452
    mpfr_clear(t);
 
453
    mpfr_clear(ch);
 
454
    mpfr_clear(sh);
 
455
    mpfr_clear(th);
 
456
    mpfr_clear(ach);
 
457
    mpfr_clear(ash);
 
458
    mpfr_clear(ath);
 
459
    return(1);
 
460
  } 
 
461
 
 
462
  /******asinh********/
 
463
 
 
464
  tester=mpfr_asinh(ash,t,GMP_RNDD);
 
465
  if (!MPFR_IS_INF(ash) || MPFR_SIGN(ash) > 0  || tester!=0 )
 
466
  {
 
467
    printf("asinh(-INF) \n");
 
468
    mpfr_clear(t);
 
469
    mpfr_clear(ch);
 
470
    mpfr_clear(sh);
 
471
    mpfr_clear(th);
 
472
    mpfr_clear(ach);
 
473
    mpfr_clear(ash);
 
474
    mpfr_clear(ath);
 
475
    return(1);
 
476
  } 
 
477
 
 
478
  /******atanh********/
 
479
 
 
480
  tester=mpfr_atanh(ath,t,GMP_RNDD);
 
481
  if (!MPFR_IS_INF(ath) || MPFR_SIGN(ath) > 0 || tester != 0 )
 
482
  {
 
483
    printf("atanh(-INF) \n");
 
484
    mpfr_clear(t);
 
485
    mpfr_clear(ch);
 
486
    mpfr_clear(sh);
 
487
    mpfr_clear(th);
 
488
    mpfr_clear(ach);
 
489
    mpfr_clear(ash);
 
490
    mpfr_clear(ath);
 
491
   return(1);
 
492
  } 
 
493
 
 
494
  mpfr_clear(t);
 
495
  mpfr_clear(ch);
 
496
  mpfr_clear(sh);
 
497
  mpfr_clear(th);
 
498
  mpfr_clear(ach);
 
499
  mpfr_clear(ash);
 
500
  mpfr_clear(ath);
 
501
 
 
502
 
 
503
  return(0);
 
504
 
 
505
}
 
506
 
 
507
int
 
508
check_O (void)
 
509
{
 
510
 
 
511
 mpfr_t t, ch,sh,th,ach,ash,ath;
 
512
 
 
513
 mpfr_init2(t,20);
 
514
 mpfr_init2(ch,40);
 
515
 mpfr_init2(sh,40);
 
516
 mpfr_init2(th,40);
 
517
 mpfr_init2(ach,40);
 
518
 mpfr_init2(ash,40);
 
519
 mpfr_init2(ath,40);
 
520
 
 
521
 mpfr_set_ui(t,2,GMP_RNDD);
 
522
 
 
523
 /******acosh o cosh********/
 
524
 
 
525
  mpfr_cosh(ch,t,GMP_RNDN);
 
526
  mpfr_acosh(ach,ch,GMP_RNDN);
 
527
  if(mpfr_cmp_ui(ach,2)!=0)
 
528
  {
 
529
    printf("cosh o acosh \n");
 
530
    mpfr_clear(t);
 
531
    mpfr_clear(ch);
 
532
    mpfr_clear(sh);
 
533
    mpfr_clear(th);
 
534
    mpfr_clear(ach);
 
535
    mpfr_clear(ash);
 
536
    mpfr_clear(ath);
 
537
    return(1);
 
538
  }
 
539
 
 
540
  /******asinh o sinh********/
 
541
 
 
542
  mpfr_sinh(sh,t,GMP_RNDN);
 
543
  mpfr_asinh(ash,sh,GMP_RNDN);
 
544
  if(mpfr_cmp_ui(ash,2)!=0)
 
545
  {
 
546
    printf("sinh o asinh \n");
 
547
    mpfr_clear(t);
 
548
    mpfr_clear(ch);
 
549
    mpfr_clear(sh);
 
550
    mpfr_clear(th);
 
551
    mpfr_clear(ach);
 
552
    mpfr_clear(ash);
 
553
    mpfr_clear(ath);
 
554
    return(1);
 
555
  }
 
556
  
 
557
 
 
558
  /******atanh o tanh********/
 
559
 
 
560
  mpfr_tanh(th,t,GMP_RNDN);
 
561
  mpfr_atanh(ath,th,GMP_RNDU);
 
562
 
 
563
  /*
 
564
  mpfr_out_str(stdout, 2,40,th,GMP_RNDN);
 
565
  putchar('\n');
 
566
 
 
567
  mpfr_out_str(stdout, 2,40,ath,GMP_RNDU);
 
568
  putchar('\n');
 
569
  */
 
570
 
 
571
  if(mpfr_cmp_ui(ath,2)!=0)
 
572
  {
 
573
    printf("tanh o atanh \n");
 
574
    mpfr_clear(t);
 
575
    mpfr_clear(ch);
 
576
    mpfr_clear(sh);
 
577
    mpfr_clear(th);
 
578
    mpfr_clear(ach);
 
579
    mpfr_clear(ash);
 
580
    mpfr_clear(ath);
 
581
    return(1);
 
582
  }
 
583
 
 
584
  mpfr_clear(t);
 
585
  mpfr_clear(ch);
 
586
  mpfr_clear(sh);
 
587
  mpfr_clear(th);
 
588
  mpfr_clear(ach);
 
589
  mpfr_clear(ash);
 
590
  mpfr_clear(ath);
 
591
 
 
592
 return(0);
 
593
 
 
594
}
 
595
 
 
596
int
 
597
main(void)
 
598
{
 
599
 
 
600
if (check_INF())printf("Error in evaluation of INF\n");
 
601
if (check_NAN())printf("Error in evaluation of NAN\n");
 
602
/*if (check_O())printf("Error in evaluation of composition hyperbolic function\n");*/
 
603
 
 
604
return(0);
 
605
 
 
606
 
 
607
}