module BishBosh.Cartesian.Ordinate(
yOrigin,
yLength,
yMin,
yMax,
yBounds,
yRange,
toIx,
fromIx,
firstRank,
lastRank,
pawnsFirstRank,
enPassantRank,
reflect,
translate,
maybeTranslate,
inBounds
) where
import qualified BishBosh.Attribute.LogicalColour as Attribute.LogicalColour
import qualified BishBosh.Cartesian.Abscissa as Cartesian.Abscissa
import qualified BishBosh.Data.Enum as Data.Enum
import qualified BishBosh.Property.Opposable as Property.Opposable
import qualified BishBosh.Type.Length as Type.Length
import qualified Control.Exception
import qualified Data.Array.IArray
yOrigin :: Int
yOrigin :: Int
yOrigin = Int
Cartesian.Abscissa.xOrigin
yLength :: Type.Length.Distance
yLength :: Int
yLength = Int
Cartesian.Abscissa.xLength
yMin :: Enum y => y
yMin :: y
yMin = Int -> y
forall a. Enum a => Int -> a
toEnum Int
yOrigin
yMax :: Enum y => y
yMax :: y
yMax = Int -> y
forall a. Enum a => Int -> a
toEnum (Int -> y) -> Int -> y
forall a b. (a -> b) -> a -> b
$ Int
yOrigin Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int
forall a. Enum a => a -> a
pred Int
yLength)
yBounds :: Enum y => (y, y)
yBounds :: (y, y)
yBounds = (y
forall y. Enum y => y
yMin, y
forall y. Enum y => y
yMax)
yRange :: Enum y => [y]
yRange :: [y]
yRange = (y -> y -> [y]) -> (y, y) -> [y]
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry y -> y -> [y]
forall a. Enum a => a -> a -> [a]
enumFromTo (y, y)
forall y. Enum y => (y, y)
yBounds
toIx :: Enum y => y -> Int
{-# INLINE toIx #-}
toIx :: y -> Int
toIx = Int -> Int -> Int
forall a. Num a => a -> a -> a
subtract Int
yOrigin (Int -> Int) -> (y -> Int) -> y -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. y -> Int
forall a. Enum a => a -> Int
fromEnum
fromIx :: Enum y => Int -> y
{-# INLINE fromIx #-}
fromIx :: Int -> y
fromIx = Int -> y
forall a. Enum a => Int -> a
toEnum (Int -> y) -> (Int -> Int) -> Int -> y
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
yOrigin)
firstRank :: Enum y => Attribute.LogicalColour.LogicalColour -> y
firstRank :: LogicalColour -> y
firstRank LogicalColour
Attribute.LogicalColour.Black = y
forall y. Enum y => y
yMax
firstRank LogicalColour
_ = y
forall y. Enum y => y
yMin
lastRank :: Enum y => Attribute.LogicalColour.LogicalColour -> y
lastRank :: LogicalColour -> y
lastRank = LogicalColour -> y
forall y. Enum y => LogicalColour -> y
firstRank (LogicalColour -> y)
-> (LogicalColour -> LogicalColour) -> LogicalColour -> y
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LogicalColour -> LogicalColour
forall a. Opposable a => a -> a
Property.Opposable.getOpposite
pawnsFirstRank :: Enum y => Attribute.LogicalColour.LogicalColour -> y
{-# INLINE pawnsFirstRank #-}
pawnsFirstRank :: LogicalColour -> y
pawnsFirstRank LogicalColour
Attribute.LogicalColour.Black = y -> y
forall a. Enum a => a -> a
pred y
forall y. Enum y => y
yMax
pawnsFirstRank LogicalColour
_ = y -> y
forall a. Enum a => a -> a
succ y
forall y. Enum y => y
yMin
enPassantRank :: Enum y => Attribute.LogicalColour.LogicalColour -> y
{-# INLINE enPassantRank #-}
enPassantRank :: LogicalColour -> y
enPassantRank LogicalColour
Attribute.LogicalColour.Black = Int -> y
forall a. Enum a => Int -> a
toEnum (Int -> y) -> Int -> y
forall a b. (a -> b) -> a -> b
$ Int
yOrigin Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3
enPassantRank LogicalColour
_ = Int -> y
forall a. Enum a => Int -> a
toEnum (Int -> y) -> Int -> y
forall a b. (a -> b) -> a -> b
$ Int
yOrigin Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4
reflect :: Enum y => y -> y
reflect :: y -> y
reflect = (Int -> Int) -> y -> y
forall a b. (Enum a, Enum b) => (Int -> Int) -> a -> b
Data.Enum.translate ((Int -> Int) -> y -> y) -> (Int -> Int) -> y -> y
forall a b. (a -> b) -> a -> b
$ (
Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
yOrigin Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int
forall a. Enum a => a -> a
pred Int
yLength))
) (Int -> Int) -> (Int -> Int) -> Int -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int
forall a. Num a => a -> a
negate
inBounds :: (Enum y, Ord y) => y -> Bool
{-# INLINE inBounds #-}
inBounds :: y -> Bool
inBounds y
y = y
y y -> y -> Bool
forall a. Ord a => a -> a -> Bool
>= y
forall y. Enum y => y
yMin Bool -> Bool -> Bool
&& y
y y -> y -> Bool
forall a. Ord a => a -> a -> Bool
<= y
forall y. Enum y => y
yMax
translate :: (Enum y, Ord y) => (y -> y) -> y -> y
translate :: (y -> y) -> y -> y
translate y -> y
transformation = (\y
y -> Bool -> y -> y
forall a. (?callStack::CallStack) => Bool -> a -> a
Control.Exception.assert (y -> Bool
forall y. (Enum y, Ord y) => y -> Bool
inBounds y
y) y
y) (y -> y) -> (y -> y) -> y -> y
forall b c a. (b -> c) -> (a -> b) -> a -> c
. y -> y
transformation
maybeTranslate :: (Enum y, Ord y) => (y -> y) -> y -> Maybe y
maybeTranslate :: (y -> y) -> y -> Maybe y
maybeTranslate y -> y
transformation = (
\y
y -> if y -> Bool
forall y. (Enum y, Ord y) => y -> Bool
inBounds y
y
then y -> Maybe y
forall a. a -> Maybe a
Just y
y
else Maybe y
forall a. Maybe a
Nothing
) (y -> Maybe y) -> (y -> y) -> y -> Maybe y
forall b c a. (b -> c) -> (a -> b) -> a -> c
. y -> y
transformation
type ArrayByOrdinate y = Data.Array.IArray.Array y
listArrayByOrdinate :: (
Data.Array.IArray.IArray a e,
Data.Array.IArray.Ix y,
Enum y
) => [e] -> a y e
listArrayByOrdinate :: [e] -> a y e
listArrayByOrdinate = (y, y) -> [e] -> a y e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [e] -> a i e
Data.Array.IArray.listArray (y, y)
forall y. Enum y => (y, y)
yBounds