From 73a081bd55c0f9c38acfd5b379daf80b91af9a11 Mon Sep 17 00:00:00 2001 From: Stephen Heumann Date: Sat, 20 Nov 2021 19:33:04 -0600 Subject: [PATCH] Add header declarations and documentation for new math functions. --- ORCACDefs/math.h | 46 +++++++++++++++++++++++ cc.notes | 98 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 144 insertions(+) diff --git a/ORCACDefs/math.h b/ORCACDefs/math.h index faca23c..b82e897 100644 --- a/ORCACDefs/math.h +++ b/ORCACDefs/math.h @@ -24,6 +24,9 @@ typedef long double double_t; #define NAN (0.0F/0.0F) +#define ILOGB0 (-32767-1) +#define ILOGBNAN (-32767-1) + #define FP_INFINITE 0xFE #define FP_NAN 0xFD #define FP_NORMAL 0x00 @@ -81,4 +84,47 @@ double ldexp(double, int); double modf(double, double *); double pow(double, double); +double cbrt(double); +float cbrtf(float); +long double cbrtl(long double); +double copysign(double, double); +float copysignf(float, float); +long double copysignl(long double, long double); +double exp2(double); +float exp2f(float); +long double exp2l(long double); +double expm1(double); +float expm1f(float); +long double expm1l(long double); +int ilogb(double); +int ilogbf(float); +int ilogbl(long double); +double log1p(double); +float log1pf(float); +long double log1pl(long double); +double log2(double); +float log2f(float); +long double log2l(long double); +double logb(double); +float logbf(float); +long double logbl(long double); +long lrint(double); +long lrintf(float); +long lrintl(long double); +double remainder(double, double); +float remainderf(float, float); +long double remainderl(long double, long double); +double remquo(double, double, int *); +float remquof(float, float, int *); +long double remquol(long double, long double, int *); +double rint(double); +float rintf(float); +long double rintl(long double); +double scalbn(double, int); +float scalbnf(float, int); +long double scalbnl(long double, int); +double trunc(double); +float truncf(float); +long double truncl(long double); + #endif diff --git a/cc.notes b/cc.notes index 57b2512..43feeca 100644 --- a/cc.notes +++ b/cc.notes @@ -873,6 +873,104 @@ int isunordered(real-floating x, real-floating y); These macros accept arguments of any real floating types, i.e. float, double, or long double. They return 1 if x and y have the indicated relationship, or 0 if they do not. These macros differ from the ordinary relational operators in that the macros will not raise the "invalid" floating-point exception if x and y are unordered because one or both is a quiet NaN. (In ORCA/C, they will raise the "invalid" exception for signaling NaNs.) +19. (C99) Several new functions operating on floating-point values have been added. Each of these has a version using each of the three real floating types (float, double, and long double) for its arguments and/or return values, as shown below. Under ORCA/C, however, these types are all passed and returned using the SANE extended format (the format of long double), and for most of these functions the three versions will actually behave identically. + +Also, note that under ORCA/C these functions generally will not set errno for error conditions (e.g. domain and range errors). However, they do set floating-point exceptions as appropriate. The functions documented above can be used to retrieve these exceptions, allowing errors to be detected. + +#include +double cbrt(double x); +float cbrtf(float x); +long double cbrtl(long double x); + +These functions return the cube root of x. + +#include +double copysign(double x, double y); +float copysignf(float x, float y); +long double copysignl(long double x, long double y); + +These functions return a value with the magnitude of x and the sign of y. If x is a NaN, they return a NaN with the same NaN code but with the sign bit of y. + +#include +double exp2(double x); +float exp2f(float x); +long double exp2l(long double x); + +These functions return 2^x. + +#include +double expm1(double x); +float expm1f(float x); +long double expm1l(long double x); + +These functions return e^x - 1. + +#include +int ilogb(double x); +int ilogbf(float x); +int ilogbl(long double x); + +These functions extract the binary exponent of x as an integer value, treating denormalized numbers as if they were normalized. If x is 0, infinite, or NaN, they return the macro values FP_ILOGB0, INT_MAX, or FP_ILOGBNAN, respectively. + +#include +double log1p(double x); +float log1pf(float x); +long double log1pl(long double x); + +These functions return the natural logarithm of 1+x. + +#include +double log2(double x); +float log2f(float x); +long double log2l(long double x); + +These functions return the base-2 logarithm of x. + +#include +double logb(double x); +float logbf(float x); +long double logbl(long double x); + +These functions extract the binary exponent of x as an integer value in floating-point format, treating denormalized numbers as if they were normalized. + +#include +long lrint(double x); +long lrintf(float x); +long lrintl(long double x); + +These functions round x to an integer using the current rounding direction and return it as a long. If the value is outside the range of the return type, the number returned is unspecified. + +#include +double remainder(double x, double y); +float remainderf(float x, float y); +long double remainderl(long double x, long double y); +double remquo(double x, double y, int *quo); +float remquof(float x, float y, int *quo); +long double remquol(long double x, long double y, int *quo); + +These functions return x REM y as specified by IEEE 754: r = x - ny, where n is the integer nearest to the exact value of x/y. When x/y is halfway between two integers, n is chosen to be even. If r = 0, its sign is that of x. The remquo functions also set *quo to a value whose sign is the same as x/y and whose magnitude gives the low-order 7 bits of the absolute value of n. + +#include +double rint(double x); +float rintf(float x); +long double rintl(long double x); + +These functions round x to an integer using the current rounding direction. + +#include +double scalbn(double x, int n); +float scalbnf(float x, int n); +long double scalbnl(long double x, int n); + +These functions return x * 2^n, computed efficiently. + +#include +double trunc(double x); +float truncf(float x); +long double truncl(long double x); + +These functions truncate x to an integer (discarding the fractional part). + -- Compiler changes introduced in C 2.1.0 ----------------------------------- The Default .h File