{-# OPTIONS -fglasgow-exts #-}
-- -fglasgow-exts for RULES
module Algebra.ToInteger where

import qualified Number.Ratio as Ratio

import qualified Algebra.ToRational     as ToRational
import qualified Algebra.Field          as Field
import qualified Algebra.PrincipalIdealDomain as PID
import qualified Algebra.RealIntegral   as RealIntegral
import qualified Algebra.Ring           as Ring

import Number.Ratio (T((:%)), )

import Algebra.Field ((^-), )
import Algebra.Ring ((^), fromInteger, )

import Data.Int  (Int,  Int8,  Int16,  Int32,  Int64,  )
import Data.Word (Word, Word8, Word16, Word32, Word64, )

import qualified Prelude as P
import PreludeBase
import Prelude (Int, Integer, Float, Double, )


{- |
The two classes 'Algebra.ToInteger.C' and 'Algebra.ToRational.C'
exist to allow convenient conversions,
primarily between the built-in types.
They should satisfy

>   fromInteger .  toInteger === id
>    toRational .  toInteger === toRational

Conversions must be lossless,
that is, they do not round in any way.
For rounding see "Algebra.RealField".
With the instances for 'Prelude.Float' and 'Prelude.Double'
we acknowledge that these types actually represent rationals
rather than (approximated) real numbers.
However, this contradicts to the 'Algebra.Transcendental.C' instance.
-}
class (ToRational.C a, RealIntegral.C a) => C a where
   toInteger :: a -> Integer


fromIntegral :: (C a, Ring.C b) => a -> b
fromIntegral = fromInteger . toInteger


-- generated by GenerateRules.hs
{-# RULES
     "NP.fromIntegral :: Integer -> Int"     fromIntegral = P.fromIntegral :: Integer -> Int;
     "NP.fromIntegral :: Integer -> Integer" fromIntegral = P.fromIntegral :: Integer -> Integer;
     "NP.fromIntegral :: Integer -> Float"   fromIntegral = P.fromIntegral :: Integer -> Float;
     "NP.fromIntegral :: Integer -> Double"  fromIntegral = P.fromIntegral :: Integer -> Double;
     "NP.fromIntegral :: Int -> Int"         fromIntegral = P.fromIntegral :: Int -> Int;
     "NP.fromIntegral :: Int -> Integer"     fromIntegral = P.fromIntegral :: Int -> Integer;
     "NP.fromIntegral :: Int -> Float"       fromIntegral = P.fromIntegral :: Int -> Float;
     "NP.fromIntegral :: Int -> Double"      fromIntegral = P.fromIntegral :: Int -> Double;
     "NP.fromIntegral :: Int8 -> Int"        fromIntegral = P.fromIntegral :: Int8 -> Int;
     "NP.fromIntegral :: Int8 -> Integer"    fromIntegral = P.fromIntegral :: Int8 -> Integer;
     "NP.fromIntegral :: Int8 -> Float"      fromIntegral = P.fromIntegral :: Int8 -> Float;
     "NP.fromIntegral :: Int8 -> Double"     fromIntegral = P.fromIntegral :: Int8 -> Double;
     "NP.fromIntegral :: Int16 -> Int"       fromIntegral = P.fromIntegral :: Int16 -> Int;
     "NP.fromIntegral :: Int16 -> Integer"   fromIntegral = P.fromIntegral :: Int16 -> Integer;
     "NP.fromIntegral :: Int16 -> Float"     fromIntegral = P.fromIntegral :: Int16 -> Float;
     "NP.fromIntegral :: Int16 -> Double"    fromIntegral = P.fromIntegral :: Int16 -> Double;
     "NP.fromIntegral :: Int32 -> Int"       fromIntegral = P.fromIntegral :: Int32 -> Int;
     "NP.fromIntegral :: Int32 -> Integer"   fromIntegral = P.fromIntegral :: Int32 -> Integer;
     "NP.fromIntegral :: Int32 -> Float"     fromIntegral = P.fromIntegral :: Int32 -> Float;
     "NP.fromIntegral :: Int32 -> Double"    fromIntegral = P.fromIntegral :: Int32 -> Double;
     "NP.fromIntegral :: Int64 -> Int"       fromIntegral = P.fromIntegral :: Int64 -> Int;
     "NP.fromIntegral :: Int64 -> Integer"   fromIntegral = P.fromIntegral :: Int64 -> Integer;
     "NP.fromIntegral :: Int64 -> Float"     fromIntegral = P.fromIntegral :: Int64 -> Float;
     "NP.fromIntegral :: Int64 -> Double"    fromIntegral = P.fromIntegral :: Int64 -> Double;
     "NP.fromIntegral :: Word -> Int"        fromIntegral = P.fromIntegral :: Word -> Int;
     "NP.fromIntegral :: Word -> Integer"    fromIntegral = P.fromIntegral :: Word -> Integer;
     "NP.fromIntegral :: Word -> Float"      fromIntegral = P.fromIntegral :: Word -> Float;
     "NP.fromIntegral :: Word -> Double"     fromIntegral = P.fromIntegral :: Word -> Double;
     "NP.fromIntegral :: Word8 -> Int"       fromIntegral = P.fromIntegral :: Word8 -> Int;
     "NP.fromIntegral :: Word8 -> Integer"   fromIntegral = P.fromIntegral :: Word8 -> Integer;
     "NP.fromIntegral :: Word8 -> Float"     fromIntegral = P.fromIntegral :: Word8 -> Float;
     "NP.fromIntegral :: Word8 -> Double"    fromIntegral = P.fromIntegral :: Word8 -> Double;
     "NP.fromIntegral :: Word16 -> Int"      fromIntegral = P.fromIntegral :: Word16 -> Int;
     "NP.fromIntegral :: Word16 -> Integer"  fromIntegral = P.fromIntegral :: Word16 -> Integer;
     "NP.fromIntegral :: Word16 -> Float"    fromIntegral = P.fromIntegral :: Word16 -> Float;
     "NP.fromIntegral :: Word16 -> Double"   fromIntegral = P.fromIntegral :: Word16 -> Double;
     "NP.fromIntegral :: Word32 -> Int"      fromIntegral = P.fromIntegral :: Word32 -> Int;
     "NP.fromIntegral :: Word32 -> Integer"  fromIntegral = P.fromIntegral :: Word32 -> Integer;
     "NP.fromIntegral :: Word32 -> Float"    fromIntegral = P.fromIntegral :: Word32 -> Float;
     "NP.fromIntegral :: Word32 -> Double"   fromIntegral = P.fromIntegral :: Word32 -> Double;
     "NP.fromIntegral :: Word64 -> Int"      fromIntegral = P.fromIntegral :: Word64 -> Int;
     "NP.fromIntegral :: Word64 -> Integer"  fromIntegral = P.fromIntegral :: Word64 -> Integer;
     "NP.fromIntegral :: Word64 -> Float"    fromIntegral = P.fromIntegral :: Word64 -> Float;
     "NP.fromIntegral :: Word64 -> Double"   fromIntegral = P.fromIntegral :: Word64 -> Double;
  #-}


instance C Integer where {-#INLINE toInteger #-}; toInteger = id

instance C Int     where {-#INLINE toInteger #-}; toInteger = P.toInteger
instance C Int8    where {-#INLINE toInteger #-}; toInteger = P.toInteger
instance C Int16   where {-#INLINE toInteger #-}; toInteger = P.toInteger
instance C Int32   where {-#INLINE toInteger #-}; toInteger = P.toInteger
instance C Int64   where {-#INLINE toInteger #-}; toInteger = P.toInteger

instance C Word    where {-#INLINE toInteger #-}; toInteger = P.toInteger
instance C Word8   where {-#INLINE toInteger #-}; toInteger = P.toInteger
instance C Word16  where {-#INLINE toInteger #-}; toInteger = P.toInteger
instance C Word32  where {-#INLINE toInteger #-}; toInteger = P.toInteger
instance C Word64  where {-#INLINE toInteger #-}; toInteger = P.toInteger


instance (C a, PID.C a) => ToRational.C (Ratio.T a) where
   toRational (x:%y)   =  toInteger x :% toInteger y


{-|
A prefix function of '(Algebra.Ring.^)'
with a parameter order that fits the needs of partial application
and function composition.
It has generalised exponent.

See: Argument order of @expNat@ on
<http://www.haskell.org/pipermail/haskell-cafe/2006-September/018022.html>
-}
ringPower :: (Ring.C a, C b) => b -> a -> a
ringPower exponent basis = basis ^ toInteger exponent

{- |
A prefix function of '(Algebra.Field.^-)'.
It has a generalised exponent.
-}
fieldPower :: (Field.C a, C b) => b -> a -> a
fieldPower exponent basis = basis ^- toInteger exponent