{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE FlexibleInstances #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Data.Fixed
-- Copyright   :  (c) Ashley Yakeley 2005, 2006, 2009
--
-- Maintainer  :  Ashley Yakeley <ashley@semantic.org>
-- Stability   :  experimental
-- Portability :  portable
--
-- This module defines a \"Fixed\" type for fixed-precision arithmetic.
-- The parameter to 'Fixed' is any type that's an instance of 'HasResolution'.
-- 'HasResolution' has a single method that gives the resolution of the 'Fixed'
-- type.
--
-- This module also contains generalisations of 'div', 'mod', and 'divMod' to
-- work with any 'Real' instance.
--
-----------------------------------------------------------------------------

module Data.Fixed
(
div',mod',divMod',

Fixed(..), HasResolution(..),
showFixed,
E0,Uni,
E1,Deci,
E2,Centi,
E3,Milli,
E6,Micro,
E9,Nano,
E12,Pico
) where

import Data.Data
import GHC.TypeLits (KnownNat, natVal)

default () -- avoid any defaulting shenanigans

-- | Generalisation of 'div' to any instance of 'Real'
div' :: (Real a,Integral b) => a -> a -> b
div' :: forall a b. (Real a, Integral b) => a -> a -> b
div' a
n a
d = forall a b. (RealFrac a, Integral b) => a -> b
floor ((forall a. Real a => a -> Rational
toRational a
n) forall a. Fractional a => a -> a -> a
/ (forall a. Real a => a -> Rational
toRational a
d))

-- | Generalisation of 'divMod' to any instance of 'Real'
divMod' :: (Real a,Integral b) => a -> a -> (b,a)
divMod' :: forall a b. (Real a, Integral b) => a -> a -> (b, a)
divMod' a
n a
d = (b
f,a
n forall a. Num a => a -> a -> a
- (forall a b. (Integral a, Num b) => a -> b
fromIntegral b
f) forall a. Num a => a -> a -> a
* a
d) where
f :: b
f = forall a b. (Real a, Integral b) => a -> a -> b
div' a
n a
d

-- | Generalisation of 'mod' to any instance of 'Real'
mod' :: (Real a) => a -> a -> a
mod' :: forall a. Real a => a -> a -> a
mod' a
n a
d = a
n forall a. Num a => a -> a -> a
- (forall a. Num a => Integer -> a
fromInteger Integer
f) forall a. Num a => a -> a -> a
* a
d where
f :: Integer
f = forall a b. (Real a, Integral b) => a -> a -> b
div' a
n a
d

-- | The type parameter should be an instance of 'HasResolution'.
newtype Fixed (a :: k) = MkFixed Integer
deriving ( Fixed a -> Fixed a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k (a :: k). Fixed a -> Fixed a -> Bool
/= :: Fixed a -> Fixed a -> Bool
\$c/= :: forall k (a :: k). Fixed a -> Fixed a -> Bool
== :: Fixed a -> Fixed a -> Bool
\$c== :: forall k (a :: k). Fixed a -> Fixed a -> Bool
Eq  -- ^ @since 2.01
, Fixed a -> Fixed a -> Bool
Fixed a -> Fixed a -> Ordering
Fixed a -> Fixed a -> Fixed a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall k (a :: k). Eq (Fixed a)
forall k (a :: k). Fixed a -> Fixed a -> Bool
forall k (a :: k). Fixed a -> Fixed a -> Ordering
forall k (a :: k). Fixed a -> Fixed a -> Fixed a
min :: Fixed a -> Fixed a -> Fixed a
\$cmin :: forall k (a :: k). Fixed a -> Fixed a -> Fixed a
max :: Fixed a -> Fixed a -> Fixed a
\$cmax :: forall k (a :: k). Fixed a -> Fixed a -> Fixed a
>= :: Fixed a -> Fixed a -> Bool
\$c>= :: forall k (a :: k). Fixed a -> Fixed a -> Bool
> :: Fixed a -> Fixed a -> Bool
\$c> :: forall k (a :: k). Fixed a -> Fixed a -> Bool
<= :: Fixed a -> Fixed a -> Bool
\$c<= :: forall k (a :: k). Fixed a -> Fixed a -> Bool
< :: Fixed a -> Fixed a -> Bool
\$c< :: forall k (a :: k). Fixed a -> Fixed a -> Bool
compare :: Fixed a -> Fixed a -> Ordering
\$ccompare :: forall k (a :: k). Fixed a -> Fixed a -> Ordering
Ord -- ^ @since 2.01
)

-- We do this because the automatically derived Data instance requires (Data a) context.
-- Our manual instance has the more general (Typeable a) context.
tyFixed :: DataType
tyFixed :: DataType
tyFixed = String -> [Constr] -> DataType
mkDataType String
"Data.Fixed.Fixed" [Constr
conMkFixed]
conMkFixed :: Constr
conMkFixed :: Constr
conMkFixed = DataType -> String -> [String] -> Fixity -> Constr
mkConstr DataType
tyFixed String
"MkFixed" [] Fixity
Prefix

-- | @since 4.1.0.0
instance (Typeable k,Typeable a) => Data (Fixed (a :: k)) where
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fixed a -> c (Fixed a)
gfoldl forall d b. Data d => c (d -> b) -> d -> c b
k forall g. g -> c g
z (MkFixed Integer
a) = forall d b. Data d => c (d -> b) -> d -> c b
k (forall g. g -> c g
z forall k (a :: k). Integer -> Fixed a
MkFixed) Integer
a
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Fixed a)
gunfold forall b r. Data b => c (b -> r) -> c r
k forall r. r -> c r
z Constr
_ = forall b r. Data b => c (b -> r) -> c r
k (forall r. r -> c r
z forall k (a :: k). Integer -> Fixed a
MkFixed)
dataTypeOf :: Fixed a -> DataType
dataTypeOf Fixed a
_ = DataType
tyFixed
toConstr :: Fixed a -> Constr
toConstr Fixed a
_ = Constr
conMkFixed

class HasResolution (a :: k) where
resolution ::

-- | For example, @Fixed 1000@ will give you a 'Fixed' with a resolution of 1000.
instance  where
resolution :: forall (p :: Nat -> *). p n -> Integer
resolution p n
_ = forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (forall {k} (t :: k). Proxy t
Proxy :: Proxy n)

withType :: (Proxy a -> f a) -> f a
withType :: forall {k} (a :: k) (f :: k -> *). (Proxy a -> f a) -> f a
withType Proxy a -> f a
foo = Proxy a -> f a
foo forall {k} (t :: k). Proxy t
Proxy

withResolution :: (HasResolution a) => (Integer -> f a) -> f a
withResolution :: forall {k} (a :: k) (f :: k -> *).
HasResolution a =>
(Integer -> f a) -> f a
withResolution Integer -> f a
foo = forall {k} (a :: k) (f :: k -> *). (Proxy a -> f a) -> f a
withType (Integer -> f a
foo forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k (a :: k) (p :: k -> *). HasResolution a => p a -> Integer
resolution)

-- | @since 2.01
--
-- Recall that, for numeric types, 'succ' and 'pred' typically add and subtract
-- @1@, respectively. This is not true in the case of 'Fixed', whose successor
-- and predecessor functions intuitively return the "next" and "previous" values
-- in the enumeration. The results of these functions thus depend on the
-- resolution of the 'Fixed' value. For example, when enumerating values of
-- resolution @10^-3@ of @type Milli = Fixed E3@,
--
-- @
--   succ (0.000 :: Milli) == 1.001
-- @
--
--
-- and likewise
--
-- @
--   pred (0.000 :: Milli) == -0.001
-- @
--
--
-- In other words, 'succ' and 'pred' increment and decrement a fixed-precision
-- value by the least amount such that the value's resolution is unchanged.
-- For example, @10^-12@ is the smallest (positive) amount that can be added to
-- a value of @type Pico = Fixed E12@ without changing its resolution, and so
--
-- @
--   succ (0.000000000000 :: Pico) == 0.000000000001
-- @
--
--
-- and similarly
--
-- @
--   pred (0.000000000000 :: Pico) == -0.000000000001
-- @
--
--
-- This is worth bearing in mind when defining 'Fixed' arithmetic sequences. In
-- particular, you may be forgiven for thinking the sequence
--
-- @
--   [1..10] :: [Pico]
-- @
--
--
-- evaluates to @[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] :: [Pico]@.
--
-- However, this is not true. On the contrary, similarly to the above
-- implementations of 'succ' and 'pred', @enumFromTo :: Pico -> Pico -> [Pico]@
-- has a "step size" of @10^-12@. Hence, the list @[1..10] :: [Pico]@ has
-- the form
--
-- @
--   [1.000000000000, 1.00000000001, 1.00000000002, ..., 10.000000000000]
-- @
--
--
-- and contains @9 * 10^12 + 1@ values.
instance  where
succ :: Fixed a -> Fixed a
succ (MkFixed Integer
a) = forall k (a :: k). Integer -> Fixed a
MkFixed (forall a. Enum a => a -> a
succ Integer
a)
pred :: Fixed a -> Fixed a
pred (MkFixed Integer
a) = forall k (a :: k). Integer -> Fixed a
MkFixed (forall a. Enum a => a -> a
pred Integer
a)
toEnum :: Int -> Fixed a
toEnum = forall k (a :: k). Integer -> Fixed a
MkFixed forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => Int -> a
toEnum
fromEnum :: Fixed a -> Int
a) = forall a. Enum a => a -> Int
a
enumFrom :: Fixed a -> [Fixed a]
enumFrom (MkFixed Integer
a) = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall k (a :: k). Integer -> Fixed a
MkFixed (forall a. Enum a => a -> [a]
enumFrom Integer
a)
enumFromThen :: Fixed a -> Fixed a -> [Fixed a]
enumFromThen (MkFixed Integer
a) (MkFixed Integer
b) = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall k (a :: k). Integer -> Fixed a
MkFixed (forall a. Enum a => a -> a -> [a]
enumFromThen Integer
a Integer
b)
enumFromTo :: Fixed a -> Fixed a -> [Fixed a]
enumFromTo (MkFixed Integer
a) (MkFixed Integer
b) = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall k (a :: k). Integer -> Fixed a
MkFixed (forall a. Enum a => a -> a -> [a]
enumFromTo Integer
a Integer
b)
enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a]
enumFromThenTo (MkFixed Integer
a) (MkFixed Integer
b) (MkFixed Integer
c) = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall k (a :: k). Integer -> Fixed a
MkFixed (forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo Integer
a Integer
b Integer
c)

-- | @since 2.01
instance (HasResolution a) => Num (Fixed a) where
(MkFixed Integer
a) + :: Fixed a -> Fixed a -> Fixed a
+ (MkFixed Integer
b) = forall k (a :: k). Integer -> Fixed a
MkFixed (Integer
a forall a. Num a => a -> a -> a
+ Integer
b)
(MkFixed Integer
a) - :: Fixed a -> Fixed a -> Fixed a
- (MkFixed Integer
b) = forall k (a :: k). Integer -> Fixed a
MkFixed (Integer
a forall a. Num a => a -> a -> a
- Integer
b)
fa :: Fixed a
fa@(MkFixed Integer
a) * :: Fixed a -> Fixed a -> Fixed a
* (MkFixed Integer
b) = forall k (a :: k). Integer -> Fixed a
MkFixed (forall a. Integral a => a -> a -> a
div (Integer
a forall a. Num a => a -> a -> a
* Integer
b) (forall k (a :: k) (p :: k -> *). HasResolution a => p a -> Integer
resolution Fixed a
fa))
negate :: Fixed a -> Fixed a
negate (MkFixed Integer
a) = forall k (a :: k). Integer -> Fixed a
MkFixed (forall a. Num a => a -> a
negate Integer
a)
abs :: Fixed a -> Fixed a
abs (MkFixed Integer
a) = forall k (a :: k). Integer -> Fixed a
MkFixed (forall a. Num a => a -> a
abs Integer
a)
signum :: Fixed a -> Fixed a
signum (MkFixed Integer
a) = forall a. Num a => Integer -> a
fromInteger (forall a. Num a => a -> a
signum Integer
a)
fromInteger :: Integer -> Fixed a
fromInteger Integer
i = forall {k} (a :: k) (f :: k -> *).
HasResolution a =>
(Integer -> f a) -> f a
withResolution (\Integer
res -> forall k (a :: k). Integer -> Fixed a
MkFixed (Integer
i forall a. Num a => a -> a -> a
* Integer
res))

-- | @since 2.01
instance (HasResolution a) => Real (Fixed a) where
toRational :: Fixed a -> Rational
toRational fa :: Fixed a
fa@(MkFixed Integer
a) = (forall a. Real a => a -> Rational
toRational Integer
a) forall a. Fractional a => a -> a -> a
/ (forall a. Real a => a -> Rational
toRational (forall k (a :: k) (p :: k -> *). HasResolution a => p a -> Integer
resolution Fixed a
fa))

-- | @since 2.01
instance  where
fa :: Fixed a
fa@(MkFixed Integer
a) / :: Fixed a -> Fixed a -> Fixed a
/ (MkFixed Integer
b) = forall k (a :: k). Integer -> Fixed a
MkFixed (forall a. Integral a => a -> a -> a
div (Integer
a forall a. Num a => a -> a -> a
* (forall k (a :: k) (p :: k -> *). HasResolution a => p a -> Integer
resolution Fixed a
fa)) Integer
b)
recip :: Fixed a -> Fixed a
recip fa :: Fixed a
fa@(MkFixed Integer
a) = forall k (a :: k). Integer -> Fixed a
MkFixed (forall a. Integral a => a -> a -> a
div (Integer
res forall a. Num a => a -> a -> a
* Integer
res) Integer
a) where
res :: Integer
res = forall k (a :: k) (p :: k -> *). HasResolution a => p a -> Integer
resolution Fixed a
fa
fromRational :: Rational -> Fixed a
fromRational Rational
r = forall {k} (a :: k) (f :: k -> *).
HasResolution a =>
(Integer -> f a) -> f a
withResolution (\Integer
res -> forall k (a :: k). Integer -> Fixed a
MkFixed (forall a b. (RealFrac a, Integral b) => a -> b
floor (Rational
r forall a. Num a => a -> a -> a
* (forall a. Real a => a -> Rational
toRational Integer
res))))

-- | @since 2.01
instance  where
properFraction :: forall b. Integral b => Fixed a -> (b, Fixed a)
properFraction Fixed a
a = (b
i,Fixed a
a forall a. Num a => a -> a -> a
- (forall a b. (Integral a, Num b) => a -> b
fromIntegral b
i)) where
i :: b
i = forall a b. (RealFrac a, Integral b) => a -> b
truncate Fixed a
a
truncate :: forall b. Integral b => Fixed a -> b
truncate Fixed a
f = forall a b. (RealFrac a, Integral b) => a -> b
truncate (forall a. Real a => a -> Rational
toRational Fixed a
f)
round :: forall b. Integral b => Fixed a -> b
round Fixed a
f = forall a b. (RealFrac a, Integral b) => a -> b
round (forall a. Real a => a -> Rational
toRational Fixed a
f)
ceiling :: forall b. Integral b => Fixed a -> b
ceiling Fixed a
f = forall a b. (RealFrac a, Integral b) => a -> b
ceiling (forall a. Real a => a -> Rational
toRational Fixed a
f)
floor :: forall b. Integral b => Fixed a -> b
floor Fixed a
f = forall a b. (RealFrac a, Integral b) => a -> b
floor (forall a. Real a => a -> Rational
toRational Fixed a
f)

chopZeros :: Integer -> String
chopZeros :: Integer -> String
chopZeros Integer
0 = String
""
chopZeros Integer
a | forall a. Integral a => a -> a -> a
mod Integer
a Integer
10 forall a. Eq a => a -> a -> Bool
== Integer
0 = Integer -> String
chopZeros (forall a. Integral a => a -> a -> a
div Integer
a Integer
10)
chopZeros Integer
a = forall a. Show a => a -> String
show Integer
a

-- only works for positive a
showIntegerZeros :: Bool -> Int -> Integer -> String
showIntegerZeros :: Bool -> Int -> Integer -> String
showIntegerZeros Bool
True Int
_ Integer
0 = String
""
showIntegerZeros  Int
digits Integer
a = forall a. Int -> a -> [a]
replicate (Int
digits forall a. Num a => a -> a -> a
- forall (t :: * -> *) a. Foldable t => t a -> Int
length String
s) Char
'0' forall a. [a] -> [a] -> [a]
++ String
s' where
s :: String
s = forall a. Show a => a -> String
show Integer
a
s' :: String
s' = if  then Integer -> String
chopZeros Integer
a else String
s

withDot :: String -> String
withDot :: String -> String
withDot String
"" = String
""
withDot String
s = Char
'.'forall a. a -> [a] -> [a]
:String
s

-- | First arg is whether to chop off trailing zeros
showFixed :: (HasResolution a) => Bool -> Fixed a -> String
showFixed :: forall {k} (a :: k). HasResolution a => Bool -> Fixed a -> String
showFixed  fa :: Fixed a
fa@(MkFixed Integer
a) | Integer
a forall a. Ord a => a -> a -> Bool
< Integer
0 = String
"-" forall a. [a] -> [a] -> [a]
++ (forall {k} (a :: k). HasResolution a => Bool -> Fixed a -> String
showFixed  (forall a. a -> a -> a
asTypeOf (forall k (a :: k). Integer -> Fixed a
MkFixed (forall a. Num a => a -> a
negate Integer
a)) Fixed a
fa))
showFixed  fa :: Fixed a
fa@(MkFixed Integer
a) = (forall a. Show a => a -> String
show Integer
i) forall a. [a] -> [a] -> [a]
++ (String -> String
withDot (Bool -> Int -> Integer -> String
showIntegerZeros  Int
digits Integer
fracNum)) where
res :: Integer
res = forall k (a :: k) (p :: k -> *). HasResolution a => p a -> Integer
resolution Fixed a
fa
(Integer
i,Integer
d) = forall a. Integral a => a -> a -> (a, a)
divMod Integer
a Integer
res
-- enough digits to be unambiguous
digits :: Int
digits = forall a b. (RealFrac a, Integral b) => a -> b
ceiling (forall a. Floating a => a -> a -> a
logBase Double
10 (forall a. Num a => Integer -> a
fromInteger Integer
res) :: Double)
maxnum :: Integer
maxnum = Integer
10 forall a b. (Num a, Integral b) => a -> b -> a
^ Int
digits
-- read floors, so show must ceil for `read . show = id` to hold. See #9240
fracNum :: Integer
fracNum = forall a. Integral a => a -> a -> a
divCeil (Integer
d forall a. Num a => a -> a -> a
* Integer
maxnum) Integer
res
divCeil :: a -> a -> a
divCeil a
x a
y = (a
x forall a. Num a => a -> a -> a
+ a
y forall a. Num a => a -> a -> a
- a
1) forall a. Integral a => a -> a -> a
`div` a
y

-- | @since 2.01
instance (HasResolution a) => Show (Fixed a) where
showsPrec :: Int -> Fixed a -> String -> String
showsPrec Int
p Fixed a
n = Bool -> (String -> String) -> String -> String
showParen (Int
p forall a. Ord a => a -> a -> Bool
> Int
6 Bool -> Bool -> Bool
&& Fixed a
n forall a. Ord a => a -> a -> Bool
< Fixed a
0) forall a b. (a -> b) -> a -> b
\$ String -> String -> String
showString forall a b. (a -> b) -> a -> b
\$ forall {k} (a :: k). HasResolution a => Bool -> Fixed a -> String
showFixed Bool
False Fixed a
n

-- | @since 4.3.0.0
instance (HasResolution a) => Read (Fixed a) where
readNumber forall {k} (a :: k).
HasResolution a =>
convertFixed

convertFixed :: forall a . HasResolution a => Lexeme -> ReadPrec (Fixed a)
convertFixed :: forall {k} (a :: k).
HasResolution a =>
convertFixed (Number Number
n)
| Just (Integer
i, Integer
f) <- Integer -> Number -> Maybe (Integer, Integer)
numberToFixed Integer
e Number
n =
forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. Num a => Integer -> a
fromInteger Integer
i forall a. Num a => a -> a -> a
+ (forall a. Num a => Integer -> a
fromInteger Integer
f forall a. Fractional a => a -> a -> a
/ (Fixed a
10 forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
e)))
where r :: Integer
r = forall k (a :: k) (p :: k -> *). HasResolution a => p a -> Integer
resolution (forall {k} (t :: k). Proxy t
Proxy :: Proxy a)
-- round 'e' up to help make the 'read . show == id' property
-- possible also for cases where 'resolution' is not a
-- power-of-10, such as e.g. when 'resolution = 128'
e :: Integer
e = forall a b. (RealFrac a, Integral b) => a -> b
ceiling (forall a. Floating a => a -> a -> a
logBase Double
10 (forall a. Num a => Integer -> a
fromInteger Integer
r) :: Double)
convertFixed Lexeme
_ = forall a. ReadPrec a
pfail

data E0

-- | @since 4.1.0.0
instance HasResolution E0 where
resolution :: forall (p :: * -> *). p E0 -> Integer
resolution p E0
_ = Integer
1
-- | resolution of 1, this works the same as Integer
type Uni = Fixed E0

data E1

-- | @since 4.1.0.0
instance HasResolution E1 where
resolution :: forall (p :: * -> *). p E1 -> Integer
resolution p E1
_ = Integer
10
-- | resolution of 10^-1 = .1
type Deci = Fixed E1

data E2

-- | @since 4.1.0.0
instance HasResolution E2 where
resolution :: forall (p :: * -> *). p E2 -> Integer
resolution p E2
_ = Integer
100
-- | resolution of 10^-2 = .01, useful for many monetary currencies
type Centi = Fixed E2

data E3

-- | @since 4.1.0.0
instance HasResolution E3 where
resolution :: forall (p :: * -> *). p E3 -> Integer
resolution p E3
_ = Integer
1000
-- | resolution of 10^-3 = .001
type Milli = Fixed E3

data E6

-- | @since 2.01
instance HasResolution E6 where
resolution :: forall (p :: * -> *). p E6 -> Integer
resolution p E6
_ = Integer
1000000
-- | resolution of 10^-6 = .000001
type Micro = Fixed E6

data E9

-- | @since 4.1.0.0
instance HasResolution E9 where
resolution :: forall (p :: * -> *). p E9 -> Integer
resolution p E9
_ = Integer
1000000000
-- | resolution of 10^-9 = .000000001
type Nano = Fixed E9

data E12

-- | @since 2.01
instance HasResolution E12 where
resolution :: forall (p :: * -> *). p E12 -> Integer
resolution p E12
_ = Integer
1000000000000
-- | resolution of 10^-12 = .000000000001
type Pico = Fixed E12