-- |
-- Module      : Foundation.Numerical
-- License     : BSD-style
-- Maintainer  : Vincent Hanquez <vincent@snarc.org>
-- Stability   : experimental
-- Portability : portable
--
-- Compared to the Haskell hierarchy of number classes
-- this provide a more flexible approach that is closer to the
-- mathematical foundation (group, field, etc)
--
-- This try to only provide one feature per class, at the expense of
-- the number of classes.
--
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeSynonymInstances #-}
module Foundation.Numerical
    ( IsIntegral(..)
    , IsNatural(..)
    , Signed(..)
    , Additive(..)
    , Subtractive(..)
    , Multiplicative(..)
    , IDivisible(..)
    , Divisible(..)
    , Sign(..)
    , recip
    , IntegralRounding(..)
    , FloatingPoint(..)
    ) where

import           Basement.Compat.Base
import           Basement.Numerical.Number
import           Basement.Numerical.Additive
import           Basement.Numerical.Subtractive
import           Basement.Numerical.Multiplicative
import           Foundation.Numerical.Floating
import qualified Prelude

-- | Sign of a signed number
data Sign = SignNegative | SignZero | SignPositive
    deriving (Sign -> Sign -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sign -> Sign -> Bool
$c/= :: Sign -> Sign -> Bool
== :: Sign -> Sign -> Bool
$c== :: Sign -> Sign -> Bool
Eq)

orderingToSign :: Ordering -> Sign
orderingToSign :: Ordering -> Sign
orderingToSign Ordering
EQ = Sign
SignZero
orderingToSign Ordering
GT = Sign
SignNegative
orderingToSign Ordering
LT = Sign
SignPositive

-- | types that have sign and can be made absolute
class Signed a where
    {-# MINIMAL abs, signum #-}
    abs    :: a -> a
    signum :: a -> Sign

instance Signed Integer where
    abs :: Integer -> Integer
abs = forall a. Num a => a -> a
Prelude.abs
    signum :: Integer -> Sign
signum = Ordering -> Sign
orderingToSign forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. Ord a => a -> a -> Ordering
compare Integer
0
instance Signed Int where
    abs :: Int -> Int
abs = forall a. Num a => a -> a
Prelude.abs
    signum :: Int -> Sign
signum = Ordering -> Sign
orderingToSign forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. Ord a => a -> a -> Ordering
compare Int
0
instance Signed Int8 where
    abs :: Int8 -> Int8
abs = forall a. Num a => a -> a
Prelude.abs
    signum :: Int8 -> Sign
signum = Ordering -> Sign
orderingToSign forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. Ord a => a -> a -> Ordering
compare Int8
0
instance Signed Int16 where
    abs :: Int16 -> Int16
abs = forall a. Num a => a -> a
Prelude.abs
    signum :: Int16 -> Sign
signum = Ordering -> Sign
orderingToSign forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. Ord a => a -> a -> Ordering
compare Int16
0
instance Signed Int32 where
    abs :: Int32 -> Int32
abs = forall a. Num a => a -> a
Prelude.abs
    signum :: Int32 -> Sign
signum = Ordering -> Sign
orderingToSign forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. Ord a => a -> a -> Ordering
compare Int32
0
instance Signed Int64 where
    abs :: Int64 -> Int64
abs = forall a. Num a => a -> a
Prelude.abs
    signum :: Int64 -> Sign
signum = Ordering -> Sign
orderingToSign forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. Ord a => a -> a -> Ordering
compare Int64
0
instance Signed Float where
    abs :: Float -> Float
abs = forall a. Num a => a -> a
Prelude.abs
    signum :: Float -> Sign
signum = Ordering -> Sign
orderingToSign forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. Ord a => a -> a -> Ordering
compare Float
0
instance Signed Double where
    abs :: Double -> Double
abs = forall a. Num a => a -> a
Prelude.abs
    signum :: Double -> Sign
signum = Ordering -> Sign
orderingToSign forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. Ord a => a -> a -> Ordering
compare Double
0

class IntegralRounding a where
    -- | Round up, to the next integral.
    --
    -- Also known as 'ceiling'
    roundUp       :: Integral n => a -> n

    -- | Round down, to the previous integral
    --
    -- Also known as 'floor'
    roundDown     :: Integral n => a -> n

    -- | Truncate to the closest integral to the fractional number
    -- closer to 0.
    --
    -- This is equivalent to roundUp for negative Number
    -- and roundDown for positive Number
    roundTruncate :: Integral n => a -> n

    -- | Round to the nearest integral
    --
    -- > roundNearest 3.6
    -- 4
    -- > roundNearest 3.4
    -- 3
    roundNearest  :: Integral n => a -> n

instance IntegralRounding Prelude.Rational where
    roundUp :: forall n. Integral n => Rational -> n
roundUp       = forall a. Integral a => Integer -> a
fromInteger forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. (RealFrac a, Integral b) => a -> b
Prelude.ceiling
    roundDown :: forall n. Integral n => Rational -> n
roundDown     = forall a. Integral a => Integer -> a
fromInteger forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. (RealFrac a, Integral b) => a -> b
Prelude.floor
    roundTruncate :: forall n. Integral n => Rational -> n
roundTruncate = forall a. Integral a => Integer -> a
fromInteger forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. (RealFrac a, Integral b) => a -> b
Prelude.truncate
    roundNearest :: forall n. Integral n => Rational -> n
roundNearest  = forall a. Integral a => Integer -> a
fromInteger forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. (RealFrac a, Integral b) => a -> b
Prelude.round

instance IntegralRounding Prelude.Double where
    roundUp :: forall n. Integral n => Double -> n
roundUp       = forall a. Integral a => Integer -> a
fromInteger forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. (RealFrac a, Integral b) => a -> b
Prelude.ceiling
    roundDown :: forall n. Integral n => Double -> n
roundDown     = forall a. Integral a => Integer -> a
fromInteger forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. (RealFrac a, Integral b) => a -> b
Prelude.floor
    roundTruncate :: forall n. Integral n => Double -> n
roundTruncate = forall a. Integral a => Integer -> a
fromInteger forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. (RealFrac a, Integral b) => a -> b
Prelude.truncate
    roundNearest :: forall n. Integral n => Double -> n
roundNearest  = forall a. Integral a => Integer -> a
fromInteger forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. (RealFrac a, Integral b) => a -> b
Prelude.round

instance IntegralRounding Prelude.Float where
    roundUp :: forall n. Integral n => Float -> n
roundUp       = forall a. Integral a => Integer -> a
fromInteger forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. (RealFrac a, Integral b) => a -> b
Prelude.ceiling
    roundDown :: forall n. Integral n => Float -> n
roundDown     = forall a. Integral a => Integer -> a
fromInteger forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. (RealFrac a, Integral b) => a -> b
Prelude.floor
    roundTruncate :: forall n. Integral n => Float -> n
roundTruncate = forall a. Integral a => Integer -> a
fromInteger forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. (RealFrac a, Integral b) => a -> b
Prelude.truncate
    roundNearest :: forall n. Integral n => Float -> n
roundNearest  = forall a. Integral a => Integer -> a
fromInteger forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. (RealFrac a, Integral b) => a -> b
Prelude.round