int main( int argc, char *argv[] )
{
const char *prefixTextPtr;
uint_fast8_t roundingMode;
bool exact;
int functionCode;
const char *argPtr;
long i;
int functionAttribs;
float32_t (*trueFunction_abz_f32)( float32_t, float32_t );
bool (*trueFunction_ab_f32_z_bool)( float32_t, float32_t );
float64_t (*trueFunction_abz_f64)( float64_t, float64_t );
bool (*trueFunction_ab_f64_z_bool)( float64_t, float64_t );
#ifdef EXTFLOAT80
void
(*trueFunction_abz_extF80)(
const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
bool
(*trueFunction_ab_extF80_z_bool)(
const extFloat80_t *, const extFloat80_t * );
#endif
#ifdef FLOAT128
void
(*trueFunction_abz_f128)(
const float128_t *, const float128_t *, float128_t * );
bool
(*trueFunction_ab_f128_z_bool)( const float128_t *, const float128_t * );
#endif
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
fail_programName = "testfloat_gen";
if ( argc <= 1 ) goto writeHelpMessage;
prefixTextPtr = 0;
softfloat_detectTininess = softfloat_tininess_beforeRounding;
#ifdef EXTFLOAT80
extF80_roundingPrecision = 80;
#endif
roundingMode = softfloat_round_near_even;
exact = false;
genCases_setLevel( 1 );
genLoops_trueFlagsPtr = &softfloat_exceptionFlags;
genLoops_forever = false;
genLoops_givenCount = false;
functionCode = 0;
for (;;) {
--argc;
if ( ! argc ) break;
argPtr = *++argv;
if ( ! argPtr ) break;
if ( argPtr[0] == '-' ) ++argPtr;
if (
! strcmp( argPtr, "help" ) || ! strcmp( argPtr, "-help" )
|| ! strcmp( argPtr, "h" )
) {
writeHelpMessage:
fputs(
"testfloat_gen [<option>...] <type>|<function>\n"
" <option>: (* is default)\n"
" -help --Write this message and exit.\n"
" -prefix <text> --Write <text> as a line of output before any test cases.\n"
" -level <num> --Testing level <num> (1 or 2).\n"
" * -level 1\n"
" -n <num> --Generate <num> test cases.\n"
" -forever --Generate test cases indefinitely (implies `-level 2').\n"
#ifdef EXTFLOAT80
" -precision32 --For extF80, rounding precision is 32 bits.\n"
" -precision64 --For extF80, rounding precision is 64 bits.\n"
" * -precision80 --For extF80, rounding precision is 80 bits.\n"
#endif
" * -rnear_even --Round to nearest/even.\n"
" -rminMag --Round to minimum magnitude (toward zero).\n"
" -rmin --Round to minimum (down).\n"
" -rmax --Round to maximum (up).\n"
" -rnear_maxMag --Round to nearest/maximum magnitude (nearest/away).\n"
" * -tininessbefore --Detect underflow tininess before rounding.\n"
" -tininessafter --Detect underflow tininess after rounding.\n"
" * -notexact --Rounding to integer is not exact (no inexact\n"
" exceptions).\n"
" -exact --Rounding to integer is exact (raising inexact\n"
" exceptions).\n"
" <type>:\n"
" <int> --Generate test cases with one integer operand.\n"
" <float> --Generate test cases with one floating-point operand.\n"
" <float> <num> --Generate test cases with <num> (1, 2, or 3)\n"
" floating-point operands.\n"
" <function>:\n"
" <int>_to_<float> <float>_add <float>_eq\n"
" <float>_to_<int> <float>_sub <float>_le\n"
" <float>_to_<float> <float>_mul <float>_lt\n"
" <float>_roundToInt <float>_mulAdd <float>_eq_signaling\n"
" <float>_div <float>_le_quiet\n"
" <float>_rem <float>_lt_quiet\n"
" <float>_sqrt\n"
" <int>:\n"
" ui32 --Unsigned 32-bit integer.\n"
" ui64 --Unsigned 64-bit integer.\n"
" i32 --Signed 32-bit integer.\n"
" i64 --Signed 64-bit integer.\n"
" <float>:\n"
" f32 --Binary 32-bit floating-point (single-precision).\n"
" f64 --Binary 64-bit floating-point (double-precision).\n"
#ifdef EXTFLOAT80
" extF80 --Binary 80-bit extended floating-point.\n"
#endif
#ifdef FLOAT128
" f128 --Binary 128-bit floating-point (quadruple-precision).\n"
#endif
,
stdout
);
return EXIT_SUCCESS;
} else if ( ! strcmp( argPtr, "prefix" ) ) {
if ( argc < 2 ) goto optionError;
prefixTextPtr = argv[1];
--argc;
++argv;
} else if ( ! strcmp( argPtr, "level" ) ) {
if ( argc < 2 ) goto optionError;
i = strtol( argv[1], (char **) &argPtr, 10 );
if ( *argPtr ) goto optionError;
genCases_setLevel( i );
--argc;
++argv;
} else if ( ! strcmp( argPtr, "level1" ) ) {
genCases_setLevel( 1 );
} else if ( ! strcmp( argPtr, "level2" ) ) {
genCases_setLevel( 2 );
} else if ( ! strcmp( argPtr, "n" ) ) {
if ( argc < 2 ) goto optionError;
genLoops_forever = true;
genLoops_givenCount = true;
i = strtol( argv[1], (char **) &argPtr, 10 );
if ( *argPtr ) goto optionError;
genLoops_count = i;
--argc;
++argv;
} else if ( ! strcmp( argPtr, "forever" ) ) {
genCases_setLevel( 2 );
genLoops_forever = true;
genLoops_givenCount = false;
#ifdef EXTFLOAT80
} else if ( ! strcmp( argPtr, "precision32" ) ) {
extF80_roundingPrecision = 32;
} else if ( ! strcmp( argPtr, "precision64" ) ) {
extF80_roundingPrecision = 64;
} else if ( ! strcmp( argPtr, "precision80" ) ) {
extF80_roundingPrecision = 80;
#endif
} else if (
! strcmp( argPtr, "rnear_even" )
|| ! strcmp( argPtr, "rneareven" )
|| ! strcmp( argPtr, "rnearest_even" )
) {
roundingMode = softfloat_round_near_even;
} else if (
! strcmp( argPtr, "rminmag" ) || ! strcmp( argPtr, "rminMag" )
) {
roundingMode = softfloat_round_minMag;
} else if ( ! strcmp( argPtr, "rmin" ) ) {
roundingMode = softfloat_round_min;
} else if ( ! strcmp( argPtr, "rmax" ) ) {
roundingMode = softfloat_round_max;
} else if (
! strcmp( argPtr, "rnear_maxmag" )
|| ! strcmp( argPtr, "rnear_maxMag" )
|| ! strcmp( argPtr, "rnearmaxmag" )
|| ! strcmp( argPtr, "rnearest_maxmag" )
|| ! strcmp( argPtr, "rnearest_maxMag" )
) {
roundingMode = softfloat_round_near_maxMag;
} else if ( ! strcmp( argPtr, "tininessbefore" ) ) {
softfloat_detectTininess = softfloat_tininess_beforeRounding;
} else if ( ! strcmp( argPtr, "tininessafter" ) ) {
softfloat_detectTininess = softfloat_tininess_afterRounding;
} else if ( ! strcmp( argPtr, "notexact" ) ) {
exact = false;
} else if ( ! strcmp( argPtr, "exact" ) ) {
exact = true;
} else if (
! strcmp( argPtr, "ui32" ) || ! strcmp( argPtr, "uint32" )
) {
functionCode = TYPE_UI32;
if ( 2 <= argc ) goto absorbArg1;
} else if (
! strcmp( argPtr, "ui64" ) || ! strcmp( argPtr, "uint64" )
) {
functionCode = TYPE_UI64;
if ( 2 <= argc ) goto absorbArg1;
} else if (
! strcmp( argPtr, "i32" ) || ! strcmp( argPtr, "int32" )
) {
functionCode = TYPE_I32;
if ( 2 <= argc ) goto absorbArg1;
} else if (
! strcmp( argPtr, "i64" ) || ! strcmp( argPtr, "int64" )
) {
functionCode = TYPE_I64;
if ( 2 <= argc ) goto absorbArg1;
} else if (
! strcmp( argPtr, "f32" ) || ! strcmp( argPtr, "float32" )
) {
functionCode = TYPE_F32;
goto absorbArg;
} else if (
! strcmp( argPtr, "f64" ) || ! strcmp( argPtr, "float64" )
) {
functionCode = TYPE_F64;
#ifdef EXTFLOAT80
goto absorbArg;
} else if (
! strcmp( argPtr, "extF80" ) || ! strcmp( argPtr, "extFloat80" )
) {
functionCode = TYPE_EXTF80;
#endif
#ifdef FLOAT128
goto absorbArg;
} else if (
! strcmp( argPtr, "f128" ) || ! strcmp( argPtr, "float128" )
) {
functionCode = TYPE_F128;
#endif
absorbArg:
if ( 2 <= argc ) {
if ( ! strcmp( argv[1], "2" ) ) {
--argc;
++argv;
++functionCode;
} else if ( ! strcmp( argv[1], "3" ) ) {
--argc;
++argv;
functionCode += 2;
} else {
absorbArg1:
if ( ! strcmp( argv[1], "1" ) ) {
--argc;
++argv;
}
}
}
} else {
functionCode = 1;
while ( strcmp( argPtr, functionInfos[functionCode].namePtr ) ) {
++functionCode;
if ( functionCode == NUM_FUNCTIONS ) goto invalidArg;
}
functionAttribs = functionInfos[functionCode].attribs;
if (
(functionAttribs & FUNC_ARG_EXACT)
&& ! (functionAttribs & FUNC_ARG_ROUNDINGMODE)
) {
goto invalidArg;
}
}
}
if ( ! functionCode ) fail( "Type or function argument required" );
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
if ( prefixTextPtr ) {
fputs( prefixTextPtr, stdout );
fputc( '\n', stdout );
}
softfloat_roundingMode = roundingMode;
signal( SIGINT, catchSIGINT );
signal( SIGTERM, catchSIGINT );
switch ( functionCode ) {
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
case TYPE_UI32:
gen_a_ui32();
break;
case TYPE_UI64:
gen_a_ui64();
break;
case TYPE_I32:
gen_a_i32();
break;
case TYPE_I64:
gen_a_i64();
break;
case TYPE_F32:
gen_a_f32();
break;
case TYPE_F32_2:
gen_ab_f32();
break;
case TYPE_F32_3:
gen_abc_f32();
break;
case TYPE_F64:
gen_a_f64();
break;
case TYPE_F64_2:
gen_ab_f64();
break;
case TYPE_F64_3:
gen_abc_f64();
break;
#ifdef EXTFLOAT80
case TYPE_EXTF80:
gen_a_extF80();
break;
case TYPE_EXTF80_2:
gen_ab_extF80();
break;
case TYPE_EXTF80_3:
gen_abc_extF80();
break;
#endif
#ifdef FLOAT128
case TYPE_F128:
gen_a_f128();
break;
case TYPE_F128_2:
gen_ab_f128();
break;
case TYPE_F128_3:
gen_abc_f128();
break;
#endif
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
case UI32_TO_F32:
gen_a_ui32_z_f32( ui32_to_f32 );
break;
case UI32_TO_F64:
gen_a_ui32_z_f64( ui32_to_f64 );
break;
#ifdef EXTFLOAT80
case UI32_TO_EXTF80:
gen_a_ui32_z_extF80( ui32_to_extF80M );
break;
#endif
#ifdef FLOAT128
case UI32_TO_F128:
gen_a_ui32_z_f128( ui32_to_f128M );
break;
#endif
case UI64_TO_F32:
gen_a_ui64_z_f32( ui64_to_f32 );
break;
case UI64_TO_F64:
gen_a_ui64_z_f64( ui64_to_f64 );
break;
#ifdef EXTFLOAT80
case UI64_TO_EXTF80:
gen_a_ui64_z_extF80( ui64_to_extF80M );
break;
#endif
#ifdef FLOAT128
case UI64_TO_F128:
gen_a_ui64_z_f128( ui64_to_f128M );
break;
#endif
case I32_TO_F32:
gen_a_i32_z_f32( i32_to_f32 );
break;
case I32_TO_F64:
gen_a_i32_z_f64( i32_to_f64 );
break;
#ifdef EXTFLOAT80
case I32_TO_EXTF80:
gen_a_i32_z_extF80( i32_to_extF80M );
break;
#endif
#ifdef FLOAT128
case I32_TO_F128:
gen_a_i32_z_f128( i32_to_f128M );
break;
#endif
case I64_TO_F32:
gen_a_i64_z_f32( i64_to_f32 );
break;
case I64_TO_F64:
gen_a_i64_z_f64( i64_to_f64 );
break;
#ifdef EXTFLOAT80
case I64_TO_EXTF80:
gen_a_i64_z_extF80( i64_to_extF80M );
break;
#endif
#ifdef FLOAT128
case I64_TO_F128:
gen_a_i64_z_f128( i64_to_f128M );
break;
#endif
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
case F32_TO_UI32:
gen_a_f32_z_ui32_rx( f32_to_ui32, roundingMode, exact );
break;
case F32_TO_UI64:
gen_a_f32_z_ui64_rx( f32_to_ui64, roundingMode, exact );
break;
case F32_TO_I32:
gen_a_f32_z_i32_rx( f32_to_i32, roundingMode, exact );
break;
case F32_TO_I64:
gen_a_f32_z_i64_rx( f32_to_i64, roundingMode, exact );
break;
case F32_TO_F64:
gen_a_f32_z_f64( f32_to_f64 );
break;
#ifdef EXTFLOAT80
case F32_TO_EXTF80:
gen_a_f32_z_extF80( f32_to_extF80M );
break;
#endif
#ifdef FLOAT128
case F32_TO_F128:
gen_a_f32_z_f128( f32_to_f128M );
break;
#endif
case F32_ROUNDTOINT:
gen_az_f32_rx( f32_roundToInt, roundingMode, exact );
break;
case F32_ADD:
trueFunction_abz_f32 = f32_add;
goto gen_abz_f32;
case F32_SUB:
trueFunction_abz_f32 = f32_sub;
goto gen_abz_f32;
case F32_MUL:
trueFunction_abz_f32 = f32_mul;
goto gen_abz_f32;
case F32_DIV:
trueFunction_abz_f32 = f32_div;
goto gen_abz_f32;
case F32_REM:
trueFunction_abz_f32 = f32_rem;
gen_abz_f32:
gen_abz_f32( trueFunction_abz_f32 );
break;
case F32_MULADD:
gen_abcz_f32( f32_mulAdd );
break;
case F32_SQRT:
gen_az_f32( f32_sqrt );
break;
case F32_EQ:
trueFunction_ab_f32_z_bool = f32_eq;
goto gen_ab_f32_z_bool;
case F32_LE:
trueFunction_ab_f32_z_bool = f32_le;
goto gen_ab_f32_z_bool;
case F32_LT:
trueFunction_ab_f32_z_bool = f32_lt;
goto gen_ab_f32_z_bool;
case F32_EQ_SIGNALING:
trueFunction_ab_f32_z_bool = f32_eq_signaling;
goto gen_ab_f32_z_bool;
case F32_LE_QUIET:
trueFunction_ab_f32_z_bool = f32_le_quiet;
goto gen_ab_f32_z_bool;
case F32_LT_QUIET:
trueFunction_ab_f32_z_bool = f32_lt_quiet;
gen_ab_f32_z_bool:
gen_ab_f32_z_bool( trueFunction_ab_f32_z_bool );
break;
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
case F64_TO_UI32:
gen_a_f64_z_ui32_rx( f64_to_ui32, roundingMode, exact );
break;
case F64_TO_UI64:
gen_a_f64_z_ui64_rx( f64_to_ui64, roundingMode, exact );
break;
case F64_TO_I32:
gen_a_f64_z_i32_rx( f64_to_i32, roundingMode, exact );
break;
case F64_TO_I64:
gen_a_f64_z_i64_rx( f64_to_i64, roundingMode, exact );
break;
case F64_TO_F32:
gen_a_f64_z_f32( f64_to_f32 );
break;
#ifdef EXTFLOAT80
case F64_TO_EXTF80:
gen_a_f64_z_extF80( f64_to_extF80M );
break;
#endif
#ifdef FLOAT128
case F64_TO_F128:
gen_a_f64_z_f128( f64_to_f128M );
break;
#endif
case F64_ROUNDTOINT:
gen_az_f64_rx( f64_roundToInt, roundingMode, exact );
break;
case F64_ADD:
trueFunction_abz_f64 = f64_add;
goto gen_abz_f64;
case F64_SUB:
trueFunction_abz_f64 = f64_sub;
goto gen_abz_f64;
case F64_MUL:
trueFunction_abz_f64 = f64_mul;
goto gen_abz_f64;
case F64_DIV:
trueFunction_abz_f64 = f64_div;
goto gen_abz_f64;
case F64_REM:
trueFunction_abz_f64 = f64_rem;
gen_abz_f64:
gen_abz_f64( trueFunction_abz_f64 );
break;
case F64_MULADD:
gen_abcz_f64( f64_mulAdd );
break;
case F64_SQRT:
gen_az_f64( f64_sqrt );
break;
case F64_EQ:
trueFunction_ab_f64_z_bool = f64_eq;
goto gen_ab_f64_z_bool;
case F64_LE:
trueFunction_ab_f64_z_bool = f64_le;
goto gen_ab_f64_z_bool;
case F64_LT:
trueFunction_ab_f64_z_bool = f64_lt;
goto gen_ab_f64_z_bool;
case F64_EQ_SIGNALING:
trueFunction_ab_f64_z_bool = f64_eq_signaling;
goto gen_ab_f64_z_bool;
case F64_LE_QUIET:
trueFunction_ab_f64_z_bool = f64_le_quiet;
goto gen_ab_f64_z_bool;
case F64_LT_QUIET:
trueFunction_ab_f64_z_bool = f64_lt_quiet;
gen_ab_f64_z_bool:
gen_ab_f64_z_bool( trueFunction_ab_f64_z_bool );
break;
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
#ifdef EXTFLOAT80
case EXTF80_TO_UI32:
gen_a_extF80_z_ui32_rx( extF80M_to_ui32, roundingMode, exact );
break;
case EXTF80_TO_UI64:
gen_a_extF80_z_ui64_rx( extF80M_to_ui64, roundingMode, exact );
break;
case EXTF80_TO_I32:
gen_a_extF80_z_i32_rx( extF80M_to_i32, roundingMode, exact );
break;
case EXTF80_TO_I64:
gen_a_extF80_z_i64_rx( extF80M_to_i64, roundingMode, exact );
break;
case EXTF80_TO_F32:
gen_a_extF80_z_f32( extF80M_to_f32 );
break;
case EXTF80_TO_F64:
gen_a_extF80_z_f64( extF80M_to_f64 );
break;
#ifdef FLOAT128
case EXTF80_TO_F128:
gen_a_extF80_z_f128( extF80M_to_f128M );
break;
#endif
case EXTF80_ROUNDTOINT:
gen_az_extF80_rx( extF80M_roundToInt, roundingMode, exact );
break;
case EXTF80_ADD:
trueFunction_abz_extF80 = extF80M_add;
goto gen_abz_extF80;
case EXTF80_SUB:
trueFunction_abz_extF80 = extF80M_sub;
goto gen_abz_extF80;
case EXTF80_MUL:
trueFunction_abz_extF80 = extF80M_mul;
goto gen_abz_extF80;
case EXTF80_DIV:
trueFunction_abz_extF80 = extF80M_div;
goto gen_abz_extF80;
case EXTF80_REM:
trueFunction_abz_extF80 = extF80M_rem;
gen_abz_extF80:
gen_abz_extF80( trueFunction_abz_extF80 );
break;
case EXTF80_SQRT:
gen_az_extF80( extF80M_sqrt );
break;
case EXTF80_EQ:
trueFunction_ab_extF80_z_bool = extF80M_eq;
goto gen_ab_extF80_z_bool;
case EXTF80_LE:
trueFunction_ab_extF80_z_bool = extF80M_le;
goto gen_ab_extF80_z_bool;
case EXTF80_LT:
trueFunction_ab_extF80_z_bool = extF80M_lt;
goto gen_ab_extF80_z_bool;
case EXTF80_EQ_SIGNALING:
trueFunction_ab_extF80_z_bool = extF80M_eq_signaling;
goto gen_ab_extF80_z_bool;
case EXTF80_LE_QUIET:
trueFunction_ab_extF80_z_bool = extF80M_le_quiet;
goto gen_ab_extF80_z_bool;
case EXTF80_LT_QUIET:
trueFunction_ab_extF80_z_bool = extF80M_lt_quiet;
gen_ab_extF80_z_bool:
gen_ab_extF80_z_bool( trueFunction_ab_extF80_z_bool );
break;
#endif
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
#ifdef FLOAT128
case F128_TO_UI32:
gen_a_f128_z_ui32_rx( f128M_to_ui32, roundingMode, exact );
break;
case F128_TO_UI64:
gen_a_f128_z_ui64_rx( f128M_to_ui64, roundingMode, exact );
break;
case F128_TO_I32:
gen_a_f128_z_i32_rx( f128M_to_i32, roundingMode, exact );
break;
case F128_TO_I64:
gen_a_f128_z_i64_rx( f128M_to_i64, roundingMode, exact );
break;
case F128_TO_F32:
gen_a_f128_z_f32( f128M_to_f32 );
break;
case F128_TO_F64:
gen_a_f128_z_f64( f128M_to_f64 );
break;
#ifdef EXTFLOAT80
case F128_TO_EXTF80:
gen_a_f128_z_extF80( f128M_to_extF80M );
break;
#endif
case F128_ROUNDTOINT:
gen_az_f128_rx( f128M_roundToInt, roundingMode, exact );
break;
case F128_ADD:
trueFunction_abz_f128 = f128M_add;
goto gen_abz_f128;
case F128_SUB:
trueFunction_abz_f128 = f128M_sub;
goto gen_abz_f128;
case F128_MUL:
trueFunction_abz_f128 = f128M_mul;
goto gen_abz_f128;
case F128_DIV:
trueFunction_abz_f128 = f128M_div;
goto gen_abz_f128;
case F128_REM:
trueFunction_abz_f128 = f128M_rem;
gen_abz_f128:
gen_abz_f128( trueFunction_abz_f128 );
break;
case F128_MULADD:
gen_abcz_f128( f128M_mulAdd );
break;
case F128_SQRT:
gen_az_f128( f128M_sqrt );
break;
case F128_EQ:
trueFunction_ab_f128_z_bool = f128M_eq;
goto gen_ab_f128_z_bool;
case F128_LE:
trueFunction_ab_f128_z_bool = f128M_le;
goto gen_ab_f128_z_bool;
case F128_LT:
trueFunction_ab_f128_z_bool = f128M_lt;
goto gen_ab_f128_z_bool;
case F128_EQ_SIGNALING:
trueFunction_ab_f128_z_bool = f128M_eq_signaling;
goto gen_ab_f128_z_bool;
case F128_LE_QUIET:
trueFunction_ab_f128_z_bool = f128M_le_quiet;
goto gen_ab_f128_z_bool;
case F128_LT_QUIET:
trueFunction_ab_f128_z_bool = f128M_lt_quiet;
gen_ab_f128_z_bool:
gen_ab_f128_z_bool( trueFunction_ab_f128_z_bool );
break;
#endif
}
return EXIT_SUCCESS;
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
optionError:
fail( "`%s' option requires numeric argument", *argv );
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
invalidArg:
fail( "Invalid argument `%s'", *argv );
}
SGVector<float64_t> CKernelMeanMatching::compute_weights()
{
int32_t i,j;
ASSERT(m_kernel)
ASSERT(m_training_indices.vlen)
ASSERT(m_test_indices.vlen)
int32_t n_tr = m_training_indices.vlen;
int32_t n_te = m_test_indices.vlen;
SGVector<float64_t> weights(n_tr);
weights.zero();
kmm_K = SG_MALLOC(float64_t, n_tr*n_tr);
kmm_K_ld = n_tr;
float64_t* diag_K = SG_MALLOC(float64_t, n_tr);
for (i=0; i<n_tr; i++)
{
float64_t d = m_kernel->kernel(m_training_indices[i], m_training_indices[i]);
diag_K[i] = d;
kmm_K[i*n_tr+i] = d;
for (j=i+1; j<n_tr; j++)
{
d = m_kernel->kernel(m_training_indices[i],m_training_indices[j]);
kmm_K[i*n_tr+j] = d;
kmm_K[j*n_tr+i] = d;
}
}
float64_t* kappa = SG_MALLOC(float64_t, n_tr);
for (i=0; i<n_tr; i++)
{
float64_t avg = 0.0;
for (j=0; j<n_te; j++)
avg+= m_kernel->kernel(m_training_indices[i],m_test_indices[j]);
avg *= float64_t(n_tr)/n_te;
kappa[i] = -avg;
}
float64_t* a = SG_MALLOC(float64_t, n_tr);
for (i=0; i<n_tr; i++) a[i] = 1.0;
float64_t* LB = SG_MALLOC(float64_t, n_tr);
float64_t* UB = SG_MALLOC(float64_t, n_tr);
float64_t B = 2.0;
for (i=0; i<n_tr; i++)
{
LB[i] = 0.0;
UB[i] = B;
}
for (i=0; i<n_tr; i++)
weights[i] = 1.0/float64_t(n_tr);
libqp_state_T result =
libqp_gsmo_solver(&kmm_get_col,diag_K,kappa,a,1.0,LB,UB,weights,n_tr,1000,1e-9,NULL);
SG_DEBUG("libqp exitflag=%d, %d iterations passed, primal objective=%f\n",
result.exitflag,result.nIter,result.QP);
SG_FREE(kappa);
SG_FREE(a);
SG_FREE(LB);
SG_FREE(UB);
SG_FREE(diag_K);
SG_FREE(kmm_K);
return weights;
}
static
void
testFunctionInstance(
int functionCode, uint_fast8_t roundingMode, bool exact )
{
#ifdef FLOAT16
float16_t (*trueFunction_abz_f16)( float16_t, float16_t );
float16_t (*subjFunction_abz_f16)( float16_t, float16_t );
bool (*trueFunction_ab_f16_z_bool)( float16_t, float16_t );
bool (*subjFunction_ab_f16_z_bool)( float16_t, float16_t );
#endif
float32_t (*trueFunction_abz_f32)( float32_t, float32_t );
float32_t (*subjFunction_abz_f32)( float32_t, float32_t );
bool (*trueFunction_ab_f32_z_bool)( float32_t, float32_t );
bool (*subjFunction_ab_f32_z_bool)( float32_t, float32_t );
float64_t (*trueFunction_abz_f64)( float64_t, float64_t );
float64_t (*subjFunction_abz_f64)( float64_t, float64_t );
bool (*trueFunction_ab_f64_z_bool)( float64_t, float64_t );
bool (*subjFunction_ab_f64_z_bool)( float64_t, float64_t );
#ifdef EXTFLOAT80
void (*trueFunction_abz_extF80M)(
const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
void (*subjFunction_abz_extF80M)(
const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
bool (*trueFunction_ab_extF80M_z_bool)(
const extFloat80_t *, const extFloat80_t * );
bool (*subjFunction_ab_extF80M_z_bool)(
const extFloat80_t *, const extFloat80_t * );
#endif
#ifdef FLOAT128
void (*trueFunction_abz_f128M)(
const float128_t *, const float128_t *, float128_t * );
void (*subjFunction_abz_f128M)(
const float128_t *, const float128_t *, float128_t * );
bool (*trueFunction_ab_f128M_z_bool)(
const float128_t *, const float128_t * );
bool (*subjFunction_ab_f128M_z_bool)(
const float128_t *, const float128_t * );
#endif
fputs( "Testing ", stderr );
verCases_writeFunctionName( stderr );
fputs( ".\n", stderr );
switch ( functionCode ) {
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
#ifdef FLOAT16
case UI32_TO_F16:
test_a_ui32_z_f16( slow_ui32_to_f16, ui32_to_f16 );
break;
#endif
case UI32_TO_F32:
test_a_ui32_z_f32( slow_ui32_to_f32, ui32_to_f32 );
break;
case UI32_TO_F64:
test_a_ui32_z_f64( slow_ui32_to_f64, ui32_to_f64 );
break;
#ifdef EXTFLOAT80
case UI32_TO_EXTF80:
test_a_ui32_z_extF80( slow_ui32_to_extF80M, ui32_to_extF80M );
break;
#endif
#ifdef FLOAT128
case UI32_TO_F128:
test_a_ui32_z_f128( slow_ui32_to_f128M, ui32_to_f128M );
break;
#endif
#ifdef FLOAT16
case UI64_TO_F16:
test_a_ui64_z_f16( slow_ui64_to_f16, ui64_to_f16 );
break;
#endif
case UI64_TO_F32:
test_a_ui64_z_f32( slow_ui64_to_f32, ui64_to_f32 );
break;
case UI64_TO_F64:
test_a_ui64_z_f64( slow_ui64_to_f64, ui64_to_f64 );
break;
#ifdef EXTFLOAT80
case UI64_TO_EXTF80:
test_a_ui64_z_extF80( slow_ui64_to_extF80M, ui64_to_extF80M );
break;
#endif
#ifdef FLOAT128
case UI64_TO_F128:
test_a_ui64_z_f128( slow_ui64_to_f128M, ui64_to_f128M );
break;
#endif
#ifdef FLOAT16
case I32_TO_F16:
test_a_i32_z_f16( slow_i32_to_f16, i32_to_f16 );
break;
#endif
case I32_TO_F32:
test_a_i32_z_f32( slow_i32_to_f32, i32_to_f32 );
break;
case I32_TO_F64:
test_a_i32_z_f64( slow_i32_to_f64, i32_to_f64 );
break;
#ifdef EXTFLOAT80
case I32_TO_EXTF80:
test_a_i32_z_extF80( slow_i32_to_extF80M, i32_to_extF80M );
break;
#endif
#ifdef FLOAT128
case I32_TO_F128:
test_a_i32_z_f128( slow_i32_to_f128M, i32_to_f128M );
break;
#endif
#ifdef FLOAT16
case I64_TO_F16:
test_a_i64_z_f16( slow_i64_to_f16, i64_to_f16 );
break;
#endif
case I64_TO_F32:
test_a_i64_z_f32( slow_i64_to_f32, i64_to_f32 );
break;
case I64_TO_F64:
test_a_i64_z_f64( slow_i64_to_f64, i64_to_f64 );
break;
#ifdef EXTFLOAT80
case I64_TO_EXTF80:
test_a_i64_z_extF80( slow_i64_to_extF80M, i64_to_extF80M );
break;
#endif
#ifdef FLOAT128
case I64_TO_F128:
test_a_i64_z_f128( slow_i64_to_f128M, i64_to_f128M );
break;
#endif
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
#ifdef FLOAT16
case F16_TO_UI32:
test_a_f16_z_ui32_rx(
slow_f16_to_ui32, f16_to_ui32, roundingMode, exact );
break;
case F16_TO_UI64:
test_a_f16_z_ui64_rx(
slow_f16_to_ui64, f16_to_ui64, roundingMode, exact );
break;
case F16_TO_I32:
test_a_f16_z_i32_rx(
slow_f16_to_i32, f16_to_i32, roundingMode, exact );
break;
case F16_TO_I64:
test_a_f16_z_i64_rx(
slow_f16_to_i64, f16_to_i64, roundingMode, exact );
break;
case F16_TO_UI32_R_MINMAG:
test_a_f16_z_ui32_x(
slow_f16_to_ui32_r_minMag, f16_to_ui32_r_minMag, exact );
break;
case F16_TO_UI64_R_MINMAG:
test_a_f16_z_ui64_x(
slow_f16_to_ui64_r_minMag, f16_to_ui64_r_minMag, exact );
break;
case F16_TO_I32_R_MINMAG:
test_a_f16_z_i32_x(
slow_f16_to_i32_r_minMag, f16_to_i32_r_minMag, exact );
break;
case F16_TO_I64_R_MINMAG:
test_a_f16_z_i64_x(
slow_f16_to_i64_r_minMag, f16_to_i64_r_minMag, exact );
break;
case F16_TO_F32:
test_a_f16_z_f32( slow_f16_to_f32, f16_to_f32 );
break;
case F16_TO_F64:
test_a_f16_z_f64( slow_f16_to_f64, f16_to_f64 );
break;
#ifdef EXTFLOAT80
case F16_TO_EXTF80:
test_a_f16_z_extF80( slow_f16_to_extF80M, f16_to_extF80M );
break;
#endif
#ifdef FLOAT128
case F16_TO_F128:
test_a_f16_z_f128( slow_f16_to_f128M, f16_to_f128M );
break;
#endif
case F16_ROUNDTOINT:
test_az_f16_rx(
slow_f16_roundToInt, f16_roundToInt, roundingMode, exact );
break;
case F16_ADD:
trueFunction_abz_f16 = slow_f16_add;
subjFunction_abz_f16 = f16_add;
goto test_abz_f16;
case F16_SUB:
trueFunction_abz_f16 = slow_f16_sub;
subjFunction_abz_f16 = f16_sub;
goto test_abz_f16;
case F16_MUL:
trueFunction_abz_f16 = slow_f16_mul;
subjFunction_abz_f16 = f16_mul;
goto test_abz_f16;
case F16_DIV:
trueFunction_abz_f16 = slow_f16_div;
subjFunction_abz_f16 = f16_div;
goto test_abz_f16;
case F16_REM:
trueFunction_abz_f16 = slow_f16_rem;
subjFunction_abz_f16 = f16_rem;
test_abz_f16:
test_abz_f16( trueFunction_abz_f16, subjFunction_abz_f16 );
break;
case F16_MULADD:
test_abcz_f16( slow_f16_mulAdd, f16_mulAdd );
break;
case F16_SQRT:
test_az_f16( slow_f16_sqrt, f16_sqrt );
break;
case F16_EQ:
trueFunction_ab_f16_z_bool = slow_f16_eq;
subjFunction_ab_f16_z_bool = f16_eq;
goto test_ab_f16_z_bool;
case F16_LE:
trueFunction_ab_f16_z_bool = slow_f16_le;
subjFunction_ab_f16_z_bool = f16_le;
goto test_ab_f16_z_bool;
case F16_LT:
trueFunction_ab_f16_z_bool = slow_f16_lt;
subjFunction_ab_f16_z_bool = f16_lt;
goto test_ab_f16_z_bool;
case F16_EQ_SIGNALING:
trueFunction_ab_f16_z_bool = slow_f16_eq_signaling;
subjFunction_ab_f16_z_bool = f16_eq_signaling;
goto test_ab_f16_z_bool;
case F16_LE_QUIET:
trueFunction_ab_f16_z_bool = slow_f16_le_quiet;
subjFunction_ab_f16_z_bool = f16_le_quiet;
goto test_ab_f16_z_bool;
case F16_LT_QUIET:
trueFunction_ab_f16_z_bool = slow_f16_lt_quiet;
subjFunction_ab_f16_z_bool = f16_lt_quiet;
test_ab_f16_z_bool:
test_ab_f16_z_bool(
trueFunction_ab_f16_z_bool, subjFunction_ab_f16_z_bool );
break;
#endif
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
case F32_TO_UI32:
test_a_f32_z_ui32_rx(
slow_f32_to_ui32, f32_to_ui32, roundingMode, exact );
break;
case F32_TO_UI64:
test_a_f32_z_ui64_rx(
slow_f32_to_ui64, f32_to_ui64, roundingMode, exact );
break;
case F32_TO_I32:
test_a_f32_z_i32_rx(
slow_f32_to_i32, f32_to_i32, roundingMode, exact );
break;
case F32_TO_I64:
test_a_f32_z_i64_rx(
slow_f32_to_i64, f32_to_i64, roundingMode, exact );
break;
case F32_TO_UI32_R_MINMAG:
test_a_f32_z_ui32_x(
slow_f32_to_ui32_r_minMag, f32_to_ui32_r_minMag, exact );
break;
case F32_TO_UI64_R_MINMAG:
test_a_f32_z_ui64_x(
slow_f32_to_ui64_r_minMag, f32_to_ui64_r_minMag, exact );
break;
case F32_TO_I32_R_MINMAG:
test_a_f32_z_i32_x(
slow_f32_to_i32_r_minMag, f32_to_i32_r_minMag, exact );
break;
case F32_TO_I64_R_MINMAG:
test_a_f32_z_i64_x(
slow_f32_to_i64_r_minMag, f32_to_i64_r_minMag, exact );
break;
#ifdef FLOAT16
case F32_TO_F16:
test_a_f32_z_f16( slow_f32_to_f16, f32_to_f16 );
break;
#endif
case F32_TO_F64:
test_a_f32_z_f64( slow_f32_to_f64, f32_to_f64 );
break;
#ifdef EXTFLOAT80
case F32_TO_EXTF80:
test_a_f32_z_extF80( slow_f32_to_extF80M, f32_to_extF80M );
break;
#endif
#ifdef FLOAT128
case F32_TO_F128:
test_a_f32_z_f128( slow_f32_to_f128M, f32_to_f128M );
break;
#endif
case F32_ROUNDTOINT:
test_az_f32_rx(
slow_f32_roundToInt, f32_roundToInt, roundingMode, exact );
break;
case F32_ADD:
trueFunction_abz_f32 = slow_f32_add;
subjFunction_abz_f32 = f32_add;
goto test_abz_f32;
case F32_SUB:
trueFunction_abz_f32 = slow_f32_sub;
subjFunction_abz_f32 = f32_sub;
goto test_abz_f32;
case F32_MUL:
trueFunction_abz_f32 = slow_f32_mul;
subjFunction_abz_f32 = f32_mul;
goto test_abz_f32;
case F32_DIV:
trueFunction_abz_f32 = slow_f32_div;
subjFunction_abz_f32 = f32_div;
goto test_abz_f32;
case F32_REM:
trueFunction_abz_f32 = slow_f32_rem;
subjFunction_abz_f32 = f32_rem;
test_abz_f32:
test_abz_f32( trueFunction_abz_f32, subjFunction_abz_f32 );
break;
case F32_MULADD:
test_abcz_f32( slow_f32_mulAdd, f32_mulAdd );
break;
case F32_SQRT:
test_az_f32( slow_f32_sqrt, f32_sqrt );
break;
case F32_EQ:
trueFunction_ab_f32_z_bool = slow_f32_eq;
subjFunction_ab_f32_z_bool = f32_eq;
goto test_ab_f32_z_bool;
case F32_LE:
trueFunction_ab_f32_z_bool = slow_f32_le;
subjFunction_ab_f32_z_bool = f32_le;
goto test_ab_f32_z_bool;
case F32_LT:
trueFunction_ab_f32_z_bool = slow_f32_lt;
subjFunction_ab_f32_z_bool = f32_lt;
goto test_ab_f32_z_bool;
case F32_EQ_SIGNALING:
trueFunction_ab_f32_z_bool = slow_f32_eq_signaling;
subjFunction_ab_f32_z_bool = f32_eq_signaling;
goto test_ab_f32_z_bool;
case F32_LE_QUIET:
trueFunction_ab_f32_z_bool = slow_f32_le_quiet;
subjFunction_ab_f32_z_bool = f32_le_quiet;
goto test_ab_f32_z_bool;
case F32_LT_QUIET:
trueFunction_ab_f32_z_bool = slow_f32_lt_quiet;
subjFunction_ab_f32_z_bool = f32_lt_quiet;
test_ab_f32_z_bool:
test_ab_f32_z_bool(
trueFunction_ab_f32_z_bool, subjFunction_ab_f32_z_bool );
break;
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
case F64_TO_UI32:
test_a_f64_z_ui32_rx(
slow_f64_to_ui32, f64_to_ui32, roundingMode, exact );
break;
case F64_TO_UI64:
test_a_f64_z_ui64_rx(
slow_f64_to_ui64, f64_to_ui64, roundingMode, exact );
break;
case F64_TO_I32:
test_a_f64_z_i32_rx(
slow_f64_to_i32, f64_to_i32, roundingMode, exact );
break;
case F64_TO_I64:
test_a_f64_z_i64_rx(
slow_f64_to_i64, f64_to_i64, roundingMode, exact );
break;
case F64_TO_UI32_R_MINMAG:
test_a_f64_z_ui32_x(
slow_f64_to_ui32_r_minMag, f64_to_ui32_r_minMag, exact );
break;
case F64_TO_UI64_R_MINMAG:
test_a_f64_z_ui64_x(
slow_f64_to_ui64_r_minMag, f64_to_ui64_r_minMag, exact );
break;
case F64_TO_I32_R_MINMAG:
test_a_f64_z_i32_x(
slow_f64_to_i32_r_minMag, f64_to_i32_r_minMag, exact );
break;
case F64_TO_I64_R_MINMAG:
test_a_f64_z_i64_x(
slow_f64_to_i64_r_minMag, f64_to_i64_r_minMag, exact );
break;
#ifdef FLOAT16
case F64_TO_F16:
test_a_f64_z_f16( slow_f64_to_f16, f64_to_f16 );
break;
#endif
case F64_TO_F32:
test_a_f64_z_f32( slow_f64_to_f32, f64_to_f32 );
break;
#ifdef EXTFLOAT80
case F64_TO_EXTF80:
test_a_f64_z_extF80( slow_f64_to_extF80M, f64_to_extF80M );
break;
#endif
#ifdef FLOAT128
case F64_TO_F128:
test_a_f64_z_f128( slow_f64_to_f128M, f64_to_f128M );
break;
#endif
case F64_ROUNDTOINT:
test_az_f64_rx(
slow_f64_roundToInt, f64_roundToInt, roundingMode, exact );
break;
case F64_ADD:
trueFunction_abz_f64 = slow_f64_add;
subjFunction_abz_f64 = f64_add;
goto test_abz_f64;
case F64_SUB:
trueFunction_abz_f64 = slow_f64_sub;
subjFunction_abz_f64 = f64_sub;
goto test_abz_f64;
case F64_MUL:
trueFunction_abz_f64 = slow_f64_mul;
subjFunction_abz_f64 = f64_mul;
goto test_abz_f64;
case F64_DIV:
trueFunction_abz_f64 = slow_f64_div;
subjFunction_abz_f64 = f64_div;
goto test_abz_f64;
case F64_REM:
trueFunction_abz_f64 = slow_f64_rem;
subjFunction_abz_f64 = f64_rem;
test_abz_f64:
test_abz_f64( trueFunction_abz_f64, subjFunction_abz_f64 );
break;
case F64_MULADD:
test_abcz_f64( slow_f64_mulAdd, f64_mulAdd );
break;
case F64_SQRT:
test_az_f64( slow_f64_sqrt, f64_sqrt );
break;
case F64_EQ:
trueFunction_ab_f64_z_bool = slow_f64_eq;
subjFunction_ab_f64_z_bool = f64_eq;
goto test_ab_f64_z_bool;
case F64_LE:
trueFunction_ab_f64_z_bool = slow_f64_le;
subjFunction_ab_f64_z_bool = f64_le;
goto test_ab_f64_z_bool;
case F64_LT:
trueFunction_ab_f64_z_bool = slow_f64_lt;
subjFunction_ab_f64_z_bool = f64_lt;
goto test_ab_f64_z_bool;
case F64_EQ_SIGNALING:
trueFunction_ab_f64_z_bool = slow_f64_eq_signaling;
subjFunction_ab_f64_z_bool = f64_eq_signaling;
goto test_ab_f64_z_bool;
case F64_LE_QUIET:
trueFunction_ab_f64_z_bool = slow_f64_le_quiet;
subjFunction_ab_f64_z_bool = f64_le_quiet;
goto test_ab_f64_z_bool;
case F64_LT_QUIET:
trueFunction_ab_f64_z_bool = slow_f64_lt_quiet;
subjFunction_ab_f64_z_bool = f64_lt_quiet;
test_ab_f64_z_bool:
test_ab_f64_z_bool(
trueFunction_ab_f64_z_bool, subjFunction_ab_f64_z_bool );
break;
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
#ifdef EXTFLOAT80
case EXTF80_TO_UI32:
test_a_extF80_z_ui32_rx(
slow_extF80M_to_ui32, extF80M_to_ui32, roundingMode, exact );
break;
case EXTF80_TO_UI64:
test_a_extF80_z_ui64_rx(
slow_extF80M_to_ui64, extF80M_to_ui64, roundingMode, exact );
break;
case EXTF80_TO_I32:
test_a_extF80_z_i32_rx(
slow_extF80M_to_i32, extF80M_to_i32, roundingMode, exact );
break;
case EXTF80_TO_I64:
test_a_extF80_z_i64_rx(
slow_extF80M_to_i64, extF80M_to_i64, roundingMode, exact );
break;
case EXTF80_TO_UI32_R_MINMAG:
test_a_extF80_z_ui32_x(
slow_extF80M_to_ui32_r_minMag, extF80M_to_ui32_r_minMag, exact );
break;
case EXTF80_TO_UI64_R_MINMAG:
test_a_extF80_z_ui64_x(
slow_extF80M_to_ui64_r_minMag, extF80M_to_ui64_r_minMag, exact );
break;
case EXTF80_TO_I32_R_MINMAG:
test_a_extF80_z_i32_x(
slow_extF80M_to_i32_r_minMag, extF80M_to_i32_r_minMag, exact );
break;
case EXTF80_TO_I64_R_MINMAG:
test_a_extF80_z_i64_x(
slow_extF80M_to_i64_r_minMag, extF80M_to_i64_r_minMag, exact );
break;
#ifdef FLOAT16
case EXTF80_TO_F16:
test_a_extF80_z_f16( slow_extF80M_to_f16, extF80M_to_f16 );
break;
#endif
case EXTF80_TO_F32:
test_a_extF80_z_f32( slow_extF80M_to_f32, extF80M_to_f32 );
break;
case EXTF80_TO_F64:
test_a_extF80_z_f64( slow_extF80M_to_f64, extF80M_to_f64 );
break;
#ifdef FLOAT128
case EXTF80_TO_F128:
test_a_extF80_z_f128( slow_extF80M_to_f128M, extF80M_to_f128M );
break;
#endif
case EXTF80_ROUNDTOINT:
test_az_extF80_rx(
slow_extF80M_roundToInt, extF80M_roundToInt, roundingMode, exact );
break;
case EXTF80_ADD:
trueFunction_abz_extF80M = slow_extF80M_add;
subjFunction_abz_extF80M = extF80M_add;
goto test_abz_extF80;
case EXTF80_SUB:
trueFunction_abz_extF80M = slow_extF80M_sub;
subjFunction_abz_extF80M = extF80M_sub;
goto test_abz_extF80;
case EXTF80_MUL:
trueFunction_abz_extF80M = slow_extF80M_mul;
subjFunction_abz_extF80M = extF80M_mul;
goto test_abz_extF80;
case EXTF80_DIV:
trueFunction_abz_extF80M = slow_extF80M_div;
subjFunction_abz_extF80M = extF80M_div;
goto test_abz_extF80;
case EXTF80_REM:
trueFunction_abz_extF80M = slow_extF80M_rem;
subjFunction_abz_extF80M = extF80M_rem;
test_abz_extF80:
test_abz_extF80( trueFunction_abz_extF80M, subjFunction_abz_extF80M );
break;
case EXTF80_SQRT:
test_az_extF80( slow_extF80M_sqrt, extF80M_sqrt );
break;
case EXTF80_EQ:
trueFunction_ab_extF80M_z_bool = slow_extF80M_eq;
subjFunction_ab_extF80M_z_bool = extF80M_eq;
goto test_ab_extF80_z_bool;
case EXTF80_LE:
trueFunction_ab_extF80M_z_bool = slow_extF80M_le;
subjFunction_ab_extF80M_z_bool = extF80M_le;
goto test_ab_extF80_z_bool;
case EXTF80_LT:
trueFunction_ab_extF80M_z_bool = slow_extF80M_lt;
subjFunction_ab_extF80M_z_bool = extF80M_lt;
goto test_ab_extF80_z_bool;
case EXTF80_EQ_SIGNALING:
trueFunction_ab_extF80M_z_bool = slow_extF80M_eq_signaling;
subjFunction_ab_extF80M_z_bool = extF80M_eq_signaling;
goto test_ab_extF80_z_bool;
case EXTF80_LE_QUIET:
trueFunction_ab_extF80M_z_bool = slow_extF80M_le_quiet;
subjFunction_ab_extF80M_z_bool = extF80M_le_quiet;
goto test_ab_extF80_z_bool;
case EXTF80_LT_QUIET:
trueFunction_ab_extF80M_z_bool = slow_extF80M_lt_quiet;
subjFunction_ab_extF80M_z_bool = extF80M_lt_quiet;
test_ab_extF80_z_bool:
test_ab_extF80_z_bool(
trueFunction_ab_extF80M_z_bool, subjFunction_ab_extF80M_z_bool );
break;
#endif
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
#ifdef FLOAT128
case F128_TO_UI32:
test_a_f128_z_ui32_rx(
slow_f128M_to_ui32, f128M_to_ui32, roundingMode, exact );
break;
case F128_TO_UI64:
test_a_f128_z_ui64_rx(
slow_f128M_to_ui64, f128M_to_ui64, roundingMode, exact );
break;
case F128_TO_I32:
test_a_f128_z_i32_rx(
slow_f128M_to_i32, f128M_to_i32, roundingMode, exact );
break;
case F128_TO_I64:
test_a_f128_z_i64_rx(
slow_f128M_to_i64, f128M_to_i64, roundingMode, exact );
break;
case F128_TO_UI32_R_MINMAG:
test_a_f128_z_ui32_x(
slow_f128M_to_ui32_r_minMag, f128M_to_ui32_r_minMag, exact );
break;
case F128_TO_UI64_R_MINMAG:
test_a_f128_z_ui64_x(
slow_f128M_to_ui64_r_minMag, f128M_to_ui64_r_minMag, exact );
break;
case F128_TO_I32_R_MINMAG:
test_a_f128_z_i32_x(
slow_f128M_to_i32_r_minMag, f128M_to_i32_r_minMag, exact );
break;
case F128_TO_I64_R_MINMAG:
test_a_f128_z_i64_x(
slow_f128M_to_i64_r_minMag, f128M_to_i64_r_minMag, exact );
break;
#ifdef FLOAT16
case F128_TO_F16:
test_a_f128_z_f16( slow_f128M_to_f16, f128M_to_f16 );
break;
#endif
case F128_TO_F32:
test_a_f128_z_f32( slow_f128M_to_f32, f128M_to_f32 );
break;
case F128_TO_F64:
test_a_f128_z_f64( slow_f128M_to_f64, f128M_to_f64 );
break;
#ifdef EXTFLOAT80
case F128_TO_EXTF80:
test_a_f128_z_extF80( slow_f128M_to_extF80M, f128M_to_extF80M );
break;
#endif
case F128_ROUNDTOINT:
test_az_f128_rx(
slow_f128M_roundToInt, f128M_roundToInt, roundingMode, exact );
break;
case F128_ADD:
trueFunction_abz_f128M = slow_f128M_add;
subjFunction_abz_f128M = f128M_add;
goto test_abz_f128;
case F128_SUB:
trueFunction_abz_f128M = slow_f128M_sub;
subjFunction_abz_f128M = f128M_sub;
goto test_abz_f128;
case F128_MUL:
trueFunction_abz_f128M = slow_f128M_mul;
subjFunction_abz_f128M = f128M_mul;
goto test_abz_f128;
case F128_DIV:
trueFunction_abz_f128M = slow_f128M_div;
subjFunction_abz_f128M = f128M_div;
goto test_abz_f128;
case F128_REM:
trueFunction_abz_f128M = slow_f128M_rem;
subjFunction_abz_f128M = f128M_rem;
test_abz_f128:
test_abz_f128( trueFunction_abz_f128M, subjFunction_abz_f128M );
break;
case F128_MULADD:
test_abcz_f128( slow_f128M_mulAdd, f128M_mulAdd );
break;
case F128_SQRT:
test_az_f128( slow_f128M_sqrt, f128M_sqrt );
break;
case F128_EQ:
trueFunction_ab_f128M_z_bool = slow_f128M_eq;
subjFunction_ab_f128M_z_bool = f128M_eq;
goto test_ab_f128_z_bool;
case F128_LE:
trueFunction_ab_f128M_z_bool = slow_f128M_le;
subjFunction_ab_f128M_z_bool = f128M_le;
goto test_ab_f128_z_bool;
case F128_LT:
trueFunction_ab_f128M_z_bool = slow_f128M_lt;
subjFunction_ab_f128M_z_bool = f128M_lt;
goto test_ab_f128_z_bool;
case F128_EQ_SIGNALING:
trueFunction_ab_f128M_z_bool = slow_f128M_eq_signaling;
subjFunction_ab_f128M_z_bool = f128M_eq_signaling;
goto test_ab_f128_z_bool;
case F128_LE_QUIET:
trueFunction_ab_f128M_z_bool = slow_f128M_le_quiet;
subjFunction_ab_f128M_z_bool = f128M_le_quiet;
goto test_ab_f128_z_bool;
case F128_LT_QUIET:
trueFunction_ab_f128M_z_bool = slow_f128M_lt_quiet;
subjFunction_ab_f128M_z_bool = f128M_lt_quiet;
test_ab_f128_z_bool:
test_ab_f128_z_bool(
trueFunction_ab_f128M_z_bool, subjFunction_ab_f128M_z_bool );
break;
#endif
}
if ( (verCases_errorStop && verCases_anyErrors) || verCases_stop ) {
verCases_exitWithStatus();
}
}
