big_int.hpp

Go to the documentation of this file.

/*****************************************************************************
    
    big_int.hpp.

    This file is a part of the Arageli library.
    
    Big Integer Numbers implementation.

    This module implements a class big_int for representing
    Big Integer Numbers, i.e. `arbitrary precision' integers.

    WARNIG. This file has no complate implementation.

    Copyright (C) Nikolai Yu. Zolotykh, 1999 -- 2005
    University of Nizhni Novgorod, Russia

*****************************************************************************/

#ifndef __ARAGELI_big_int_h__
#define __ARAGELI_big_int_h__

#include "config.hpp"

#include <cstddef>
#include <iostream>
#include <cstdlib>
#include <string>
#include <cctype>
#include <cmath>
#include <limits>

#include "frwrddecl.hpp"

#include "type_traits.hpp"
#include "type_pair_traits.hpp"
#include "exception.hpp"
#include "factory.hpp"
#include "powerest.hpp"
#include "intalg.hpp"
#include "bigar.hpp"

#include "std_import.hpp"

namespace Arageli
{

namespace _Internal
{
    // a = b / c; res = b % c
    void xdivide (big_int& a, const big_int& b, const big_int& c, big_int& res);
}


// The following declaration is needed only for one additional definition
// in big_int class.  That definition is created for GCC compatibility only.
// See template <typename TT2> big_int::big_int (const rational<big_int>& x).

// template <typename T> class rational;    // see rational.hpp


class big_int
{
    // A type for one elementary digit.
    // Number consist of sequence of objects of this type.
    typedef _Internal::digit digit;

public:


    class exception : public virtual Arageli::exception
    {
        std::string msg_m;
    public:
        
        exception () {}
        

        exception (const std::string& msg_a) : msg_m(msg_a) {}
        

        virtual std::string msg () const { return msg_m; }
    };

    // WARNING!  A message storage is duplicated in the incorrec_string class.
    // Realy two verstions of this storage are presented in the class.
    // TODO: Resolve it.


    class incorrect_string : public exception, public Arageli::incorrect_string
    {
    public:
        incorrect_string (const std::string& msg_a)
        : Arageli::incorrect_string(msg_a) {}

        virtual std::string msg () const { return Arageli::incorrect_string::msg(); }
    };



    big_int () { alloc_zero(); }
    

    big_int (const char* str);
    

    big_int (const big_int& b)
    {
        ARAGELI_ASSERT_0(this != &b);
        b.number->refs++;
        number = b.number;
    }



    template <typename T>
    big_int (const rational<T>& x)
    {
        alloc_zero();
        *this = x.numerator()/x.denominator();
    }
    
    
    big_int (char x) { from_native_int(x); }
    big_int (signed char x) { from_native_int(x); }
    big_int (unsigned char x) { from_native_int(x); }
    big_int (signed short x) { from_native_int(x); }
    big_int (unsigned short x) { from_native_int(x); }
    big_int (signed int x) { from_native_int(x); }
    big_int (unsigned int x) { from_native_int(x); }
    big_int (signed long int x) { from_native_int(x); }
    big_int (unsigned long int x) { from_native_int(x); }
    big_int (bool x) { from_native_int(x); }

    #ifdef ARAGELI_INT64_SUPPORT

        big_int (signed __int64 x) { from_native_int(x); }
        big_int (unsigned __int64 x) { from_native_int(x); }

    #endif

    #ifdef ARAGELI_LONG_LONG_SUPPORT

        big_int (signed long long x) { from_native_int(x); }
        big_int (unsigned long long x) { from_native_int(x); }

    #endif

    big_int (float x) { from_native_float(x); }
    big_int (double x) { from_native_float(x); }
    big_int (long double x) { from_native_float(x); }



    
    operator char () const
    { return to_native_int<char>(); }
    
    operator signed char () const
    { return to_native_int<signed char>(); }
    
    operator unsigned char () const
    { return to_native_int<unsigned char>(); }
    
    operator signed short () const
    { return to_native_int<signed short>(); }
    
    operator unsigned short () const
    { return to_native_int<unsigned short>(); }
    
    operator signed int () const
    { return to_native_int<signed int>(); }
    
    operator unsigned int () const
    { return to_native_int<unsigned int>(); }
    
    operator signed long int () const
    { return to_native_int<signed long>(); }
    
    operator unsigned long int () const
    { return to_native_int<unsigned long>(); }
    
    operator bool () const { return !is_null(); }

    #ifdef ARAGELI_INT64_SUPPORT

        operator signed __int64 () const
        { return to_native_int<signed __int64>(); }
        
        operator unsigned __int64 () const
        { return to_native_int<unsigned __int64>(); }

    #endif

    #ifdef ARAGELI_LONG_LONG_SUPPORT

        operator signed long long () const
        { return to_native_int<signed long long>(); }
        
        operator unsigned long long () const
        { return to_native_int<unsigned long long>(); }

    #endif

    operator float () const { return to_native_float<float>(); }
    operator double () const { return to_native_float<double>(); }
    operator long double () const { return to_native_float<long double>(); }



    bool operator! () const { return is_null(); }

    ~big_int () { free_number(); }


    big_int& operator= (const big_int & b);

    big_int& operator= (const char* s)
    { return *this = big_int(s); }

    big_int& operator= (char x) { from_native_int(x); return *this; }
    big_int& operator= (signed char x) { from_native_int(x); return *this; }
    big_int& operator= (unsigned char x) { from_native_int(x); return *this; }
    big_int& operator= (signed short x) { from_native_int(x); return *this; }
    big_int& operator= (unsigned short x) { from_native_int(x); return *this; }
    big_int& operator= (signed int x) { from_native_int(x); return *this; }
    big_int& operator= (unsigned int x) { from_native_int(x); return *this; }
    big_int& operator= (signed long int x) { from_native_int(x); return *this; }
    big_int& operator= (unsigned long int x) { from_native_int(x); return *this; }
    big_int& operator= (bool x) { from_native_int(x); return *this; }

    #ifdef ARAGELI_INT64_SUPPORT

        big_int& operator= (signed __int64 x) { from_native_int(x); return *this; }
        big_int& operator= (unsigned __int64 x) { from_native_int(x); return *this; }

    #endif

    #ifdef ARAGELI_LONG_LONG_SUPPORT

        big_int& operator= (signed long long x) { from_native_int(x); return *this; }
        big_int& operator= (unsigned long long x) { from_native_int(x); return *this; }

    #endif

    big_int& operator= (float x) { from_native_float(x); return *this; }
    big_int& operator= (double x) { from_native_float(x); return *this; }
    big_int& operator= (long double x) { from_native_float(x); return *this; }

    template <typename T>
    big_int& operator= (const rational<T>& x)
    { return *this = big_int(x); }


    std::size_t length () const;


    bool operator[] (std::size_t k) const;


    int sign () const { return number->sign; }

    inline bool is_null () const;

    inline bool is_unit () const;

    inline bool is_opposite_unit () const;


    const big_int& operator+ () const  { return *this; }
    
    big_int operator- () const;


    big_int& operator++ () { return *this = *this + big_int(1); }


    big_int& operator-- () { return *this = *this - big_int(1); }
    

    big_int operator++ (int) { big_int t = *this; operator++(); return t; }


    big_int operator-- (int) { big_int t = *this; operator--(); return t; }

    friend big_int operator+ (const big_int & b, const big_int & c);
    friend big_int operator- (const big_int & b, const big_int & c);
    friend big_int operator* (const big_int & b, const big_int & c);
    friend big_int operator/ (const big_int & b, const big_int & c);
    friend big_int operator% (const big_int & b, const big_int & c);
    friend big_int operator& (const big_int & b, const big_int & c);
    friend big_int operator| (const big_int & b, const big_int & c);
    friend big_int operator^ (const big_int & b, const big_int & c);
    friend std::ostream& operator<< (std::ostream& s, const big_int& x);
    friend std::istream& operator>> (std::istream& s, big_int& x);
    friend int cmp (const big_int & a, const big_int & b);
    
    friend void _Internal::xdivide
    (big_int& a, const big_int& b, const big_int& c, big_int& res);


    static big_int random_with_length (std::size_t len)
    {
        return
            len ?
            random_with_length_or_less(len - 1) + (big_int(1) << (len - 1)) :
            big_int();
    }


    static big_int random_in_range (const big_int& max);
    

    static big_int random_with_length_or_less (std::size_t len);
    
    friend big_int operator<< (const big_int& a, std::size_t n);
    friend big_int operator>> (const big_int& a, std::size_t n);
    friend big_int& operator>>= (big_int& a, std::size_t n);


    bool bit (std::size_t k) const { return operator[](k); }

    bool is_even () const
    {
        if(!number->len)return true;
        return !(operator[](0));
    }


    #ifdef ARAGELI_DISABLE_PARTICULAR_COMPILER_WARNINGS
        #pragma warning (push)
        #pragma warning (disable : 4800)
    #endif

    bool is_odd () const
    {
        if(!number->len)return false;
        return (operator[](0));
    }

    #ifdef ARAGELI_DISABLE_PARTICULAR_COMPILER_WARNINGS
        #pragma warning (pop)
    #endif


    void swap (big_int& x) { std::swap(number, x.number); }

private:

    friend class big_float; // see big_float.hpp source file

    // the following type is used inside the big_int unit and implements
    // the storage for a Big Integer Number

    struct big_struct
    {
        int sign;       // the sign: 0, 1 or -1
        digit *data;    // the storage for digits
        std::size_t len;        // the number of digits
        int refs;       // the number of points to this number
    } *number;

    // number allocation routines
    void alloc_number (int new_sign, digit* new_mem, std::size_t new_len);
    void free_number ();
    void free_mem_and_alloc_number (int new_sign, digit* new_data, std::size_t new_len);
    void alloc_zero () { alloc_number(0, 0, 0); }
    void free_mem_and_alloc_zero ();

    static digit* get_mem_for_data (std::size_t nitems);
    static void free_data (digit *p);
    static digit* realloc_data (digit* p, std::size_t newnitems);
    
    static void copy_data
        (digit* dest, const digit* source, std::size_t newnitems);

    // Erases leading zeros.
    static digit* optimize (std::size_t& new_len, digit * p, std::size_t len);

    template <typename T>
    void from_native_int (const T& x);

    template <typename T>
    void from_native_float (const T& x);

    template <typename T>
    T to_native_int () const;

    template <typename T>
    T to_native_float () const;

    template <typename T>
    T to_native_int_without_sign () const;

};


inline std::size_t nbits (const big_int& x) { return x.length(); }


std::ostream & operator<< (std::ostream & s, const big_int & x);
    
std::istream & operator>> (std::istream & s, big_int & x);


int cmp (const big_int & a, const big_int & b);


template <typename TT>
inline int sign (const big_int& x)
{ return x.sign(); }



big_int operator+ (const big_int & b, const big_int & c);
big_int operator- (const big_int & b, const big_int & c);
big_int operator* (const big_int & b, const big_int & c);
big_int operator/ (const big_int & b, const big_int & c);
big_int operator% (const big_int & b, const big_int & c);

big_int operator<< (const big_int& a, std::size_t n);
big_int operator>> (const big_int& a, std::size_t n);

// WARNING.  The following operators have not implemented yet.
big_int operator| (const big_int& a, const big_int& b);
big_int operator& (const big_int& a, const big_int& b);
big_int operator^ (const big_int& a, const big_int& b);

template <typename T>
inline big_int operator<< (const big_int& a, const T& b)
{ return a << std::size_t(b); }

template <typename T>
inline big_int operator>> (const big_int& a, const T& b)
{ return a >> std::size_t(b); }

template <typename T>
inline big_int& operator<<= (big_int& a, const T& b)
{ return a = a << b; }

inline big_int& operator>>= (big_int& a, std::size_t b)
{
    if(a.number->len == 1)
    {
        if(a.number->refs > 1)
        {
            a.number->refs--;
            big_int::digit* newdata = big_int::get_mem_for_data(1);
            *newdata = *a.number->data;
            a.alloc_number(a.number->sign, newdata, 1);
        }
        
        if(b >= _Internal::bits_per_digit || !(*a.number->data >>= b))
            a.free_mem_and_alloc_zero();
    }
    else
        a = a >> b;

    return a;
}

template <typename T>
inline big_int& operator>>= (big_int& a, const T& b)
{ return a >>= std::size_t(b); }






inline void divide (const big_int& a, const big_int& b, big_int& q, big_int& r)
{ return _Internal::xdivide(q, a, b, r); }


#define _ARAGELI_big_int_CMP1(OPER)                             \
inline bool operator OPER (const big_int& a, const big_int& b)  \
{ return cmp(a, b) OPER 0; }


_ARAGELI_big_int_CMP1(==)
_ARAGELI_big_int_CMP1(!=)
_ARAGELI_big_int_CMP1(<)
_ARAGELI_big_int_CMP1(>)
_ARAGELI_big_int_CMP1(<=)
_ARAGELI_big_int_CMP1(>=)



/***************************/
/*                         */
/*   Combined operators    */
/*                         */
/***************************/

#define _ARAGELI_big_int_COMBINED_OPER(OPER)                        \
    inline big_int& operator OPER##= (big_int& b, const big_int& c) \
    { return b = b OPER c; }


_ARAGELI_big_int_COMBINED_OPER(+)
_ARAGELI_big_int_COMBINED_OPER(-)
_ARAGELI_big_int_COMBINED_OPER(*)
_ARAGELI_big_int_COMBINED_OPER(/)
_ARAGELI_big_int_COMBINED_OPER(%)
//_ARAGELI_big_int_COMBINED_OPER(>>)
//_ARAGELI_big_int_COMBINED_OPER(<<)


#define _ARAGELI_big_int_MIXED_AOPER1(NATIVE, AOPER)            \
    inline big_int& operator AOPER (big_int& b, NATIVE c)       \
    { return b AOPER big_int(c); }                              \
                                                                \
    inline NATIVE& operator AOPER (NATIVE& b, const big_int& c) \
    { return b AOPER (NATIVE)c; }   /* WARNING */

#define _ARAGELI_big_int_MIXED_BOPER1(NATIVE, BOPER)            \
    inline big_int operator BOPER (NATIVE b, const big_int& c)  \
    { return big_int(b) BOPER c; }                              \
                                                                \
    inline big_int operator BOPER (const big_int& b, NATIVE c)  \
    { return b BOPER big_int(c); }


#define _ARAGELI_big_int_MIXED_COMARE1(NATIVE, BOPER)           \
    inline bool operator BOPER (NATIVE b, const big_int& c)     \
    { return big_int(b) BOPER c; }                              \
                                                                \
    inline bool operator BOPER (const big_int& b, NATIVE c)     \
    { return b BOPER big_int(c); }


#define _ARAGELI_big_int_MIXED_COMPARE3(NATIVE)     \
    _ARAGELI_big_int_MIXED_COMARE1(NATIVE, ==)      \
    _ARAGELI_big_int_MIXED_COMARE1(NATIVE, !=)      \
    _ARAGELI_big_int_MIXED_COMARE1(NATIVE, <=)      \
    _ARAGELI_big_int_MIXED_COMARE1(NATIVE, >=)      \
    _ARAGELI_big_int_MIXED_COMARE1(NATIVE, <)       \
    _ARAGELI_big_int_MIXED_COMARE1(NATIVE, >)


#ifdef ARAGELI_INT64_SUPPORT

#define _ARAGELI_big_int_MIXED_INT_AOPER2(AOPER)                \
    _ARAGELI_big_int_MIXED_AOPER1(char, AOPER)                  \
    _ARAGELI_big_int_MIXED_AOPER1(signed char, AOPER)           \
    _ARAGELI_big_int_MIXED_AOPER1(unsigned char, AOPER)         \
    _ARAGELI_big_int_MIXED_AOPER1(signed short, AOPER)          \
    _ARAGELI_big_int_MIXED_AOPER1(unsigned short, AOPER)        \
    _ARAGELI_big_int_MIXED_AOPER1(signed int, AOPER)            \
    _ARAGELI_big_int_MIXED_AOPER1(unsigned int, AOPER)          \
    _ARAGELI_big_int_MIXED_AOPER1(signed long, AOPER)           \
    _ARAGELI_big_int_MIXED_AOPER1(unsigned long, AOPER)         \
    _ARAGELI_big_int_MIXED_AOPER1(signed __int64, AOPER)        \
    _ARAGELI_big_int_MIXED_AOPER1(unsigned __int64, AOPER)      \
    _ARAGELI_big_int_MIXED_AOPER1(bool, AOPER)

#define _ARAGELI_big_int_MIXED_INT_BOPER2(BOPER)                \
    _ARAGELI_big_int_MIXED_BOPER1(char, BOPER)                  \
    _ARAGELI_big_int_MIXED_BOPER1(signed char, BOPER)           \
    _ARAGELI_big_int_MIXED_BOPER1(unsigned char, BOPER)         \
    _ARAGELI_big_int_MIXED_BOPER1(signed short, BOPER)          \
    _ARAGELI_big_int_MIXED_BOPER1(unsigned short, BOPER)        \
    _ARAGELI_big_int_MIXED_BOPER1(signed int, BOPER)            \
    _ARAGELI_big_int_MIXED_BOPER1(unsigned int, BOPER)          \
    _ARAGELI_big_int_MIXED_BOPER1(signed long, BOPER)           \
    _ARAGELI_big_int_MIXED_BOPER1(unsigned long, BOPER)         \
    _ARAGELI_big_int_MIXED_BOPER1(signed __int64, BOPER)        \
    _ARAGELI_big_int_MIXED_BOPER1(unsigned __int64, BOPER)      \
    _ARAGELI_big_int_MIXED_BOPER1(bool, BOPER)

#else

#define _ARAGELI_big_int_MIXED_INT_AOPER2(AOPER)                \
    _ARAGELI_big_int_MIXED_AOPER1(char, AOPER)                  \
    _ARAGELI_big_int_MIXED_AOPER1(signed char, AOPER)           \
    _ARAGELI_big_int_MIXED_AOPER1(unsigned char, AOPER)         \
    _ARAGELI_big_int_MIXED_AOPER1(signed short, AOPER)          \
    _ARAGELI_big_int_MIXED_AOPER1(unsigned short, AOPER)        \
    _ARAGELI_big_int_MIXED_AOPER1(signed int, AOPER)            \
    _ARAGELI_big_int_MIXED_AOPER1(unsigned int, AOPER)          \
    _ARAGELI_big_int_MIXED_AOPER1(signed long, AOPER)           \
    _ARAGELI_big_int_MIXED_AOPER1(unsigned long, AOPER)         \
    _ARAGELI_big_int_MIXED_AOPER1(bool, AOPER)

#define _ARAGELI_big_int_MIXED_INT_BOPER2(BOPER)                \
    _ARAGELI_big_int_MIXED_BOPER1(char, BOPER)                  \
    _ARAGELI_big_int_MIXED_BOPER1(signed char, BOPER)           \
    _ARAGELI_big_int_MIXED_BOPER1(unsigned char, BOPER)         \
    _ARAGELI_big_int_MIXED_BOPER1(signed short, BOPER)          \
    _ARAGELI_big_int_MIXED_BOPER1(unsigned short, BOPER)        \
    _ARAGELI_big_int_MIXED_BOPER1(signed int, BOPER)            \
    _ARAGELI_big_int_MIXED_BOPER1(unsigned int, BOPER)          \
    _ARAGELI_big_int_MIXED_BOPER1(signed long, BOPER)           \
    _ARAGELI_big_int_MIXED_BOPER1(unsigned long, BOPER)         \
    _ARAGELI_big_int_MIXED_BOPER1(bool, BOPER)

#endif

#define _ARAGELI_big_int_MIXED_FLOAT_AOPER2(AOPER)              \
    _ARAGELI_big_int_MIXED_AOPER1(float, AOPER)                 \
    _ARAGELI_big_int_MIXED_AOPER1(double, AOPER)                \
    _ARAGELI_big_int_MIXED_AOPER1(long double, AOPER)

#define _ARAGELI_big_int_MIXED_FLOAT_BOPER2(BOPER)              \
    _ARAGELI_big_int_MIXED_BOPER1(float, BOPER)                 \
    _ARAGELI_big_int_MIXED_BOPER1(double, BOPER)                \
    _ARAGELI_big_int_MIXED_BOPER1(long double, BOPER)


#ifdef ARAGELI_DISABLE_PARTICULAR_COMPILER_WARNINGS
    #pragma warning (push)
    #pragma warning (disable : 4804)
    #pragma warning (disable : 4800)
#endif


_ARAGELI_big_int_MIXED_INT_AOPER2(+=)
_ARAGELI_big_int_MIXED_INT_AOPER2(-=)
_ARAGELI_big_int_MIXED_INT_AOPER2(*=)
_ARAGELI_big_int_MIXED_INT_AOPER2(/=)

_ARAGELI_big_int_MIXED_FLOAT_AOPER2(+=)
_ARAGELI_big_int_MIXED_FLOAT_AOPER2(-=)
_ARAGELI_big_int_MIXED_FLOAT_AOPER2(*=)
_ARAGELI_big_int_MIXED_FLOAT_AOPER2(/=)

_ARAGELI_big_int_MIXED_INT_AOPER2(%=)

//_ARAGELI_big_int_MIXED_INT_AOPER2(<<=)
//_ARAGELI_big_int_MIXED_INT_AOPER2(>>=)

#ifdef ARAGELI_DISABLE_PARTICULAR_COMPILER_WARNINGS
    #pragma warning (pop)
#endif

_ARAGELI_big_int_MIXED_INT_BOPER2(+)
_ARAGELI_big_int_MIXED_INT_BOPER2(-)
_ARAGELI_big_int_MIXED_INT_BOPER2(*)
_ARAGELI_big_int_MIXED_INT_BOPER2(/)

_ARAGELI_big_int_MIXED_FLOAT_BOPER2(+)
_ARAGELI_big_int_MIXED_FLOAT_BOPER2(-)
_ARAGELI_big_int_MIXED_FLOAT_BOPER2(*)
_ARAGELI_big_int_MIXED_FLOAT_BOPER2(/)

_ARAGELI_big_int_MIXED_INT_BOPER2(%)
//_ARAGELI_big_int_MIXED_INT_BOPER2(<<)
//_ARAGELI_big_int_MIXED_INT_BOPER2(>>)

//_ARAGELI_big_int_MIXED_INT_BOPER2(==)
//_ARAGELI_big_int_MIXED_INT_BOPER2(!=)
//_ARAGELI_big_int_MIXED_INT_BOPER2(<)
//_ARAGELI_big_int_MIXED_INT_BOPER2(>)
//_ARAGELI_big_int_MIXED_INT_BOPER2(<=)
//_ARAGELI_big_int_MIXED_INT_BOPER2(>=)

//_ARAGELI_big_int_MIXED_FLOAT_BOPER2(==)
//_ARAGELI_big_int_MIXED_FLOAT_BOPER2(!=)
//_ARAGELI_big_int_MIXED_FLOAT_BOPER2(<)
//_ARAGELI_big_int_MIXED_FLOAT_BOPER2(>)
//_ARAGELI_big_int_MIXED_FLOAT_BOPER2(<=)
//_ARAGELI_big_int_MIXED_FLOAT_BOPER2(>=)

_ARAGELI_big_int_MIXED_COMPARE3(char)
_ARAGELI_big_int_MIXED_COMPARE3(signed char)
_ARAGELI_big_int_MIXED_COMPARE3(unsigned char)
_ARAGELI_big_int_MIXED_COMPARE3(signed short)
_ARAGELI_big_int_MIXED_COMPARE3(unsigned short)
_ARAGELI_big_int_MIXED_COMPARE3(signed int)
_ARAGELI_big_int_MIXED_COMPARE3(unsigned int)
_ARAGELI_big_int_MIXED_COMPARE3(signed long)
_ARAGELI_big_int_MIXED_COMPARE3(unsigned long)
_ARAGELI_big_int_MIXED_COMPARE3(bool)

_ARAGELI_big_int_MIXED_COMPARE3(float)
_ARAGELI_big_int_MIXED_COMPARE3(double)
_ARAGELI_big_int_MIXED_COMPARE3(long double)


#ifdef ARAGELI_INT64_SUPPORT

    _ARAGELI_big_int_MIXED_COMPARE3(signed __int64)
    _ARAGELI_big_int_MIXED_COMPARE3(unsigned __int64)

#endif


inline bool big_int::is_null () const { return number->sign == 0; }

inline bool big_int::is_unit () const
{ return number->len == 1 && number->sign == +1 && *number->data == 1; }

inline bool big_int::is_opposite_unit () const
{ return number->len == 1 && number->sign == -1 && *number->data == 1; }

inline bool is_null (const big_int& x)
{ return x.is_null(); }

inline bool is_unit (const big_int& x)
{ return x.is_unit(); }

inline bool is_opposite_unit (const big_int& x)
{ return x.is_opposite_unit(); }

inline bool is_positive (const big_int& x)
{ return x.sign() > 0; }

inline bool is_negative (const big_int& x)
{ return x.sign() < 0; }

inline bool is_even (const big_int& x)
{ return x.is_even(); }


inline bool is_odd (const big_int& x)
{ return x.is_odd(); }


// WARNING! This function prototype is placed here because header dependences.
// WARNING! The problem appears only if ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE macro is undefined.
// TODO: Resolve this problem and delete.
template <typename T>
T intsqrt (const T& a);


inline big_int sqrt (const big_int& a)
{ return intsqrt(a); }

inline big_int abs (const big_int& x)
{
    if(x.sign() < 0)return -x;
    else return x;
}


inline big_int pow (const big_int& x, int p)
{ return power(x, p); }


inline big_int pow (const big_int& x, const big_int& p)
{ return power(x, p); }

inline big_int log2 (const big_int& x) { return x.length() - 1; }

}


namespace std
{

inline Arageli::big_int sqrt (const Arageli::big_int& a)
{ return Arageli::sqrt(a); }

inline Arageli::big_int abs (const Arageli::big_int& x)
{ return Arageli::abs(x); }


inline Arageli::big_int pow (const Arageli::big_int& x, int p)
{ return Arageli::pow(x, p); }


inline Arageli::big_int pow
(const Arageli::big_int& x, const Arageli::big_int& p)
{ return Arageli::pow(x, p); }

template <> class numeric_limits<Arageli::big_int>
{
    typedef Arageli::big_int TTT;

public:

    static const bool is_specialized = true;

    static TTT min () throw() { return TTT(); }
    static TTT max () throw() { return TTT(); }
    static const int digits = 0;
    static const int digits10 = 0;
    static const bool is_signed = true;
    static const bool is_integer = true;
    static const bool is_exact = true;
    static const int radix = 2;
    static TTT epsilon () throw() { return TTT(); }
    static TTT round_error () throw() { return TTT(); }
    static const int min_exponent = 0;
    static const int min_exponent10 = 0;
    static const int max_exponent = 0;
    static const int max_exponent10 = 0;
    static const bool has_infinity = false;
    static const bool has_quiet_NaN = false;
    static const bool has_signaling_NaN = false;
    static const float_denorm_style has_denorm = denorm_absent;
    static const bool has_denorm_loss = false;
    static TTT infinity () throw() { return TTT(); }
    static TTT quiet_NaN () throw() { return TTT(); }
    static TTT signaling_NaN () throw() { return TTT(); }
    static TTT denorm_min () throw() { return TTT(); }
    static const bool is_iec559 = false;
    static const bool is_bounded = false;
    static const bool is_modulo = false;
    static const bool traps = true;
    static const bool tinyness_before = false;
    static const float_round_style round = round_toward_zero;
};


inline void swap (Arageli::big_int& a, Arageli::big_int& b)
{ a.swap(b); }


}


namespace Arageli
{

#if 0

template <typename T2>
struct type_pair_traits<big_int, T2>
{
    static const bool is_specialized = type_traits<T2>::is_specialized;
    static const bool is_convertible = type_traits<T2>::is_number;
    static const bool is_safe_convertible = false;
    static const bool is_assignable = is_convertible;
    static const bool is_safe_assignable = is_safe_convertible;
    static const bool is_initializable = is_convertible;
    static const bool is_safe_initializable = is_safe_convertible;
};


template <typename T1>
struct type_pair_traits<T1, big_int>
{
    static const bool is_specialized = type_traits<T1>::is_specialized;
    static const bool is_convertible = type_traits<T1>::is_number;

    static const bool is_safe_convertible =
        type_traits<T1>::is_integer_number &&
        std::numeric_limits<T1>::is_specialized &&
        std::numeric_limits<T1>::is_bounded;
    
    static const bool is_assignable = is_convertible;
    static const bool is_safe_assignable = is_safe_convertible;
    static const bool is_initializable = is_convertible;
    static const bool is_safe_initializable = is_safe_convertible;
};


template <>
struct type_pair_traits<big_int, big_int> :
    public type_pair_traits_for_the_same<big_int> {};

#endif

}


#ifdef ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE
    #define ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE_BIG_INT
    #include "big_int.cpp"
    #undef  ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE_BIG_INT
#endif


#endif

---