Release 3b. See "doc/TestFloat-history.html".

1 files changed, 655 insertions, 4 deletions

diff --git a/source/genLoops.c b/source/genLoops.c
index 620d306..f8a843a 100644
--- a/source/genLoops.c
+++ b/source/genLoops.c
@@ -1,12 +1,12 @@
 
 /*============================================================================
 
-This C source file is part of TestFloat, Release 3a, a package of programs for
+This C source file is part of TestFloat, Release 3b, a package of programs for
 testing the correctness of floating-point arithmetic complying with the IEEE
 Standard for Floating-Point, by John R. Hauser.
 
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
@@ -53,6 +53,9 @@ bool genLoops_givenCount;
 uint_fast64_t genLoops_count;
 uint_fast8_t *genLoops_trueFlagsPtr;
 
+#ifdef FLOAT16
+union ui16_f16 { uint16_t ui; float16_t f; };
+#endif
 union ui32_f32 { uint32_t ui; float32_t f; };
 union ui64_f64 { uint64_t ui; float64_t f; };
 
@@ -102,6 +105,23 @@ static bool writeGenOutputs_bool( bool z, uint_fast8_t flags )
 
 }
 
+#ifdef FLOAT16
+
+static bool writeGenOutputs_ui16( uint_fast16_t z, uint_fast8_t flags )
+{
+
+    writeHex_ui16( z, ' ' );
+    writeGenOutput_flags( flags );
+    if ( genLoops_givenCount ) {
+        --genLoops_count;
+        if ( ! genLoops_count ) return true;
+    }
+    return false;
+
+}
+
+#endif
+
 static bool writeGenOutputs_ui32( uint_fast32_t z, uint_fast8_t flags )
 {
 
@@ -141,7 +161,7 @@ static void writeHex_uiExtF80M( const extFloat80_t *aPtr, char sepChar )
 }
 
 static
- bool writeGenOutputs_extF80M( const extFloat80_t *aPtr, uint_fast8_t flags )
+bool writeGenOutputs_extF80M( const extFloat80_t *aPtr, uint_fast8_t flags )
 {
 
     writeHex_uiExtF80M( aPtr, ' ' );
@@ -247,6 +267,70 @@ void gen_a_i64( void )
 
 }
 
+#ifdef FLOAT16
+
+void gen_a_f16( void )
+{
+    union ui16_f16 uA;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        uA.f = genCases_f16_a;
+        writeHex_ui16( uA.ui, '\n' );
+        if ( genLoops_givenCount ) {
+            --genLoops_count;
+            if ( ! genLoops_count ) break;
+        }
+    }
+
+}
+
+void gen_ab_f16( void )
+{
+    union ui16_f16 u;
+
+    genCases_f16_ab_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_ab_next();
+        u.f = genCases_f16_a;
+        writeHex_ui16( u.ui, ' ' );
+        u.f = genCases_f16_b;
+        writeHex_ui16( u.ui, '\n' );
+        if ( genLoops_givenCount ) {
+            --genLoops_count;
+            if ( ! genLoops_count ) break;
+        }
+    }
+
+}
+
+void gen_abc_f16( void )
+{
+    union ui16_f16 u;
+
+    genCases_f16_abc_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_abc_next();
+        u.f = genCases_f16_a;
+        writeHex_ui16( u.ui, ' ' );
+        u.f = genCases_f16_b;
+        writeHex_ui16( u.ui, ' ' );
+        u.f = genCases_f16_c;
+        writeHex_ui16( u.ui, '\n' );
+        if ( genLoops_givenCount ) {
+            --genLoops_count;
+            if ( ! genLoops_count ) break;
+        }
+    }
+
+}
+
+#endif
+
 void gen_a_f32( void )
 {
     union ui32_f32 uA;
@@ -477,6 +561,28 @@ void gen_abc_f128( void )
 
 #endif
 
+#ifdef FLOAT16
+
+void gen_a_ui32_z_f16( float16_t trueFunction( uint32_t ) )
+{
+    union ui16_f16 uTrueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_ui32_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_ui32_a_next();
+        writeHex_ui32( genCases_ui32_a, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        uTrueZ.f = trueFunction( genCases_ui32_a );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break;
+    }
+
+}
+
+#endif
+
 void gen_a_ui32_z_f32( float32_t trueFunction( uint32_t ) )
 {
     union ui32_f32 uTrueZ;
@@ -557,6 +663,28 @@ void gen_a_ui32_z_f128( void trueFunction( uint32_t, float128_t * ) )
 
 #endif
 
+#ifdef FLOAT16
+
+void gen_a_ui64_z_f16( float16_t trueFunction( uint64_t ) )
+{
+    union ui16_f16 uTrueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_ui64_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_ui64_a_next();
+        writeHex_ui64( genCases_ui64_a, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        uTrueZ.f = trueFunction( genCases_ui64_a );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break;
+    }
+
+}
+
+#endif
+
 void gen_a_ui64_z_f32( float32_t trueFunction( uint64_t ) )
 {
     union ui32_f32 uTrueZ;
@@ -637,6 +765,28 @@ void gen_a_ui64_z_f128( void trueFunction( uint64_t, float128_t * ) )
 
 #endif
 
+#ifdef FLOAT16
+
+void gen_a_i32_z_f16( float16_t trueFunction( int32_t ) )
+{
+    union ui16_f16 uTrueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_i32_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_i32_a_next();
+        writeHex_ui32( genCases_i32_a, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        uTrueZ.f = trueFunction( genCases_i32_a );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break;
+    }
+
+}
+
+#endif
+
 void gen_a_i32_z_f32( float32_t trueFunction( int32_t ) )
 {
     union ui32_f32 uTrueZ;
@@ -717,6 +867,28 @@ void gen_a_i32_z_f128( void trueFunction( int32_t, float128_t * ) )
 
 #endif
 
+#ifdef FLOAT16
+
+void gen_a_i64_z_f16( float16_t trueFunction( int64_t ) )
+{
+    union ui16_f16 uTrueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_i64_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_i64_a_next();
+        writeHex_ui64( genCases_i64_a, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        uTrueZ.f = trueFunction( genCases_i64_a );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break;
+    }
+
+}
+
+#endif
+
 void gen_a_i64_z_f32( float32_t trueFunction( int64_t ) )
 {
     union ui32_f32 uTrueZ;
@@ -797,6 +969,393 @@ void gen_a_i64_z_f128( void trueFunction( int64_t, float128_t * ) )
 
 #endif
 
+#ifdef FLOAT16
+
+void
+ gen_a_f16_z_ui32_rx(
+     uint_fast32_t trueFunction( float16_t, uint_fast8_t, bool ),
+     uint_fast8_t roundingMode,
+     bool exact
+ )
+{
+    union ui16_f16 uA;
+    uint_fast32_t trueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        uA.f = genCases_f16_a;
+        writeHex_ui16( uA.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        trueZ = trueFunction( genCases_f16_a, roundingMode, exact );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break;
+    }
+
+}
+
+void
+ gen_a_f16_z_ui64_rx(
+     uint_fast64_t trueFunction( float16_t, uint_fast8_t, bool ),
+     uint_fast8_t roundingMode,
+     bool exact
+ )
+{
+    union ui16_f16 uA;
+    uint_fast64_t trueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        uA.f = genCases_f16_a;
+        writeHex_ui16( uA.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        trueZ = trueFunction( genCases_f16_a, roundingMode, exact );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break;
+    }
+
+}
+
+void
+ gen_a_f16_z_i32_rx(
+     int_fast32_t trueFunction( float16_t, uint_fast8_t, bool ),
+     uint_fast8_t roundingMode,
+     bool exact
+ )
+{
+    union ui16_f16 uA;
+    int_fast32_t trueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        uA.f = genCases_f16_a;
+        writeHex_ui16( uA.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        trueZ = trueFunction( genCases_f16_a, roundingMode, exact );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break;
+    }
+
+}
+
+void
+ gen_a_f16_z_i64_rx(
+     int_fast64_t trueFunction( float16_t, uint_fast8_t, bool ),
+     uint_fast8_t roundingMode,
+     bool exact
+ )
+{
+    union ui16_f16 uA;
+    int_fast64_t trueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        uA.f = genCases_f16_a;
+        writeHex_ui16( uA.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        trueZ = trueFunction( genCases_f16_a, roundingMode, exact );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break;
+    }
+
+}
+
+void
+ gen_a_f16_z_ui32_x(
+     uint_fast32_t trueFunction( float16_t, bool ), bool exact )
+{
+    union ui16_f16 uA;
+    uint_fast32_t trueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        uA.f = genCases_f16_a;
+        writeHex_ui16( uA.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        trueZ = trueFunction( genCases_f16_a, exact );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break;
+    }
+
+}
+
+void
+ gen_a_f16_z_ui64_x(
+     uint_fast64_t trueFunction( float16_t, bool ), bool exact )
+{
+    union ui16_f16 uA;
+    uint_fast64_t trueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        uA.f = genCases_f16_a;
+        writeHex_ui16( uA.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        trueZ = trueFunction( genCases_f16_a, exact );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break;
+    }
+
+}
+
+void
+ gen_a_f16_z_i32_x( int_fast32_t trueFunction( float16_t, bool ), bool exact )
+{
+    union ui16_f16 uA;
+    int_fast32_t trueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        uA.f = genCases_f16_a;
+        writeHex_ui16( uA.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        trueZ = trueFunction( genCases_f16_a, exact );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break;
+    }
+
+}
+
+void
+ gen_a_f16_z_i64_x( int_fast64_t trueFunction( float16_t, bool ), bool exact )
+{
+    union ui16_f16 uA;
+    int_fast64_t trueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        uA.f = genCases_f16_a;
+        writeHex_ui16( uA.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        trueZ = trueFunction( genCases_f16_a, exact );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break;
+    }
+
+}
+
+void gen_a_f16_z_f32( float32_t trueFunction( float16_t ) )
+{
+    union ui16_f16 uA;
+    union ui32_f32 uTrueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        uA.f = genCases_f16_a;
+        writeHex_ui16( uA.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        uTrueZ.f = trueFunction( genCases_f16_a );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui32( uTrueZ.ui, trueFlags ) ) break;
+    }
+
+}
+
+void gen_a_f16_z_f64( float64_t trueFunction( float16_t ) )
+{
+    union ui16_f16 uA;
+    union ui64_f64 uTrueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        uA.f = genCases_f16_a;
+        writeHex_ui16( uA.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        uTrueZ.f = trueFunction( genCases_f16_a );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui64( uTrueZ.ui, trueFlags ) ) break;
+    }
+
+}
+
+#ifdef EXTFLOAT80
+
+void gen_a_f16_z_extF80( void trueFunction( float16_t, extFloat80_t * ) )
+{
+    union ui16_f16 uA;
+    extFloat80_t trueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        uA.f = genCases_f16_a;
+        writeHex_ui16( uA.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        trueFunction( genCases_f16_a, &trueZ );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_extF80M( &trueZ, trueFlags ) ) break;
+    }
+
+}
+
+#endif
+
+#ifdef FLOAT128
+
+void gen_a_f16_z_f128( void trueFunction( float16_t, float128_t * ) )
+{
+    union ui16_f16 uA;
+    float128_t trueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        uA.f = genCases_f16_a;
+        writeHex_ui16( uA.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        trueFunction( genCases_f16_a, &trueZ );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_f128M( &trueZ, trueFlags ) ) break;
+    }
+
+}
+
+#endif
+
+void gen_az_f16( float16_t trueFunction( float16_t ) )
+{
+    union ui16_f16 u;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        u.f = genCases_f16_a;
+        writeHex_ui16( u.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        u.f = trueFunction( genCases_f16_a );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui16( u.ui, trueFlags ) ) break;
+    }
+
+}
+
+void
+ gen_az_f16_rx(
+     float16_t trueFunction( float16_t, uint_fast8_t, bool ),
+     uint_fast8_t roundingMode,
+     bool exact
+ )
+{
+    union ui16_f16 u;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_a_next();
+        u.f = genCases_f16_a;
+        writeHex_ui16( u.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        u.f = trueFunction( genCases_f16_a, roundingMode, exact );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui16( u.ui, trueFlags ) ) break;
+    }
+
+}
+
+void gen_abz_f16( float16_t trueFunction( float16_t, float16_t ) )
+{
+    union ui16_f16 u;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_ab_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_ab_next();
+        u.f = genCases_f16_a;
+        writeHex_ui16( u.ui, ' ' );
+        u.f = genCases_f16_b;
+        writeHex_ui16( u.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        u.f = trueFunction( genCases_f16_a, genCases_f16_b );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui16( u.ui, trueFlags ) ) break;
+    }
+
+}
+
+void gen_abcz_f16( float16_t trueFunction( float16_t, float16_t, float16_t ) )
+{
+    union ui16_f16 u;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_abc_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_abc_next();
+        u.f = genCases_f16_a;
+        writeHex_ui16( u.ui, ' ' );
+        u.f = genCases_f16_b;
+        writeHex_ui16( u.ui, ' ' );
+        u.f = genCases_f16_c;
+        writeHex_ui16( u.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        u.f = trueFunction( genCases_f16_a, genCases_f16_b, genCases_f16_c );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui16( u.ui, trueFlags ) ) break;
+    }
+
+}
+
+void gen_ab_f16_z_bool( bool trueFunction( float16_t, float16_t ) )
+{
+    union ui16_f16 u;
+    bool trueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f16_ab_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f16_ab_next();
+        u.f = genCases_f16_a;
+        writeHex_ui16( u.ui, ' ' );
+        u.f = genCases_f16_b;
+        writeHex_ui16( u.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        trueZ = trueFunction( genCases_f16_a, genCases_f16_b );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_bool( trueZ, trueFlags ) ) break;
+    }
+
+}
+
+#endif
+
 void
  gen_a_f32_z_ui32_rx(
      uint_fast32_t trueFunction( float32_t, uint_fast8_t, bool ),
@@ -983,6 +1542,30 @@ void
 
 }
 
+#ifdef FLOAT16
+
+void gen_a_f32_z_f16( float16_t trueFunction( float32_t ) )
+{
+    union ui32_f32 uA;
+    union ui16_f16 uTrueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f32_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f32_a_next();
+        uA.f = genCases_f32_a;
+        writeHex_ui32( uA.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        uTrueZ.f = trueFunction( genCases_f32_a );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break;
+    }
+
+}
+
+#endif
+
 void gen_a_f32_z_f64( float64_t trueFunction( float32_t ) )
 {
     union ui32_f32 uA;
@@ -1346,6 +1929,30 @@ void
 
 }
 
+#ifdef FLOAT16
+
+void gen_a_f64_z_f16( float16_t trueFunction( float64_t ) )
+{
+    union ui64_f64 uA;
+    union ui16_f16 uTrueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f64_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f64_a_next();
+        uA.f = genCases_f64_a;
+        writeHex_ui64( uA.ui, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        uTrueZ.f = trueFunction( genCases_f64_a );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break;
+    }
+
+}
+
+#endif
+
 void gen_a_f64_z_f32( float32_t trueFunction( float64_t ) )
 {
     union ui64_f64 uA;
@@ -1697,6 +2304,28 @@ void
 
 }
 
+#ifdef FLOAT16
+
+void gen_a_extF80_z_f16( float16_t trueFunction( const extFloat80_t * ) )
+{
+    union ui16_f16 uTrueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_extF80_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_extF80_a_next();
+        writeHex_uiExtF80M( &genCases_extF80_a, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        uTrueZ.f = trueFunction( &genCases_extF80_a );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break;
+    }
+
+}
+
+#endif
+
 void gen_a_extF80_z_f32( float32_t trueFunction( const extFloat80_t * ) )
 {
     union ui32_f32 uTrueZ;
@@ -2050,6 +2679,28 @@ void
 
 }
 
+#ifdef FLOAT16
+
+void gen_a_f128_z_f16( float16_t trueFunction( const float128_t * ) )
+{
+    union ui16_f16 uTrueZ;
+    uint_fast8_t trueFlags;
+
+    genCases_f128_a_init();
+    checkEnoughCases();
+    while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) {
+        genCases_f128_a_next();
+        writeHex_uiF128M( &genCases_f128_a, ' ' );
+        *genLoops_trueFlagsPtr = 0;
+        uTrueZ.f = trueFunction( &genCases_f128_a );
+        trueFlags = *genLoops_trueFlagsPtr;
+        if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break;
+    }
+
+}
+
+#endif
+
 void gen_a_f128_z_f32( float32_t trueFunction( const float128_t * ) )
 {
     union ui32_f32 uTrueZ;