forked from Github_Repos/cvw
665 lines
19 KiB
C
665 lines
19 KiB
C
|
|
/*============================================================================
|
|
|
|
This C source file is part of TestFloat, Release 3e, 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.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright notice,
|
|
this list of conditions, and the following disclaimer.
|
|
|
|
2. Redistributions in binary form must reproduce the above copyright notice,
|
|
this list of conditions, and the following disclaimer in the documentation
|
|
and/or other materials provided with the distribution.
|
|
|
|
3. Neither the name of the University nor the names of its contributors may
|
|
be used to endorse or promote products derived from this software without
|
|
specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
|
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
|
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
|
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
=============================================================================*/
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include "platform.h"
|
|
#include "random.h"
|
|
#include "softfloat.h"
|
|
#include "genCases.h"
|
|
|
|
struct sequence {
|
|
int expNum, term1Num, term2Num;
|
|
bool done;
|
|
};
|
|
|
|
union ui32_f32 { uint32_t ui; float32_t f; };
|
|
|
|
enum {
|
|
f32NumQIn = 22,
|
|
f32NumQOut = 50,
|
|
f32NumP1 = 4,
|
|
f32NumP2 = 88
|
|
};
|
|
static const uint32_t f32QIn[f32NumQIn] = {
|
|
0x00000000, /* positive, subnormal */
|
|
0x00800000, /* positive, -126 */
|
|
0x33800000, /* positive, -24 */
|
|
0x3E800000, /* positive, -2 */
|
|
0x3F000000, /* positive, -1 */
|
|
0x3F800000, /* positive, 0 */
|
|
0x40000000, /* positive, 1 */
|
|
0x40800000, /* positive, 2 */
|
|
0x4B800000, /* positive, 24 */
|
|
0x7F000000, /* positive, 127 */
|
|
0x7F800000, /* positive, infinity or NaN */
|
|
0x80000000, /* negative, subnormal */
|
|
0x80800000, /* negative, -126 */
|
|
0xB3800000, /* negative, -24 */
|
|
0xBE800000, /* negative, -2 */
|
|
0xBF000000, /* negative, -1 */
|
|
0xBF800000, /* negative, 0 */
|
|
0xC0000000, /* negative, 1 */
|
|
0xC0800000, /* negative, 2 */
|
|
0xCB800000, /* negative, 24 */
|
|
0xFE800000, /* negative, 126 */
|
|
0xFF800000 /* negative, infinity or NaN */
|
|
};
|
|
static const uint32_t f32QOut[f32NumQOut] = {
|
|
0x00000000, /* positive, subnormal */
|
|
0x00800000, /* positive, -126 */
|
|
0x01000000, /* positive, -125 */
|
|
0x33800000, /* positive, -24 */
|
|
0x3D800000, /* positive, -4 */
|
|
0x3E000000, /* positive, -3 */
|
|
0x3E800000, /* positive, -2 */
|
|
0x3F000000, /* positive, -1 */
|
|
0x3F800000, /* positive, 0 */
|
|
0x40000000, /* positive, 1 */
|
|
0x40800000, /* positive, 2 */
|
|
0x41000000, /* positive, 3 */
|
|
0x41800000, /* positive, 4 */
|
|
0x4B800000, /* positive, 24 */
|
|
0x4E000000, /* positive, 29 */
|
|
0x4E800000, /* positive, 30 */
|
|
0x4F000000, /* positive, 31 */
|
|
0x4F800000, /* positive, 32 */
|
|
0x5E000000, /* positive, 61 */
|
|
0x5E800000, /* positive, 62 */
|
|
0x5F000000, /* positive, 63 */
|
|
0x5F800000, /* positive, 64 */
|
|
0x7E800000, /* positive, 126 */
|
|
0x7F000000, /* positive, 127 */
|
|
0x7F800000, /* positive, infinity or NaN */
|
|
0x80000000, /* negative, subnormal */
|
|
0x80800000, /* negative, -126 */
|
|
0x81000000, /* negative, -125 */
|
|
0xB3800000, /* negative, -24 */
|
|
0xBD800000, /* negative, -4 */
|
|
0xBE000000, /* negative, -3 */
|
|
0xBE800000, /* negative, -2 */
|
|
0xBF000000, /* negative, -1 */
|
|
0xBF800000, /* negative, 0 */
|
|
0xC0000000, /* negative, 1 */
|
|
0xC0800000, /* negative, 2 */
|
|
0xC1000000, /* negative, 3 */
|
|
0xC1800000, /* negative, 4 */
|
|
0xCB800000, /* negative, 24 */
|
|
0xCE000000, /* negative, 29 */
|
|
0xCE800000, /* negative, 30 */
|
|
0xCF000000, /* negative, 31 */
|
|
0xCF800000, /* negative, 32 */
|
|
0xDE000000, /* negative, 61 */
|
|
0xDE800000, /* negative, 62 */
|
|
0xDF000000, /* negative, 63 */
|
|
0xDF800000, /* negative, 64 */
|
|
0xFE800000, /* negative, 126 */
|
|
0xFF000000, /* negative, 127 */
|
|
0xFF800000 /* negative, infinity or NaN */
|
|
};
|
|
static const uint32_t f32P1[f32NumP1] = {
|
|
0x00000000,
|
|
0x00000001,
|
|
0x007FFFFF,
|
|
0x007FFFFE
|
|
};
|
|
static const uint32_t f32P2[f32NumP2] = {
|
|
0x00000000,
|
|
0x00000001,
|
|
0x00000002,
|
|
0x00000004,
|
|
0x00000008,
|
|
0x00000010,
|
|
0x00000020,
|
|
0x00000040,
|
|
0x00000080,
|
|
0x00000100,
|
|
0x00000200,
|
|
0x00000400,
|
|
0x00000800,
|
|
0x00001000,
|
|
0x00002000,
|
|
0x00004000,
|
|
0x00008000,
|
|
0x00010000,
|
|
0x00020000,
|
|
0x00040000,
|
|
0x00080000,
|
|
0x00100000,
|
|
0x00200000,
|
|
0x00400000,
|
|
0x00600000,
|
|
0x00700000,
|
|
0x00780000,
|
|
0x007C0000,
|
|
0x007E0000,
|
|
0x007F0000,
|
|
0x007F8000,
|
|
0x007FC000,
|
|
0x007FE000,
|
|
0x007FF000,
|
|
0x007FF800,
|
|
0x007FFC00,
|
|
0x007FFE00,
|
|
0x007FFF00,
|
|
0x007FFF80,
|
|
0x007FFFC0,
|
|
0x007FFFE0,
|
|
0x007FFFF0,
|
|
0x007FFFF8,
|
|
0x007FFFFC,
|
|
0x007FFFFE,
|
|
0x007FFFFF,
|
|
0x007FFFFD,
|
|
0x007FFFFB,
|
|
0x007FFFF7,
|
|
0x007FFFEF,
|
|
0x007FFFDF,
|
|
0x007FFFBF,
|
|
0x007FFF7F,
|
|
0x007FFEFF,
|
|
0x007FFDFF,
|
|
0x007FFBFF,
|
|
0x007FF7FF,
|
|
0x007FEFFF,
|
|
0x007FDFFF,
|
|
0x007FBFFF,
|
|
0x007F7FFF,
|
|
0x007EFFFF,
|
|
0x007DFFFF,
|
|
0x007BFFFF,
|
|
0x0077FFFF,
|
|
0x006FFFFF,
|
|
0x005FFFFF,
|
|
0x003FFFFF,
|
|
0x001FFFFF,
|
|
0x000FFFFF,
|
|
0x0007FFFF,
|
|
0x0003FFFF,
|
|
0x0001FFFF,
|
|
0x0000FFFF,
|
|
0x00007FFF,
|
|
0x00003FFF,
|
|
0x00001FFF,
|
|
0x00000FFF,
|
|
0x000007FF,
|
|
0x000003FF,
|
|
0x000001FF,
|
|
0x000000FF,
|
|
0x0000007F,
|
|
0x0000003F,
|
|
0x0000001F,
|
|
0x0000000F,
|
|
0x00000007,
|
|
0x00000003
|
|
};
|
|
|
|
static const uint_fast64_t f32NumQInP1 = f32NumQIn * f32NumP1;
|
|
static const uint_fast64_t f32NumQOutP1 = f32NumQOut * f32NumP1;
|
|
|
|
static float32_t f32NextQInP1( struct sequence *sequencePtr )
|
|
{
|
|
int expNum, sigNum;
|
|
union ui32_f32 uZ;
|
|
|
|
expNum = sequencePtr->expNum;
|
|
sigNum = sequencePtr->term1Num;
|
|
uZ.ui = f32QIn[expNum] | f32P1[sigNum];
|
|
++sigNum;
|
|
if ( f32NumP1 <= sigNum ) {
|
|
sigNum = 0;
|
|
++expNum;
|
|
if ( f32NumQIn <= expNum ) {
|
|
expNum = 0;
|
|
sequencePtr->done = true;
|
|
}
|
|
sequencePtr->expNum = expNum;
|
|
}
|
|
sequencePtr->term1Num = sigNum;
|
|
return uZ.f;
|
|
|
|
}
|
|
|
|
static float32_t f32NextQOutP1( struct sequence *sequencePtr )
|
|
{
|
|
int expNum, sigNum;
|
|
union ui32_f32 uZ;
|
|
|
|
expNum = sequencePtr->expNum;
|
|
sigNum = sequencePtr->term1Num;
|
|
uZ.ui = f32QOut[expNum] | f32P1[sigNum];
|
|
++sigNum;
|
|
if ( f32NumP1 <= sigNum ) {
|
|
sigNum = 0;
|
|
++expNum;
|
|
if ( f32NumQOut <= expNum ) {
|
|
expNum = 0;
|
|
sequencePtr->done = true;
|
|
}
|
|
sequencePtr->expNum = expNum;
|
|
}
|
|
sequencePtr->term1Num = sigNum;
|
|
return uZ.f;
|
|
|
|
}
|
|
|
|
static const uint_fast64_t f32NumQInP2 = f32NumQIn * f32NumP2;
|
|
static const uint_fast64_t f32NumQOutP2 = f32NumQOut * f32NumP2;
|
|
|
|
static float32_t f32NextQInP2( struct sequence *sequencePtr )
|
|
{
|
|
int expNum, sigNum;
|
|
union ui32_f32 uZ;
|
|
|
|
expNum = sequencePtr->expNum;
|
|
sigNum = sequencePtr->term1Num;
|
|
uZ.ui = f32QIn[expNum] | f32P2[sigNum];
|
|
++sigNum;
|
|
if ( f32NumP2 <= sigNum ) {
|
|
sigNum = 0;
|
|
++expNum;
|
|
if ( f32NumQIn <= expNum ) {
|
|
expNum = 0;
|
|
sequencePtr->done = true;
|
|
}
|
|
sequencePtr->expNum = expNum;
|
|
}
|
|
sequencePtr->term1Num = sigNum;
|
|
return uZ.f;
|
|
|
|
}
|
|
|
|
static float32_t f32NextQOutP2( struct sequence *sequencePtr )
|
|
{
|
|
int expNum, sigNum;
|
|
union ui32_f32 uZ;
|
|
|
|
expNum = sequencePtr->expNum;
|
|
sigNum = sequencePtr->term1Num;
|
|
uZ.ui = f32QOut[expNum] | f32P2[sigNum];
|
|
++sigNum;
|
|
if ( f32NumP2 <= sigNum ) {
|
|
sigNum = 0;
|
|
++expNum;
|
|
if ( f32NumQOut <= expNum ) {
|
|
expNum = 0;
|
|
sequencePtr->done = true;
|
|
}
|
|
sequencePtr->expNum = expNum;
|
|
}
|
|
sequencePtr->term1Num = sigNum;
|
|
return uZ.f;
|
|
|
|
}
|
|
|
|
static float32_t f32RandomQOutP3( void )
|
|
{
|
|
union ui32_f32 uZ;
|
|
|
|
uZ.ui =
|
|
f32QOut[randomN_ui8( f32NumQOut )]
|
|
| ((f32P2[randomN_ui8( f32NumP2 )] + f32P2[randomN_ui8( f32NumP2 )])
|
|
& 0x007FFFFF);
|
|
return uZ.f;
|
|
|
|
}
|
|
|
|
static float32_t f32RandomQOutPInf( void )
|
|
{
|
|
union ui32_f32 uZ;
|
|
|
|
uZ.ui = f32QOut[randomN_ui8( f32NumQOut )] | (random_ui32() & 0x007FFFFF);
|
|
return uZ.f;
|
|
|
|
}
|
|
|
|
enum { f32NumQInfWeightMasks = 7 };
|
|
static const uint32_t f32QInfWeightMasks[f32NumQInfWeightMasks] = {
|
|
0xFF800000,
|
|
0xFF800000,
|
|
0xBF800000,
|
|
0x9F800000,
|
|
0x8F800000,
|
|
0x87800000,
|
|
0x83800000
|
|
};
|
|
static const uint32_t f32QInfWeightOffsets[f32NumQInfWeightMasks] = {
|
|
0x00000000,
|
|
0x00000000,
|
|
0x20000000,
|
|
0x30000000,
|
|
0x38000000,
|
|
0x3C000000,
|
|
0x3E000000
|
|
};
|
|
|
|
static float32_t f32RandomQInfP3( void )
|
|
{
|
|
int weightMaskNum;
|
|
union ui32_f32 uZ;
|
|
|
|
weightMaskNum = randomN_ui8( f32NumQInfWeightMasks );
|
|
uZ.ui =
|
|
(((uint_fast32_t) random_ui16()<<16
|
|
& f32QInfWeightMasks[weightMaskNum])
|
|
+ f32QInfWeightOffsets[weightMaskNum])
|
|
| ((f32P2[randomN_ui8( f32NumP2 )] + f32P2[randomN_ui8( f32NumP2 )])
|
|
& 0x007FFFFF);
|
|
return uZ.f;
|
|
|
|
}
|
|
|
|
static float32_t f32RandomQInfPInf( void )
|
|
{
|
|
int weightMaskNum;
|
|
union ui32_f32 uZ;
|
|
|
|
weightMaskNum = randomN_ui8( f32NumQInfWeightMasks );
|
|
uZ.ui =
|
|
(random_ui32() & (f32QInfWeightMasks[weightMaskNum] | 0x007FFFFF))
|
|
+ f32QInfWeightOffsets[weightMaskNum];
|
|
return uZ.f;
|
|
|
|
}
|
|
|
|
static float32_t f32Random( void )
|
|
{
|
|
|
|
switch ( random_ui8() & 7 ) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
return f32RandomQOutP3();
|
|
case 3:
|
|
return f32RandomQOutPInf();
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
return f32RandomQInfP3();
|
|
case 7:
|
|
return f32RandomQInfPInf();
|
|
}
|
|
|
|
}
|
|
|
|
static struct sequence sequenceA, sequenceB, sequenceC;
|
|
static float32_t currentA, currentB, currentC;
|
|
static int subcase;
|
|
|
|
float32_t genCases_f32_a, genCases_f32_b, genCases_f32_c;
|
|
|
|
void genCases_f32_a_init( void )
|
|
{
|
|
|
|
sequenceA.expNum = 0;
|
|
sequenceA.term1Num = 0;
|
|
sequenceA.term2Num = 0;
|
|
sequenceA.done = false;
|
|
subcase = 0;
|
|
genCases_total =
|
|
(genCases_level == 1) ? 3 * f32NumQOutP1 : 2 * f32NumQOutP2;
|
|
genCases_done = false;
|
|
|
|
}
|
|
|
|
void genCases_f32_a_next( void )
|
|
{
|
|
|
|
if ( genCases_level == 1 ) {
|
|
switch ( subcase ) {
|
|
case 0:
|
|
case 1:
|
|
genCases_f32_a = f32Random();
|
|
break;
|
|
case 2:
|
|
genCases_f32_a = f32NextQOutP1( &sequenceA );
|
|
genCases_done = sequenceA.done;
|
|
subcase = -1;
|
|
break;
|
|
}
|
|
} else {
|
|
switch ( subcase ) {
|
|
case 0:
|
|
genCases_f32_a = f32Random();
|
|
break;
|
|
case 1:
|
|
genCases_f32_a = f32NextQOutP2( &sequenceA );
|
|
genCases_done = sequenceA.done;
|
|
subcase = -1;
|
|
break;
|
|
}
|
|
}
|
|
++subcase;
|
|
|
|
}
|
|
|
|
void genCases_f32_ab_init( void )
|
|
{
|
|
|
|
sequenceA.expNum = 0;
|
|
sequenceA.term1Num = 0;
|
|
sequenceA.term2Num = 0;
|
|
sequenceA.done = false;
|
|
sequenceB.expNum = 0;
|
|
sequenceB.term1Num = 0;
|
|
sequenceB.term2Num = 0;
|
|
sequenceB.done = false;
|
|
subcase = 0;
|
|
if ( genCases_level == 1 ) {
|
|
genCases_total = 6 * f32NumQInP1 * f32NumQInP1;
|
|
currentA = f32NextQInP1( &sequenceA );
|
|
} else {
|
|
genCases_total = 2 * f32NumQInP2 * f32NumQInP2;
|
|
currentA = f32NextQInP2( &sequenceA );
|
|
}
|
|
genCases_done = false;
|
|
|
|
}
|
|
|
|
void genCases_f32_ab_next( void )
|
|
{
|
|
|
|
if ( genCases_level == 1 ) {
|
|
switch ( subcase ) {
|
|
case 0:
|
|
if ( sequenceB.done ) {
|
|
sequenceB.done = false;
|
|
currentA = f32NextQInP1( &sequenceA );
|
|
}
|
|
currentB = f32NextQInP1( &sequenceB );
|
|
case 2:
|
|
case 4:
|
|
genCases_f32_a = f32Random();
|
|
genCases_f32_b = f32Random();
|
|
break;
|
|
case 1:
|
|
genCases_f32_a = currentA;
|
|
genCases_f32_b = f32Random();
|
|
break;
|
|
case 3:
|
|
genCases_f32_a = f32Random();
|
|
genCases_f32_b = currentB;
|
|
break;
|
|
case 5:
|
|
genCases_f32_a = currentA;
|
|
genCases_f32_b = currentB;
|
|
genCases_done = sequenceA.done & sequenceB.done;
|
|
subcase = -1;
|
|
break;
|
|
}
|
|
} else {
|
|
switch ( subcase ) {
|
|
case 0:
|
|
genCases_f32_a = f32Random();
|
|
genCases_f32_b = f32Random();
|
|
break;
|
|
case 1:
|
|
if ( sequenceB.done ) {
|
|
sequenceB.done = false;
|
|
currentA = f32NextQInP2( &sequenceA );
|
|
}
|
|
genCases_f32_a = currentA;
|
|
genCases_f32_b = f32NextQInP2( &sequenceB );
|
|
genCases_done = sequenceA.done & sequenceB.done;
|
|
subcase = -1;
|
|
break;
|
|
}
|
|
}
|
|
++subcase;
|
|
|
|
}
|
|
|
|
void genCases_f32_abc_init( void )
|
|
{
|
|
|
|
sequenceA.expNum = 0;
|
|
sequenceA.term1Num = 0;
|
|
sequenceA.term2Num = 0;
|
|
sequenceA.done = false;
|
|
sequenceB.expNum = 0;
|
|
sequenceB.term1Num = 0;
|
|
sequenceB.term2Num = 0;
|
|
sequenceB.done = false;
|
|
sequenceC.expNum = 0;
|
|
sequenceC.term1Num = 0;
|
|
sequenceC.term2Num = 0;
|
|
sequenceC.done = false;
|
|
subcase = 0;
|
|
if ( genCases_level == 1 ) {
|
|
genCases_total = 9 * f32NumQInP1 * f32NumQInP1 * f32NumQInP1;
|
|
currentA = f32NextQInP1( &sequenceA );
|
|
currentB = f32NextQInP1( &sequenceB );
|
|
} else {
|
|
genCases_total = 2 * f32NumQInP2 * f32NumQInP2 * f32NumQInP2;
|
|
currentA = f32NextQInP2( &sequenceA );
|
|
currentB = f32NextQInP2( &sequenceB );
|
|
}
|
|
genCases_done = false;
|
|
|
|
}
|
|
|
|
void genCases_f32_abc_next( void )
|
|
{
|
|
|
|
if ( genCases_level == 1 ) {
|
|
switch ( subcase ) {
|
|
case 0:
|
|
if ( sequenceC.done ) {
|
|
sequenceC.done = false;
|
|
if ( sequenceB.done ) {
|
|
sequenceB.done = false;
|
|
currentA = f32NextQInP1( &sequenceA );
|
|
}
|
|
currentB = f32NextQInP1( &sequenceB );
|
|
}
|
|
currentC = f32NextQInP1( &sequenceC );
|
|
genCases_f32_a = f32Random();
|
|
genCases_f32_b = f32Random();
|
|
genCases_f32_c = currentC;
|
|
break;
|
|
case 1:
|
|
genCases_f32_a = currentA;
|
|
genCases_f32_b = currentB;
|
|
genCases_f32_c = f32Random();
|
|
break;
|
|
case 2:
|
|
genCases_f32_a = f32Random();
|
|
genCases_f32_b = f32Random();
|
|
genCases_f32_c = f32Random();
|
|
break;
|
|
case 3:
|
|
genCases_f32_a = f32Random();
|
|
genCases_f32_b = currentB;
|
|
genCases_f32_c = currentC;
|
|
break;
|
|
case 4:
|
|
genCases_f32_a = currentA;
|
|
genCases_f32_b = f32Random();
|
|
genCases_f32_c = f32Random();
|
|
break;
|
|
case 5:
|
|
genCases_f32_a = f32Random();
|
|
genCases_f32_b = currentB;
|
|
genCases_f32_c = f32Random();
|
|
break;
|
|
case 6:
|
|
genCases_f32_a = currentA;
|
|
genCases_f32_b = f32Random();
|
|
genCases_f32_c = currentC;
|
|
break;
|
|
case 7:
|
|
genCases_f32_a = f32Random();
|
|
genCases_f32_b = f32Random();
|
|
genCases_f32_c = f32Random();
|
|
break;
|
|
case 8:
|
|
genCases_f32_a = currentA;
|
|
genCases_f32_b = currentB;
|
|
genCases_f32_c = currentC;
|
|
genCases_done = sequenceA.done & sequenceB.done & sequenceC.done;
|
|
subcase = -1;
|
|
break;
|
|
}
|
|
} else {
|
|
switch ( subcase ) {
|
|
case 0:
|
|
genCases_f32_a = f32Random();
|
|
genCases_f32_b = f32Random();
|
|
genCases_f32_c = f32Random();
|
|
break;
|
|
case 1:
|
|
if ( sequenceC.done ) {
|
|
sequenceC.done = false;
|
|
if ( sequenceB.done ) {
|
|
sequenceB.done = false;
|
|
currentA = f32NextQInP2( &sequenceA );
|
|
}
|
|
currentB = f32NextQInP2( &sequenceB );
|
|
}
|
|
genCases_f32_a = currentA;
|
|
genCases_f32_b = currentB;
|
|
genCases_f32_c = f32NextQInP2( &sequenceC );
|
|
genCases_done = sequenceA.done & sequenceB.done & sequenceC.done;
|
|
subcase = -1;
|
|
break;
|
|
}
|
|
}
|
|
++subcase;
|
|
|
|
}
|
|
|