Add BigInt::signum

Author: randombit

src/fuzzer/bn_cmp.cpp

@@ -54,17 +54,17 @@ void fuzz(const std::span<const uint8_t> in) {
 
    if(is_lt) {
       FUZZER_ASSERT_TRUE(!is_gt);
-      FUZZER_ASSERT_TRUE(d1.is_nonzero());
-      FUZZER_ASSERT_TRUE(d2.is_nonzero());
-      FUZZER_ASSERT_TRUE(d1.is_negative());
-      FUZZER_ASSERT_TRUE(d2.is_positive());
+      FUZZER_ASSERT_TRUE(d1.signum() != 0);
+      FUZZER_ASSERT_TRUE(d2.signum() != 0);
+      FUZZER_ASSERT_TRUE(d1.signum() < 0);
+      FUZZER_ASSERT_TRUE(d2.signum() > 0);
    }
 
    if(is_gt) {
       FUZZER_ASSERT_TRUE(!is_lt);
-      FUZZER_ASSERT_TRUE(d1.is_nonzero());
-      FUZZER_ASSERT_TRUE(d2.is_nonzero());
-      FUZZER_ASSERT_TRUE(d1.is_positive());
-      FUZZER_ASSERT_TRUE(d2.is_negative());
+      FUZZER_ASSERT_TRUE(d1.signum() != 0);
+      FUZZER_ASSERT_TRUE(d2.signum() != 0);
+      FUZZER_ASSERT_TRUE(d1.signum() > 0);
+      FUZZER_ASSERT_TRUE(d2.signum() < 0);
    }
 }

src/fuzzer/invert.cpp

@@ -23,7 +23,7 @@ Botan::BigInt ref_inverse_mod(const Botan::BigInt& n, const Botan::BigInt& mod)
    Botan::BigInt C = 0;
    Botan::BigInt D = 1;
 
-   while(u.is_nonzero()) {
+   while(!u.is_zero()) {
       const size_t u_zero_bits = Botan::low_zero_bits(u);
       u >>= u_zero_bits;
       for(size_t i = 0; i != u_zero_bits; ++i) {
@@ -61,7 +61,7 @@ Botan::BigInt ref_inverse_mod(const Botan::BigInt& n, const Botan::BigInt& mod)
       return 0;  // no modular inverse
    }
 
-   while(D.is_negative()) {
+   while(D.signum() < 0) {
       D += mod;
    }
    while(D >= mod) {

src/lib/asn1/ber_dec.cpp

@@ -427,7 +427,7 @@ BER_Decoder& BER_Decoder::decode(size_t& out, ASN1_Type type_tag, ASN1_Class cla
    BigInt integer;
    decode(integer, type_tag, class_tag);
 
-   if(integer.is_negative()) {
+   if(integer.signum() < 0) {
       throw BER_Decoding_Error("Decoded small integer value was negative");
    }
 

src/lib/codec/base58/base58.cpp

@@ -100,7 +100,7 @@ std::string base58_encode(BigInt v, size_t leading_zeros) {
    BigInt q;
    std::vector<uint8_t> digits;
 
-   while(v.is_nonzero()) {
+   while(!v.is_zero()) {
       word r = 0;
       ct_divide_word(v, radix, q, r);
 

src/lib/ffi/ffi_mp.cpp

@@ -62,11 +62,11 @@ int botan_mp_set_from_mp(botan_mp_t dest, const botan_mp_t source) {
 }
 
 int botan_mp_is_negative(const botan_mp_t mp) {
-   return BOTAN_FFI_VISIT(mp, [](const auto& bn) { return bn.is_negative() ? 1 : 0; });
+   return BOTAN_FFI_VISIT(mp, [](const auto& bn) { return bn.signum() < 0 ? 1 : 0; });
 }
 
 int botan_mp_is_positive(const botan_mp_t mp) {
-   return BOTAN_FFI_VISIT(mp, [](const auto& bn) { return bn.is_positive() ? 1 : 0; });
+   return BOTAN_FFI_VISIT(mp, [](const auto& bn) { return bn.signum() >= 0 ? 1 : 0; });
 }
 
 int botan_mp_flip_sign(botan_mp_t mp) {

src/lib/math/bigint/big_code.cpp

@@ -86,7 +86,7 @@ std::string BigInt::to_dec_string() const {
    std::string s;
    s.reserve(1 + digits.size());
 
-   if(is_negative()) {
+   if(signum() < 0) {
       s += "-";
    }
 
@@ -113,7 +113,7 @@ std::string BigInt::to_hex_string() const {
    }
 
    std::string hrep;
-   if(is_negative()) {
+   if(signum() < 0) {
       hrep += "-";
    }
    hrep += "0x";
@@ -184,7 +184,7 @@ BigInt BigInt::from_radix_digits(std::string_view digits, size_t radix) {
 * Encode two BigInt, with leading 0s if needed, and concatenate
 */
 secure_vector<uint8_t> BigInt::encode_fixed_length_int_pair(const BigInt& n1, const BigInt& n2, size_t bytes) {
-   if(n1.is_negative() || n2.is_negative()) {
+   if(n1.signum() < 0 || n2.signum() < 0) {
       throw Encoding_Error("encode_fixed_length_int_pair: values must be positive");
    }
    if(n1.bytes() > bytes || n2.bytes() > bytes) {

src/lib/math/bigint/big_ops2.cpp

@@ -43,7 +43,7 @@ BigInt& BigInt::add(const word y[], size_t y_words, Sign y_sign) {
 }
 
 BigInt& BigInt::mod_add(const BigInt& s, const BigInt& mod, secure_vector<word>& ws) {
-   if(this->is_negative() || s.is_negative() || mod.is_negative()) {
+   if(this->signum() < 0 || s.signum() < 0 || mod.signum() < 0) {
       throw Invalid_Argument("BigInt::mod_add expects all arguments are positive");
    }
 
@@ -92,7 +92,7 @@ BigInt& BigInt::mod_add(const BigInt& s, const BigInt& mod, secure_vector<word>&
 }
 
 BigInt& BigInt::mod_sub(const BigInt& s, const BigInt& mod, secure_vector<word>& ws) {
-   if(this->is_negative() || s.is_negative() || mod.is_negative()) {
+   if(this->signum() < 0 || s.signum() < 0 || mod.signum() < 0) {
       throw Invalid_Argument("BigInt::mod_sub expects all arguments are positive");
    }
 
@@ -120,7 +120,7 @@ BigInt& BigInt::mod_sub(const BigInt& s, const BigInt& mod, secure_vector<word>&
 }
 
 BigInt& BigInt::mod_mul(uint8_t y, const BigInt& mod, secure_vector<word>& ws) {
-   BOTAN_ARG_CHECK(this->is_negative() == false, "*this must be positive");
+   BOTAN_ARG_CHECK(this->signum() >= 0, "*this must be positive");
    BOTAN_ARG_CHECK(y < 16, "y too large");
 
    BOTAN_DEBUG_ASSERT(*this < mod);
@@ -202,7 +202,7 @@ BigInt& BigInt::operator*=(word y) {
 * Division Operator
 */
 BigInt& BigInt::operator/=(const BigInt& y) {
-   if(y.sig_words() == 1 && is_positive() && y.is_positive() && is_power_of_2(y.word_at(0))) {
+   if(y.sig_words() == 1 && signum() >= 0 && y.signum() >= 0 && is_power_of_2(y.word_at(0))) {
       (*this) >>= (y.bits() - 1);
    } else {
       (*this) = (*this) / y;
@@ -267,8 +267,8 @@ BigInt& BigInt::operator<<=(size_t shift) {
 BigInt& BigInt::operator>>=(size_t shift) {
    bigint_shr1(m_data.mutable_data(), m_data.size(), shift);
 
-   if(is_negative() && is_zero()) {
-      set_sign(Positive);
+   if(sig_words() == 0 && m_signedness == Negative) {
+      m_signedness = Positive;
    }
 
    return (*this);

src/lib/math/bigint/big_ops3.cpp

@@ -104,7 +104,7 @@ BigInt operator*(const BigInt& x, word y) {
 * Division Operator
 */
 BigInt operator/(const BigInt& x, const BigInt& y) {
-   if(y.sig_words() == 1 && y.is_positive()) {
+   if(y.sig_words() == 1 && y.signum() >= 0) {
       return x / y.word_at(0);
    }
 
@@ -135,10 +135,10 @@ BigInt operator%(const BigInt& n, const BigInt& mod) {
    if(mod.is_zero()) {
       throw Invalid_Argument("BigInt::operator% divide by zero");
    }
-   if(mod.is_negative()) {
+   if(mod.signum() < 0) {
       throw Invalid_Argument("BigInt::operator% modulus must be > 0");
    }
-   if(n.is_positive() && mod.is_positive() && n < mod) {
+   if(n.signum() >= 0 && mod.signum() >= 0 && n < mod) {
       return n;
    }
 
@@ -166,7 +166,7 @@ word operator%(const BigInt& n, word mod) {
 
    word remainder = 0;
 
-   if(n.is_positive() && is_power_of_2(mod)) {
+   if(n.signum() >= 0 && is_power_of_2(mod)) {
       remainder = (n.word_at(0) & (mod - 1));
    } else {
       const divide_precomp redc_mod(mod);
@@ -213,7 +213,7 @@ BigInt operator>>(const BigInt& x, size_t shift) {
    BigInt y = BigInt::with_capacity(x_sw - shift_words);
    bigint_shr2(y.mutable_data(), x._data(), x_sw, shift);
 
-   if(x.is_negative() && y.is_zero()) {
+   if(x.signum() < 0 && y.is_zero()) {
       y.set_sign(BigInt::Positive);
    } else {
       y.set_sign(x.sign());

src/lib/math/bigint/big_rand.cpp

@@ -42,7 +42,7 @@ void BigInt::randomize(RandomNumberGenerator& rng, size_t bitsize, bool set_high
 * Generate a random integer within given range
 */
 BigInt BigInt::random_integer(RandomNumberGenerator& rng, const BigInt& min, const BigInt& max) {
-   if(min.is_negative() || max.is_negative() || max <= min) {
+   if(min.signum() < 0 || max.signum() < 0 || max <= min) {
       throw Invalid_Argument("BigInt::random_integer invalid range");
    }
 

src/lib/math/bigint/bigint.cpp

@@ -120,7 +120,7 @@ uint8_t BigInt::byte_at(size_t n) const {
 }
 
 int32_t BigInt::cmp_word(word other) const {
-   if(is_negative()) {
+   if(signum() < 0) {
       return -1;  // other is positive ...
    }
 
@@ -137,15 +137,15 @@ int32_t BigInt::cmp_word(word other) const {
 */
 int32_t BigInt::cmp(const BigInt& other, bool check_signs) const {
    if(check_signs) {
-      if(other.is_positive() && this->is_negative()) {
+      if(other.signum() >= 0 && this->signum() < 0) {
          return -1;
       }
 
-      if(other.is_negative() && this->is_positive()) {
+      if(other.signum() < 0 && this->signum() >= 0) {
          return 1;
       }
 
-      if(other.is_negative() && this->is_negative()) {
+      if(other.signum() < 0 && this->signum() < 0) {
          return (-bigint_cmp(this->_data(), this->size(), other._data(), other.size()));
       }
    }
@@ -162,15 +162,15 @@ bool BigInt::is_equal(const BigInt& other) const {
 }
 
 bool BigInt::is_less_than(const BigInt& other) const {
-   if(this->is_negative() && other.is_positive()) {
+   if(this->signum() < 0 && other.signum() >= 0) {
       return true;
    }
 
-   if(this->is_positive() && other.is_negative()) {
+   if(this->signum() >= 0 && other.signum() < 0) {
       return false;
    }
 
-   if(other.is_negative() && this->is_negative()) {
+   if(other.signum() < 0 && this->signum() < 0) {
       return bigint_ct_is_lt(other._data(), other.size(), this->_data(), this->size()).as_bool();
    }
 
@@ -265,7 +265,7 @@ uint32_t BigInt::get_substring(size_t offset, size_t length) const {
 * Convert this number to a uint32_t, if possible
 */
 uint32_t BigInt::to_u32bit() const {
-   if(is_negative()) {
+   if(signum() < 0) {
       throw Encoding_Error("BigInt::to_u32bit: Number is negative");
    }
    if(bits() > 32) {
@@ -327,7 +327,7 @@ BigInt BigInt::operator-() const {
 }
 
 size_t BigInt::reduce_below(const BigInt& p, secure_vector<word>& ws) {
-   if(p.is_negative() || this->is_negative()) {
+   if(p.signum() < 0 || this->signum() < 0) {
       throw Invalid_Argument("BigInt::reduce_below both values must be positive");
    }
 
@@ -359,7 +359,7 @@ size_t BigInt::reduce_below(const BigInt& p, secure_vector<word>& ws) {
 }
 
 void BigInt::ct_reduce_below(const BigInt& mod, secure_vector<word>& ws, size_t bound) {
-   if(mod.is_negative() || this->is_negative()) {
+   if(mod.signum() < 0 || this->signum() < 0) {
       throw Invalid_Argument("BigInt::ct_reduce_below both values must be positive");
    }
 
@@ -447,7 +447,7 @@ void BigInt::assign_from_bytes(std::span<const uint8_t> bytes) {
 }
 
 void BigInt::ct_cond_add(bool predicate, const BigInt& value) {
-   if(this->is_negative() || value.is_negative()) {
+   if(this->signum() < 0 || value.signum() < 0) {
       throw Invalid_Argument("BigInt::ct_cond_add requires both values to be positive");
    }
    const size_t v_words = value.sig_words();