module Chapter05 where

import Data.List (find)

sndItem0 :: [a] -> a
sndItem0 :: forall a. [a] -> a
sndItem0 [a]
as =
  if [a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [a]
as
    then [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"Empty list has no second element."
    else
      if [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
as Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1
        then [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"1-item list has no 2nd item."
        else [a]
as [a] -> Int -> a
forall a. HasCallStack => [a] -> Int -> a
!! Int
1

-- Return an infinite list of a single Int
repeatInt :: Int -> [Int]
repeatInt :: Int -> [Int]
repeatInt = Int -> [Int]
forall a. a -> [a]
repeat

null' :: [a] -> Bool
null' :: forall a. [a] -> Bool
null' [a]
as = [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
as Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0

last' :: [a] -> a
-- last' as = head $ reverse as
last' :: forall a. [a] -> a
last' = [a] -> a
forall a. HasCallStack => [a] -> a
head ([a] -> a) -> ([a] -> [a]) -> [a] -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [a]
forall a. [a] -> [a]
reverse

palindrome :: String -> Bool
palindrome :: [Char] -> Bool
palindrome [Char]
as = [Char] -> [Char]
forall a. [a] -> [a]
reverse [Char]
as [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
as

cycle' :: [a] -> [a]
cycle' :: forall a. [a] -> [a]
cycle' [] = [Char] -> [a]
forall a. HasCallStack => [Char] -> a
error [Char]
"empty list"
cycle' [a]
as = [[a]] -> [a]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[a]] -> [a]) -> [[a]] -> [a]
forall a b. (a -> b) -> a -> b
$ [a] -> [[a]]
forall a. a -> [a]
repeat [a]
as

type R = Double

euler :: R
euler :: R
euler = [R] -> R
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [R
1 R -> R -> R
forall a. Fractional a => a -> a -> a
/ Integer -> R
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
n R -> R -> R
forall a. Floating a => a -> a -> a
** R
2 | Integer
n <- [Integer
1 .. Integer
100]]

pi' :: R
pi' :: R
pi' = R -> R
forall a. Floating a => a -> a
sqrt (R -> R) -> R -> R
forall a b. (a -> b) -> a -> b
$ R
euler R -> R -> R
forall a. Num a => a -> a -> a
* R
6

fact :: Integer -> Integer
fact :: Integer -> Integer
fact Integer
n = [Integer] -> Integer
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
product [Integer
n, (Integer
n Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
1) .. Integer
1]

expList :: R -> [R]
expList :: R -> [R]
expList R
x = [(R
1 R -> R -> R
forall a. Num a => a -> a -> a
+ R
x R -> R -> R
forall a. Fractional a => a -> a -> a
/ R
n) R -> R -> R
forall a. Floating a => a -> a -> a
** R
n | R
n <- [R
1, R
2 ..]]

calcSeriesLengthWithinPercent :: (R -> [R]) -> (R -> R) -> R -> R -> Maybe Int
calcSeriesLengthWithinPercent :: (R -> [R]) -> (R -> R) -> R -> R -> Maybe Int
calcSeriesLengthWithinPercent R -> [R]
seriesFn R -> R
actFn R
pct R
x =
  (R, Int) -> Int
forall a b. (a, b) -> b
snd ((R, Int) -> Int) -> Maybe (R, Int) -> Maybe Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((R, Int) -> Bool) -> [(R, Int)] -> Maybe (R, Int)
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find (\(R, Int)
tup -> (R, Int) -> R
forall a b. (a, b) -> a
fst (R, Int)
tup R -> R -> Bool
forall a. Ord a => a -> a -> Bool
>= (R -> R
actFn R
x R -> R -> R
forall a. Num a => a -> a -> a
* ((R
100 R -> R -> R
forall a. Num a => a -> a -> a
- R
pct) R -> R -> R
forall a. Fractional a => a -> a -> a
/ R
100))) ([R] -> [Int] -> [(R, Int)]
forall a b. [a] -> [b] -> [(a, b)]
zip (R -> [R]
seriesFn R
x) [Int
1 ..])

expSeries :: R -> [R]
expSeries :: R -> [R]
expSeries R
x =
  let terms :: Integer -> [R]
      terms :: Integer -> [R]
terms Integer
i =
        [ R
x R -> Integer -> R
forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
m R -> R -> R
forall a. Fractional a => a -> a -> a
/ Integer -> R
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Integer
fact Integer
m)
          | Integer
m <- [Integer
0 .. Integer
i]
        ]
   in [[R] -> R
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([R] -> R) -> [R] -> R
forall a b. (a -> b) -> a -> b
$ Integer -> [R]
terms Integer
i | Integer
i <- [Integer
1 ..]]