I Love Big Numbers!

My big integer class is finally finished. I have not tested it extensively yet. Anybody who is willing to find a tiny and clearly implemented big number class would find it worthy to have a try. Bug reports are always welcomed.

big_unsigned.hpp:
/***************************************************************************
 *   Copyright (C) 2008 by Liu Kaipeng                                     *
 *   LiuKaipeng at gmail dot com                                           *
 ***************************************************************************/
#ifndef BIG_UNSIGNED_H
#define BIG_UNSIGNED_H
#include <algorithm>
#include <fstream>
#include <limits>
#include <sstream>
#include <vector>
/*
 * basic_big_unsigned - A implementation of big unsigned operations.
 *
 * This class is in fact a wrapper of the underlying container.
 */
template<typename Type, typename Container = std::vector<Type> >
struct basic_big_unsigned
{
  typedef basic_big_unsigned self_type;
  typedef Container container_type;
  typedef typename container_type::value_type value_type;
  typedef typename container_type::size_type size_type;
  static int const repr_digits = std::numeric_limits<value_type>::digits;
  static value_type const repr_base = 1 << (repr_digits / 2);
  // Constructs.
  basic_big_unsigned() {}
 
  basic_big_unsigned(value_type other) { 
    if (other) repr_.push_back(other), progress(0); 
  }
  explicit basic_big_unsigned(container_type const& repr) : repr_(repr) {}
  // Conversions.
  value_type value() const {
    value_type u = value_type();
    for (size_type i = 0; i != repr_.size() && i != 2; ++i) 
      u = u * repr_base + repr_[i];
    return u;
  }
  // Representations.
  container_type& repr() { return repr_; }
  container_type const& repr() const { return repr_; }
  bool is_zero() const { return repr_.empty(); }
  // Operations.
  self_type& operator+=(self_type const& other) {
    if (repr_.size() < other.repr_.size())
      repr_.resize(other.repr_.size());
    size_type i = 0;
    value_type carry = 0;
    for (; i != other.repr_.size(); ++i)
      if (overflow(repr_[i] += other.repr_[i] + carry))
        repr_[i] -= repr_base, carry = 1;
      else
        carry = 0;
    if (carry != 0)
      if (i == repr_.size()) repr_.push_back(carry);
      else repr_[i] += carry, progress(i);
    return *this;
  }
  self_type& operator+=(value_type other) {
    if (overflow(other))
      return *this += self_type(other);
    if (is_zero()) repr_.resize(1);
    repr_[0] += other;
    progress(0);
    return *this;
  }
  self_type operator+(self_type const& other) const {
    self_type tmp(*this); tmp += other; return tmp;
  }
  self_type operator+(value_type other) const {
    self_type tmp(*this); tmp += other; return tmp;
  }
  self_type& operator-=(self_type const& other) {
    size_type i = 0;
    for (; i != other.repr_.size(); ++i)
      if (underflow(repr_[i] -= other.repr_[i]))
        --repr_[i+1], repr_[i] += repr_base;
    degress(i);
    return *this;
  }
  self_type& operator-=(value_type other) {
    repr_[0] -= other;
    degress(0);
    return *this;
  }
  self_type operator-(self_type const& other) const {
    self_type tmp(*this); return tmp -= other;
  }
  self_type operator-(value_type other) const {
    self_type tmp(*this); return tmp -= other;
  }
  self_type& operator*=(self_type const& other) {
    return *this = *this * other;
  }
  self_type& operator*=(value_type other) {
    if (overflow(other))
      return *this *= self_type(other);
    value_type carry = 0;
    for (size_type i = 0; i != repr_.size(); ++i) {
      repr_[i] *= other;
      repr_[i] += carry;
      carry = repr_[i] / repr_base;
      repr_[i] -= carry * repr_base;
    }
    if (carry != 0) repr_.push_back(carry);
    return *this;
  }
  self_type operator*(self_type const& other) const {
    self_type tmp;
    if (!other.is_zero()) {
      tmp.repr_.resize(repr_.size() + other.repr_.size());
      for (size_t i = 0; i != repr_.size(); ++i)
        for (size_t j = 0; j != other.repr_.size(); ++j)
          if (overflow(tmp.repr_[i+j] += repr_[i] * other.repr_[j])) {
            tmp.repr_[i+j+1] += tmp.repr_[i+j] / repr_base;
            tmp.repr_[i+j] %= repr_base;
          }
      tmp.strip();
    }
    return tmp;
  }
  self_type operator*(value_type other) const {
    self_type tmp(*this); return tmp *= other;
  }
  self_type& operator/=(self_type const& other) {
    return *this = *this / other;
  }
  self_type& operator/=(value_type other) {
    value_type rem;
    div_with_rem(other, rem);
    return *this;
  }
  self_type operator/(self_type const& other) const {
    self_type tmp(*this);
    tmp = tmp.div_to_rem(other);
    return tmp;
  }
  self_type operator/(value_type other) const {
    self_type tmp(*this); return tmp /= other;
  }
  self_type& operator%=(self_type const& other) {
    div_to_rem(other);
    return *this;
  }
  self_type& operator%=(value_type other) {
    div_to_rem(self_type(other));
    return *this;
  }
  self_type operator%(self_type const& other) const {
    self_type tmp(*this); return tmp %= other;
  }
  value_type operator%(value_type other) const {
    value_type rem;
    self_type tmp(*this);
    tmp.div_with_rem(other, rem);
    return rem;
  }
  self_type& operator++() { return *this += 1; }
  self_type operator++(int) { self_type tmp(*this); return tmp += 1; }
  self_type& operator--() { return *this -= 1; }
  self_type operator--(int) { self_type tmp(*this); return tmp -= 1; }
  // Modular operations.
  self_type div_to_rem(self_type const& other) {
    self_type tmp;
    if (!is_zero() && repr_.size() >= other.repr_.size()) {
      tmp.repr_.resize(repr_.size() - other.repr_.size() + 1);
      for (size_type i = tmp.repr_.size(); i != 0; --i) {
        value_type high = repr_base - 1, low = 0,
          mul = (high + low + 1) >> 1;
        for (; high > low; mul = (high + low + 1) >> 1)
          if (less_mul_shift(other, mul, i-1)) high = mul - 1;
          else low = mul;
        sub_mul_shift(other, mul, i-1);
        tmp.repr_[i-1] = mul;
      }
      tmp.degress(tmp.repr_.size());
    }
    return tmp;
  }
  void div_with_rem(value_type other, value_type& rem) {
    rem = 0;
    for (size_type i = repr_.size(); i != 0; --i) {
      rem = rem * repr_base + repr_[i-1];
      repr_[i-1] = rem / other;
      rem -= repr_[i-1] * other;
    }
    strip();
  }
private:
  static bool overflow(value_type u) { return u >= repr_base; }
  static bool underflow(value_type u) { return u - repr_base < -repr_base; }
  void strip() { for (; !is_zero() && repr_.back() == 0; ) repr_.pop_back(); }
  void progress(size_type pos) {
    value_type carry = 0;
    for (; pos != repr_.size() && overflow(repr_[pos] += carry); ++pos) {
      carry = repr_[pos] / repr_base;
      repr_[pos] -= carry * repr_base;
    }
    if (pos == repr_.size() && carry != 0) repr_.push_back(carry);
  }
  void degress(size_type pos) {
    value_type borrow = 0;
    for (; pos != repr_.size() && underflow(repr_[pos] -= borrow); ++pos) {
      borrow = (repr_base - 1 - repr_[pos]) / repr_base;
      repr_[pos] += borrow * repr_base;
    }
    if (pos == repr_.size() && borrow != 0) repr_.clear();
    strip();
  }
  bool less_mul_shift(self_type const& other, value_type mul, size_type shift) 
    const {
    if (repr_.size() < other.repr_.size() + shift && mul)
      return true;
    value_type rem = 0, pro = 0;
    for (size_type i = repr_.size(), j = i - shift; i != shift; --i, --j) {
      rem = rem * repr_base + repr_[i-1];
      pro = other.repr_.size() < j ? 0 : other.repr_[j-1] * mul;
      if (rem < pro) return true;
      if ((rem -= pro) >= mul) return false;
    }
    return false;
  }
  void sub_mul_shift(self_type const& other, value_type mul, size_type shift) {
    size_type i = shift;
    for (; i != other.repr_.size() + shift; ++i) {
      if (underflow(repr_[i] -= other.repr_[i-shift] * mul)) {
        value_type borrow = (repr_base - 1 - repr_[i]) / repr_base;
        repr_[i+1] -= borrow;
        repr_[i] += borrow * repr_base;
      }
    }
    degress(i);
  }
private:
  container_type repr_;
};
// Comparisons of basic_big_unsigned.
template<typename Type, typename Container>
inline bool operator==(basic_big_unsigned<Type, Container> const& x,
                       basic_big_unsigned<Type, Container> const& y) {
  return x.repr() == y.repr();
}
template<typename Type, typename Container>
inline bool operator!=(basic_big_unsigned<Type, Container> const& x,
                       basic_big_unsigned<Type, Container> const& y) {
  return !(x == y);
}
template<typename Type, typename Container>
inline bool operator<(basic_big_unsigned<Type, Container> const& x,
                      basic_big_unsigned<Type, Container> const& y) {
  if (x.repr().size() != y.repr().size())
    return x.repr().size() < y.repr().size();
  else
    return std::lexicographical_compare(x.repr().rbegin(), x.repr().rend(),
                                        y.repr().rbegin(), y.repr().rend());
}
template<typename Type, typename Container>
inline bool operator>(basic_big_unsigned<Type, Container> const& x,
                      basic_big_unsigned<Type, Container> const& y) {
  return y < x;
}
template<typename Type, typename Container>
inline bool operator<=(basic_big_unsigned<Type, Container> const& x,
                       basic_big_unsigned<Type, Container> const& y) {
  return !(y < x);
}
template<typename Type, typename Container>
inline bool operator>=(basic_big_unsigned<Type, Container> const& x,
                       basic_big_unsigned<Type, Container> const& y) {
  return !(x < y);
}
// Input and output of basic_big_unsigned.
template<typename Type, typename Container>
std::istream& operator>>(std::istream& is,
                         basic_big_unsigned<Type, Container>& u) {
  typedef basic_big_unsigned<Type, Container> big_unsigned_type;
  typedef typename big_unsigned_type::value_type value_type;
  value_type base = big_unsigned_type::repr_base;
  std::size_t digits = 4;
  std::ios_base::fmtflags flags = is.flags();
  if (flags & std::ios_base::dec) base = 10000;
  if (flags & std::ios_base::oct) digits = 5;
  u.repr().clear();
  value_type val;
  std::stringstream ss;
  ss.flags(is.flags());
  for (char buf[5]; is.read(buf, digits) && ss.write(buf, is.gcount()); )
    ss >> val, u *= base, u += val;
  return is;
}
template<typename Type, typename Container>
std::ostream& operator<<(std::ostream& os,
                         basic_big_unsigned<Type, Container> const& u) {
  typedef basic_big_unsigned<Type, Container> big_unsigned_type;
  typedef typename big_unsigned_type::value_type value_type;
  if (u.is_zero()) return os << "0";
  value_type base = big_unsigned_type::repr_base;
  std::size_t digits = 4;
  std::ios_base::fmtflags flags = os.flags();
  if (flags & std::ios_base::dec) base = 10000;
  if (flags & std::ios_base::oct) digits = 5;
  value_type val;
  std::vector<value_type> vals;
  for (big_unsigned_type tmp(u); !tmp.is_zero(); vals.push_back(val))
    tmp.div_with_rem(base, val);
  os << vals.back();
  if (vals.size() > 1) {
    char f = os.fill('0');
    for (std::size_t i = vals.size() - 1; i != 0; --i)
      os.width(digits), os << vals[i-1];
    os.fill(f);
  }
  return os;
}
typedef basic_big_unsigned<unsigned> big_unsigned;
#endif /* BIG_UNSIGNED_H */
I Love Big Numbers!

[轉帖]使用NMT和pmap解決JVM資源泄漏問題原創

Python實現大麥網搶票的四大關鍵技術點解析

Python 安裝庫指令大全

salesforce零基礎學習（一百三十八）零碎知識點小總結（十）

一款開源的.NET程序集反編譯、編輯和調試神器

關於接口協議，你必須要知道這些！

基於 Milvus + LlamaIndex 實現高級 RAG

【2024-05-21】以茶會友

Christmas is Halloween!

UVa Problem Solution: 10026 - Shoemaker's Problem

UVa Problem Solution: 10127 - Ones

UVa Problem Solution: 701 - The Archaeologist's Dilemma

UVa Problem Solution: 10035 - Primary Arithmatic

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結
