Để giải trí và tìm hiểu thêm về cách hoạt động của các phao, tôi đã thử tạo một hàm lấy hai phao có độ chính xác đơn và cộng chúng lại.

Những gì tôi đã làm cho đến nay rất hiệu quả đối với các số có cùng dấu, nhưng nó sẽ không hiệu quả khi các số có dấu ngược nhau. Tôi đã xem nhiều câu hỏi và trang web ( UAF , Làm cách nào để thêm dấu phẩy động 8 bit với các dấu hiệu khác nhau , ICL , Thêm số dấu phẩy động 32 bit. , Làm thế nào để cộng và trừ các số chính xác một nửa dấu phẩy động 16 bit? , Làm thế nào để trừ số IEEE 754? ), nhưng hầu hết những người đề xuất phép trừ đều mô tả nó là "về cơ bản giống nhau, nhưng trừ", điều mà tôi không thấy hữu ích lắm. UAF 确实giải thích

Giá trị phủ định được xử lý bằng cách trước tiên chuyển đổi thành phần bù 2 và sau đó thực hiện phép cộng. Sau khi phép cộng được thực hiện, kết quả được chuyển đổi trở lại dạng cường độ dấu.

Nhưng tôi dường như không thể tìm ra cách để làm điều đó. tôi đã tìm thấy nó cái nàyVà cái nàyNó giải thích độ lớn có dấu là gì và cách chuyển đổi giữa nó và phần bù hai, vì vậy tôi đã thử chuyển đổi như thế này:

manz = manx + ( ( (nhiều | 0x01000000) ^ 0x007FFFFF) + 1);

Như thế này:

manz = manx + ( ( (nhiều | 0x01000000) ^ 0x007FFFFF) + 1);
manz = ( ((manz - 1) ^ 0x007FFFFFF) & 0xFEFFFFFF);

Nhưng không có cái nào trong số này hoạt động.

Khi thử các phương pháp trừ được mô tả bởi các nguồn khác, tôi đã thử đảo ngược phần định trị của một số âm theo nhiều cách khác nhau:

manz = manx - nhiều;
manz = manx + (nhiều - (1<<23));
manz = manx + (nhiều - (1<<24));
manz = manx + ( (nhiều - (1<<23)) & 0x007FFFFF );
manz = manx + ( (nhiều - (1<<23)) + 1);
manz = manx + ( (~nhiều & 0x007FFFFF) + 1);
manz = manx + (~nhiều + 1);
manz = manx + ( (nhiều ^ 0x007FFFFF) + 1);
manz = manx + ( (nhiều ^ 0x00FFFFFF) + 1);
manz = manx + ( (nhiều ^ 0x003FFFFF) + 1);

Đây là câu lệnh sẽ xử lý phép cộng theo dấu, sau khi căn chỉnh mantissa:

expz = expy;
if(signx != signy) { // dấu opp
  if(manx < nhiều) {
    ký hiệu = ký hiệu;
    manz = nhiều + ((manx ^ 0x007FFFFF) + 1);
  } else if(manx > many) {
    signz = signx;
    manz = manx - ((nhiều ^ 0x007FFFFF) + 1);
  } khác { // x == y
    ký hiệu = 0x00000000;
    expz = 0x00000000;
    manz = 0x00000000;
  }
} khác {
  signz = signx;
  manz = manx + nhiều;
}

Đây là đoạn mã tiếp theo, giúp chuẩn hóa các số trong trường hợp tràn, nó hoạt động khi chúng có cùng dấu, nhưng tôi không chắc nó có ý nghĩa như thế nào khi trừ:

if(manz & 0x01000000) {
  expz++;
  manz = (manz >> 1) + (manz & 0x1);
}
manz &= 0x007FFFFF;

Sử dụng giá trị thử nghiệm -3.34632F Và 34.8532413F, tôi đã nhận được câu trả lời 0x427E0716 (63.506920) khi nào thì nên 0x41FC0E2D (31.506922) và giá trị kiểm tra 3.34632F Và -34.8532413F Khi tôi nhận được câu trả lời 0xC27E0716 (-63.506920) và nó phải là 0xC1FC0E2D (-31.506922).

Tôi đã có thể giải quyết vấn đề của mình bằng cách thay đổi cách chuẩn hóa số float khi trừ.

expz = expy;
if(signx != signy) { // dấu opp
  if(manx < nhiều) {
    ký hiệu = ký hiệu;
    manz = nhiều - manx;
  } else if(manx > many) {
    signz = signx;
    manz = manx - nhiều;
  } khác { // x == y
    ký hiệu = 0x00000000;
    expz = 0x00000000;
    manz = 0x00000000;
  }
  //Bình thường hóa phép trừ
  while((manz & 0x00800000) == 0 && manz) {
      manz <<= 1;
      expz--;
  }
} khác {
  signz = signx;
  manz = manx + nhiều;
  //Bình thường hóa phép cộng
  if(manz & 0x01000000) {
    expz++;
    manz = (manz >> 1) + ( (x & 0x2) ? (x & 0x1) : 0 );
  }
}
manz &= 0x007FFFFF;

câu trả lời hay nhất

Làm thế nào để cộng hai số dấu phẩy động trái dấu?

Hầu hết thời gian bạn sẽ không.

Đối với tất cả công việc với các kiểu số không thể dựa vào "tràn phần bù hai" (ví dụ: float, thư viện số học lớn...), bạn luôn kết thúc như thế này:

add_signed(v1, v2) {
    nếu(v1 < 0) {
        nếu(v2 < 0) {
            // Cả hai đều âm
            return -add_unsigned(-v1, -v2);
        } khác {
            // Dấu khác, v1 âm
            trả về trừ_unsigned(v2, -v1);
        }
    } khác {
        nếu(v2 < 0) {
            // Dấu khác, v2 âm
            trả về trừ_unsigned(v1, -v2);
        } khác {
            // Cả hai đều dương
            trả về add_unsigned(v1, v2);
        }
    }
 }

trừ_signed(v1, v2) {
    trả về add_signed(v1, -v2);
}

add_unsigned(v1, v2) {
    // Ở đây chúng ta biết rằng v1 và v2 sẽ không bao giờ âm, và
    // chúng ta biết rằng kết quả sẽ không bao giờ âm
    ...
}

trừ_unsigned(v1, v2) {
    nếu(v1 < v2) {
        trả về -subtract_unsigned(v2, v1);
    }
    // Ở đây chúng ta biết rằng v1 và v2 sẽ không bao giờ âm, và
    // chúng ta biết rằng kết quả sẽ không bao giờ âm
    ...
}

Nói cách khác; tất cả các phép cộng thực và tất cả các phép trừ thực đều xảy ra trên các số không dấu ("không bao giờ âm").

Chỉ cần thêm một ví dụ đầy đủ hơn về mô phỏng dấu phẩy động 32 bit (trong C, chưa được kiểm tra và có thể có lỗi, có thể hoạt động hoặc không hoạt động với các bất chuẩn, không hỗ trợ "NaN/s" hoặc vô số, Không hỗ trợ tràn hoặc tràn, không "mantissa dịch trái để giảm mất độ chính xác trước khi làm tròn" và không hỗ trợ các chế độ làm tròn khác với "làm tròn về 0"):

#define SIGN_FLAG 0x80000000U
#define EXPONENT_MASK 0x7F800000U
#define MANTISSA_MASK 0x007FFFFFU
#define IMPLIED_BIT 0x00800000U
#xác định OVERFLOW_BIT 0x01000000U
#define EXPONENT_ONE 0x00800000U

uint32_t add_signed(uint32_t v1, uint32_t v2) {
    if( (v1 & SIGN_FLAG) != 0) {
        if( (v2 & SIGN_FLAG) != 0) {
            // Cả hai đều âm
            trả về SIGN_FLAG | add_unsigned(v1 & ~SIGN_FLAG, v2 & ~SIGN_FLAG);
        } khác {
            // Dấu khác, v1 âm
            trả về trừ_unsigned(v2, v1 & ~SIGN_FLAG);
        }
    } khác {
        if( (v2 & SIGN_FLAG) != 0) {
            // Dấu khác, v2 âm
            trả về trừ_unsigned(v1, v2 & ~SIGN_FLAG);
        } khác {
            // Cả hai đều dương
            trả về add_unsigned(v1, v2);
        }
    }
 }

uint32_ttrừ_signed(uint32_t v1, uint32_t v2) {
    trả về add_signed(v1, v2 ^ SIGN_FLAG);
}

uint32_t add_unsigned(uint32_t v1, uint32_t v2) {
    // Ở đây chúng ta biết rằng v1 và v2 sẽ không bao giờ âm, và
    // chúng ta biết rằng kết quả sẽ không bao giờ âm

    if(v1 < v2) { // CẢNH BÁO: So sánh cả số mũ và số mũ
        trả về add_unsigned(v2, v1);
    }

    // Ở đây ta biết số mũ của v1 không nhỏ hơn số mũ của v2

    uint32_t m1 = (v1 & MANTISSA_MASK) |
    uint32_t m2 = (v2 & MANTISSA_MASK) |
    uint32_t exp2 = v2 & EXPONENT_MASK;
    uint32_t expr = v1 & EXPONENT_MASK;

    while(exp2 < expr) {
        m2 >>= 1;
        exp2 += EXPONENT_ONE;
    }
    uint32_t mr = m1+m2;
    if( (mr & OVERFLOW_BIT) != 0) {
        ông >> 1;
        expr += EXPONENT_ONE;
    }
    trả về expr | (mr & ~IMPLIED_BIT);
}

uint32_ttrừ_unsigned(uint32_t v1, uint32_t v2) {
    nếu(v1 == v2) {
        return 0;
    }
    nếu(v1 < v2) {
        trả về SIGN_FLAG ^trừ_unsigned(v2, v1);
    }

    // Ở đây chúng ta biết số mũ của v1 không nhỏ hơn số mũ của v2,
    // và (nếu số mũ bằng nhau) phần định trị của v1 lớn hơn
    // so với phần định trị của v2 và do đó kết quả sẽ là
    // tích cực

    uint32_t m1 = (v1 & MANTISSA_MASK) |
    uint32_t m2 = (v2 & MANTISSA_MASK) |
    uint32_t exp2 = v2 & EXPONENT_MASK;
    uint32_t expr = v1 & EXPONENT_MASK;

    while(exp2 < expr) {
        m2 >>= 1;
        exp2 += EXPONENT_ONE;
    }
    uint32_t mr = m1-m2;
    while( (mr & IMPLIED_BIT) == 0) {
        ông <<= 1;
        expr -= EXPONENT_ONE;
    }
    trả về expr | (mr & ~IMPLIED_BIT);
}

Về c - làm thế nào để thêm hai số float có dấu hiệu trái ngược nhau? , chúng tôi đã tìm thấy một câu hỏi tương tự trên Stack Overflow: https://stackoverflow.com/questions/58384951/