mpn.h

Go to the documentation of this file.

/* Part of the C++ Multi-Precision arithmetic library

   Written by Brian Sipos <bjs5075@rit.edu> or <brian@sipos.yi.org>
   Copyright 2001,2002,2003 Brian Sipos

   The MP++ library is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   The MP++ library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with the MP++ library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef MPN_H
#define MPN_H

#include <string>
#include "config.h"

namespace mp {

class mpn_ {
 public:
  typedef mp::size_type size_type;   
  typedef mp::limb_type limb_type;   
  typedef mp::limb_long_type limb_long_type; 
  typedef mp::radix_type radix_type; 

  static const size_type limb_size_bits; 
  static const limb_type limb_full; 
  static const size_type size_max;  

  static const std::string string_digits;

  static const byte capabilities();

  static void interrupt();

  mpn_(limb_type n = 0, size_type size = 0) :
    alloc_(0), data_(NULL) {
    init(n, size);
  }
  mpn_(const mpn_ &n, size_type size = 0) :
    alloc_(0), data_(NULL) {
    init(n, size);
  }

  ~mpn_() {
    delete [] data_;
  }

  void init(limb_type n, size_type size = 0);

  void init(const mpn_ &n, size_type size = 0);

  void clear(); 

  void resize(size_type size);

  void swap(mpn_ &n);

  size_type size() const;

  bool isZero() const;

  size_type low_zeros() const;

  void shift_l(size_type n);
  void shift_r(size_type n);

  void setString(const std::string &s, radix_type b);

  std::string getString(radix_type b) const;

  void print() const; 

  raw_type getRaw() const; 
  void setRaw(const raw_type &data); 


  const limb_type & operator [] (size_type i) const;
  limb_type & operator [] (size_type i);

  int compare(const mpn_ &n) const;

  void add(const mpn_ &n);

  void sub(const mpn_ &n);

  void mul(const mpn_ &n);

  void div_mod(mpn_ &n);

  void sqr(); 


  static void prng_seed(limb_long_type seed);

  static void prng_seed(const mpn_ &seed);

  void prng(size_type n);

  size_type popcount() const; // returns the number of set bits

  void bitwise(const mpn_ &y, int type);

  void bitwise_not();

  void setUse();

 protected:
  size_type alloc_; 
  size_type use_;   
  limb_type *data_; 

#ifdef _MP_INTERRUPTABLE
  static bool interrupted; 

  void onInterrupt() const;
#endif

  void add_l(limb_type n);

  void sub_l(limb_type n);

  void mul_l(limb_type n);

  void div_mod_l(limb_type &n);
};

radix_type guessbase(const std::string &s, radix_type b);

std::string::size_type isNum(const std::string &s, radix_type b);

void setchunk(mpn_::radix_type b, std::string::size_type &chunksize,
              mpn_::limb_type &chunk);

void stringclean(std::string &s, mpn_::radix_type b, int clear_zero);

} // End namespace mp++
#endif

---