定点数原理

public static FP operator +(FP x,FP y)
{
    var xl = x._value;
    var yl = y._value;
    var sum = xl + yl;
    //通过符号位判断溢出
    if (((~(xl ^ yl) & (xl ^ sum)) & Min_Value) != 0)
    {
        sum = xl > 0 ? Max_Value : Min_Value;
    }
    FP result;
    result._value = sum;
    return result;
}

public static FP operator -(FP x, FP y)
{
    var xl = x._value;
    var yl = y._value;
    var diff = xl - yl;
    //通过符号位判断溢出
    if ((((xl ^ yl) & (xl ^ diff)) & Min_Value) != 0)
    {
        diff = xl > 0 ? Max_Value : Min_Value;
    }
    FP result;
    result._value = diff;
    return result;
}

public static FP operator *(FP x, FP y)
{
    var xl = x._value;
    var yl = y._value;

    bool opSignsEqual = ((xl ^ yl) & Min_Value) == 0;

    if (xl < 0)
    {
        xl = -xl;
    }
    if(yl < 0)
    {
        yl = -yl;
    }

    var xlo = (xl & 0x00000000FFFFFFFF);
    var xhi = xl >> FRACTIONAL_PLACES;
    var ylo = (yl & 0x00000000FFFFFFFF);
    var yhi = yl >> FRACTIONAL_PLACES;

    //分解计算过程
    var lolo = xlo * ylo;
    var lohi = xlo * yhi;
    var hilo = xhi * ylo;
    var hihi = xhi * yhi;

    //修正位数
    var loResult = lolo >> FRACTIONAL_PLACES;
    var midResult1 = hilo;
    var midResult2 = lohi;
    var hiResult = hihi << FRACTIONAL_PLACES;

    bool overflow = false;
    var sum = AddOverflowHelper(loResult, midResult1, ref overflow);
    sum = AddOverflowHelper(sum, midResult2, ref overflow);
    sum = AddOverflowHelper(sum, hiResult, ref overflow);

    if(overflow)
    {
        sum = Max_Value;
    }
    if (!opSignsEqual)
    {
        sum = -sum;
    }

    FP result;
    result._value = sum;
    return result;
}

/// <summary>
/// 只在同号情况下有用，计算是否溢出
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="overflow"></param>
/// <returns></returns>
static long AddOverflowHelper(long x, long y, ref bool overflow)
{
    var sum = x + y;
    // x + y overflows if sign(x) ^ sign(y) != sign(sum)
    overflow |= ((x ^ y ^ sum) & Min_Value) != 0;
    return sum;
}

public static FP operator /(FP x, FP y)
{
    var xl = x._value;
    var yl = y._value;

    if (yl == 0)
    {
        return Max_Value;
        //throw new DivideByZeroException();
    }

    var remainder = (ulong)(xl >= 0 ? xl : -xl);
    var divider = (ulong)(yl >= 0 ? yl : -yl);
    var quotient = 0UL;
    var bitPos = Num_Bit / 2 + 1;

    //加速除法，减少小数部分多余的0数量
    // If the divider is divisible by 2^n, take advantage of it.
    while ((divider & 0xF) == 0 && bitPos >= 4)
    {
        divider >>= 4;
        bitPos -= 4;
    }
    //除法计算
    while (remainder != 0 && bitPos >= 0)
    {
        //计算被除数前导零数量
        int shift = CountLeadingZeroes(remainder);
        if (shift > bitPos)
        {
            shift = bitPos;
        }
        //移动被除数到允许的最高位
        remainder <<= shift;
        bitPos -= shift;
        //求商和余数
        var div = remainder / divider;
        remainder = remainder % divider;
        //把商加到总商中
        quotient += div << bitPos;

        // Detect overflow
        //0xFFFFFFFFFFFFFFFF >> bitPos得到64-bitPos个1
        //取反得到11100....（64-bitPos个0）
        //如果结果不为0，说明超出最大位数，溢出
        if ((div & ~(0xFFFFFFFFFFFFFFFF >> bitPos)) != 0)
        {
            return ((xl ^ yl) & Min_Value) == 0 ? MaxValue : MinValue;
        }
        //前进一位
        remainder <<= 1;
        --bitPos;
    }

    // rounding
    ++quotient;
    var result = (long)(quotient >> 1);
    if (((xl ^ yl) & Min_Value) != 0)
    {
        result = -result;
    }

    FP r;
    r._value = result;
    return r;
    //return new FP(result);
}

/// <summary>
/// 求前导0个数
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
public static int CountLeadingZeroes(ulong x)
{
    int result = 0;
    //如果最高四位（二进制）都为0，则左移四位，加速计算
    while ((x & 0xF000000000000000) == 0) { result += 4; x <<= 4; }
    //如果最高一位（二进制）为0，则左移一位
    while ((x & 0x8000000000000000) == 0) { result += 1; x <<= 1; }
    return result;
}

public static FP operator %(FP x, FP y)
{
    FP result;
    // 判断是否为特殊情况：被除数是最小负数且除数是-1
    // 这种情况下整数溢出会导致结果为0
    result._value = x._value == Min_Value & y._value == -1 ?
        0 :
        x._value % y._value;
    return result;
}

public static FP operator -(FP x)
{
    //负数比正数多表示一位，因此正数可以直接转为负数，而最小负数不能直接转为正数，而是转为最大正值
    return x._value == Min_Value ? MaxValue : new FP(-x._value);
}

public static bool operator ==(FP x, FP y)
{
    return x._value == y._value;
}

public static bool operator !=(FP x, FP y)
{
    return x._value != y._value;
}

public static bool operator >(FP x, FP y)
{
    return x._value > y._value;
}

public static bool operator <(FP x, FP y)
{
    return x._value < y._value;
}

public static bool operator >=(FP x, FP y)
{
    return x._value >= y._value;
}

public static bool operator <=(FP x, FP y)
{
    return x._value <= y._value;
}