Debian Codegraph @

share/libc/math.h

raw
1 /**************************************************************************/
2 /* */
3 /* This file is part of Frama-C. */
4 /* */
5 /* Copyright (C) 2007-2022 */
6 /* CEA (Commissariat à l'énergie atomique et aux énergies */
7 /* alternatives) */
8 /* */
9 /* you can redistribute it and/or modify it under the terms of the GNU */
10 /* Lesser General Public License as published by the Free Software */
11 /* Foundation, version 2.1. */
12 /* */
13 /* It is distributed in the hope that it will be useful, */
14 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
15 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
16 /* GNU Lesser General Public License for more details. */
17 /* */
18 /* See the GNU Lesser General Public License version 2.1 */
19 /* for more details (enclosed in the file licenses/LGPLv2.1). */
20 /* */
21 /**************************************************************************/
22
23 /* ISO C: 7.12 */
24 #ifndef __FC_MATH
25 #define __FC_MATH
26 #include "features.h"
27 __PUSH_FC_STDLIB
28
29 #include "__fc_string_axiomatic.h"
30 #include "errno.h"
31
32 __BEGIN_DECLS
33
34 typedef float float_t;
35 typedef double double_t;
36
37 #define MATH_ERRNO 1
38 #define MATH_ERREXCEPT 2
39
40 /* The constants below are not part of C99/C11 but they are defined in POSIX */
41 #define M_E 0x1.5bf0a8b145769p1 /* e */
42 #define M_LOG2E 0x1.71547652b82fep0 /* log_2 e */
43 #define M_LOG10E 0x1.bcb7b1526e50ep-2 /* log_10 e */
44 #define M_LN2 0x1.62e42fefa39efp-1 /* log_e 2 */
45 #define M_LN10 0x1.26bb1bbb55516p1 /* log_e 10 */
46 #define M_PI 0x1.921fb54442d18p1 /* pi */
47 #define M_PI_2 0x1.921fb54442d18p0 /* pi/2 */
48 #define M_PI_4 0x1.921fb54442d18p-1 /* pi/4 */
49 #define M_1_PI 0x1.45f306dc9c883p-2 /* 1/pi */
50 #define M_2_PI 0x1.45f306dc9c883p-1 /* 2/pi */
51 #define M_2_SQRTPI 0x1.20dd750429b6dp0 /* 2/sqrt(pi) */
52 #define M_SQRT2 0x1.6a09e667f3bcdp0 /* sqrt(2) */
53 #define M_SQRT1_2 0x1.6a09e667f3bcdp-1 /* 1/sqrt(2) */
54
55 /* The following specifications will set errno. */
56 #define math_errhandling MATH_ERRNO
57
58 #define FP_NAN 0
59 #define FP_INFINITE 1
60 #define FP_ZERO 2
61 #define FP_SUBNORMAL 3
62 #define FP_NORMAL 4
63
64 #define FP_ILOGB0 __FC_INT_MIN
65 #define FP_ILOGBNAN __FC_INT_MIN
66
67 #include "float.h" // for DBL_MIN and FLT_MIN
68
69 /*@
70 assigns \result \from x;
71 behavior nan:
72 assumes is_nan: \is_NaN(x);
73 ensures fp_nan: \result == FP_NAN;
74 behavior inf:
75 assumes is_infinite: !\is_NaN(x) && !\is_finite(x);
76 ensures fp_infinite: \result == FP_INFINITE;
77 behavior zero:
78 assumes is_a_zero: x == 0.0; // also includes -0.0
79 ensures fp_zero: \result == FP_ZERO;
80 behavior subnormal:
81 assumes is_finite: \is_finite(x);
82 assumes is_subnormal: (x > 0.0 && x < FLT_MIN) || (x < 0.0 && x > -FLT_MIN);
83 ensures fp_subnormal: \result == FP_SUBNORMAL;
84 behavior normal:
85 assumes is_finite: \is_finite(x);
86 assumes not_subnormal: (x <= -FLT_MIN || x >= FLT_MIN);
87 ensures fp_normal: \result == FP_NORMAL;
88 complete behaviors;
89 disjoint behaviors;
90 */
91 int __fc_fpclassifyf(float x);
92
93 /*@
94 assigns \result \from x;
95 behavior nan:
96 assumes is_nan: \is_NaN(x);
97 ensures fp_nan: \result == FP_NAN;
98 behavior inf:
99 assumes is_infinite: !\is_NaN(x) && !\is_finite(x);
100 ensures fp_infinite: \result == FP_INFINITE;
101 behavior zero:
102 assumes is_a_zero: x == 0.0; // also includes -0.0
103 ensures fp_zero: \result == FP_ZERO;
104 behavior subnormal:
105 assumes is_finite: \is_finite(x);
106 assumes is_subnormal: (x > 0.0 && x < DBL_MIN) || (x < 0.0 && x > -DBL_MIN);
107 ensures fp_subnormal: \result == FP_SUBNORMAL;
108 behavior normal:
109 assumes is_finite: \is_finite(x);
110 assumes not_subnormal: (x <= -DBL_MIN || x >= DBL_MIN);
111 ensures fp_normal: \result == FP_NORMAL;
112 complete behaviors;
113 disjoint behaviors;
114 */
115 int __fc_fpclassify(double x);
116
117 // Incorrect in presence of long double with >64 bits
118 #define fpclassify(x) \
119 (sizeof(x) == sizeof(float) ? __fc_fpclassifyf(x) : __fc_fpclassify(x))
120
121 #define isinf(x) \
122 (sizeof(x) == sizeof(float) ? __fc_fpclassifyf(x) == FP_INFINITE : __fc_fpclassify(x) == FP_INFINITE)
123
124 #define isnan(x) \
125 (sizeof(x) == sizeof(float) ? __fc_fpclassifyf(x) == FP_NAN : __fc_fpclassify(x) == FP_NAN)
126
127 #define isnormal(x) \
128 (sizeof(x) == sizeof(float) ? __fc_fpclassifyf(x) == FP_NORMAL : __fc_fpclassify(x) == FP_NORMAL)
129
130
131 /*@
132 assigns errno, \result \from x;
133 behavior normal:
134 assumes in_domain: \is_finite(x) && \abs(x) <= 1;
135 assigns \result \from x;
136 ensures positive_result: \is_finite(\result) && \result >= 0;
137 ensures no_error: errno == \old(errno);
138 behavior domain_error:
139 assumes out_of_domain: \is_infinite(x) || (\is_finite(x) && \abs(x) > 1);
140 ensures nan_result: \is_NaN(\result);
141 ensures errno_set: errno == EDOM;
142 behavior nan:
143 assumes nan_arg: \is_NaN(x);
144 assigns \result \from x;
145 ensures nan_result: \is_NaN(\result);
146 ensures no_error: errno == \old(errno);
147 complete behaviors;
148 disjoint behaviors;
149 */
150 extern double acos(double x);
151
152 /*@
153 assigns errno, \result \from x;
154 behavior normal:
155 assumes in_domain: \is_finite(x) && \abs(x) <= 1;
156 assigns \result \from x;
157 ensures positive_result: \is_finite(\result) && \result >= 0;
158 ensures no_error: errno == \old(errno);
159 behavior domain_error:
160 assumes out_of_domain: \is_infinite(x) || (\is_finite(x) && \abs(x) > 1);
161 ensures nan_result: \is_NaN(\result);
162 ensures errno_set: errno == EDOM;
163 behavior nan:
164 assumes nan_arg: \is_NaN(x);
165 assigns \result \from x;
166 ensures nan_result: \is_NaN(\result);
167 ensures no_error: errno == \old(errno);
168 complete behaviors;
169 disjoint behaviors;
170 */
171 extern float acosf(float x);
172
173 /*@
174 assigns errno, \result \from x;
175 behavior normal:
176 assumes in_domain: \is_finite(x) && \abs(x) <= 1;
177 assigns \result \from x;
178 ensures positive_result: \is_finite(\result) && \result >= 0;
179 ensures no_error: errno == \old(errno);
180 behavior domain_error:
181 assumes out_of_domain: \is_infinite(x) || (\is_finite(x) && \abs(x) > 1);
182 ensures nan_result: \is_NaN(\result);
183 ensures errno_set: errno == EDOM;
184 behavior nan:
185 assumes nan_arg: \is_NaN(x);
186 assigns \result \from x;
187 ensures nan_result: \is_NaN(\result);
188 ensures no_error: errno == \old(errno);
189 complete behaviors;
190 disjoint behaviors;
191 */
192 extern long double acosl(long double x);
193
194 /*@
195 assigns errno, \result \from x;
196 behavior normal:
197 assumes in_domain: \is_finite(x) && \abs(x) <= 1;
198 assigns \result \from x;
199 ensures finite_result: \is_finite(\result);
200 ensures no_error: errno == \old(errno);
201 behavior domain_error:
202 assumes out_of_domain: \is_infinite(x) || (\is_finite(x) && \abs(x) > 1);
203 ensures nan_result: \is_NaN(\result);
204 ensures errno_set: errno == EDOM;
205 behavior nan:
206 assumes nan_arg: \is_NaN(x);
207 assigns \result \from x;
208 ensures nan_result: \is_NaN(\result);
209 ensures no_error: errno == \old(errno);
210 complete behaviors;
211 disjoint behaviors;
212 */
213 extern double asin(double x);
214
215 /*@
216 assigns errno, \result \from x;
217 behavior normal:
218 assumes in_domain: \is_finite(x) && \abs(x) <= 1;
219 assigns \result \from x;
220 ensures finite_result: \is_finite(\result);
221 ensures no_error: errno == \old(errno);
222 behavior domain_error:
223 assumes out_of_domain: \is_infinite(x) || (\is_finite(x) && \abs(x) > 1);
224 ensures nan_result: \is_NaN(\result);
225 ensures errno_set: errno == EDOM;
226 behavior nan:
227 assumes nan_arg: \is_NaN(x);
228 assigns \result \from x;
229 ensures nan_result: \is_NaN(\result);
230 ensures no_error: errno == \old(errno);
231 complete behaviors;
232 disjoint behaviors;
233 */
234 extern float asinf(float x);
235
236 /*@
237 assigns errno, \result \from x;
238 behavior normal:
239 assumes in_domain: \is_finite(x) && \abs(x) <= 1;
240 assigns \result \from x;
241 ensures finite_result: \is_finite(\result);
242 ensures no_error: errno == \old(errno);
243 behavior domain_error:
244 assumes out_of_domain: \is_infinite(x) || (\is_finite(x) && \abs(x) > 1);
245 ensures nan_result: \is_NaN(\result);
246 ensures errno_set: errno == EDOM;
247 behavior nan:
248 assumes nan_arg: \is_NaN(x);
249 assigns \result \from x;
250 ensures nan_result: \is_NaN(\result);
251 ensures no_error: errno == \old(errno);
252 complete behaviors;
253 disjoint behaviors;
254 */
255 extern long double asinl(long double x);
256
257 /*@
258 assigns \result \from x;
259 behavior normal:
260 assumes number_arg: !\is_NaN(x);
261 ensures finite_result: \is_finite(\result);
262 ensures result_domain: -1.571 <= \result <= 1.571;
263 behavior nan:
264 assumes nan_arg: \is_NaN(x);
265 ensures nan_result: \is_NaN(\result);
266 complete behaviors;
267 disjoint behaviors;
268 */
269 extern float atanf(float x);
270
271 /*@
272 assigns \result \from x;
273 behavior normal:
274 assumes number_arg: !\is_NaN(x);
275 ensures finite_result: \is_finite(\result);
276 ensures result_domain: -1.571 <= \result <= 1.571;
277 behavior nan:
278 assumes nan_arg: \is_NaN(x);
279 ensures nan_result: \is_NaN(\result);
280 complete behaviors;
281 disjoint behaviors;
282 */
283 extern double atan(double x);
284
285 /*@
286 assigns \result \from x;
287 behavior normal:
288 assumes number_arg: !\is_NaN(x);
289 ensures finite_result: \is_finite(\result);
290 ensures result_domain: -1.571 <= \result <= 1.571;
291 behavior nan:
292 assumes nan_arg: \is_NaN(x);
293 ensures nan_result: \is_NaN(\result);
294 complete behaviors;
295 disjoint behaviors;
296 */
297 extern long double atanl(long double x);
298
299 /*@
300 assigns \result \from x, y;
301 behavior normal:
302 assumes number_args: !\is_NaN(x) && !\is_NaN(y);
303 ensures finite_result: \is_finite(\result);
304 behavior nan:
305 assumes nan_arg: \is_NaN(x) || \is_NaN(y);
306 ensures nan_result: \is_NaN(\result);
307 complete behaviors;
308 disjoint behaviors;
309 */
310 extern double atan2(double y, double x);
311
312 /*@
313 assigns \result \from x, y;
314 behavior normal:
315 assumes number_args: !\is_NaN(x) && !\is_NaN(y);
316 ensures finite_result: \is_finite(\result);
317 behavior nan:
318 assumes nan_arg: \is_NaN(x) || \is_NaN(y);
319 ensures nan_result: \is_NaN(\result);
320 complete behaviors;
321 disjoint behaviors;
322 */
323 extern float atan2f(float y, float x);
324
325 /*@
326 assigns \result \from x, y;
327 behavior normal:
328 assumes number_args: !\is_NaN(x) && !\is_NaN(y);
329 ensures finite_result: \is_finite(\result);
330 behavior nan:
331 assumes nan_arg: \is_NaN(x) || \is_NaN(y);
332 ensures nan_result: \is_NaN(\result);
333 complete behaviors;
334 disjoint behaviors;
335 */
336 extern long double atan2l(long double y, long double x);
337
338 /*@
339 assigns errno, \result \from x;
340 behavior normal:
341 assumes finite_arg: \is_finite(x);
342 assigns \result \from x;
343 ensures finite_result: \is_finite(\result);
344 ensures result_domain: -1. <= \result <= 1.;
345 ensures no_error: errno == \old(errno);
346 behavior infinity:
347 assumes infinite_arg: \is_infinite(x);
348 ensures nan_result: \is_NaN(\result);
349 ensures errno_set: errno == EDOM;
350 behavior nan:
351 assumes nan_arg: \is_NaN(x);
352 assigns \result \from x;
353 ensures nan_result: \is_NaN(\result);
354 ensures no_error: errno == \old(errno);
355 complete behaviors;
356 disjoint behaviors;
357 */
358 extern double cos(double x);
359
360 /*@
361 assigns errno, \result \from x;
362 behavior normal:
363 assumes finite_arg: \is_finite(x);
364 assigns \result \from x;
365 ensures finite_result: \is_finite(\result);
366 ensures result_domain: -1. <= \result <= 1.;
367 ensures no_error: errno == \old(errno);
368 behavior infinity:
369 assumes infinite_arg: \is_infinite(x);
370 ensures nan_result: \is_NaN(\result);
371 ensures errno_set: errno == EDOM;
372 behavior nan:
373 assumes nan_arg: \is_NaN(x);
374 assigns \result \from x;
375 ensures nan_result: \is_NaN(\result);
376 ensures no_error: errno == \old(errno);
377 complete behaviors;
378 disjoint behaviors;
379 */
380 extern float cosf(float x);
381
382 /*@
383 assigns errno, \result \from x;
384 behavior normal:
385 assumes finite_arg: \is_finite(x);
386 assigns \result \from x;
387 ensures finite_result: \is_finite(\result);
388 ensures result_domain: -1. <= \result <= 1.;
389 ensures no_error: errno == \old(errno);
390 behavior infinity:
391 assumes infinite_arg: \is_infinite(x);
392 ensures nan_result: \is_NaN(\result);
393 ensures errno_set: errno == EDOM;
394 behavior nan:
395 assumes nan_arg: \is_NaN(x);
396 assigns \result \from x;
397 ensures nan_result: \is_NaN(\result);
398 ensures no_error: errno == \old(errno);
399 complete behaviors;
400 disjoint behaviors;
401 */
402 extern long double cosl(long double x);
403
404 /*@
405 assigns errno, \result \from x;
406 behavior normal:
407 assumes finite_arg: \is_finite(x);
408 assigns \result \from x;
409 ensures finite_result: \is_finite(\result);
410 ensures result_domain: -1. <= \result <= 1.;
411 ensures no_error: errno == \old(errno);
412 behavior infinity:
413 assumes infinite_arg: \is_infinite(x);
414 ensures nan_result: \is_NaN(\result);
415 ensures errno_set: errno == EDOM;
416 behavior nan:
417 assumes nan_arg: \is_NaN(x);
418 assigns \result \from x;
419 ensures nan_result: \is_NaN(\result);
420 ensures no_error: errno == \old(errno);
421 complete behaviors;
422 disjoint behaviors;
423 */
424 extern double sin(double x);
425
426 /*@
427 assigns errno, \result \from x;
428 behavior normal:
429 assumes finite_arg: \is_finite(x);
430 assigns \result \from x;
431 ensures finite_result: \is_finite(\result);
432 ensures result_domain: -1. <= \result <= 1.;
433 ensures no_error: errno == \old(errno);
434 behavior infinity:
435 assumes infinite_arg: \is_infinite(x);
436 ensures nan_result: \is_NaN(\result);
437 ensures errno_set: errno == EDOM;
438 behavior nan:
439 assumes nan_arg: \is_NaN(x);
440 assigns \result \from x;
441 ensures nan_result: \is_NaN(\result);
442 ensures no_error: errno == \old(errno);
443 complete behaviors;
444 disjoint behaviors;
445 */
446 extern float sinf(float x);
447
448 /*@
449 assigns errno, \result \from x;
450 behavior normal:
451 assumes finite_arg: \is_finite(x);
452 assigns \result \from x;
453 ensures finite_result: \is_finite(\result);
454 ensures result_domain: -1. <= \result <= 1.;
455 ensures no_error: errno == \old(errno);
456 behavior infinity:
457 assumes infinite_arg: \is_infinite(x);
458 ensures nan_result: \is_NaN(\result);
459 ensures errno_set: errno == EDOM;
460 behavior nan:
461 assumes nan_arg: \is_NaN(x);
462 assigns \result \from x;
463 ensures nan_result: \is_NaN(\result);
464 ensures no_error: errno == \old(errno);
465 complete behaviors;
466 disjoint behaviors;
467 */
468 extern long double sinl(long double x);
469
470 /* Note: the specs of tan/tanf below assume that, for a finite x,
471 * the result is always finite. This is _not_ guaranteed by the standard,
472 * but testing with the GNU libc, plus some mathematical arguments
473 * (see https://stackoverflow.com/questions/67482420) indicate that,
474 * in practice, the result is _never_ infinite.
475 * If you know of any implementations in which a finite argument
476 * produces an infinite result, please inform us.
477 */
478 /*@
479 assigns errno, \result \from x;
480 behavior zero:
481 assumes zero_arg: \is_finite(x) && x == 0.;
482 assigns \result \from x;
483 ensures zero_res: \is_finite(\result) && \result == x;
484 ensures no_error: errno == \old(errno);
485 behavior finite_non_zero:
486 assumes finite_arg: \is_finite(x) && x != 0.;
487 ensures finite_result: \is_finite(\result);
488 ensures maybe_error: errno == \old(errno) || errno == ERANGE;
489 behavior infinity:
490 assumes infinite_arg: \is_infinite(x);
491 ensures nan_result: \is_NaN(\result);
492 ensures errno_set: errno == EDOM;
493 behavior nan:
494 assumes nan_arg: \is_NaN(x);
495 assigns \result \from x;
496 ensures nan_result: \is_NaN(\result);
497 ensures no_error: errno == \old(errno);
498 complete behaviors;
499 disjoint behaviors;
500 */
501 extern double tan(double x);
502
503 /*@
504 assigns errno, \result \from x;
505 behavior zero:
506 assumes zero_arg: \is_finite(x) && x == 0.;
507 assigns \result \from x;
508 ensures zero_res: \is_finite(\result) && \result == x;
509 ensures no_error: errno == \old(errno);
510 behavior finite_non_zero:
511 assumes finite_arg: \is_finite(x) && x != 0.;
512 ensures finite_result: \is_finite(\result);
513 ensures maybe_error: errno == \old(errno) || errno == ERANGE;
514 behavior infinity:
515 assumes infinite_arg: \is_infinite(x);
516 ensures nan_result: \is_NaN(\result);
517 ensures errno_set: errno == EDOM;
518 behavior nan:
519 assumes nan_arg: \is_NaN(x);
520 assigns \result \from x;
521 ensures nan_result: \is_NaN(\result);
522 ensures no_error: errno == \old(errno);
523 complete behaviors;
524 disjoint behaviors;
525 */
526 extern float tanf(float x);
527
528 /*@
529 assigns errno, \result \from x;
530 ensures maybe_error: errno == \old(errno) || errno == EDOM || errno == ERANGE;
531 */
532 extern long double tanl(long double x);
533
534 /*@
535 assigns errno, \result \from x;
536 behavior normal:
537 assumes in_domain: \is_finite(x) && x >= 1;
538 assigns \result \from x;
539 ensures positive_result: \is_finite(\result) && \result >= 0;
540 ensures no_error: errno == \old(errno);
541 behavior infinite:
542 assumes is_plus_infinity: \is_plus_infinity(x);
543 assigns \result \from x;
544 ensures result_plus_infinity: \is_plus_infinity(\result);
545 ensures no_error: errno == \old(errno);
546 behavior domain_error:
547 assumes out_of_domain: \is_minus_infinity(x) || (\is_finite(x) && x < 1);
548 ensures nan_result: \is_NaN(\result);
549 ensures errno_set: errno == EDOM;
550 behavior nan:
551 assumes nan_arg: \is_NaN(x);
552 assigns \result \from x;
553 ensures nan_result: \is_NaN(\result);
554 ensures no_error: errno == \old(errno);
555 complete behaviors;
556 disjoint behaviors;
557 */
558 extern double acosh(double x);
559
560 /*@
561 assigns errno, \result \from x;
562 behavior normal:
563 assumes in_domain: \is_finite(x) && x >= 1;
564 assigns \result \from x;
565 ensures positive_result: \is_finite(\result) && \result >= 0;
566 ensures no_error: errno == \old(errno);
567 behavior infinite:
568 assumes is_plus_infinity: \is_plus_infinity(x);
569 assigns \result \from x;
570 ensures result_plus_infinity: \is_plus_infinity(\result);
571 ensures no_error: errno == \old(errno);
572 behavior domain_error:
573 assumes out_of_domain: \is_minus_infinity(x) || (\is_finite(x) && x < 1);
574 ensures nan_result: \is_NaN(\result);
575 ensures errno_set: errno == EDOM;
576 behavior nan:
577 assumes nan_arg: \is_NaN(x);
578 assigns \result \from x;
579 ensures nan_result: \is_NaN(\result);
580 ensures no_error: errno == \old(errno);
581 complete behaviors;
582 disjoint behaviors;
583 */
584 extern float acoshf(float x);
585
586 /*@
587 assigns errno, \result \from x;
588 behavior normal:
589 assumes in_domain: \is_finite(x) && x >= 1;
590 assigns \result \from x;
591 ensures positive_result: \is_finite(\result) && \result >= 0;
592 ensures no_error: errno == \old(errno);
593 behavior infinite:
594 assumes is_plus_infinity: \is_plus_infinity(x);
595 assigns \result \from x;
596 ensures result_plus_infinity: \is_plus_infinity(\result);
597 ensures no_error: errno == \old(errno);
598 behavior domain_error:
599 assumes out_of_domain: \is_minus_infinity(x) || (\is_finite(x) && x < 1);
600 ensures nan_result: \is_NaN(\result);
601 ensures errno_set: errno == EDOM;
602 behavior nan:
603 assumes nan_arg: \is_NaN(x);
604 assigns \result \from x;
605 ensures nan_result: \is_NaN(\result);
606 ensures no_error: errno == \old(errno);
607 complete behaviors;
608 disjoint behaviors;
609 */
610 extern long double acoshl(long double x);
611
612 extern double asinh(double x);
613 extern float asinhf(float x);
614 extern long double asinhl(long double x);
615
616 extern double atanh(double x);
617 extern float atanhf(float x);
618 extern long double atanhl(long double x);
619
620 extern double cosh(double x);
621 extern float coshf(float x);
622 extern long double coshl(long double x);
623
624 extern double sinh(double x);
625 extern float sinhf(float x);
626 extern long double sinhl(long double x);
627
628 extern double tanh(double x);
629 extern float tanhf(float x);
630 extern long double tanhl(long double x);
631
632 /*@
633 assigns errno, \result \from x;
634 behavior normal:
635 assumes finite_arg: \is_finite(x);
636 assumes domain_arg: x >= -0x1.74910d52d3051p9 && x <= 0x1.62e42fefa39efp+9;
637 assigns \result \from x;
638 ensures res_finite: \is_finite(\result);
639 ensures positive_result: \result > 0.;
640 ensures no_error: errno == \old(errno);
641 behavior overflow:
642 assumes overflow_arg: \is_finite(x) && x > 0x1.62e42fefa39efp+9;
643 ensures infinite_res: \is_plus_infinity(\result);
644 ensures errno_set: errno == ERANGE;
645 behavior plus_infinity:
646 assumes plus_infinity_arg: \is_plus_infinity(x);
647 assigns \result \from x;
648 ensures infinity_result: \is_plus_infinity(\result);
649 ensures no_error: errno == \old(errno);
650 behavior underflow:
651 assumes underflow_arg: \is_finite(x) && x < -0x1.74910d52d3051p9;
652 ensures zero_res: \result == 0.;
653 ensures errno_set: errno == ERANGE;
654 behavior minus_infinity:
655 assumes plus_infinity_arg: \is_minus_infinity(x);
656 assigns \result \from x;
657 ensures zero_result: \is_finite(\result) && \result == 0.;
658 ensures no_error: errno == \old(errno);
659 behavior nan:
660 assumes nan_arg: \is_NaN(x);
661 assigns \result \from x;
662 ensures nan_result: \is_NaN(\result);
663 ensures no_error: errno == \old(errno);
664 complete behaviors;
665 disjoint behaviors;
666 */
667 extern double exp(double x);
668
669 /*@
670 assigns errno, \result \from x;
671 behavior normal:
672 assumes finite_arg: \is_finite(x);
673 assumes domain_arg: x >= -0x1.9fe368p6 && x <= 0x1.62e42ep+6;
674 assigns \result \from x;
675 ensures res_finite: \is_finite(\result);
676 ensures positive_result: \result > 0.;
677 ensures no_error: errno == \old(errno);
678 behavior overflow:
679 assumes overflow_arg: \is_finite(x) && x > 0x1.62e42ep+6;
680 ensures infinite_res: \is_plus_infinity(\result);
681 ensures errno_set: errno == ERANGE;
682 behavior plus_infinity:
683 assumes plus_infinity_arg: \is_plus_infinity(x);
684 assigns \result \from x;
685 ensures infinity_result: \is_plus_infinity(\result);
686 ensures no_error: errno == \old(errno);
687 behavior underflow:
688 assumes underflow_arg: \is_finite(x) && x < -0x1.9fe368p6;
689 ensures zero_res: \result == 0.;
690 ensures errno_set: errno == ERANGE;
691 behavior minus_infinity:
692 assumes plus_infinity_arg: \is_minus_infinity(x);
693 assigns \result \from x;
694 ensures zero_result: \is_finite(\result) && \result == 0.;
695 ensures no_error: errno == \old(errno);
696 behavior nan:
697 assumes nan_arg: \is_NaN(x);
698 assigns \result \from x;
699 ensures nan_result: \is_NaN(\result);
700 ensures no_error: errno == \old(errno);
701 complete behaviors;
702 disjoint behaviors;
703 */
704 extern float expf(float x);
705
706 extern long double expl(long double x);
707
708 extern double exp2(double x);
709 extern float exp2f(float x);
710 extern long double exp2l(long double x);
711
712 extern double expm1(double x);
713 extern float expm1f(float x);
714 extern long double expm1l(long double x);
715
716 /*@
717 requires valid_exp: \valid(exp);
718 assigns \result, *exp \from x;
719 behavior normal:
720 assumes finite_arg: \is_finite(x);
721 assumes arg_nonzero: x != 0.0;
722 ensures finite_result: \is_finite(\result);
723 ensures bounded_result: 0.5 <= \result < 1.0;
724 ensures initialization:exp: \initialized(exp);
725 behavior infinite:
726 assumes infinite_arg: \is_plus_infinity(x) || \is_minus_infinity(x);
727 ensures infinite_result: \is_infinite(\result);
728 ensures result_same_infinite: \result == x;
729 behavior zero:
730 assumes zero_arg: \is_finite(x) && x == 0.;
731 ensures finite_result: \is_finite(\result);
732 ensures zero_result: \result == 0.0;
733 ensures initialization:exp: \initialized(exp);
734 ensures zero_exp: *exp == 0;
735 behavior nan:
736 assumes nan_arg: \is_NaN(x);
737 ensures nan_result: \is_NaN(\result);
738 complete behaviors;
739 disjoint behaviors;
740 */
741 extern double frexp(double x, int *exp);
742
743 /*@
744 requires valid_exp: \valid(exp);
745 assigns \result, *exp \from x;
746 behavior normal:
747 assumes finite_arg: \is_finite(x);
748 assumes arg_nonzero: x != 0.0;
749 ensures finite_result: \is_finite(\result);
750 ensures bounded_result: 0.5 <= \result < 1.0;
751 ensures initialization:exp: \initialized(exp);
752 behavior infinite:
753 assumes infinite_arg: \is_plus_infinity(x) || \is_minus_infinity(x);
754 ensures infinite_result: \is_infinite(\result);
755 ensures result_same_infinite: \result == x;
756 behavior zero:
757 assumes zero_arg: \is_finite(x) && x == 0.;
758 ensures finite_result: \is_finite(\result);
759 ensures zero_result: \result == x;
760 ensures initialization:exp: \initialized(exp);
761 ensures zero_exp: *exp == 0;
762 behavior nan:
763 assumes nan_arg: \is_NaN(x);
764 ensures nan_result: \is_NaN(\result);
765 complete behaviors;
766 disjoint behaviors;
767 */
768 extern float frexpf(float x, int *exp);
769
770 /*@
771 requires valid_exp: \valid(exp);
772 assigns \result, *exp \from x;
773 behavior normal:
774 assumes finite_arg: \is_finite(x);
775 assumes arg_nonzero: x != 0.0;
776 ensures finite_result: \is_finite(\result);
777 ensures bounded_result: 0.5 <= \result < 1.0;
778 ensures initialization:exp: \initialized(exp);
779 behavior infinite:
780 assumes infinite_arg: \is_plus_infinity(x) || \is_minus_infinity(x);
781 ensures infinite_result: \is_infinite(\result);
782 ensures result_same_infinite: \result == x;
783 behavior zero:
784 assumes zero_arg: \is_finite(x) && x == 0.;
785 ensures finite_result: \is_finite(\result);
786 ensures zero_result: \result == x;
787 ensures initialization:exp: \initialized(exp);
788 ensures zero_exp: *exp == 0;
789 behavior nan:
790 assumes nan_arg: \is_NaN(x);
791 ensures nan_result: \is_NaN(\result);
792 complete behaviors;
793 disjoint behaviors;
794 */
795 extern long double frexpl(long double x, int *exp);
796
797 extern int ilogb(double x);
798 extern int ilogbf(float x);
799 extern int ilogbl(long double x);
800
801 /*@
802 assigns errno, \result \from x, exp;
803 behavior normal:
804 assumes finite_logic_res: \is_finite((double)(x * pow(2.0d, (double)exp)));
805 ensures finite_result: \is_finite(\result);
806 ensures errno: errno == ERANGE || errno == \old(errno); //ERANGE if underflow
807 behavior overflow_not_nan:
808 assumes not_nan_arg: !\is_NaN(x);
809 assumes infinite_logic_res: !\is_finite((double)(x * pow(2.0d, (double)exp)));
810 ensures infinite_result: \is_infinite(\result);
811 ensures errno: errno == ERANGE || errno == \old(errno);
812 behavior nan:
813 assumes nan_arg: \is_NaN(x);
814 assigns \result \from x;
815 ensures nan_result: \is_NaN(\result);
816 complete behaviors;
817 disjoint behaviors;
818 */
819 extern double ldexp(double x, int exp);
820
821 /*@
822 assigns errno, \result \from x, exp;
823 behavior normal:
824 assumes finite_logic_res: \is_finite((float)(x * pow(2.0f, (float)exp)));
825 ensures finite_result: \is_finite(\result);
826 ensures errno: errno == ERANGE || errno == \old(errno); //ERANGE if underflow
827 behavior overflow_not_nan:
828 assumes not_nan_arg: !\is_NaN(x);
829 assumes infinite_logic_res: !\is_finite((float)(x * pow(2.0f, (float)exp)));
830 ensures infinite_result: \is_infinite(\result);
831 ensures errno: errno == ERANGE || errno == \old(errno);
832 behavior nan:
833 assumes nan_arg: \is_NaN(x);
834 assigns \result \from x;
835 ensures nan_result: \is_NaN(\result);
836 complete behaviors;
837 disjoint behaviors;
838 */
839 extern float ldexpf(float x, int exp);
840
841 extern long double ldexpl(long double x, int exp);
842
843 /*@
844 assigns errno, \result \from x;
845 behavior normal:
846 assumes finite_arg: \is_finite(x);
847 assumes arg_positive: x > 0;
848 assigns \result \from x;
849 ensures finite_result: \is_finite(\result);
850 ensures no_error: errno == \old(errno);
851 behavior infinite:
852 assumes infinite_arg: \is_plus_infinity(x);
853 assigns \result \from x;
854 ensures infinite_result: \is_plus_infinity(\result);
855 ensures no_error: errno == \old(errno);
856 behavior zero:
857 assumes zero_arg: \is_finite(x) && x == 0.;
858 ensures infinite_result: \is_minus_infinity(\result); // -HUGE_VAL
859 ensures errno_set: errno == ERANGE;
860 behavior negative:
861 assumes negative_arg: \is_minus_infinity(x) || (\is_finite(x) && x < -0.);
862 ensures nan_result: \is_NaN(\result);
863 ensures errno_set: errno == EDOM;
864 behavior nan:
865 assumes nan_arg: \is_NaN(x);
866 assigns \result \from x;
867 ensures nan_result: \is_NaN(\result);
868 ensures no_error: errno == \old(errno);
869 complete behaviors;
870 disjoint behaviors;
871 */
872 extern double log(double x);
873
874 /*@
875 assigns errno, \result \from x;
876 behavior normal:
877 assumes finite_arg: \is_finite(x);
878 assumes arg_positive: x > 0;
879 assigns \result \from x;
880 ensures finite_result: \is_finite(\result);
881 ensures no_error: errno == \old(errno);
882 behavior infinite:
883 assumes infinite_arg: \is_plus_infinity(x);
884 assigns \result \from x;
885 ensures infinite_result: \is_plus_infinity(\result);
886 ensures no_error: errno == \old(errno);
887 behavior zero:
888 assumes zero_arg: \is_finite(x) && x == 0.;
889 ensures infinite_result: \is_minus_infinity(\result); // -HUGE_VALF
890 ensures errno_set: errno == ERANGE;
891 behavior negative:
892 assumes negative_arg: \is_minus_infinity(x) || (\is_finite(x) && x < -0.);
893 ensures nan_result: \is_NaN(\result);
894 ensures errno_set: errno == EDOM;
895 behavior nan:
896 assumes nan_arg: \is_NaN(x);
897 assigns \result \from x;
898 ensures nan_result: \is_NaN(\result);
899 ensures no_error: errno == \old(errno);
900 complete behaviors;
901 disjoint behaviors;
902 */
903 extern float logf(float x);
904
905 /*@
906 assigns errno, \result \from x;
907 behavior normal:
908 assumes finite_arg: \is_finite(x);
909 assumes arg_positive: x > 0;
910 assigns \result \from x;
911 ensures finite_result: \is_finite(\result);
912 ensures no_error: errno == \old(errno);
913 behavior infinite:
914 assumes infinite_arg: \is_plus_infinity(x);
915 assigns \result \from x;
916 ensures infinite_result: \is_plus_infinity(\result);
917 ensures no_error: errno == \old(errno);
918 behavior zero:
919 assumes zero_arg: \is_finite(x) && x == 0.;
920 ensures infinite_result: \is_minus_infinity(\result); // -HUGE_VALL
921 ensures errno_set: errno == ERANGE;
922 behavior negative:
923 assumes negative_arg: \is_minus_infinity(x) || (\is_finite(x) && x < -0.);
924 ensures nan_result: \is_NaN(\result);
925 ensures errno_set: errno == EDOM;
926 behavior nan:
927 assumes nan_arg: \is_NaN(x);
928 assigns \result \from x;
929 ensures nan_result: \is_NaN(\result);
930 ensures no_error: errno == \old(errno);
931 complete behaviors;
932 disjoint behaviors;
933 */
934 extern long double logl(long double x);
935
936 /*@
937 assigns errno, \result \from x;
938 behavior normal:
939 assumes finite_arg: \is_finite(x);
940 assumes arg_positive: x > 0;
941 assigns \result \from x;
942 ensures finite_result: \is_finite(\result);
943 ensures no_error: errno == \old(errno);
944 behavior infinite:
945 assumes infinite_arg: \is_plus_infinity(x);
946 assigns \result \from x;
947 ensures infinite_result: \is_plus_infinity(\result);
948 ensures no_error: errno == \old(errno);
949 behavior zero:
950 assumes zero_arg: \is_finite(x) && x == 0.;
951 ensures infinite_result: \is_minus_infinity(\result); // -HUGE_VAL
952 ensures errno_set: errno == ERANGE;
953 behavior negative:
954 assumes negative_arg: \is_minus_infinity(x) || (\is_finite(x) && x < -0.);
955 ensures nan_result: \is_NaN(\result);
956 ensures errno_set: errno == EDOM;
957 behavior nan:
958 assumes nan_arg: \is_NaN(x);
959 assigns \result \from x;
960 ensures nan_result: \is_NaN(\result);
961 ensures no_error: errno == \old(errno);
962 complete behaviors;
963 disjoint behaviors;
964 */
965 extern double log10(double x);
966
967 /*@
968 assigns errno, \result \from x;
969 behavior normal:
970 assumes finite_arg: \is_finite(x);
971 assumes arg_positive: x > 0;
972 assigns \result \from x;
973 ensures finite_result: \is_finite(\result);
974 ensures no_error: errno == \old(errno);
975 behavior infinite:
976 assumes infinite_arg: \is_plus_infinity(x);
977 assigns \result \from x;
978 ensures infinite_result: \is_plus_infinity(\result);
979 ensures no_error: errno == \old(errno);
980 behavior zero:
981 assumes zero_arg: \is_finite(x) && x == 0.;
982 ensures infinite_result: \is_minus_infinity(\result); // -HUGE_VALF
983 ensures errno_set: errno == ERANGE;
984 behavior negative:
985 assumes negative_arg: \is_minus_infinity(x) || (\is_finite(x) && x < -0.);
986 ensures nan_result: \is_NaN(\result);
987 ensures errno_set: errno == EDOM;
988 behavior nan:
989 assumes nan_arg: \is_NaN(x);
990 assigns \result \from x;
991 ensures nan_result: \is_NaN(\result);
992 ensures no_error: errno == \old(errno);
993 complete behaviors;
994 disjoint behaviors;
995 */
996 extern float log10f(float x);
997
998 /*@
999 assigns errno, \result \from x;
1000 behavior normal:
1001 assumes finite_arg: \is_finite(x);
1002 assumes arg_positive: x > 0;
1003 assigns \result \from x;
1004 ensures finite_result: \is_finite(\result);
1005 ensures no_error: errno == \old(errno);
1006 behavior infinite:
1007 assumes infinite_arg: \is_plus_infinity(x);
1008 assigns \result \from x;
1009 ensures infinite_result: \is_plus_infinity(\result);
1010 ensures no_error: errno == \old(errno);
1011 behavior zero:
1012 assumes zero_arg: \is_finite(x) && x == 0.;
1013 ensures infinite_result: \is_minus_infinity(\result); // -HUGE_VALL
1014 ensures errno_set: errno == ERANGE;
1015 behavior negative:
1016 assumes negative_arg: \is_minus_infinity(x) || (\is_finite(x) && x < -0.);
1017 ensures nan_result: \is_NaN(\result);
1018 ensures errno_set: errno == EDOM;
1019 behavior nan:
1020 assumes nan_arg: \is_NaN(x);
1021 assigns \result \from x;
1022 ensures nan_result: \is_NaN(\result);
1023 ensures no_error: errno == \old(errno);
1024 complete behaviors;
1025 disjoint behaviors;
1026 */
1027 extern long double log10l(long double x);
1028
1029 extern double log1p(double x);
1030 extern float log1pf(float x);
1031 extern long double log1pl(long double x);
1032
1033 /*@
1034 assigns errno, \result \from x;
1035 behavior normal:
1036 assumes finite_arg: \is_finite(x);
1037 assumes arg_positive: x > 0;
1038 assigns \result \from x;
1039 ensures finite_result: \is_finite(\result);
1040 ensures no_error: errno == \old(errno);
1041 behavior infinite:
1042 assumes infinite_arg: \is_plus_infinity(x);
1043 assigns \result \from x;
1044 ensures infinite_result: \is_plus_infinity(\result);
1045 ensures no_error: errno == \old(errno);
1046 behavior zero:
1047 assumes zero_arg: \is_finite(x) && x == 0.;
1048 ensures infinite_result: \is_minus_infinity(\result); // -HUGE_VAL
1049 ensures errno_set: errno == ERANGE;
1050 behavior negative:
1051 assumes negative_arg: \is_minus_infinity(x) || (\is_finite(x) && x < -0.);
1052 ensures nan_result: \is_NaN(\result);
1053 ensures errno_set: errno == EDOM;
1054 behavior nan:
1055 assumes nan_arg: \is_NaN(x);
1056 assigns \result \from x;
1057 ensures nan_result: \is_NaN(\result);
1058 ensures no_error: errno == \old(errno);
1059 complete behaviors;
1060 disjoint behaviors;
1061 */
1062 extern double log2(double x);
1063
1064 /*@
1065 assigns errno, \result \from x;
1066 behavior normal:
1067 assumes finite_arg: \is_finite(x);
1068 assumes arg_positive: x > 0;
1069 assigns \result \from x;
1070 ensures finite_result: \is_finite(\result);
1071 ensures no_error: errno == \old(errno);
1072 behavior infinite:
1073 assumes infinite_arg: \is_plus_infinity(x);
1074 assigns \result \from x;
1075 ensures infinite_result: \is_plus_infinity(\result);
1076 ensures no_error: errno == \old(errno);
1077 behavior zero:
1078 assumes zero_arg: \is_finite(x) && x == 0.;
1079 ensures infinite_result: \is_minus_infinity(\result); // -HUGE_VALF
1080 ensures errno_set: errno == ERANGE;
1081 behavior negative:
1082 assumes negative_arg: \is_minus_infinity(x) || (\is_finite(x) && x < -0.);
1083 ensures nan_result: \is_NaN(\result);
1084 ensures errno_set: errno == EDOM;
1085 behavior nan:
1086 assumes nan_arg: \is_NaN(x);
1087 assigns \result \from x;
1088 ensures nan_result: \is_NaN(\result);
1089 ensures no_error: errno == \old(errno);
1090 complete behaviors;
1091 disjoint behaviors;
1092 */
1093 extern float log2f(float x);
1094
1095 /*@
1096 assigns errno, \result \from x;
1097 behavior normal:
1098 assumes finite_arg: \is_finite(x);
1099 assumes arg_positive: x > 0;
1100 assigns \result \from x;
1101 ensures finite_result: \is_finite(\result);
1102 ensures no_error: errno == \old(errno);
1103 behavior infinite:
1104 assumes infinite_arg: \is_plus_infinity(x);
1105 assigns \result \from x;
1106 ensures infinite_result: \is_plus_infinity(\result);
1107 ensures no_error: errno == \old(errno);
1108 behavior zero:
1109 assumes zero_arg: \is_finite(x) && x == 0.;
1110 ensures infinite_result: \is_minus_infinity(\result); // -HUGE_VALL
1111 ensures errno_set: errno == ERANGE;
1112 behavior negative:
1113 assumes negative_arg: \is_minus_infinity(x) || (\is_finite(x) && x < -0.);
1114 ensures nan_result: \is_NaN(\result);
1115 ensures errno_set: errno == EDOM;
1116 behavior nan:
1117 assumes nan_arg: \is_NaN(x);
1118 assigns \result \from x;
1119 ensures nan_result: \is_NaN(\result);
1120 ensures no_error: errno == \old(errno);
1121 complete behaviors;
1122 disjoint behaviors;
1123 */
1124 extern long double log2l(long double x);
1125
1126 extern double logb(double x);
1127 extern float logbf(float x);
1128 extern long double logbl(long double x);
1129
1130 extern double modf(double value, double *iptr);
1131 extern float modff(float value, float *iptr);
1132 extern long double modfl(long double value, long double *iptr);
1133
1134 extern double scalbn(double x, int n);
1135 extern float scalbnf(float x, int n);
1136 extern long double scalbnl(long double x, int n);
1137
1138 extern double scalbln(double x, long int n);
1139 extern float scalblnf(float x, long int n);
1140 extern long double scalblnl(long double x, long int n);
1141
1142 extern double cbrt(double x);
1143 extern float cbrtf(float x);
1144 extern long double cbrtl(long double x);
1145
1146 /*@
1147 assigns \result \from x;
1148 behavior normal:
1149 assumes finite_arg: \is_finite(x);
1150 ensures res_finite: \is_finite(\result);
1151 ensures positive_result: \result >= 0.;
1152 ensures equal_magnitude_result: \result == x || \result == -x;
1153 behavior infinity:
1154 assumes infinite_arg: \is_infinite(x);
1155 ensures infinite_result: \is_plus_infinity(\result);
1156 behavior nan:
1157 assumes nan_arg: \is_NaN(x);
1158 ensures nan_result: \is_NaN(\result);
1159 complete behaviors;
1160 disjoint behaviors;
1161 */
1162 extern double fabs(double x);
1163
1164 /*@
1165 assigns \result \from x;
1166 behavior normal:
1167 assumes finite_arg: \is_finite(x);
1168 ensures res_finite: \is_finite(\result);
1169 ensures positive_result: \result >= 0.;
1170 ensures equal_magnitude_result: \result == x || \result == -x;
1171 behavior infinity:
1172 assumes infinite_arg: \is_infinite(x);
1173 ensures infinite_result: \is_plus_infinity(\result);
1174 behavior nan:
1175 assumes nan_arg: \is_NaN(x);
1176 ensures nan_result: \is_NaN(\result);
1177 complete behaviors;
1178 disjoint behaviors;
1179 */
1180 extern float fabsf(float x);
1181
1182 /*@
1183 assigns \result \from x;
1184 behavior normal:
1185 assumes finite_arg: \is_finite(x);
1186 ensures res_finite: \is_finite(\result);
1187 ensures positive_result: \result >= 0.;
1188 ensures equal_magnitude_result: \result == x || \result == -x;
1189 behavior infinity:
1190 assumes infinite_arg: \is_infinite(x);
1191 ensures infinite_result: \is_plus_infinity(\result);
1192 behavior nan:
1193 assumes nan_arg: \is_NaN(x);
1194 ensures nan_result: \is_NaN(\result);
1195 complete behaviors;
1196 disjoint behaviors;
1197 */
1198 extern long double fabsl(long double x);
1199
1200 extern double hypot(double x, double y);
1201 extern float hypotf(float x, float y);
1202 extern long double hypotl(long double x, long double y);
1203
1204 /*@
1205 assigns errno, \result \from x, y;
1206 behavior normal:
1207 assumes finite_logic_res: \is_finite(pow(x, y));
1208 ensures finite_result: \is_finite(\result);
1209 ensures errno: errno == ERANGE || errno == \old(errno);
1210 behavior overflow:
1211 assumes infinite_logic_res: !\is_finite(pow(x, y));
1212 ensures infinite_result: !\is_finite(\result);
1213 ensures errno: errno == ERANGE || errno == EDOM || errno == \old(errno);
1214 complete behaviors;
1215 disjoint behaviors;
1216 */
1217 extern double pow(double x, double y);
1218
1219 /*@
1220 assigns errno, \result \from x, y;
1221 behavior normal:
1222 assumes finite_logic_res: \is_finite(pow(x, y));
1223 ensures finite_result: \is_finite(\result);
1224 ensures errno: errno == ERANGE || errno == \old(errno);
1225 behavior overflow:
1226 assumes infinite_logic_res: !\is_finite(pow(x, y));
1227 ensures infinite_result: !\is_finite(\result);
1228 ensures errno: errno == ERANGE || errno == EDOM || errno == \old(errno);
1229 complete behaviors;
1230 disjoint behaviors;
1231 */
1232 extern float powf(float x, float y);
1233
1234 extern long double powl(long double x, long double y);
1235
1236 /*@
1237 assigns errno, \result \from x;
1238 behavior normal:
1239 assumes finite_arg: \is_finite(x);
1240 assumes arg_positive: x >= -0.;
1241 assigns \result \from x;
1242 ensures finite_result: \is_finite(\result);
1243 ensures positive_result: \result >= -0.;
1244 ensures result_value: \result == sqrt(x);
1245 ensures no_error: errno == \old(errno);
1246 behavior negative:
1247 assumes negative_arg: \is_minus_infinity(x) || (\is_finite(x) && x < -0.);
1248 ensures nan_result: \is_NaN(\result);
1249 ensures errno_set: errno == EDOM;
1250 behavior infinity:
1251 assumes infinite_arg: \is_plus_infinity(x);
1252 assigns \result \from x;
1253 ensures infinite_result: \is_plus_infinity(\result);
1254 ensures no_error: errno == \old(errno);
1255 behavior nan:
1256 assumes nan_arg: \is_NaN(x);
1257 assigns \result \from x;
1258 ensures nan_result: \is_NaN(\result);
1259 ensures no_error: errno == \old(errno);
1260 complete behaviors;
1261 disjoint behaviors;
1262 */
1263 extern double sqrt(double x);
1264
1265 /*@
1266 assigns errno, \result \from x;
1267 behavior normal:
1268 assumes finite_arg: \is_finite(x);
1269 assumes arg_positive: x >= -0.;
1270 assigns \result \from x;
1271 ensures finite_result: \is_finite(\result);
1272 ensures positive_result: \result >= -0.;
1273 ensures result_value: \result == sqrt(x);
1274 ensures no_error: errno == \old(errno);
1275 behavior negative:
1276 assumes negative_arg: \is_minus_infinity(x) || (\is_finite(x) && x < -0.);
1277 ensures nan_result: \is_NaN(\result);
1278 ensures errno_set: errno == EDOM;
1279 behavior infinity:
1280 assumes infinite_arg: \is_plus_infinity(x);
1281 assigns \result \from x;
1282 ensures infinite_result: \is_plus_infinity(\result);
1283 ensures no_error: errno == \old(errno);
1284 behavior nan:
1285 assumes nan_arg: \is_NaN(x);
1286 assigns \result \from x;
1287 ensures nan_result: \is_NaN(\result);
1288 ensures no_error: errno == \old(errno);
1289 complete behaviors;
1290 disjoint behaviors;
1291 */
1292 extern float sqrtf(float x);
1293
1294 /*@
1295 assigns errno, \result \from x;
1296 behavior normal:
1297 assumes finite_arg: \is_finite(x);
1298 assumes arg_positive: x >= -0.;
1299 assigns \result \from x;
1300 ensures finite_result: \is_finite(\result);
1301 ensures positive_result: \result >= -0.;
1302 ensures no_error: errno == \old(errno);
1303 behavior negative:
1304 assumes negative_arg: \is_minus_infinity(x) || (\is_finite(x) && x < -0.);
1305 ensures nan_result: \is_NaN(\result);
1306 ensures errno_set: errno == EDOM;
1307 behavior infinity:
1308 assumes infinite_arg: \is_plus_infinity(x);
1309 assigns \result \from x;
1310 ensures infinite_result: \is_plus_infinity(\result);
1311 ensures no_error: errno == \old(errno);
1312 behavior nan:
1313 assumes nan_arg: \is_NaN(x);
1314 assigns \result \from x;
1315 ensures nan_result: \is_NaN(\result);
1316 ensures no_error: errno == \old(errno);
1317 complete behaviors;
1318 disjoint behaviors;
1319 */
1320 extern long double sqrtl(long double x);
1321
1322 extern double erf(double x);
1323 extern float erff(float x);
1324 extern long double erfl(long double x);
1325
1326 extern double erfc(double x);
1327 extern float erfcf(float x);
1328 extern long double erfcl(long double x);
1329
1330 extern double lgamma(double x);
1331 extern float lgammaf(float x);
1332 extern long double lgammal(long double x);
1333
1334 extern double tgamma(double x);
1335 extern float tgammaf(float x);
1336 extern long double tgammal(long double x);
1337
1338 /*@
1339 assigns \result \from x;
1340 behavior finite:
1341 assumes finite_arg: \is_finite(x);
1342 ensures finite_result: \is_finite(\result);
1343 behavior infinite:
1344 assumes infinite_arg: \is_infinite(x);
1345 ensures infinite_result: \is_infinite(\result);
1346 ensures equal_result: \result == x;
1347 behavior nan:
1348 assumes nan_arg: \is_NaN(x);
1349 ensures nan_result: \is_NaN(\result);
1350 complete behaviors;
1351 disjoint behaviors;
1352 */
1353 extern double ceil(double x);
1354
1355 /*@
1356 assigns \result \from x;
1357 behavior finite:
1358 assumes finite_arg: \is_finite(x);
1359 ensures finite_result: \is_finite(\result);
1360 behavior infinite:
1361 assumes infinite_arg: \is_infinite(x);
1362 ensures infinite_result: \is_infinite(\result);
1363 ensures equal_result: \result == x;
1364 behavior nan:
1365 assumes nan_arg: \is_NaN(x);
1366 ensures nan_result: \is_NaN(\result);
1367 complete behaviors;
1368 disjoint behaviors;
1369 */
1370 extern float ceilf(float x);
1371
1372 /*@
1373 assigns \result \from x;
1374 behavior finite:
1375 assumes finite_arg: \is_finite(x);
1376 ensures finite_result: \is_finite(\result);
1377 behavior infinite:
1378 assumes infinite_arg: \is_infinite(x);
1379 ensures infinite_result: \is_infinite(\result);
1380 ensures equal_result: \result == x;
1381 behavior nan:
1382 assumes nan_arg: \is_NaN(x);
1383 ensures nan_result: \is_NaN(\result);
1384 complete behaviors;
1385 disjoint behaviors;
1386 */
1387 extern long double ceill(long double x);
1388
1389 /*@
1390 assigns \result \from x;
1391 behavior finite:
1392 assumes finite_arg: \is_finite(x);
1393 ensures finite_result: \is_finite(\result);
1394 behavior infinite:
1395 assumes infinite_arg: \is_infinite(x);
1396 ensures infinite_result: \is_infinite(\result);
1397 ensures equal_result: \result == x;
1398 behavior nan:
1399 assumes nan_arg: \is_NaN(x);
1400 ensures nan_result: \is_NaN(\result);
1401 complete behaviors;
1402 disjoint behaviors;
1403 */
1404 extern double floor(double x);
1405
1406 /*@
1407 assigns \result \from x;
1408 behavior finite:
1409 assumes finite_arg: \is_finite(x);
1410 ensures finite_result: \is_finite(\result);
1411 behavior infinite:
1412 assumes infinite_arg: \is_infinite(x);
1413 ensures infinite_result: \is_infinite(\result);
1414 ensures equal_result: \result == x;
1415 behavior nan:
1416 assumes nan_arg: \is_NaN(x);
1417 ensures nan_result: \is_NaN(\result);
1418 complete behaviors;
1419 disjoint behaviors;
1420 */
1421 extern float floorf(float x);
1422
1423 /*@
1424 assigns \result \from x;
1425 behavior finite:
1426 assumes finite_arg: \is_finite(x);
1427 ensures finite_result: \is_finite(\result);
1428 behavior infinite:
1429 assumes infinite_arg: \is_infinite(x);
1430 ensures infinite_result: \is_infinite(\result);
1431 ensures equal_result: \result == x;
1432 behavior nan:
1433 assumes nan_arg: \is_NaN(x);
1434 ensures nan_result: \is_NaN(\result);
1435 complete behaviors;
1436 disjoint behaviors;
1437 */
1438 extern long double floorl(long double x);
1439
1440 extern double nearbyint(double x);
1441 extern float nearbyintf(float x);
1442 extern long double nearbyintl(long double x);
1443
1444 extern double rint(double x);
1445 extern float rintf(float x);
1446 extern long double rintl(long double x);
1447
1448 extern long int lrint(double x);
1449 extern long int lrintf(float x);
1450 extern long int lrintl(long double x);
1451
1452 extern long long int llrint(double x);
1453 extern long long int llrintf(float x);
1454 extern long long int llrintl(long double x);
1455
1456 /*@
1457 assigns \result \from x;
1458 behavior finite:
1459 assumes finite_arg: \is_finite(x);
1460 ensures finite_result: \is_finite(\result);
1461 behavior infinite:
1462 assumes infinite_arg: \is_infinite(x);
1463 ensures infinite_result: \is_infinite(\result);
1464 ensures equal_result: \result == x;
1465 behavior nan:
1466 assumes nan_arg: \is_NaN(x);
1467 ensures nan_result: \is_NaN(\result);
1468 complete behaviors;
1469 disjoint behaviors;
1470 */
1471 extern double round(double x);
1472
1473 /*@
1474 assigns \result \from x;
1475 behavior finite:
1476 assumes finite_arg: \is_finite(x);
1477 ensures finite_result: \is_finite(\result);
1478 behavior infinite:
1479 assumes infinite_arg: \is_infinite(x);
1480 ensures infinite_result: \is_infinite(\result);
1481 ensures equal_result: \result == x;
1482 behavior nan:
1483 assumes nan_arg: \is_NaN(x);
1484 ensures nan_result: \is_NaN(\result);
1485 complete behaviors;
1486 disjoint behaviors;
1487 */
1488 extern float roundf(float x);
1489
1490 /*@
1491 assigns \result \from x;
1492 behavior finite:
1493 assumes finite_arg: \is_finite(x);
1494 ensures finite_result: \is_finite(\result);
1495 behavior infinite:
1496 assumes infinite_arg: \is_infinite(x);
1497 ensures infinite_result: \is_infinite(\result);
1498 ensures equal_result: \result == x;
1499 behavior nan:
1500 assumes nan_arg: \is_NaN(x);
1501 ensures nan_result: \is_NaN(\result);
1502 complete behaviors;
1503 disjoint behaviors;
1504 */
1505 extern long double roundl(long double x);
1506
1507 extern long int lround(double x);
1508 extern long int lroundf(float x);
1509 extern long int lroundl(long double x);
1510
1511 extern long long int llround(double x);
1512 extern long long int llroundf(float x);
1513 extern long long int llroundl(long double x);
1514
1515 /*@
1516 assigns \result \from x;
1517 behavior finite:
1518 assumes finite_arg: \is_finite(x);
1519 ensures finite_result: \is_finite(\result);
1520 behavior infinite:
1521 assumes infinite_arg: \is_infinite(x);
1522 ensures infinite_result: \is_infinite(\result);
1523 ensures equal_result: \result == x;
1524 behavior nan:
1525 assumes nan_arg: \is_NaN(x);
1526 ensures nan_result: \is_NaN(\result);
1527 complete behaviors;
1528 disjoint behaviors;
1529 */
1530 extern double trunc(double x);
1531
1532 /*@
1533 assigns \result \from x;
1534 behavior finite:
1535 assumes finite_arg: \is_finite(x);
1536 ensures finite_result: \is_finite(\result);
1537 behavior infinite:
1538 assumes infinite_arg: \is_infinite(x);
1539 ensures infinite_result: \is_infinite(\result);
1540 ensures equal_result: \result == x;
1541 behavior nan:
1542 assumes nan_arg: \is_NaN(x);
1543 ensures nan_result: \is_NaN(\result);
1544 complete behaviors;
1545 disjoint behaviors;
1546 */
1547 extern float truncf(float x);
1548
1549 /*@
1550 assigns \result \from x;
1551 behavior finite:
1552 assumes finite_arg: \is_finite(x);
1553 ensures finite_result: \is_finite(\result);
1554 behavior infinite:
1555 assumes infinite_arg: \is_infinite(x);
1556 ensures infinite_result: \is_infinite(\result);
1557 ensures equal_result: \result == x;
1558 behavior nan:
1559 assumes nan_arg: \is_NaN(x);
1560 ensures nan_result: \is_NaN(\result);
1561 complete behaviors;
1562 disjoint behaviors;
1563 */
1564 extern long double truncl(long double x);
1565
1566 /*@
1567 assigns errno, \result \from x, y;
1568 behavior normal:
1569 assumes in_domain: !\is_NaN(x) && !\is_NaN(y) && y != 0.;
1570 assigns \result \from x, y;
1571 ensures finite_result: \is_finite(\result);
1572 ensures no_error: errno == \old(errno);
1573 behavior domain_error:
1574 assumes out_of_domain: \is_infinite(x) || y == 0.;
1575 ensures nan_result: \is_NaN(\result);
1576 ensures errno_set: errno == EDOM;
1577 behavior nan:
1578 assumes nan_args: \is_NaN(x) || \is_NaN(y);
1579 assigns \result \from x, y;
1580 ensures nan_result: \is_NaN(\result);
1581 ensures no_error: errno == \old(errno);
1582 complete behaviors;
1583 disjoint behaviors;
1584 */
1585 extern double fmod(double x, double y);
1586
1587 /*@
1588 assigns errno, \result \from x, y;
1589 behavior normal:
1590 assumes in_domain: !\is_NaN(x) && !\is_NaN(y) && y != 0.;
1591 assigns \result \from x, y;
1592 ensures finite_result: \is_finite(\result);
1593 ensures no_error: errno == \old(errno);
1594 behavior domain_error:
1595 assumes out_of_domain: \is_infinite(x) || y == 0.;
1596 ensures nan_result: \is_NaN(\result);
1597 ensures errno_set: errno == EDOM;
1598 behavior nan:
1599 assumes nan_args: \is_NaN(x) || \is_NaN(y);
1600 assigns \result \from x, y;
1601 ensures nan_result: \is_NaN(\result);
1602 ensures no_error: errno == \old(errno);
1603 complete behaviors;
1604 disjoint behaviors;
1605 */
1606 extern float fmodf(float x, float y);
1607
1608 extern long double fmodl(long double x, long double y);
1609
1610 extern double remainder(double x, double y);
1611 extern float remainderf(float x, float y);
1612 extern long double remainderl(long double x, long double y);
1613
1614 extern double remquo(double x, double y, int *quo);
1615 extern float remquof(float x, float y, int *quo);
1616 extern long double remquol(long double x, long double y, int *quo);
1617
1618 extern double copysign(double x, double y);
1619 extern float copysignf(float x, float y);
1620 extern long double copysignl(long double x, long double y);
1621
1622 /*@
1623 requires tagp_valid_string: valid_read_string(tagp);
1624 assigns \result \from indirect:tagp[0..];
1625 ensures result_is_nan: \is_NaN(\result);
1626 */
1627 extern double nan(const char *tagp);
1628
1629 /*@
1630 requires tagp_valid_string: valid_read_string(tagp);
1631 assigns \result \from indirect:tagp[0..];
1632 ensures result_is_nan: \is_NaN(\result);
1633 */
1634 extern float nanf(const char *tagp);
1635
1636 /*@
1637 requires tagp_valid_string: valid_read_string(tagp);
1638 assigns \result \from indirect:tagp[0..];
1639 ensures result_is_nan: \is_NaN(\result);
1640 */
1641 extern long double nanl(const char *tagp);
1642
1643 extern double nextafter(double x, double y);
1644 extern float nextafterf(float x, float y);
1645 extern long double nextafterl(long double x, long double y);
1646
1647 extern double nexttoward(double x, long double y);
1648 extern float nexttowardf(float x, long double y);
1649 extern long double nexttowardl(long double x, long double y);
1650
1651 extern double fdim(double x, double y);
1652 extern float fdimf(float x, float y);
1653 extern long double fdiml(long double x, long double y);
1654
1655 extern double fmax(double x, double y);
1656 extern float fmaxf(float x, float y);
1657 extern long double fmaxl(long double x, long double y);
1658
1659 extern double fmin(double x, double y);
1660 extern float fminf(float x, float y);
1661 extern long double fminl(long double x, long double y);
1662
1663 extern double fma(double x, double y, double z);
1664 extern float fmaf(float x, float y, float z);
1665 extern long double fmal(long double x, long double y, long double z);
1666
1667 /*@
1668 assigns \result \from f;
1669 behavior finite:
1670 assumes isfinite_f: \is_finite(f);
1671 ensures nonzero_result: \result > 0 || \result < 0;
1672 behavior nonfinite:
1673 assumes nonfinite_f: !\is_finite(f);
1674 ensures zero_result: \result == 0;
1675 complete behaviors;
1676 disjoint behaviors;
1677 */
1678 extern int __finitef(float f);
1679
1680 /*@
1681 assigns \result \from d;
1682 behavior finite:
1683 assumes isfinite_d: \is_finite(d);
1684 ensures nonzero_result: \result > 0 || \result < 0;
1685 behavior nonfinite:
1686 assumes nonfinite_d: !\is_finite(d);
1687 ensures zero_result: \result == 0;
1688 complete behaviors;
1689 disjoint behaviors;
1690 */
1691 extern int __finite(double d);
1692
1693 # define isfinite(x) \
1694 (sizeof (x) == sizeof (float) ? __finitef (x) : __finite (x))
1695
1696 //The (integer x) argument is just here because a function without argument is
1697 //applied differently in ACSL and C
1698
1699 /*@
1700
1701 logic float __fc_infinity(integer x) = \plus_infinity;
1702 logic float __fc_nan(integer x) = \NaN;
1703
1704 @*/
1705
1706 /*@
1707 ensures result_is_infinity: \is_plus_infinity(\result);
1708 assigns \result \from \nothing;
1709 @*/
1710 extern float __fc_infinity(int x);
1711
1712 /*@
1713 ensures result_is_nan: \is_NaN(\result);
1714 assigns \result \from \nothing;
1715 @*/
1716 extern float __fc_nan(int x);
1717
1718
1719 #define INFINITY __fc_infinity(0)
1720 #define NAN __fc_nan(0)
1721
1722 #define HUGE_VALF INFINITY
1723 #define HUGE_VAL ((double)INFINITY)
1724 #define HUGE_VALL ((long double)INFINITY)
1725
1726
1727 __END_DECLS
1728
1729 __POP_FC_STDLIB
1730 #endif