349 lines
7.0 KiB
C
349 lines
7.0 KiB
C
/* log2.c
|
||
*
|
||
* Base 2 logarithm
|
||
*
|
||
*
|
||
*
|
||
* SYNOPSIS:
|
||
*
|
||
* double x, y, log2();
|
||
*
|
||
* y = log2( x );
|
||
*
|
||
*
|
||
*
|
||
* DESCRIPTION:
|
||
*
|
||
* Returns the base 2 logarithm of x.
|
||
*
|
||
* The argument is separated into its exponent and fractional
|
||
* parts. If the exponent is between -1 and +1, the base e
|
||
* logarithm of the fraction is approximated by
|
||
*
|
||
* log(1+x) = x - 0.5 x**2 + x**3 P(x)/Q(x).
|
||
*
|
||
* Otherwise, setting z = 2(x-1)/x+1),
|
||
*
|
||
* log(x) = z + z**3 P(z)/Q(z).
|
||
*
|
||
*
|
||
*
|
||
* ACCURACY:
|
||
*
|
||
* Relative error:
|
||
* arithmetic domain # trials peak rms
|
||
* IEEE 0.5, 2.0 30000 2.0e-16 5.5e-17
|
||
* IEEE exp(+-700) 40000 1.3e-16 4.6e-17
|
||
*
|
||
* In the tests over the interval [exp(+-700)], the logarithms
|
||
* of the random arguments were uniformly distributed.
|
||
*
|
||
* ERROR MESSAGES:
|
||
*
|
||
* log2 singularity: x = 0; returns -INFINITY
|
||
* log2 domain: x < 0; returns NAN
|
||
*/
|
||
|
||
/*
|
||
Cephes Math Library Release 2.8: June, 2000
|
||
Copyright 1984, 1995, 2000 by Stephen L. Moshier
|
||
*/
|
||
|
||
#include "mconf.h"
|
||
static char fname[] = {"log2"};
|
||
|
||
/* Coefficients for log(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
|
||
* 1/sqrt(2) <= x < sqrt(2)
|
||
*/
|
||
#ifdef UNK
|
||
const static double P[] = {
|
||
1.01875663804580931796E-4,
|
||
4.97494994976747001425E-1,
|
||
4.70579119878881725854E0,
|
||
1.44989225341610930846E1,
|
||
1.79368678507819816313E1,
|
||
7.70838733755885391666E0,
|
||
};
|
||
const static double Q[] = {
|
||
/* 1.00000000000000000000E0, */
|
||
1.12873587189167450590E1,
|
||
4.52279145837532221105E1,
|
||
8.29875266912776603211E1,
|
||
7.11544750618563894466E1,
|
||
2.31251620126765340583E1,
|
||
};
|
||
#define LOG2EA 0.44269504088896340735992
|
||
#endif
|
||
|
||
#ifdef DEC
|
||
static unsigned short P[] = {
|
||
0037777,0127270,0162547,0057274,
|
||
0041001,0054665,0164317,0005341,
|
||
0041451,0034104,0031640,0105773,
|
||
0041677,0011276,0123617,0160135,
|
||
0041701,0126603,0053215,0117250,
|
||
0041420,0115777,0135206,0030232,
|
||
};
|
||
static unsigned short Q[] = {
|
||
/*0040200,0000000,0000000,0000000,*/
|
||
0041220,0144332,0045272,0174241,
|
||
0041742,0164566,0035720,0130431,
|
||
0042246,0126327,0166065,0116357,
|
||
0042372,0033420,0157525,0124560,
|
||
0042271,0167002,0066537,0172303,
|
||
0041730,0164777,0113711,0044407,
|
||
};
|
||
static unsigned short L[5] = {0037742,0124354,0122560,0057703};
|
||
#define LOG2EA (*(double *)(&L[0]))
|
||
#endif
|
||
|
||
#ifdef IBMPC
|
||
static unsigned short P[] = {
|
||
0x1bb0,0x93c3,0xb4c2,0x3f1a,
|
||
0x52f2,0x3f56,0xd6f5,0x3fdf,
|
||
0x6911,0xed92,0xd2ba,0x4012,
|
||
0xeb2e,0xc63e,0xff72,0x402c,
|
||
0xc84d,0x924b,0xefd6,0x4031,
|
||
0xdcf8,0x7d7e,0xd563,0x401e,
|
||
};
|
||
static unsigned short Q[] = {
|
||
/*0x0000,0x0000,0x0000,0x3ff0,*/
|
||
0xef8e,0xae97,0x9320,0x4026,
|
||
0xc033,0x4e19,0x9d2c,0x4046,
|
||
0xbdbd,0xa326,0xbf33,0x4054,
|
||
0xae21,0xeb5e,0xc9e2,0x4051,
|
||
0x25b2,0x9e1f,0x200a,0x4037,
|
||
};
|
||
static unsigned short L[5] = {0x0bf8,0x94ae,0x551d,0x3fdc};
|
||
#define LOG2EA (*(double *)(&L[0]))
|
||
#endif
|
||
|
||
#ifdef MIEEE
|
||
static unsigned short P[] = {
|
||
0x3f1a,0xb4c2,0x93c3,0x1bb0,
|
||
0x3fdf,0xd6f5,0x3f56,0x52f2,
|
||
0x4012,0xd2ba,0xed92,0x6911,
|
||
0x402c,0xff72,0xc63e,0xeb2e,
|
||
0x4031,0xefd6,0x924b,0xc84d,
|
||
0x401e,0xd563,0x7d7e,0xdcf8,
|
||
};
|
||
static unsigned short Q[] = {
|
||
/*0x3ff0,0x0000,0x0000,0x0000,*/
|
||
0x4026,0x9320,0xae97,0xef8e,
|
||
0x4046,0x9d2c,0x4e19,0xc033,
|
||
0x4054,0xbf33,0xa326,0xbdbd,
|
||
0x4051,0xc9e2,0xeb5e,0xae21,
|
||
0x4037,0x200a,0x9e1f,0x25b2,
|
||
};
|
||
static unsigned short L[5] = {0x3fdc,0x551d,0x94ae,0x0bf8};
|
||
#define LOG2EA (*(double *)(&L[0]))
|
||
#endif
|
||
|
||
/* Coefficients for log(x) = z + z**3 P(z)/Q(z),
|
||
* where z = 2(x-1)/(x+1)
|
||
* 1/sqrt(2) <= x < sqrt(2)
|
||
*/
|
||
|
||
#ifdef UNK
|
||
const static double R[3] = {
|
||
-7.89580278884799154124E-1,
|
||
1.63866645699558079767E1,
|
||
-6.41409952958715622951E1,
|
||
};
|
||
const static double S[3] = {
|
||
/* 1.00000000000000000000E0,*/
|
||
-3.56722798256324312549E1,
|
||
3.12093766372244180303E2,
|
||
-7.69691943550460008604E2,
|
||
};
|
||
/* log2(e) - 1 */
|
||
#define LOG2EA 0.44269504088896340735992
|
||
#endif
|
||
#ifdef DEC
|
||
static unsigned short R[12] = {
|
||
0140112,0020756,0161540,0072035,
|
||
0041203,0013743,0114023,0155527,
|
||
0141600,0044060,0104421,0050400,
|
||
};
|
||
static unsigned short S[12] = {
|
||
/*0040200,0000000,0000000,0000000,*/
|
||
0141416,0130152,0017543,0064122,
|
||
0042234,0006000,0104527,0020155,
|
||
0142500,0066110,0146631,0174731,
|
||
};
|
||
/* log2(e) - 1 */
|
||
#define LOG2EA 0.44269504088896340735992L
|
||
#endif
|
||
#ifdef IBMPC
|
||
static unsigned short R[12] = {
|
||
0x0e84,0xdc6c,0x443d,0xbfe9,
|
||
0x7b6b,0x7302,0x62fc,0x4030,
|
||
0x2a20,0x1122,0x0906,0xc050,
|
||
};
|
||
static unsigned short S[12] = {
|
||
/*0x0000,0x0000,0x0000,0x3ff0,*/
|
||
0x6d0a,0x43ec,0xd60d,0xc041,
|
||
0xe40e,0x112a,0x8180,0x4073,
|
||
0x3f3b,0x19b3,0x0d89,0xc088,
|
||
};
|
||
#endif
|
||
#ifdef MIEEE
|
||
static unsigned short R[12] = {
|
||
0xbfe9,0x443d,0xdc6c,0x0e84,
|
||
0x4030,0x62fc,0x7302,0x7b6b,
|
||
0xc050,0x0906,0x1122,0x2a20,
|
||
};
|
||
static unsigned short S[12] = {
|
||
/*0x3ff0,0x0000,0x0000,0x0000,*/
|
||
0xc041,0xd60d,0x43ec,0x6d0a,
|
||
0x4073,0x8180,0x112a,0xe40e,
|
||
0xc088,0x0d89,0x19b3,0x3f3b,
|
||
};
|
||
#endif
|
||
|
||
#ifdef ANSIPROT
|
||
extern double frexp ( double, int * );
|
||
extern double ldexp ( double, int );
|
||
extern double polevl ( double, void *, int );
|
||
extern double p1evl ( double, void *, int );
|
||
extern int isnan ( double );
|
||
extern int isfinite ( double );
|
||
#else
|
||
double frexp(), ldexp(), polevl(), p1evl();
|
||
int isnan(), isfinite();
|
||
#endif
|
||
#define SQRTH 0.70710678118654752440
|
||
extern double LOGE2, INFINITY, NAN;
|
||
|
||
double log2(x)
|
||
double x;
|
||
{
|
||
int e;
|
||
double y;
|
||
VOLATILE double z;
|
||
#ifdef DEC
|
||
short *q;
|
||
#endif
|
||
|
||
#ifdef NANS
|
||
if( isnan(x) )
|
||
return(x);
|
||
#endif
|
||
#ifdef INFINITIES
|
||
if( x == INFINITY )
|
||
return(x);
|
||
#endif
|
||
/* Test for domain */
|
||
if( x <= 0.0 )
|
||
{
|
||
if( x == 0.0 )
|
||
{
|
||
mtherr( fname, SING );
|
||
return( -INFINITY );
|
||
}
|
||
else
|
||
{
|
||
mtherr( fname, DOMAIN );
|
||
return( NAN );
|
||
}
|
||
}
|
||
|
||
/* separate mantissa from exponent */
|
||
|
||
#ifdef DEC
|
||
q = (short *)&x;
|
||
e = *q; /* short containing exponent */
|
||
e = ((e >> 7) & 0377) - 0200; /* the exponent */
|
||
*q &= 0177; /* strip exponent from x */
|
||
*q |= 040000; /* x now between 0.5 and 1 */
|
||
#endif
|
||
|
||
/* Note, frexp is used so that denormal numbers
|
||
* will be handled properly.
|
||
*/
|
||
#ifdef IBMPC
|
||
x = frexp( x, &e );
|
||
/*
|
||
q = (short *)&x;
|
||
q += 3;
|
||
e = *q;
|
||
e = ((e >> 4) & 0x0fff) - 0x3fe;
|
||
*q &= 0x0f;
|
||
*q |= 0x3fe0;
|
||
*/
|
||
#endif
|
||
|
||
/* Equivalent C language standard library function: */
|
||
#ifdef UNK
|
||
x = frexp( x, &e );
|
||
#endif
|
||
|
||
#ifdef MIEEE
|
||
x = frexp( x, &e );
|
||
#endif
|
||
|
||
|
||
/* logarithm using log(x) = z + z**3 P(z)/Q(z),
|
||
* where z = 2(x-1)/x+1)
|
||
*/
|
||
|
||
if( (e > 2) || (e < -2) )
|
||
{
|
||
if( x < SQRTH )
|
||
{ /* 2( 2x-1 )/( 2x+1 ) */
|
||
e -= 1;
|
||
z = x - 0.5;
|
||
y = 0.5 * z + 0.5;
|
||
}
|
||
else
|
||
{ /* 2 (x-1)/(x+1) */
|
||
z = x - 0.5;
|
||
z -= 0.5;
|
||
y = 0.5 * x + 0.5;
|
||
}
|
||
|
||
x = z / y;
|
||
z = x*x;
|
||
y = x * ( z * polevl( z, R, 2 ) / p1evl( z, S, 3 ) );
|
||
goto ldone;
|
||
}
|
||
|
||
|
||
|
||
/* logarithm using log(1+x) = x - .5x**2 + x**3 P(x)/Q(x) */
|
||
|
||
if( x < SQRTH )
|
||
{
|
||
e -= 1;
|
||
x = ldexp( x, 1 ) - 1.0; /* 2x - 1 */
|
||
}
|
||
else
|
||
{
|
||
x = x - 1.0;
|
||
}
|
||
|
||
z = x*x;
|
||
#if DEC
|
||
y = x * ( z * polevl( x, P, 5 ) / p1evl( x, Q, 6 ) ) - ldexp( z, -1 );
|
||
#else
|
||
y = x * ( z * polevl( x, P, 5 ) / p1evl( x, Q, 5 ) ) - ldexp( z, -1 );
|
||
#endif
|
||
|
||
ldone:
|
||
|
||
/* Multiply log of fraction by log2(e)
|
||
* and base 2 exponent by 1
|
||
*
|
||
* ***CAUTION***
|
||
*
|
||
* This sequence of operations is critical and it may
|
||
* be horribly defeated by some compiler optimizers.
|
||
*/
|
||
z = y * LOG2EA;
|
||
z += x * LOG2EA;
|
||
z += y;
|
||
z += x;
|
||
z += e;
|
||
return( z );
|
||
}
|