C++ 这个constexpr sqrt函数可移植吗？

我编写了这个sqrt的实现，它的复杂性是有限的，当double是ieee754 double时，它的精度可以精确到最后一位。问题是，这是否可以在各种endian的设备上移植（假设0LL仍然是64位）？get_分数返回52位加上开头的1位。小的双精度放大器单独处理，并确保它们在第53位也有1个。C++部分<代码>数值限制> /代码>可以很容易地用常数代替。 代码：

静态内联constexpr int16获取指数（双x）
{
uint64_t位=*（uint64_t*）和x；
int16_t val=（（位&0x7FF0000000000000ULL）>>52）-1023；
如果（val！=-1023）
返回val；
uint64_t temp_fractal=（位&0x000fffffffffull）；
对于（int i=51；i>=0；--i）{
如果（！（温度和（0x01ULL 1023）{
返回（1-2*符号）*标准：：数值限制：：无穷大（）；
}
{
数据|=（（uint64_t）（（uint16_t）（指数+1023））x）半指数-=1；
//为了安全起见
测试=使双（0，半指数，测试分数）；
如果（测试*测试>x）半指数-=1；
//查找除最后一位之外的每一位，二进制搜索结果
对于（int i=51；i>0；--i）{
测试=使双（0，半指数，测试分数）（0x01ULL=1；
半指数-=1；
}
double temp2=使双（0，半指数，测试分数）；
双del3=我的腹肌（x-temp2*temp2）；
如果（del3“…这是可移植的…”：像
uint64\u t bits=*（uint64\u t*）&x；
（其中
x
is
double
）这样的代码是未定义的行为。@RichardCriten即使double是ieee754 double，要求为64位？本节适用，因为在这种情况下，C样式转换相当于
重新解释\u cast
每当试图通过AliasedType类型的glvalue读取或修改DynamicType类型的对象的存储值时，除非以下情况之一为真：“并且本例中的代码不属于允许的表达式之一。请使用
std:：bit_cast
避免UB。”（并与constexpr兼容）。“…这是可移植的吗…”：类似于
uint64\u t bits=*（uint64\u t*）的代码&x；
（其中
x
是
double
）是未定义的行为。@RichardCriten，即使double是ieee754 double，要求为64位？本节适用，因为在这种情况下，C样式转换相当于重新解释转换每当试图通过AliasedType类型的glvalue读取或修改DynamicType类型的对象的存储值时，该行为是未定义的，除非以下情况之一为真：“并且本例中的代码不属于允许的表达式之一。使用
std:：bit_cast
避免UB（并与constepr兼容）.
static inline constexpr int16_t get_exponent(double x)
{
    uint64_t bits = *(uint64_t*)&x;
    int16_t val = ((bits & 0x7FF0000000000000ULL) >> 52) - 1023;
    if(val != -1023)
        return val;
    uint64_t temp_fractal= (bits & 0x000FFFFFFFFFFFFFULL);
    for (int i = 51; i >= 0;--i) {
        if(!(temp_fractal & (0x01ULL<<i))) --val;
        else break;
    }
    return val;
}

static inline constexpr uint64_t get_fraction(double x)
{
    uint64_t bits = *(uint64_t*)&x;
    if (bits & 0x7FF0000000000000ULL)
        return (bits & 0x000FFFFFFFFFFFFFULL) | 0x0010000000000000ULL;
    uint64_t temp_fraction = bits & 0x000FFFFFFFFFFFFFULL;
    for (int i = 51; i >= 0; --i) {
        temp_fraction<<=1;
        if(0x0010000000000000ULL & temp_fraction) break;
    }
    return temp_fraction;
}

static inline constexpr bool is_reserved(double x)
{
    return get_exponent(x) == 1024;
}

static inline constexpr double my_abs(double x)
{
    uint64_t bits = *(uint64_t*)&x;
    bits &= 0x7FFFFFFFFFFFFFFFULL;
    return *(double*)&bits;
}

constexpr double make_double(bool sign, int16_t exponent, uint64_t fractal)
{
    uint64_t data = (fractal & 0x000FFFFFFFFFFFFFULL);
    assert((fractal & 0xFFF0000000000000ULL) == 0x0010000000000000ULL);
    if (exponent < -1023) {
        fractal >>= (-1022 - exponent);
        data = fractal;
        exponent = -1023;   
    }
    else if (exponent > 1023) {
        return (1-2*sign)*std::numeric_limits<double>::infinity();
    }
    {
        data |= ((uint64_t)((uint16_t)(exponent + 1023))) << 52;
        if (sign)
            data |= 0x8000000000000000ULL;
        return *(double*)&data;
    }

}

constexpr double my_sqrt(double x)
{
    if(!x || is_reserved(x))
        return x;
    if(x < 0)
        return -std::numeric_limits<double>::quiet_NaN();
    uint64_t fraction = get_fraction(x);
    int16_t exponent = get_exponent(x);
    //C standard says it rounds to zero
    int16_t half_exponent = ((exponent-1024)/2)+512;
    uint64_t test_fraction = 0x0010000000000000ULL;
    double test = make_double(0, half_exponent, test_fraction);
    if (test * test > x) half_exponent -= 1;
    //just to be safe
    test = make_double(0, half_exponent, test_fraction);
    if (test * test > x) half_exponent -= 1;
    //find each bit except last one, binary search for result
    for (int i = 51; i > 0; --i) {
        test = make_double(0, half_exponent, test_fraction | (0x01ULL<<i));
        if(test*test<x) test_fraction |= (0x01ULL << i);
    }
    double del1 = my_abs(x - test*test);
    double temp = make_double(0, half_exponent, test_fraction | 0x01ULL);
    double del2 = my_abs(x - temp * temp);
    //see if the whole fraction needs to round up by one
    if (x > temp * temp) {
        test_fraction += 2;
        //rounding up by one made the fraction too large
        if (test_fraction >= 0x0020000000000000ULL) {
            test_fraction >>= 1;
            half_exponent -= 1;
        }
        double temp2 = make_double(0, half_exponent, test_fraction);
        double del3 = my_abs(x - temp2 * temp2);
        if(del3 <del2) return temp2;
        else return temp;
    }
    else if(del2<del1) return temp;
    else return make_double(0, half_exponent, test_fraction);
}