\begin{code}
{-# OPTIONS_GHC -XNoImplicitPrelude #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  GHC.Integer
-- Copyright   :  (c) The University of Glasgow 1994-2008
-- License     :  see libraries/integer/LICENSE
--
-- Maintainer  :  cvs-ghc@haskell.org
-- Stability   :  internal
-- Portability :  non-portable (GHC Extensions)
--
-- The 'Integer' type.
--
-----------------------------------------------------------------------------

#include "MachDeps.h"

module GHC.Integer (
    Integer(..),
    smallInteger, wordToInteger, integerToWord, toInt#,
#if WORD_SIZE_IN_BITS < 64
    integerToWord64, word64ToInteger,
    integerToInt64, int64ToInteger,
#endif
    plusInteger, minusInteger, timesInteger, negateInteger,
    eqInteger, neqInteger, absInteger, signumInteger,
    leInteger, gtInteger, ltInteger, geInteger, compareInteger,
    divModInteger, quotRemInteger, quotInteger, remInteger,
    encodeFloatInteger, floatFromInteger,
    encodeDoubleInteger, decodeDoubleInteger, doubleFromInteger,
    gcdInteger, lcmInteger,
    andInteger, orInteger, xorInteger, complementInteger,
    hashInteger,
 ) where

import qualified GHC.Integer.GMP as Impl

import GHC.Bool
import GHC.Ordering
import GHC.Prim

default ()
\end{code}

%*********************************************************
%*                                                      *
\subsection{The @Integer@ type}
%*                                                      *
%*********************************************************

Convenient boxed Integer PrimOps.

\begin{code}
newtype Integer = Integer Impl.Integer

smallInteger :: Int# -> Integer
smallInteger i = Integer (Impl.smallInteger i)

wordToInteger :: Word# -> Integer
wordToInteger w = Integer (Impl.wordToInteger w)

integerToWord :: Integer -> Word#
integerToWord (Integer i) = Impl.integerToWord i

#if WORD_SIZE_IN_BITS < 64
integerToWord64 :: Integer -> Word64#
integerToWord64 (Integer i) = Impl.integerToWord64 i

word64ToInteger :: Word64# -> Integer
word64ToInteger w = Integer (Impl.word64ToInteger w)

integerToInt64 :: Integer -> Int64#
integerToInt64 (Integer i) = Impl.integerToInt64 i

int64ToInteger :: Int64# -> Integer
int64ToInteger i = Integer (Impl.int64ToInteger i)
#endif

toInt# :: Integer -> Int#
toInt# (Integer i) = Impl.toInt# i
\end{code}


%*********************************************************
%*                                                      *
\subsection{Dividing @Integers@}
%*                                                      *
%*********************************************************

\begin{code}
-- XXX There's no good reason for us using unboxed tuples for the
-- results, but we don't have Data.Tuple available.

-- Note that we don't check for divide-by-zero here. That needs
-- to be done where it's used.
-- (we don't have error)

quotRemInteger :: Integer -> Integer -> (# Integer, Integer #)
quotRemInteger (Integer x) (Integer y)
    = case Impl.quotRemInteger x y of
      (# q, r #) -> (# Integer q, Integer r #)

divModInteger :: Integer -> Integer -> (# Integer, Integer #)
divModInteger (Integer x) (Integer y)
    = case Impl.divModInteger x y of
      (# d, m #) -> (# Integer d, Integer m #)

remInteger :: Integer -> Integer -> Integer
remInteger (Integer x) (Integer y) = Integer (Impl.remInteger x y)

quotInteger :: Integer -> Integer -> Integer
quotInteger (Integer x) (Integer y) = Integer (Impl.quotInteger x y)
\end{code}



\begin{code}
-- We can't throw an error here, so it is up to our caller to
-- not call us with both arguments being 0.
gcdInteger :: Integer -> Integer -> Integer
gcdInteger (Integer x) (Integer y) = Integer (Impl.gcdInteger x y)

lcmInteger :: Integer -> Integer -> Integer
lcmInteger (Integer x) (Integer y) = Integer (Impl.lcmInteger x y)
\end{code}


%*********************************************************
%*                                                      *
\subsection{The @Integer@ instances for @Eq@, @Ord@}
%*                                                      *
%*********************************************************

\begin{code}
eqInteger :: Integer -> Integer -> Bool
eqInteger (Integer x) (Integer y) = Impl.eqInteger x y

neqInteger :: Integer -> Integer -> Bool
neqInteger (Integer x) (Integer y) = Impl.neqInteger x y

------------------------------------------------------------------------

leInteger :: Integer -> Integer -> Bool
leInteger (Integer x) (Integer y) = Impl.leInteger x y

gtInteger :: Integer -> Integer -> Bool
gtInteger (Integer x) (Integer y) = Impl.gtInteger x y

ltInteger :: Integer -> Integer -> Bool
ltInteger (Integer x) (Integer y) = Impl.ltInteger x y

geInteger :: Integer -> Integer -> Bool
geInteger (Integer x) (Integer y) = Impl.geInteger x y

compareInteger :: Integer -> Integer -> Ordering
compareInteger (Integer x) (Integer y) = Impl.compareInteger x y
\end{code}


%*********************************************************
%*                                                      *
\subsection{The @Integer@ instances for @Num@}
%*                                                      *
%*********************************************************

\begin{code}
absInteger :: Integer -> Integer
absInteger (Integer x) = Integer (Impl.absInteger x)

signumInteger :: Integer -> Integer
signumInteger (Integer x) = Integer (Impl.signumInteger x)

plusInteger :: Integer -> Integer -> Integer
plusInteger (Integer x) (Integer y) = Integer (Impl.plusInteger x y)

minusInteger :: Integer -> Integer -> Integer
minusInteger (Integer x) (Integer y) = Integer (Impl.minusInteger x y)

timesInteger :: Integer -> Integer -> Integer
timesInteger (Integer x) (Integer y) = Integer (Impl.timesInteger x y)

negateInteger :: Integer -> Integer
negateInteger (Integer x) = Integer (Impl.negateInteger x)
\end{code}


%*********************************************************
%*                                                      *
\subsection{The @Integer@ stuff for Double@}
%*                                                      *
%*********************************************************

\begin{code}
encodeFloatInteger :: Integer -> Int# -> Float#
encodeFloatInteger (Integer x) y = Impl.encodeFloatInteger x y

encodeDoubleInteger :: Integer -> Int# -> Double#
encodeDoubleInteger (Integer x) y = Impl.encodeDoubleInteger x y

decodeDoubleInteger :: Double# -> (# Integer, Int# #)
decodeDoubleInteger d = case Impl.decodeDoubleInteger d of
                        (# i, j #) -> (# Integer i, j #)

doubleFromInteger :: Integer -> Double#
doubleFromInteger (Integer x) = Impl.doubleFromInteger x

floatFromInteger :: Integer -> Float#
floatFromInteger (Integer x) = Impl.floatFromInteger x
\end{code}

%*********************************************************
%*                                                      *
\subsection{The @Integer@ Bit definitions@}
%*                                                      *
%*********************************************************

\begin{code}
andInteger :: Integer -> Integer -> Integer
andInteger (Integer x) (Integer y) = Integer (Impl.andInteger x y)

orInteger :: Integer -> Integer -> Integer
orInteger (Integer x) (Integer y) = Integer (Impl.orInteger x y)

xorInteger :: Integer -> Integer -> Integer
xorInteger (Integer x) (Integer y) = Integer (Impl.xorInteger x y)

complementInteger :: Integer -> Integer
complementInteger (Integer x) = Integer (Impl.complementInteger x)
\end{code}

%*********************************************************
%*                                                      *
\subsection{The @Integer@ hashing@}
%*                                                      *
%*********************************************************

\begin{code}
-- This is used by hashUnique

hashInteger :: Integer -> Int#
hashInteger (Integer i) = Impl.hashInteger i
\end{code}