math16f.h

FreeRTOS 是一个源码公开的免费的嵌入式实时操作系统

        arg1f16.7 = 0;
    return arg1f16;
}


float16 operator+ _fadd16( sharedM float16 arg1f16, sharedM float16 arg2f16)
{
    char xtra, temp;
    char expo = arg1f16.high8 - arg2f16.high8;
    if (!Carry)  {
        expo = -expo;
        temp = arg1f16.high8;
        arg1f16.high8 = arg2f16.high8;
        arg2f16.high8 = temp;
        temp = arg1f16.low8;
        arg1f16.low8 = arg2f16.low8;
        arg2f16.low8 = temp;
    }
    if (expo > sizeof(arg1f16)*8-7)
        goto RETURN;
    if (!arg2f16.high8)
        goto RETURN;   // result is arg1f16

    xtra = 0;

    W = arg1f16.low8;
    temp = W;
    char sign = arg2f16.low8 ^ W;
    arg1f16.7 = 1;
    arg2f16.7 = 1;

    while (1)  {
        W = 8;
        expo -= W;
        if (!Carry)
            break;
        xtra = arg2f16.low8;
        arg2f16.low8 = 0;
    }
    expo += W;
    if (expo)  {
        do  {
            Carry = 0;
            arg2f16.low8 = rr( arg2f16.low8);
            xtra = rr( xtra);
        } while (--expo > 0);
    }


    if (sign & 0x80)  {
        // SUBTRACT
        arg1f16.low8 -= arg2f16.low8;
        if (!Carry)  {  // arg2f16 > arg1f16
            arg1f16.low8 = -arg1f16.low8;
            // xtra == 0 because arg1f16.exp == arg2f16.exp
            temp ^= 0x80;  // invert sign
        }
        xtra = -xtra;
        if (xtra)
            arg1f16.low8 --;
        // adjust result left
        if (!arg1f16.low8)  {
            arg1f16.low8 = xtra;
            if (xtra == 0)
                goto RES0;
            xtra = 0;
            arg1f16.high8 -= 8;
            if (!Carry)
                goto RES0;
        }
        while (!arg1f16.7)  {
            Carry = 0;
            xtra = rl( xtra);
            arg1f16.low8 = rl( arg1f16.low8);
            arg1f16.high8 --;
            if (!arg1f16.high8)
                goto RES0;   // UNDERFLOW?
        }
       #ifndef DISABLE_ROUNDING
        if (FpRounding  &&  (xtra & 0x80))  {
            xtra = 0; // disable recursion
            goto INCREMENT;
        }
       #endif
    }
    else  {
        // ADD arg1f16 and arg2f16
        arg1f16.low8 += arg2f16.low8;
        if (Carry)  {
          ADJUST_RIGHT:
            arg1f16.low8 = rr( arg1f16.low8);
            xtra = rr( xtra);
            arg1f16.high8 += 1;  // exp
            if (!arg1f16.high8)
                goto OVERFLOW;
        }
       #ifndef DISABLE_ROUNDING
        if (FpRounding  &&  (xtra & 0x80))  {
          INCREMENT:
            arg1f16.low8 += 1;
            if (!arg1f16.low8)  {
                Carry = 1; // prepare for shift
                arg1f16.0 = 0;  // disable recursion
                goto ADJUST_RIGHT;
            }
        }
       #endif
    }
    goto SET_SIGN;

//  UNDERFLOW:
//    FpUnderFlow = 1;
  RES0:
    arg1f16.high8 = 0;
    goto MANTISSA;

  OVERFLOW:
    FpOverflow = 1;
    arg1f16.high8 = 0xFF;
  MANTISSA:
    arg1f16.low8 = 0x80;

  SET_SIGN:
    if (!(temp & 0x80))
        arg1f16.7 = 0;

  RETURN:
    return arg1f16;
}


// SUBTRACTION

float16 operator- _fsub16( sharedM float16 arg1f16, sharedM float16 arg2f16)
{
    arg2f16.low8 ^= 0x80;
    arg1f16 += arg2f16;
    return arg1f16;
}


float16 operator=( int8 arg) @
float16 operator=( uns8 arg) @
float16 operator=( int16 arg) @
float16 operator=( uns16 arg) @
float16 operator=( int24 arg) @
float16 operator=( uns24 arg) @
float16 operator= _int32ToFloat16( int32 arg32)
{
    char expo = FpBIAS + 8 - 1;
    char xtra @ arg32.high8;
    char sign = 0;
    if (arg32 < 0)  {
        arg32 = -arg32;
        sign |= 0x80;
    }
    if (arg32.high8)  {
        expo += 8;
        arg32.low8 = arg32.midL8;
        arg32.midL8 = arg32.midH8;
        arg32.midH8 = arg32.high8;
        arg32.high8 = 0;
    }
    if (arg32.midH8)  {
        expo += 8;
        xtra = arg32.low8;
        arg32.low8 = arg32.midL8;
        arg32.midL8 = arg32.midH8;
    }
    if (arg32.midL8)  {
        expo += 8;
        xtra = arg32.low8;
        arg32.low8 = arg32.midL8;
    }
    if (!arg32.low8)
        goto RETURN;

    // arg32.low8 != 0
    goto TEST_ARG_B7;
    do  {
        xtra = rl( xtra);
        arg32.low8 = rl( arg32.low8);
        expo --;
      TEST_ARG_B7:
    } while (!arg32.7);

   #ifndef DISABLE_ROUNDING
    if (FpRounding && (xtra & 0x80))  {
        arg32.low8 += 1;
        if (!arg32.low8)  {
            arg32.low8 |= 0x80;
            expo ++;
        }
    }
   #endif

    arg32.midL8 = expo;
    if (!(sign & 0x80))
        arg32.7 = 0;

  RETURN:
    float16 rval @ arg32;
    rval.low16 = arg32.low16;
    return rval;
}


uns8 operator=( sharedM float16 arg1f16) @
int8 operator=( sharedM float16 arg1f16) @
int16 operator= _float16ToInt16( sharedM float16 arg1f16)
{
    sharedM float16 arg2f16;   // unused, but required
    char sign = arg1f16.low8;
    char expo = arg1f16.high8 - (FpBIAS-1);
    if (!Carry)
        goto RES0;
    arg1f16.7 = 1;

    arg1f16.high8 = 0;
   #ifndef DISABLE_ROUNDING
    char xtra = 0;
   #endif

    // (a): expo = 0..8 : shift 0 byte
    // (b): expo = 9..16: shift 1 byte to the left
   #if __CoreSet__ / 100 == 12
    expo -= 9;
    expo = 0xFF - expo;  // COMF (Carry unchanged)
    if (Carry)  {  // (b)
   #else
    expo = 8 - expo;
    if (!Carry)  {  // (b)
   #endif
        expo += 8;
        if (!Carry)
            goto OVERFLOW;
        arg1f16.high8 = arg1f16.low8;
        arg1f16.low8 = 0;
    }
    if (expo)  {
        do  {
            Carry = 0;
            arg1f16.high8 = rr( arg1f16.high8);
            arg1f16.low8 = rr( arg1f16.low8);
           #ifndef DISABLE_ROUNDING
            xtra = rr( xtra);
           #endif
        } while (--expo);
    }
    if (arg1f16.15)  {
       OVERFLOW:
        FpOverflow = 1;
        W = 0xFF;
        goto ASSIGNW;
       RES0:
        W = 0;
       ASSIGNW:
        arg1f16.low8 = W;
        arg1f16.high8 = W;
        arg1f16.15 = 0;
    }
    else  {
       #ifndef DISABLE_ROUNDING
        if (FpRounding && (xtra & 0x80))
            arg1f16.low8 += 1;
       #endif
        if (sign & 0x80)
            arg1f16.low16 = -arg1f16.low16;
    }
    int16 rval @ arg1f16;
    rval = arg1f16.low16;
    return rval;
}


bit operator< _f16_LT_f16( sharedM float16 arg1f16, sharedM float16 arg2f16)
{
    Carry = 0;
    if (!(arg1f16.high8 | arg2f16.high8))
        return Carry;
    if (!arg1f16.7)  {
        if (arg2f16.7)
            return Carry;
        W = arg1f16.low8 - arg2f16.low8;
        genSubW( arg1f16.high8, arg2f16.high8);
        goto RETURN;
    }
    if (!arg2f16.7)
        goto RETURN;
    W = arg2f16.low8 - arg1f16.low8;
    genSubW( arg2f16.high8, arg1f16.high8);
  RETURN:
    if (Carry)
        return 0;
    return 1;
}


bit operator>= _f16_GE_f16( sharedM float16 arg1f16, sharedM float16 arg2f16)
{
    Carry = 1;
    if (!(arg1f16.high8 | arg2f16.high8))
        return Carry;
    if (!arg1f16.7)  {
        if (arg2f16.7)
            return Carry;
        W = arg1f16.low8 - arg2f16.low8;
        genSubW( arg1f16.high8, arg2f16.high8);
        return Carry;
    }
    Carry = 0;
    if (!arg2f16.7)
        return Carry;
    W = arg2f16.low8 - arg1f16.low8;
    genSubW( arg2f16.high8, arg1f16.high8);
    return Carry;
}



bit operator> _f16_GT_f16( sharedM float16 arg1f16, sharedM float16 arg2f16)
{
    Carry = 0;
    if (!(arg1f16.high8 | arg2f16.high8))
        return Carry;
    if (!arg1f16.7)  {
        if (arg2f16.7)
            goto RETURN;
        W = arg2f16.low8 - arg1f16.low8;
        genSubW( arg2f16.high8, arg1f16.high8);
        goto RETURN;
    }
    if (!arg2f16.7)
        return Carry;
    W = arg1f16.low8 - arg2f16.low8;
    genSubW( arg1f16.high8, arg2f16.high8);
  RETURN:
    if (Carry)
        return 0;
    return 1;
}



bit operator<= _f16_LE_f16( sharedM float16 arg1f16, sharedM float16 arg2f16)
{
    Carry = 1;
    if (!(arg1f16.high8 | arg2f16.high8))
        return Carry;
    if (!arg1f16.7)  {
        Carry = 0;
        if (arg2f16.7)
            return Carry;
        W = arg2f16.low8 - arg1f16.low8;
        genSubW( arg2f16.high8, arg1f16.high8);
        return Carry;
    }
    if (!arg2f16.7)
        return Carry;
    W = arg1f16.low8 - arg2f16.low8;
    genSubW( arg1f16.high8, arg2f16.high8);
    return Carry;
}




#undef genAdd
#undef genSub
#undef genAddW
#undef genSubW

#pragma library 0