int
main ()
{
test_float ();
test_double ();
test_long_double ();
return 0;
}
static int
run_test (int, char*[])
{
// check the prescribed values of the required constants
rw_fatal ('\0' == std::money_base::none, 0, 0,
"'\\0' == money_base::none, got %d", std::money_base::none);
rw_fatal ('\1' == std::money_base::space, 0, 0,
"'\\1' == money_base::space, got %d", std::money_base::space);
rw_fatal ('\2' == std::money_base::symbol, 0, 0,
"'\\2' == money_base::symbol, got %d", std::money_base::symbol);
rw_fatal ('\3' == std::money_base::sign, 0, 0,
"'\\3' == money_base::sign, got %d", std::money_base::sign);
rw_fatal ('\4' == std::money_base::value, 0, 0,
"'\\4' == money_base::value, got %d", std::money_base::value);
if (rw_enabled ("char")) {
test_long_double (char (), "char");
test_string (char (), "char");
}
else
rw_note (0, __FILE__, __LINE__, "char test disabled");
#ifndef _RWSTD_NO_WCHAR_T
if (rw_enabled ("wchar_t")) {
test_long_double (wchar_t (), "wchar_t");
test_string (wchar_t (), "wchar_t");
}
else
rw_note (0, __FILE__, __LINE__, "wchar_t test disabled");
#endif // _RWSTD_NO_WCHAR_T
return 0;
}
int
main (void)
{
err = 0;
test_float ();
test_double ();
test_long_double ();
test_int ();
test_long_int ();
if (err != 0)
abort ();
return 0;
}
int
main ()
{
test_float ();
test_double ();
{
DECL_LONG_DOUBLE_ROUNDING
BEGIN_LONG_DOUBLE_ROUNDING ();
test_long_double ();
END_LONG_DOUBLE_ROUNDING ();
}
return 0;
}
/// \internal Precompute constants for the recursive generation of Legendre associated functions, with given normalization.
/// this function is called by \ref shtns_set_size, and assumes up-to-date values in \ref shtns.
/// For the same conventions as GSL, use \c legendre_precomp(sht_orthonormal,1);
/// \param[in] norm : normalization of the associated legendre functions (\ref shtns_norm).
/// \param[in] with_cs_phase : Condon-Shortley phase (-1)^m is included (1) or not (0)
/// \param[in] mpos_renorm : Optional renormalization for m>0.
/// 1.0 (no renormalization) is the "complex" convention, while 0.5 leads to the "real" convention (with FFTW).
static void legendre_precomp(shtns_cfg shtns, enum shtns_norm norm, int with_cs_phase, double mpos_renorm)
{
double *alm, *blm;
long int im, m, l, lm;
real t1, t2;
#if HAVE_LONG_DOUBLE_WIDER
test_long_double();
#endif
#if SHT_VERBOSE > 1
if (verbose) {
printf(" > Condon-Shortley phase = %d, normalization = %d\n", with_cs_phase, norm);
if (long_double_caps == 3) printf(" > long double has extended precision and large exponent\n");
}
#endif
if (with_cs_phase != 0) with_cs_phase = 1; // force to 1 if !=0
alm = (double *) malloc( (2*NLM)*sizeof(double) );
blm = alm;
if ((norm == sht_schmidt) || (mpos_renorm != 1.0)) {
blm = (double *) malloc( (2*NLM)*sizeof(double) );
}
if ((alm==0) || (blm==0)) shtns_runerr("not enough memory.");
shtns->alm = alm; shtns->blm = blm;
/// - Compute and store the prefactor (independant of x) of the starting value for the recurrence :
/// \f[ Y_m^m(x) = Y_0^0 \ \sqrt{ \prod_{k=1}^{m} \frac{2k+1}{2k} } \ \ (-1)^m \ (1-x^2)^{m/2} \f]
if ((norm == sht_fourpi)||(norm == sht_schmidt)) {
t1 = 1.0;
alm[0] = t1; /// \f$ Y_0^0 = 1 \f$ for Schmidt or 4pi-normalized
} else {
t1 = 0.25L/M_PIl;
alm[0] = SQRT(t1); /// \f$ Y_0^0 = 1/\sqrt{4\pi} \f$ for orthonormal
}
t1 *= mpos_renorm; // renormalization for m>0
for (im=1, m=0; im<=MMAX; ++im) {
while(m<im*MRES) {
++m;
t1 *= ((real)m + 0.5)/m; // t1 *= (m+0.5)/m;
}
t2 = SQRT(t1);
if ( m & with_cs_phase ) t2 = -t2; /// optional \f$ (-1)^m \f$ Condon-Shortley phase.
alm_im(shtns, im)[0] = t2;
}
/// - Precompute the factors alm and blm of the recurrence relation :
#pragma omp parallel for private(im,m,l,lm, t1, t2) schedule(dynamic)
for (im=0; im<=MMAX; ++im) {
m = im*MRES;
lm = im*(2*LMAX - (im-1)*MRES);
if (norm == sht_schmidt) { /// <b> For Schmidt semi-normalized </b>
t2 = SQRT(2*m+1);
alm[lm] /= t2; /// starting value divided by \f$ \sqrt{2m+1} \f$
alm[lm+1] = t2; // l=m+1
lm+=2;
for (l=m+2; l<=LMAX; ++l) {
t1 = SQRT((l+m)*(l-m));
alm[lm+1] = (2*l-1)/t1; /// \f[ a_l^m = \frac{2l-1}{\sqrt{(l+m)(l-m)}} \f]
alm[lm] = - t2/t1; /// \f[ b_l^m = -\sqrt{\frac{(l-1+m)(l-1-m)}{(l+m)(l-m)}} \f]
t2 = t1; lm+=2;
}
} else { /// <b> For orthonormal or 4pi-normalized </b>
t2 = 2*m+1;
// starting value unchanged.
alm[lm+1] = SQRT(2*m+3); // l=m+1
lm+=2;
for (l=m+2; l<=LMAX; ++l) {
t1 = (l+m)*(l-m);
alm[lm+1] = SQRT(((2*l+1)*(2*l-1))/t1); /// \f[ a_l^m = \sqrt{\frac{(2l+1)(2l-1)}{(l+m)(l-m)}} \f]
alm[lm] = - SQRT(((2*l+1)*t2)/((2*l-3)*t1)); /// \f[ b_l^m = -\sqrt{\frac{2l+1}{2l-3}\,\frac{(l-1+m)(l-1-m)}{(l+m)(l-m)}} \f]
t2 = t1; lm+=2;
}
}
/// - Compute analysis recurrence coefficients if necessary
if ((norm == sht_schmidt) || (mpos_renorm != 1.0)) {
lm = im*(2*LMAX - (im-1)*MRES);
t1 = 1.0;
t2 = alm[lm+1];
if (norm == sht_schmidt) {
t1 = 2*m+1;
t2 *= (2*m+3)/t1;
}
if (m>0) t1 /= mpos_renorm;
blm[lm] = alm[lm]*t1;
blm[lm+1] = t2;
lm+=2;
for (l=m+2; l<=LMAX; ++l) {
t1 = alm[lm];
t2 = alm[lm+1];
if (norm == sht_schmidt) {
double t3 = 2*l+1;
t1 *= t3/(2*l-3);
t2 *= t3/(2*l-1);
}
blm[lm] = t1;
blm[lm+1] = t2;
lm+=2;
}
}
}
}
int
main ( int argc, char** argv )
{
int flag = 0; // Bit 0: little, Bit 1: big, Bit 2: unknown
unsigned int k;
long m;
FILE* fp = fopen ( "config.h", "w" );
int endian;
if ( fp == NULL ) {
fprintf ( stderr, "config: Can't write 'config.h'\n");
return 1;
}
if ( argc > 1 )
fprintf ( stderr, "\n*** Compile sources with ***\n\n%s\n\n", argv[1] );
if ( argc > 2 )
fprintf ( stderr, "\n*** Execute binary with ***\n\n%s\n\n", argv[2] );
fprintf ( fp, "\n" );
fprintf ( fp, "/* Determine Endianess of the machine */\n" );
fprintf ( fp, "\n" );
fprintf ( fp, "#define HAVE_LITTLE_ENDIAN 1234\n" );
fprintf ( fp, "#define HAVE_BIG_ENDIAN 4321\n" );
fprintf ( fp, "\n" );
flag = 0;
for ( k = 0; k < sizeof(v_int); k++ )
if ( in[k] == 0x11 * (k+1) ) flag |= 1;
else if ( in[k] == 0x11 * (sizeof(v_int)-k) ) flag |= 2;
else flag |= 4;
for ( k = 0; k < sizeof(v_lng); k++ )
if ( lo[k] == 0x11 * (k+1) ) flag |= 1;
else if ( lo[k] == 0x11 * (sizeof(v_lng)-k) ) flag |= 2;
else flag |= 4;
for ( k = 0; k < sizeof(v_sht); k++ )
if ( sh[k] == 0x11 * (k+1) ) flag |= 1;
else if ( sh[k] == 0x11 * (sizeof(v_sht)-k) ) flag |= 2;
else flag |= 4;
switch (flag) {
case 1:
endian = 1;
fprintf ( fp, "#define ENDIAN HAVE_LITTLE_ENDIAN\n" );
break;
case 2:
endian = 2;
fprintf ( fp, "#define ENDIAN HAVE_BIG_ENDIAN\n" );
break;
default:
endian = 0;
fprintf ( fp, "/* unknown endianess */\n" );
break;
}
fprintf ( fp, "\n" );
fprintf ( fp, "\n" );
fprintf ( fp, "/* Test the fast float-to-int rounding trick works */\n" );
fprintf ( fp, "\n" );
flag = 0;
for ( m = 0; m <= 32767; m++ ) {
flag |= test_round_16 ( (float)(+m - 0.499) );
flag |= test_round_16 ( (float)(+m ) );
flag |= test_round_16 ( (float)(+m + 0.499) );
flag |= test_round_16 ( (float)(-m - 0.499) );
flag |= test_round_16 ( (float)(-m ) );
flag |= test_round_16 ( (float)(-m + 0.499) );
}
if ( flag == 0 )
fprintf ( fp, "#define HAVE_IEEE754_FLOAT\n" );
else
fprintf ( fp, "/* #define HAVE_IEEE754_FLOAT */\n" );
flag = 0;
for ( m = 0; (unsigned long)m <= 0x7FFFFFFF; m += 1 + (m>>16) ) {
flag |= test_round_32 ( +m - 0.499 );
flag |= test_round_32 ( +m );
flag |= test_round_32 ( +m + 0.499 );
flag |= test_round_32 ( -m - 0.499 );
flag |= test_round_32 ( -m );
flag |= test_round_32 ( -m + 0.499 );
}
if ( flag == 0 )
fprintf ( fp, "#define HAVE_IEEE754_DOUBLE\n" );
else
fprintf ( fp, "/* #define HAVE_IEEE754_DOUBLE */\n" );
fprintf ( fp, "\n" );
fprintf ( fp, "\n" );
fprintf ( fp, "/* Test the presence of a 80 bit floating point type for writing AIFF headers */\n" );
fprintf ( fp, "\n" );
if ( test_long_double(endian) )
fprintf ( fp, "#define HAVE_IEEE854_LONGDOUBLE\n" );
else
fprintf ( fp, "/* #define HAVE_IEEE854_LONGDOUBLE */\n" );
fprintf ( fp, "\n\n" );
version ( fp );
fprintf ( fp, "/* end of config.h */\n" );
fclose (fp);
return 0;
}
