{-# LANGUAGE ImportQualifiedPost #-}
{-# LANGUAGE OverloadedStrings #-}
{-# OPTIONS_HADDOCK prune #-}

-- |
-- A set of (very useful) utility functions, which notably include
-- 'display' and 'displayInformational'.
module Data.SigFig.Util where

import Data.BigDecimal (BigDecimal (..))
import Data.BigDecimal qualified as BD
import Data.SigFig.Types hiding (div)
import Data.Text (Text)
import Data.Text qualified as T
import GHC.Natural (naturalFromInteger)
import GHC.Real (Ratio ((:%)), (%))

-- | Get the rightmost significant decimal place given a number of
-- significant figures @sf@ and a BigDecimal @bd@. It is as if one
-- were calculating the value for a @Measured sf bd@.
--
-- A negative return value is allowed and meaningful.
--
-- >>> rightmostSignificantPlace 2 (BigDecimal 42 1)
-- -1
rightmostSignificantPlace :: Integer -> BigDecimal -> Integer
rightmostSignificantPlace :: Integer -> BigDecimal -> Integer
rightmostSignificantPlace Integer
sf BigDecimal
bd =
  let v' :: BigDecimal
v' = BigDecimal -> BigDecimal
BD.nf BigDecimal
bd
      dp :: Natural
dp = BigDecimal -> Natural
BD.scale BigDecimal
v'
      p :: Natural
p = BigDecimal -> Natural
BD.precision BigDecimal
v'
   in Natural -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
p Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
sf Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Natural -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
dp

-- | Force a given BigDecimal to have a certain number of significant
-- decimal places. A positive integer means to the left of decimal place,
-- negative means to the right.
--
-- ==== __Examples__
--
-- >>> forceDP (-2) (fromRational 123.456)
-- Measured {numSigFigs = 5, value = 123.46}
--
-- >>> forceDP 2 (fromRational 123.456)
-- Measured {numSigFigs = 1, value = 100}
forceDP :: Integer -> BigDecimal -> Term
forceDP :: Integer -> BigDecimal -> Term
forceDP Integer
dp BigDecimal
bd =
  let res :: BigDecimal
res = BigDecimal -> BigDecimal
BD.nf (BigDecimal -> BigDecimal) -> BigDecimal -> BigDecimal
forall a b. (a -> b) -> a -> b
$ BigDecimal -> Integer -> BigDecimal
roundToPlace BigDecimal
bd Integer
dp
   in Integer -> BigDecimal -> Term
Measured (Integer -> Integer -> Integer
forall a. Ord a => a -> a -> a
max Integer
0 (Integer -> Integer) -> Integer -> Integer
forall a b. (a -> b) -> a -> b
$ Natural -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (BigDecimal -> Natural
BD.precision BigDecimal
res) Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Natural -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (BigDecimal -> Natural
BD.scale BigDecimal
res) Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
dp) BigDecimal
res

-- | Force a given BigDecimal to have a certain number of significant figures.
-- A positive integer means to the left of decimal place, negative means to the right.
forceSF :: Integer -> BigDecimal -> Term
forceSF :: Integer -> BigDecimal -> Term
forceSF Integer
sf' BigDecimal
bd = Integer -> BigDecimal -> Term
Measured Integer
sf' (BigDecimal -> Term)
-> (BigDecimal -> BigDecimal) -> BigDecimal -> Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BigDecimal -> Integer -> BigDecimal
roundToPlace BigDecimal
bd (Integer -> BigDecimal)
-> (BigDecimal -> Integer) -> BigDecimal -> BigDecimal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> BigDecimal -> Integer
rightmostSignificantPlace Integer
sf' (BigDecimal -> Term) -> BigDecimal -> Term
forall a b. (a -> b) -> a -> b
$ BigDecimal
bd

-- | Round a BigDecimal to a specified decimal place. A positive integer means
-- to the left of decimal place, negative means to the right.
--
-- >>> roundToPlace (BigDecimal 421 1) (0)
-- 42
roundToPlace :: BigDecimal -> Integer -> BigDecimal
roundToPlace :: BigDecimal -> Integer -> BigDecimal
roundToPlace bd :: BigDecimal
bd@(BigDecimal Integer
v Natural
s) Integer
dp
  | Integer
dp Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0 = BigDecimal -> RoundingAdvice -> BigDecimal
BD.roundBD BigDecimal
bd (RoundingAdvice -> BigDecimal) -> RoundingAdvice -> BigDecimal
forall a b. (a -> b) -> a -> b
$ Natural -> RoundingAdvice
BD.halfUp (Integer -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral (- Integer
dp))
  | Bool
otherwise =
    let bd' :: BigDecimal
bd' = Integer -> Natural -> BigDecimal
BigDecimal Integer
v (Natural
s Natural -> Natural -> Natural
forall a. Num a => a -> a -> a
+ Integer -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
dp)
     in BigDecimal -> RoundingAdvice -> BigDecimal
BD.roundBD BigDecimal
bd' (Natural -> RoundingAdvice
BD.halfUp Natural
0) BigDecimal -> BigDecimal -> BigDecimal
forall a. Num a => a -> a -> a
* BigDecimal
10 BigDecimal -> Integer -> BigDecimal
forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
dp

-- | Given a term, display it in the most convenient way possible. This means,
-- if the normal representation of the number accurately represents how many
-- significant figures it has, then display it normally. Adds trailing zeroes
-- if necessary to floats and opts for scientific notation if necessary.
--
-- ==== __Examples__
--
-- >>> display $ measured 3 200
-- "200."
--
-- >>> display $ measured 3 4
-- "4.00"
--
-- >>> display $ measured 2 400
-- "4.0 x 10^2"
--
-- >>> display $ measured 2 430
-- "430"
--
-- >>> display $ measured 1 1
-- "1"
--
-- >>> display $ constant (3 % 8)
-- "0.375"
--
-- >>> display $ constant (4 % 9)
-- "4/9"
--
-- >>> display $ measured 2 4.3
-- "4.3"
display :: Term -> Text
display :: Term -> Text
display (Measured Integer
sf BigDecimal
bd) = BigDecimal -> Text
format BigDecimal
bd
  where
    ssf :: Text
ssf = String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Integer -> String
forall a. Show a => a -> String
show Integer
sf
    format :: BigDecimal -> Text
    format :: BigDecimal -> Text
format BigDecimal
term' =
      let term :: BigDecimal
term@(BigDecimal Integer
v Natural
s') = BigDecimal -> BigDecimal
BD.nf BigDecimal
term'
          s :: Integer
s = Natural -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
s' :: Integer
          termText :: Text
termText = String -> Text
T.pack (String -> Text) -> (BigDecimal -> String) -> BigDecimal -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BigDecimal -> String
forall a. Show a => a -> String
show (BigDecimal -> Text) -> BigDecimal -> Text
forall a b. (a -> b) -> a -> b
$ BigDecimal
term
          p :: Integer
p = Natural -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (BigDecimal -> Natural
BD.precision BigDecimal
term) :: Integer
          rsdp :: Integer
rsdp = Integer
p Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
sf Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
s
          rsd :: Integer
rsd = if Integer
sf Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
p then Integer
0 else Integer
v Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
`div` (Integer
10 Integer -> Integer -> Integer
forall a b. (Num a, Integral b) => a -> b -> a
^ (Integer
rsdp Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
s)) Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
`mod` Integer
10
       in if Integer
rsd Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
/= Integer
0 Bool -> Bool -> Bool
|| Integer
rsdp Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0 Bool -> Bool -> Bool
&& Integer
p Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
1
            then Text
termText
            else
              if Integer
rsdp Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>= Integer
1
                then let coef :: BigDecimal
coef = Integer -> Natural -> BigDecimal
BigDecimal Integer
v (Integer -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer
s Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ (Integer
p Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
1))) in BigDecimal -> Text
format BigDecimal
coef Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" x 10^" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> String -> Text
T.pack (Integer -> String
forall a. Show a => a -> String
show (Integer -> String) -> Integer -> String
forall a b. (a -> b) -> a -> b
$ Integer
p Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
1)
                else
                  Text
termText
                    Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> (if Integer
s Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
0 then Text
"" else Text
".")
                    Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text -> Text
T.replicate (Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Int) -> Integer -> Int
forall a b. (a -> b) -> a -> b
$ Integer
sf Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
p) Text
"0"
display (Constant v :: Rational
v@(Integer
a :% Integer
b)) =
  String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$
    if Integer -> Bool
isTerminating Integer
b
      then BigDecimal -> String
forall a. Show a => a -> String
show (BigDecimal -> String)
-> (BigDecimal -> BigDecimal) -> BigDecimal -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BigDecimal -> BigDecimal
BD.nf (BigDecimal -> String) -> BigDecimal -> String
forall a b. (a -> b) -> a -> b
$ Rational -> BigDecimal
forall a. Fractional a => Rational -> a
fromRational Rational
v
      else Integer -> String
forall a. Show a => a -> String
show Integer
a String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"/" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Integer -> String
forall a. Show a => a -> String
show Integer
b

-- | Used in the CLI. Not super pretty but gets the job done in terms of displaying enough information.
--
-- ==== __Examples__
--
-- >>> displayFull (constant 3.45)
-- "3.45 (const)"
--
-- >>> displayFull (measured 3 8500)
-- "8.50 x 10^3 (3 s.f.)"
displayFull :: Term -> Text
displayFull :: Term -> Text
displayFull t :: Term
t@(Measured Integer
sf BigDecimal
bd) = Term -> Text
display Term
t Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
annot
  where
    annot :: Text
annot = Text
" (" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> String -> Text
T.pack (Integer -> String
forall a. Show a => a -> String
show Integer
sf) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" s.f.)"
displayFull t :: Term
t@(Constant (Integer
a :% Integer
b)) = Term -> Text
display Term
t Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
annot
  where
    annot :: Text
annot = if Integer -> Bool
isTerminating Integer
b then Text
" (const)" else Text
" (non-terminating const)"

-- | Given a term, return a tuple where the first element is the output of display and the second is an annotation of the type of value. Used in the API.
--
-- ==== __Examples__
--
-- >>> displayInformational $ constant 3
-- ("3","constant value")
--
-- >>> displayInformational $ measured 2 3.4
-- ("3.4","2 significant figures")
--
-- >>> displayInformational $ measured 3 3400
-- ("3.40 x 10^3","3 significant figures")
displayInformational :: Term -> (Text, Text)
displayInformational :: Term -> (Text, Text)
displayInformational t :: Term
t@(Measured Integer
sf BigDecimal
bd) = (Term -> Text
display Term
t, Text
annot)
  where
    annot :: Text
annot = String -> Text
T.pack (Integer -> String
forall a. Show a => a -> String
show Integer
sf) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" significant figure" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> if Integer
sf Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
/= Integer
1 then Text
"s" else Text
forall a. Monoid a => a
mempty
displayInformational t :: Term
t@(Constant (Integer
a :% Integer
b)) = (Term -> Text
display Term
t, Text
annot)
  where
    annot :: Text
annot = if Integer -> Bool
isTerminating Integer
b then Text
"constant value" else Text
"constant, non-terminating decimal value"

-- | Given a denominator, tell if the decimal expansion of the fraction terminates.
-- Useful for telling whether a constant value is a terminating or non-terminating value.
-- But one should probably use 'displayInformational' to extract such information.
isTerminating :: Integer -> Bool
isTerminating :: Integer -> Bool
isTerminating = (Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
1) (Integer -> Bool) -> (Integer -> Integer) -> Integer -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
stripFactor Integer
5 (Integer -> Integer) -> (Integer -> Integer) -> Integer -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
stripFactor Integer
2
  where
    stripFactor :: p -> p -> p
stripFactor p
d p
n = case p
n p -> p -> (p, p)
forall a. Integral a => a -> a -> (a, a)
`quotRem` p
d of
      (p
q, p
0) -> p -> p -> p
stripFactor p
d p
q
      (p, p)
_ -> p
n