slinky55/RockOS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

compiled newlib, need to hook up the system calls

Browse Source
This commit is contained in:
slinky55
2026-06-28 17:58:58 -05:00
parent 43bc0df81a
commit 97357f3170
337 changed files with 47955 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
rocklibc/src/math/fabs.c Normal file
View File

@@ -0,0 +1,114 @@
/* fabs( double )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <math.h>
#ifndef REGTEST
double fabs( double x )
{
if ( isnan( x ) )
{
return NAN;
}
return ( x < 0.0 ) ? -x : x;
}
float fabsf( float x )
{
if ( isnan( x ) )
{
return NAN;
}
return ( x < 0.0 ) ? -x : x;
}
long double fabsl( long double x )
{
if ( isnan( x ) )
{
return NAN;
}
return ( x < 0.0 ) ? -x : x;
}
#endif
#ifdef TEST
#include "_PDCLIB_test.h"
#include <errno.h>
int main( void )
{
float f;
double d;
long double ld;
TESTCASE( fabsf( 3.15f ) == 3.15f );
TESTCASE( fabsf( -3.15f ) == 3.15f );
errno = 0;
TESTCASE( fabsf( INFINITY ) == INFINITY );
TESTCASE( errno == 0 );
errno = 0;
TESTCASE( fabsf( -INFINITY ) == INFINITY );
TESTCASE( errno == 0 );
errno = 0;
f = fabsf( NAN );
TESTCASE( isnan( f ) );
TESTCASE( ! signbit( f ) );
TESTCASE( errno == 0 );
f = fabsf( -NAN );
TESTCASE( isnan( f ) );
TESTCASE( ! signbit( f ) );
TESTCASE( errno == 0 );
TESTCASE( fabs( 3.15 ) == 3.15 );
TESTCASE( fabs( -3.15 ) == 3.15 );
errno = 0;
TESTCASE( fabs( INFINITY ) == INFINITY );
TESTCASE( errno == 0 );
errno = 0;
TESTCASE( fabs( -INFINITY ) == INFINITY );
TESTCASE( errno == 0 );
errno = 0;
d = fabs( NAN );
TESTCASE( isnan( d ) );
TESTCASE( ! signbit( d ) );
TESTCASE( errno == 0 );
d = fabs( -NAN );
TESTCASE( isnan( d ) );
TESTCASE( ! signbit( d ) );
TESTCASE( errno == 0 );
TESTCASE( fabsl( 3.15l ) == 3.15l );
TESTCASE( fabsl( -3.15l ) == 3.15l );
errno = 0;
TESTCASE( fabsl( INFINITY ) == INFINITY );
TESTCASE( errno == 0 );
errno = 0;
TESTCASE( fabsl( -INFINITY ) == INFINITY );
TESTCASE( errno == 0 );
errno = 0;
ld = fabsl( NAN );
TESTCASE( isnan( ld ) );
TESTCASE( ! signbit( ld ) );
TESTCASE( errno == 0 );
ld = fabsl( -NAN );
TESTCASE( isnan( ld ) );
TESTCASE( ! signbit( ld ) );
TESTCASE( errno == 0 );
return TEST_RESULTS;
}
#endif

74
rocklibc/src/math/fdim.c Normal file
View File

@@ -0,0 +1,74 @@
/* fdim( double )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <math.h>
#ifndef REGTEST
double fdim( double x, double y )
{
return fmax( x - y, 0 );
}
float fdimf( float x, float y )
{
return fmaxf( x - y, 0 );
}
long double fdiml( long double x, long double y )
{
return fmaxl( x - y, 0 );
}
#endif
#ifdef TEST
#include "_PDCLIB_test.h"
int main( void )
{
float f1, f2;
double d1, d2;
long double ld1, ld2;
f1 = 3.5f;
f2 = 3.75f;
TESTCASE( fdimf( f1, f2 ) == 0.0f );
TESTCASE( fdimf( f2, f1 ) == 0.25f );
TESTCASE( fdimf( f1, INFINITY ) == 0.0f );
TESTCASE( fdimf( INFINITY, f1 ) == INFINITY );
TESTCASE( fdimf( f1, -INFINITY ) == INFINITY );
TESTCASE( fdimf( -INFINITY, f1 ) == 0.0f );
TESTCASE( fdimf( f1, NAN ) != f1 );
TESTCASE( fdimf( NAN, f1 ) != f1 );
d1 = 3.5;
d2 = 3.75;
TESTCASE( fdim( d1, d2 ) == 0.0 );
TESTCASE( fdim( d2, d1 ) == 0.25 );
TESTCASE( fdim( d1, INFINITY ) == 0.0 );
TESTCASE( fdim( INFINITY, d1 ) == INFINITY );
TESTCASE( fdim( d1, -INFINITY ) == INFINITY );
TESTCASE( fdim( -INFINITY, d1 ) == 0.0 );
TESTCASE( fdim( d1, NAN ) != d1 );
TESTCASE( fdim( NAN, d1 ) != d1 );
ld1 = 3.5l;
ld2 = 3.75l;
TESTCASE( fdiml( ld1, ld2 ) == 0.0l );
TESTCASE( fdiml( ld2, ld1 ) == 0.25l );
TESTCASE( fdiml( ld1, INFINITY ) == 0.0l );
TESTCASE( fdiml( INFINITY, ld1 ) == INFINITY );
TESTCASE( fdiml( ld1, -INFINITY ) == INFINITY );
TESTCASE( fdiml( -INFINITY, ld1 ) == 0.0l );
TESTCASE( fdiml( ld1, NAN ) != ld1 );
TESTCASE( fdiml( NAN, ld1 ) != ld1 );
return TEST_RESULTS;
}
#endif

105
rocklibc/src/math/fmax.c Normal file
View File

@@ -0,0 +1,105 @@
/* fmax( double )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <math.h>
#ifndef REGTEST
double fmax( double x, double y )
{
if ( isnan( x ) ) return y;
if ( isnan( y ) ) return x;
return ( x > y ) ? x : y;
}
float fmaxf( float x, float y )
{
if ( isnan( x ) ) return y;
if ( isnan( y ) ) return x;
return ( x > y ) ? x : y;
}
long double fmaxl( long double x, long double y )
{
if ( isnan( x ) ) return y;
if ( isnan( y ) ) return x;
return ( x > y ) ? x : y;
}
#endif
#ifdef TEST
#include "_PDCLIB_test.h"
int main( void )
{
float f1, f2;
double d1, d2;
long double ld1, ld2;
f1 = 3.15f;
f2 = 3.16f;
TESTCASE( fmaxf( f1, f2 ) == f2 );
TESTCASE( fmaxf( f2, f1 ) == f2 );
TESTCASE( fmaxf( f1, f1 ) == f1 );
TESTCASE( fmaxf( f1, INFINITY ) == INFINITY );
TESTCASE( fmaxf( INFINITY, f1 ) == INFINITY );
TESTCASE( fmaxf( f1, -INFINITY ) == f1 );
TESTCASE( fmaxf( -INFINITY, f1 ) == f1 );
TESTCASE( fmaxf( f1, NAN ) == f1 );
TESTCASE( fmaxf( NAN, f1 ) == f1 );
TESTCASE( fmaxf( f1, -NAN ) == f1 );
TESTCASE( fmaxf( -NAN, f1 ) == f1 );
TESTCASE( fmaxf( NAN, NAN ) != fmaxf( NAN, NAN ) );
f1 = 0.0f;
f2 = -0.0f;
TESTCASE( fmaxf( f1, f2 ) == f1 );
TESTCASE( fmaxf( f2, f1 ) == f1 );
d1 = 3.15f;
d2 = 3.16f;
TESTCASE( fmax( d1, d2 ) == d2 );
TESTCASE( fmax( d2, d1 ) == d2 );
TESTCASE( fmax( d1, d1 ) == d1 );
TESTCASE( fmax( d1, INFINITY ) == INFINITY );
TESTCASE( fmax( INFINITY, d1 ) == INFINITY );
TESTCASE( fmax( d1, -INFINITY ) == d1 );
TESTCASE( fmax( -INFINITY, d1 ) == d1 );
TESTCASE( fmax( d1, NAN ) == d1 );
TESTCASE( fmax( NAN, d1 ) == d1 );
TESTCASE( fmax( d1, -NAN ) == d1 );
TESTCASE( fmax( -NAN, d1 ) == d1 );
TESTCASE( fmax( NAN, NAN ) != fmax( NAN, NAN ) );
d1 = 0.0;
d2 = -0.0;
TESTCASE( fmax( d1, d2 ) == d1 );
TESTCASE( fmax( d2, d1 ) == d1 );
ld1 = 3.15f;
ld2 = 3.16f;
TESTCASE( fmaxl( ld1, ld2 ) == ld2 );
TESTCASE( fmaxl( ld2, ld1 ) == ld2 );
TESTCASE( fmaxl( ld1, ld1 ) == ld1 );
TESTCASE( fmaxl( ld1, INFINITY ) == INFINITY );
TESTCASE( fmaxl( INFINITY, ld1 ) == INFINITY );
TESTCASE( fmaxl( ld1, -INFINITY ) == ld1 );
TESTCASE( fmaxl( -INFINITY, ld1 ) == ld1 );
TESTCASE( fmaxl( ld1, NAN ) == ld1 );
TESTCASE( fmaxl( NAN, ld1 ) == ld1 );
TESTCASE( fmaxl( ld1, -NAN ) == ld1 );
TESTCASE( fmaxl( -NAN, ld1 ) == ld1 );
TESTCASE( fmaxl( NAN, NAN ) != fmaxl( NAN, NAN ) );
ld1 = 0.0;
ld2 = -0.0;
TESTCASE( fmaxl( ld1, ld2 ) == ld1 );
TESTCASE( fmaxl( ld2, ld1 ) == ld1 );
return TEST_RESULTS;
}
#endif

105
rocklibc/src/math/fmin.c Normal file
View File

@@ -0,0 +1,105 @@
/* fmin( double )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <math.h>
#ifndef REGTEST
double fmin( double x, double y )
{
if ( isnan( x ) ) return y;
if ( isnan( y ) ) return x;
return ( x < y ) ? x : y;
}
float fminf( float x, float y )
{
if ( isnan( x ) ) return y;
if ( isnan( y ) ) return x;
return ( x < y ) ? x : y;
}
long double fminl( long double x, long double y )
{
if ( isnan( x ) ) return y;
if ( isnan( y ) ) return x;
return ( x < y ) ? x : y;
}
#endif
#ifdef TEST
#include "_PDCLIB_test.h"
int main( void )
{
float f1, f2;
double d1, d2;
long double ld1, ld2;
f1 = 3.16f;
f2 = 3.15f;
TESTCASE( fminf( f1, f2 ) == f2 );
TESTCASE( fminf( f2, f1 ) == f2 );
TESTCASE( fminf( f1, f1 ) == f1 );
TESTCASE( fminf( f1, INFINITY ) == f1 );
TESTCASE( fminf( INFINITY, f1 ) == f1 );
TESTCASE( fminf( f1, -INFINITY ) == -INFINITY );
TESTCASE( fminf( -INFINITY, f1 ) == -INFINITY );
TESTCASE( fminf( f1, NAN ) == f1 );
TESTCASE( fminf( NAN, f1 ) == f1 );
TESTCASE( fminf( f1, -NAN ) == f1 );
TESTCASE( fminf( -NAN, f1 ) == f1 );
TESTCASE( fminf( NAN, NAN ) != fminf( NAN, NAN ) );
f1 = -0.0f;
f2 = 0.0f;
TESTCASE( fminf( f1, f2 ) == f1 );
TESTCASE( fminf( f2, f1 ) == f1 );
d1 = 3.16f;
d2 = 3.15f;
TESTCASE( fmin( d1, d2 ) == d2 );
TESTCASE( fmin( d2, d1 ) == d2 );
TESTCASE( fmin( d1, d1 ) == d1 );
TESTCASE( fmin( d1, INFINITY ) == d1 );
TESTCASE( fmin( INFINITY, d1 ) == d1 );
TESTCASE( fmin( d1, -INFINITY ) == -INFINITY );
TESTCASE( fmin( -INFINITY, d1 ) == -INFINITY );
TESTCASE( fmin( d1, NAN ) == d1 );
TESTCASE( fmin( NAN, d1 ) == d1 );
TESTCASE( fmin( d1, -NAN ) == d1 );
TESTCASE( fmin( -NAN, d1 ) == d1 );
TESTCASE( fmin( NAN, NAN ) != fmin( NAN, NAN ) );
d1 = -0.0;
d2 = 0.0;
TESTCASE( fmin( d1, d2 ) == d1 );
TESTCASE( fmin( d2, d1 ) == d1 );
ld1 = 3.16f;
ld2 = 3.15f;
TESTCASE( fminl( ld1, ld2 ) == ld2 );
TESTCASE( fminl( ld2, ld1 ) == ld2 );
TESTCASE( fminl( ld1, ld1 ) == ld1 );
TESTCASE( fminl( ld1, INFINITY ) == ld1 );
TESTCASE( fminl( INFINITY, ld1 ) == ld1 );
TESTCASE( fminl( ld1, -INFINITY ) == -INFINITY );
TESTCASE( fminl( -INFINITY, ld1 ) == -INFINITY );
TESTCASE( fminl( ld1, NAN ) == ld1 );
TESTCASE( fminl( NAN, ld1 ) == ld1 );
TESTCASE( fminl( ld1, -NAN ) == ld1 );
TESTCASE( fminl( -NAN, ld1 ) == ld1 );
TESTCASE( fminl( NAN, NAN ) != fminl( NAN, NAN ) );
ld1 = -0.0;
ld2 = 0.0;
TESTCASE( fminl( ld1, ld2 ) == ld1 );
TESTCASE( fminl( ld2, ld1 ) == ld1 );
return TEST_RESULTS;
}
#endif

161
rocklibc/src/math/fpclassify.c Normal file
View File

@@ -0,0 +1,161 @@
/* fpclassify( double )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <math.h>
#ifndef REGTEST
#include "pdclib/_PDCLIB_print.h"
#include <string.h>
int _PDCLIB_fpclassifyd( double x )
{
_PDCLIB_bigint_digit_t data[ sizeof( double ) / sizeof( _PDCLIB_bigint_digit_t ) ];
_PDCLIB_bigint_digit_t digit = 0;
size_t size;
size_t i;
int exp;
memcpy( data, &x, sizeof( double ) );
exp = _PDCLIB_DBL_EXP( data );
size = _PDCLIB_DBL_SIZE( data );
for ( i = 0; i < size; ++i )
{
digit |= data[i];
}
switch ( exp )
{
case ( ( _PDCLIB_DBL_MAX_EXP - 1 ) + _PDCLIB_DBL_MAX_EXP ):
return ( digit == 0 ) ? FP_INFINITE : FP_NAN;
case 0:
return ( digit == 0 ) ? FP_ZERO : FP_SUBNORMAL;
default:
return FP_NORMAL;
}
}
int _PDCLIB_fpclassifyf( float x )
{
_PDCLIB_bigint_digit_t data[ sizeof( float ) / sizeof( _PDCLIB_bigint_digit_t ) ];
_PDCLIB_bigint_digit_t digit = 0;
size_t size;
size_t i;
int exp;
memcpy( data, &x, sizeof( float ) );
exp = _PDCLIB_FLT_EXP( data );
size = _PDCLIB_FLT_SIZE( data );
for ( i = 0; i < size; ++i )
{
digit |= data[i];
}
switch ( exp )
{
case ( ( _PDCLIB_FLT_MAX_EXP - 1 ) + _PDCLIB_FLT_MAX_EXP ):
return ( digit == 0 ) ? FP_INFINITE : FP_NAN;
case 0:
return ( digit == 0 ) ? FP_ZERO : FP_SUBNORMAL;
default:
return FP_NORMAL;
}
}
int _PDCLIB_fpclassifyl( long double x )
{
_PDCLIB_bigint_digit_t data[ sizeof( long double ) / sizeof( _PDCLIB_bigint_digit_t ) ];
_PDCLIB_bigint_digit_t digit = 0;
size_t size;
size_t i;
int exp;
memcpy( data, &x, sizeof( long double ) );
exp = _PDCLIB_LDBL_EXP( data );
size = _PDCLIB_LDBL_SIZE( data );
for ( i = 0; i < size; ++i )
{
digit |= data[i];
}
switch ( exp )
{
case ( ( _PDCLIB_LDBL_MAX_EXP - 1 ) + _PDCLIB_LDBL_MAX_EXP ):
return ( digit == 0 ) ? FP_INFINITE : FP_NAN;
case 0:
return ( digit == 0 ) ? FP_ZERO : FP_SUBNORMAL;
default:
return FP_NORMAL;
}
}
#endif
#ifdef TEST
#include "_PDCLIB_test.h"
#include <float.h>
int main( void )
{
float f;
double d;
long double ld;
f = 0.123;
TESTCASE( fpclassify( f ) == FP_NORMAL );
f = FLT_MIN;
TESTCASE( fpclassify( f ) == FP_NORMAL );
f = FLT_MIN / 2;
TESTCASE( fpclassify( f ) == FP_SUBNORMAL );
f = 0.0;
TESTCASE( fpclassify( f ) == FP_ZERO );
f = FLT_MAX;
TESTCASE( fpclassify( f ) == FP_NORMAL );
f = FLT_MAX * 2;
TESTCASE( fpclassify( f ) == FP_INFINITE );
f = 0.0 / 0.0;
TESTCASE( fpclassify( f ) == FP_NAN );
d = 0.123;
TESTCASE( fpclassify( d ) == FP_NORMAL );
d = DBL_MIN;
TESTCASE( fpclassify( d ) == FP_NORMAL );
d = DBL_MIN / 2;
TESTCASE( fpclassify( d ) == FP_SUBNORMAL );
d = 0.0;
TESTCASE( fpclassify( d ) == FP_ZERO );
d = DBL_MAX;
TESTCASE( fpclassify( d ) == FP_NORMAL );
d = DBL_MAX * 2;
TESTCASE( fpclassify( d ) == FP_INFINITE );
d = 0.0 / 0.0;
TESTCASE( fpclassify( d ) == FP_NAN );
ld = 0.123;
TESTCASE( fpclassify( ld ) == FP_NORMAL );
ld = LDBL_MIN;
TESTCASE( fpclassify( ld ) == FP_NORMAL );
ld = LDBL_MIN / 2;
TESTCASE( fpclassify( ld ) == FP_SUBNORMAL );
ld = 0.0;
TESTCASE( fpclassify( ld ) == FP_ZERO );
ld = LDBL_MAX;
TESTCASE( fpclassify( ld ) == FP_NORMAL );
ld = LDBL_MAX * 2;
TESTCASE( fpclassify( ld ) == FP_INFINITE );
ld = 0.0 / 0.0;
TESTCASE( fpclassify( ld ) == FP_NAN );
return TEST_RESULTS;
}
#endif

92
rocklibc/src/math/isfinite.c Normal file
View File

@@ -0,0 +1,92 @@
/* isfinite( double )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <math.h>
#ifndef REGTEST
#include "pdclib/_PDCLIB_print.h"
#include <string.h>
int _PDCLIB_isfinited( double x )
{
_PDCLIB_bigint_digit_t data[ sizeof( double ) / sizeof( _PDCLIB_bigint_digit_t ) ];
memcpy( data, &x, sizeof( double ) );
return _PDCLIB_DBL_EXP( data ) != ( ( _PDCLIB_DBL_MAX_EXP - 1 ) + _PDCLIB_DBL_MAX_EXP );
}
int _PDCLIB_isfinitef( float x )
{
_PDCLIB_bigint_digit_t data[ sizeof( float ) / sizeof( _PDCLIB_bigint_digit_t ) ];
memcpy( data, &x, sizeof( float ) );
return _PDCLIB_FLT_EXP( data ) != ( ( _PDCLIB_FLT_MAX_EXP - 1 ) + _PDCLIB_FLT_MAX_EXP );
}
int _PDCLIB_isfinitel( long double x )
{
_PDCLIB_bigint_digit_t data[ sizeof( long double ) / sizeof( _PDCLIB_bigint_digit_t ) ];
memcpy( data, &x, sizeof( long double ) );
return _PDCLIB_LDBL_EXP( data ) != ( ( _PDCLIB_LDBL_MAX_EXP - 1 ) + _PDCLIB_LDBL_MAX_EXP );
}
#endif
#ifdef TEST
#include "_PDCLIB_test.h"
#include <float.h>
int main( void )
{
float f;
double d;
long double ld;
f = 0.123f;
TESTCASE( isfinite( f ) );
f = FLT_MAX;
TESTCASE( isfinite( f ) );
f *= 2;
TESTCASE( ! isfinite( f ) );
f = FLT_MIN;
TESTCASE( isfinite( f ) );
f /= 2;
TESTCASE( isfinite( f ) );
f = 0.0f / 0.0f;
TESTCASE( ! isfinite( f ) );
d = 0.123;
TESTCASE( isfinite( d ) );
d = DBL_MAX;
TESTCASE( isfinite( d ) );
d *= 2;
TESTCASE( ! isfinite( d ) );
d = DBL_MIN;
TESTCASE( isfinite( d ) );
d /= 2;
TESTCASE( isfinite( d ) );
d = 0.0 / 0.0;
TESTCASE( ! isfinite( d ) );
ld = 0.123l;
TESTCASE( isfinite( ld ) );
ld = LDBL_MAX;
TESTCASE( isfinite( ld ) );
ld *= 2;
TESTCASE( ! isfinite( ld ) );
ld = LDBL_MIN;
TESTCASE( isfinite( ld ) );
ld /= 2;
TESTCASE( isfinite( ld ) );
ld = 0.0l / 0.0l;
TESTCASE( ! isfinite( ld ) );
return TEST_RESULTS;
}
#endif

123
rocklibc/src/math/isinf.c Normal file
View File

@@ -0,0 +1,123 @@
/* isinf( double )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <math.h>
#ifndef REGTEST
#include "pdclib/_PDCLIB_print.h"
#include <string.h>
int _PDCLIB_isinfd( double x )
{
_PDCLIB_bigint_digit_t data[ sizeof( double ) / sizeof( _PDCLIB_bigint_digit_t ) ];
size_t size;
int exp;
memcpy( data, &x, sizeof( double ) );
exp = _PDCLIB_DBL_EXP( data );
size = _PDCLIB_DBL_SIZE( data );
if ( exp == ( ( _PDCLIB_DBL_MAX_EXP - 1 ) + _PDCLIB_DBL_MAX_EXP ) )
{
_PDCLIB_bigint_digit_t digit = 0;
size_t i;
for ( i = 0; i < size; ++i )
{
digit |= data[i];
}
return digit == 0;
}
return 0;
}
int _PDCLIB_isinff( float x )
{
_PDCLIB_bigint_digit_t data[ sizeof( float ) / sizeof( _PDCLIB_bigint_digit_t ) ];
size_t size;
int exp;
memcpy( data, &x, sizeof( float ) );
exp = _PDCLIB_FLT_EXP( data );
size = _PDCLIB_FLT_SIZE( data );
if ( exp == ( ( _PDCLIB_FLT_MAX_EXP - 1 ) + _PDCLIB_FLT_MAX_EXP ) )
{
_PDCLIB_bigint_digit_t digit = 0;
size_t i;
for ( i = 0; i < size; ++i )
{
digit |= data[i];
}
return digit == 0;
}
return 0;
}
int _PDCLIB_isinfl( long double x )
{
_PDCLIB_bigint_digit_t data[ sizeof( long double ) / sizeof( _PDCLIB_bigint_digit_t ) ];
size_t size;
int exp;
memcpy( data, &x, sizeof( long double ) );
exp = _PDCLIB_LDBL_EXP( data );
size = _PDCLIB_LDBL_SIZE( data );
if ( exp == ( ( _PDCLIB_LDBL_MAX_EXP - 1 ) + _PDCLIB_LDBL_MAX_EXP ) )
{
_PDCLIB_bigint_digit_t digit = 0;
size_t i;
for ( i = 0; i < size; ++i )
{
digit |= data[i];
}
return digit == 0;
}
return 0;
}
#endif
#ifdef TEST
#include "_PDCLIB_test.h"
int main( void )
{
float f;
double d;
long double ld;
f = 1e100;
TESTCASE( isinf( f ) == 1 );
f = 0.0 / 0.0;
TESTCASE( isinf( f ) == 0 );
d = 1e500;
TESTCASE( isinf( d ) == 1 );
d = 0.0 / 0.0;
TESTCASE( isinf( d ) == 0 );
ld = 1e500;
TESTCASE( isinf( ld ) == 1 );
ld = 0.0 / 0.0;
TESTCASE( isinf( ld ) == 0 );
return TEST_RESULTS;
}
#endif

123
rocklibc/src/math/isnan.c Normal file
View File

@@ -0,0 +1,123 @@
/* isnan( double )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <math.h>
#ifndef REGTEST
#include "pdclib/_PDCLIB_print.h"
#include <string.h>
int _PDCLIB_isnand( double x )
{
_PDCLIB_bigint_digit_t data[ sizeof( double ) / sizeof( _PDCLIB_bigint_digit_t ) ];
size_t size;
int exp;
memcpy( data, &x, sizeof( double ) );
exp = _PDCLIB_DBL_EXP( data );
size = _PDCLIB_DBL_SIZE( data );
if ( exp == ( ( _PDCLIB_DBL_MAX_EXP - 1 ) + _PDCLIB_DBL_MAX_EXP ) )
{
_PDCLIB_bigint_digit_t digit = 0;
size_t i;
for ( i = 0; i < size; ++i )
{
digit |= data[i];
}
return digit != 0;
}
return 0;
}
int _PDCLIB_isnanf( float x )
{
_PDCLIB_bigint_digit_t data[ sizeof( float ) / sizeof( _PDCLIB_bigint_digit_t ) ];
size_t size;
int exp;
memcpy( data, &x, sizeof( float ) );
exp = _PDCLIB_FLT_EXP( data );
size = _PDCLIB_FLT_SIZE( data );
if ( exp == ( ( _PDCLIB_FLT_MAX_EXP - 1 ) + _PDCLIB_FLT_MAX_EXP ) )
{
_PDCLIB_bigint_digit_t digit = 0;
size_t i;
for ( i = 0; i < size; ++i )
{
digit |= data[i];
}
return digit != 0;
}
return 0;
}
int _PDCLIB_isnanl( long double x )
{
_PDCLIB_bigint_digit_t data[ sizeof( long double ) / sizeof( _PDCLIB_bigint_digit_t ) ];
size_t size;
int exp;
memcpy( data, &x, sizeof( long double ) );
exp = _PDCLIB_LDBL_EXP( data );
size = _PDCLIB_LDBL_SIZE( data );
if ( exp == ( ( _PDCLIB_LDBL_MAX_EXP - 1 ) + _PDCLIB_LDBL_MAX_EXP ) )
{
_PDCLIB_bigint_digit_t digit = 0;
size_t i;
for ( i = 0; i < size; ++i )
{
digit |= data[i];
}
return digit != 0;
}
return 0;
}
#endif
#ifdef TEST
#include "_PDCLIB_test.h"
int main( void )
{
float f;
double d;
long double ld;
f = 1e100;
TESTCASE( isnan( f ) == 0 );
f = 0.0 / 0.0;
TESTCASE( isnan( f ) == 1 );
d = 1e500;
TESTCASE( isnan( d ) == 0 );
d = 0.0 / 0.0;
TESTCASE( isnan( d ) == 1 );
ld = 1e500;
TESTCASE( isnan( ld ) == 0 );
ld = 0.0 / 0.0;
TESTCASE( isnan( ld ) == 1 );
return TEST_RESULTS;
}
#endif

110
rocklibc/src/math/isnormal.c Normal file
View File

@@ -0,0 +1,110 @@
/* isnormal( double )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <math.h>
#ifndef REGTEST
#include "pdclib/_PDCLIB_print.h"
#include <string.h>
int _PDCLIB_isnormald( double x )
{
_PDCLIB_bigint_digit_t data[ sizeof( double ) / sizeof( _PDCLIB_bigint_digit_t ) ];
int exp;
memcpy( data, &x, sizeof( double ) );
exp = _PDCLIB_DBL_EXP( data );
return ( exp != ( ( _PDCLIB_DBL_MAX_EXP - 1 ) + _PDCLIB_DBL_MAX_EXP ) ) && ( exp != 0 );
}
int _PDCLIB_isnormalf( float x )
{
_PDCLIB_bigint_digit_t data[ sizeof( float ) / sizeof( _PDCLIB_bigint_digit_t ) ];
int exp;
memcpy( data, &x, sizeof( float ) );
exp = _PDCLIB_FLT_EXP( data );
return ( exp != ( ( _PDCLIB_FLT_MAX_EXP - 1 ) + _PDCLIB_FLT_MAX_EXP ) ) && ( exp != 0 );
}
int _PDCLIB_isnormall( long double x )
{
_PDCLIB_bigint_digit_t data[ sizeof( long double ) / sizeof( _PDCLIB_bigint_digit_t ) ];
int exp;
memcpy( data, &x, sizeof( long double ) );
exp = _PDCLIB_LDBL_EXP( data );
return ( exp != ( ( _PDCLIB_LDBL_MAX_EXP - 1 ) + _PDCLIB_LDBL_MAX_EXP ) ) && ( exp != 0 );
}
#endif
#ifdef TEST
#include "_PDCLIB_test.h"
#include <float.h>
int main( void )
{
float f;
double d;
long double ld;
f = 0.123f;
TESTCASE( isnormal( f ) );
f = FLT_MAX;
TESTCASE( isnormal( f ) );
f = FLT_MAX * 2;
TESTCASE( ! isnormal( f ) );
f = FLT_MIN;
TESTCASE( isnormal( f ) );
f = FLT_MIN / 2;
TESTCASE( ! isnormal( f ) );
f = 0.0f;
TESTCASE( ! isnormal( f ) );
f = 1e100;
TESTCASE( ! isnormal( f ) );
f = 0.0 / 0.0;
TESTCASE( ! isnormal( f ) );
d = 0.123f;
TESTCASE( isnormal( d ) );
d = DBL_MAX;
TESTCASE( isnormal( d ) );
d = DBL_MAX * 2;
TESTCASE( ! isnormal( d ) );
d = DBL_MIN;
TESTCASE( isnormal( d ) );
d = DBL_MIN / 2;
TESTCASE( ! isnormal( d ) );
d = 0.0f;
TESTCASE( ! isnormal( d ) );
d = 1e500;
TESTCASE( ! isnormal( d ) );
d = 0.0 / 0.0;
TESTCASE( ! isnormal( d ) );
ld = 0.123f;
TESTCASE( isnormal( ld ) );
ld = LDBL_MAX;
TESTCASE( isnormal( ld ) );
ld = LDBL_MAX * 2;
TESTCASE( ! isnormal( ld ) );
ld = LDBL_MIN;
TESTCASE( isnormal( ld ) );
ld = LDBL_MIN / 2;
TESTCASE( ! isnormal( ld ) );
ld = 0.0f;
TESTCASE( ! isnormal( ld ) );
ld = 1e1000;
TESTCASE( ! isnormal( ld ) );
ld = 0.0 / 0.0;
TESTCASE( ! isnormal( ld ) );
return TEST_RESULTS;
}
#endif

69
rocklibc/src/math/signbit.c Normal file
View File

@@ -0,0 +1,69 @@
/* signbit( double )
This file is part of the Public Domain C Library (PDCLib).
Permission is granted to use, modify, and / or redistribute at will.
*/
#include <math.h>
#ifndef REGTEST
#include "pdclib/_PDCLIB_print.h"
#include <string.h>
int _PDCLIB_signbitd( double x )
{
_PDCLIB_bigint_digit_t data[ sizeof( double ) / sizeof( _PDCLIB_bigint_digit_t ) ];
memcpy( data, &x, sizeof( double ) );
return _PDCLIB_DBL_SIGN( data ) != 0;
}
int _PDCLIB_signbitf( float x )
{
_PDCLIB_bigint_digit_t data[ sizeof( float ) / sizeof( _PDCLIB_bigint_digit_t ) ];
memcpy( data, &x, sizeof( float ) );
return _PDCLIB_FLT_SIGN( data ) != 0;
}
int _PDCLIB_signbitl( long double x )
{
_PDCLIB_bigint_digit_t data[ sizeof( long double ) / sizeof( _PDCLIB_bigint_digit_t ) ];
memcpy( data, &x, sizeof( long double ) );
return _PDCLIB_LDBL_SIGN( data ) != 0;
}
#endif
#ifdef TEST
#include "_PDCLIB_test.h"
int main( void )
{
float f;
double d;
long double ld;
f = 0.123f;
TESTCASE( ! signbit( f ) );
f = -0.123f;
TESTCASE( signbit( f ) );
d = 0.123;
TESTCASE( ! signbit( d ) );
d = -0.123;
TESTCASE( signbit( d ) );
ld = 0.123l;
TESTCASE( ! signbit( ld ) );
ld = -0.123l;
TESTCASE( signbit( ld ) );
return TEST_RESULTS;
}
#endif