-----------------------------------------------------------------------------
-- |
-- Module      :  Graphics.Rendering.Chart.Axis.Int
-- Copyright   :  (c) Tim Docker 2010, 2014
-- License     :  BSD-style (see chart/COPYRIGHT)
--
-- Calculate and render integer indexed axes
{-# OPTIONS_GHC -fno-warn-orphans #-}

module Graphics.Rendering.Chart.Axis.Int(
    defaultIntAxis,
    scaledIntAxis,
    autoScaledIntAxis
) where

import Data.List(genericLength)
import Data.Int (Int8, Int16, Int32, Int64)
import Data.Word (Word8, Word16, Word32, Word64)
import Graphics.Rendering.Chart.Geometry
import Graphics.Rendering.Chart.Axis.Types
import Graphics.Rendering.Chart.Axis.Floating

instance PlotValue Int where
    toValue :: Int -> Double
toValue    = forall a b. (Integral a, Num b) => a -> b
fromIntegral
    fromValue :: Double -> Int
fromValue  = forall a b. (RealFrac a, Integral b) => a -> b
round
    autoAxis :: AxisFn Int
autoAxis   = forall i.
(Integral i, PlotValue i) =>
LinearAxisParams i -> AxisFn i
autoScaledIntAxis forall a. Show a => LinearAxisParams a
defaultIntAxis

instance PlotValue Int8 where
    toValue :: Int8 -> Double
toValue    = forall a b. (Integral a, Num b) => a -> b
fromIntegral
    fromValue :: Double -> Int8
fromValue  = forall a b. (RealFrac a, Integral b) => a -> b
round
    autoAxis :: AxisFn Int8
autoAxis   = forall i.
(Integral i, PlotValue i) =>
LinearAxisParams i -> AxisFn i
autoScaledIntAxis forall a. Show a => LinearAxisParams a
defaultIntAxis

instance PlotValue Int16 where
    toValue :: Int16 -> Double
toValue    = forall a b. (Integral a, Num b) => a -> b
fromIntegral
    fromValue :: Double -> Int16
fromValue  = forall a b. (RealFrac a, Integral b) => a -> b
round
    autoAxis :: AxisFn Int16
autoAxis   = forall i.
(Integral i, PlotValue i) =>
LinearAxisParams i -> AxisFn i
autoScaledIntAxis forall a. Show a => LinearAxisParams a
defaultIntAxis

instance PlotValue Int32 where
    toValue :: Int32 -> Double
toValue    = forall a b. (Integral a, Num b) => a -> b
fromIntegral
    fromValue :: Double -> Int32
fromValue  = forall a b. (RealFrac a, Integral b) => a -> b
round
    autoAxis :: AxisFn Int32
autoAxis   = forall i.
(Integral i, PlotValue i) =>
LinearAxisParams i -> AxisFn i
autoScaledIntAxis forall a. Show a => LinearAxisParams a
defaultIntAxis

instance PlotValue Int64 where
    toValue :: Int64 -> Double
toValue    = forall a b. (Integral a, Num b) => a -> b
fromIntegral
    fromValue :: Double -> Int64
fromValue  = forall a b. (RealFrac a, Integral b) => a -> b
round
    autoAxis :: AxisFn Int64
autoAxis   = forall i.
(Integral i, PlotValue i) =>
LinearAxisParams i -> AxisFn i
autoScaledIntAxis forall a. Show a => LinearAxisParams a
defaultIntAxis

instance PlotValue Word where
    toValue :: Word -> Double
toValue    = forall a b. (Integral a, Num b) => a -> b
fromIntegral
    fromValue :: Double -> Word
fromValue  = forall a b. (RealFrac a, Integral b) => a -> b
round
    autoAxis :: AxisFn Word
autoAxis   = forall i.
(Integral i, PlotValue i) =>
LinearAxisParams i -> AxisFn i
autoScaledIntAxis forall a. Show a => LinearAxisParams a
defaultIntAxis

instance PlotValue Word8 where
    toValue :: Word8 -> Double
toValue    = forall a b. (Integral a, Num b) => a -> b
fromIntegral
    fromValue :: Double -> Word8
fromValue  = forall a b. (RealFrac a, Integral b) => a -> b
round
    autoAxis :: AxisFn Word8
autoAxis   = forall i.
(Integral i, PlotValue i) =>
LinearAxisParams i -> AxisFn i
autoScaledIntAxis forall a. Show a => LinearAxisParams a
defaultIntAxis

instance PlotValue Word16 where
    toValue :: Word16 -> Double
toValue    = forall a b. (Integral a, Num b) => a -> b
fromIntegral
    fromValue :: Double -> Word16
fromValue  = forall a b. (RealFrac a, Integral b) => a -> b
round
    autoAxis :: AxisFn Word16
autoAxis   = forall i.
(Integral i, PlotValue i) =>
LinearAxisParams i -> AxisFn i
autoScaledIntAxis forall a. Show a => LinearAxisParams a
defaultIntAxis

instance PlotValue Word32 where
    toValue :: Word32 -> Double
toValue    = forall a b. (Integral a, Num b) => a -> b
fromIntegral
    fromValue :: Double -> Word32
fromValue  = forall a b. (RealFrac a, Integral b) => a -> b
round
    autoAxis :: AxisFn Word32
autoAxis   = forall i.
(Integral i, PlotValue i) =>
LinearAxisParams i -> AxisFn i
autoScaledIntAxis forall a. Show a => LinearAxisParams a
defaultIntAxis

instance PlotValue Word64 where
    toValue :: Word64 -> Double
toValue    = forall a b. (Integral a, Num b) => a -> b
fromIntegral
    fromValue :: Double -> Word64
fromValue  = forall a b. (RealFrac a, Integral b) => a -> b
round
    autoAxis :: AxisFn Word64
autoAxis   = forall i.
(Integral i, PlotValue i) =>
LinearAxisParams i -> AxisFn i
autoScaledIntAxis forall a. Show a => LinearAxisParams a
defaultIntAxis

instance PlotValue Integer where
    toValue :: Integer -> Double
toValue    = forall a b. (Integral a, Num b) => a -> b
fromIntegral
    fromValue :: Double -> Integer
fromValue  = forall a b. (RealFrac a, Integral b) => a -> b
round
    autoAxis :: AxisFn Integer
autoAxis   = forall i.
(Integral i, PlotValue i) =>
LinearAxisParams i -> AxisFn i
autoScaledIntAxis forall a. Show a => LinearAxisParams a
defaultIntAxis

defaultIntAxis :: (Show a) => LinearAxisParams a
defaultIntAxis :: forall a. Show a => LinearAxisParams a
defaultIntAxis  = LinearAxisParams {
    _la_labelf :: [a] -> [String]
_la_labelf  = forall a b. (a -> b) -> [a] -> [b]
map forall a. Show a => a -> String
show,
    _la_nLabels :: Int
_la_nLabels = Int
5,
    _la_nTicks :: Int
_la_nTicks  = Int
10
}

autoScaledIntAxis :: (Integral i, PlotValue i) =>
                     LinearAxisParams i -> AxisFn i
autoScaledIntAxis :: forall i.
(Integral i, PlotValue i) =>
LinearAxisParams i -> AxisFn i
autoScaledIntAxis LinearAxisParams i
lap [i]
ps = forall i.
(Integral i, PlotValue i) =>
LinearAxisParams i -> (i, i) -> AxisFn i
scaledIntAxis LinearAxisParams i
lap (i, i)
rs [i]
ps
  where
    rs :: (i, i)
rs = (forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
minimum [i]
ps,forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum [i]
ps)

scaledIntAxis :: (Integral i, PlotValue i) =>
                 LinearAxisParams i -> (i,i) -> AxisFn i
scaledIntAxis :: forall i.
(Integral i, PlotValue i) =>
LinearAxisParams i -> (i, i) -> AxisFn i
scaledIntAxis LinearAxisParams i
lap (i
minI,i
maxI) [i]
ps =
    forall x.
PlotValue x =>
([x] -> [String]) -> ([x], [x], [x]) -> AxisData x
makeAxis (forall a. LinearAxisParams a -> [a] -> [String]
_la_labelf LinearAxisParams i
lap) ([i]
labelvs,[i]
tickvs,[i]
gridvs)
  where
    range :: [a] -> (a, b)
range []  = (a
0,b
1)
    range [a]
_   | i
minI forall a. Eq a => a -> a -> Bool
== i
maxI = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ i
minIforall a. Num a => a -> a -> a
-i
1, forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ i
minIforall a. Num a => a -> a -> a
+i
1)
              | Bool
otherwise    = (forall a b. (Integral a, Num b) => a -> b
fromIntegral   i
minI,   forall a b. (Integral a, Num b) => a -> b
fromIntegral   i
maxI)
--  labelvs  :: [i]
    labelvs :: [i]
labelvs   = forall a. Integral a => a -> Range -> [a]
stepsInt (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. LinearAxisParams a -> Int
_la_nLabels LinearAxisParams i
lap) Range
r
    tickvs :: [i]
tickvs    = forall a. Integral a => a -> Range -> [a]
stepsInt (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. LinearAxisParams a -> Int
_la_nTicks LinearAxisParams i
lap)
                                  ( forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
minimum [i]
labelvs
                                  , forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum [i]
labelvs )
    gridvs :: [i]
gridvs    = [i]
labelvs
    r :: Range
r         = forall {a} {b} {a}. (Num a, Num b) => [a] -> (a, b)
range [i]
ps

stepsInt :: Integral a => a -> Range -> [a]
stepsInt :: forall a. Integral a => a -> Range -> [a]
stepsInt a
nSteps Range
range = forall {a}. a -> [a] -> [[a]] -> [a]
bestSize (forall {a}. [a] -> a
goodness [a]
alt0) [a]
alt0 [[a]]
alts
  where
    bestSize :: a -> [a] -> [[a]] -> [a]
bestSize a
n [a]
a ([a]
a':[[a]]
as) = let n' :: a
n' = forall {a}. [a] -> a
goodness [a]
a' in
                           if a
n' forall a. Ord a => a -> a -> Bool
< a
n then a -> [a] -> [[a]] -> [a]
bestSize a
n' [a]
a' [[a]]
as else [a]
a
    bestSize a
_ [a]
_ []      = []

    goodness :: [a] -> a
goodness [a]
vs          = forall a. Num a => a -> a
abs (forall i a. Num i => [a] -> i
genericLength [a]
vs forall a. Num a => a -> a -> a
- a
nSteps)

    ([a]
alt0:[[a]]
alts)          = forall a b. (a -> b) -> [a] -> [b]
map (\a
n -> forall {a} {b} {a}.
(RealFrac b, RealFrac a, Integral a) =>
a -> (a, b) -> [a]
steps a
n Range
range) [a]
sampleSteps'

    -- throw away sampleSteps that are definitely too small as
    -- they takes a long time to process                           
    sampleSteps' :: [a]
sampleSteps'         = let rangeMag :: a
rangeMag = forall a b. (RealFrac a, Integral b) => a -> b
ceiling (forall a b. (a, b) -> b
snd Range
range forall a. Num a => a -> a -> a
- forall a b. (a, b) -> a
fst Range
range)
                               
                               ([a]
s1,[a]
s2) = forall a. (a -> Bool) -> [a] -> ([a], [a])
span (forall a. Ord a => a -> a -> Bool
< (a
rangeMag forall a. Integral a => a -> a -> a
`div` a
nSteps)) [a]
sampleSteps
                           in ((forall a. [a] -> [a]
reverse forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> [a]
take Int
5 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
reverse) [a]
s1) forall a. [a] -> [a] -> [a]
++ [a]
s2

    -- generate all possible step sizes
    sampleSteps :: [a]
sampleSteps          = [a
1,a
2,a
5] forall a. [a] -> [a] -> [a]
++ [a]
sampleSteps1
    sampleSteps1 :: [a]
sampleSteps1         = [a
10,a
20,a
25,a
50] forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall a. Num a => a -> a -> a
*a
10) [a]
sampleSteps1

    steps :: a -> (a, b) -> [a]
steps a
size (a
minV,b
maxV) = forall a. (a -> Bool) -> [a] -> [a]
takeWhile (forall a. Ord a => a -> a -> Bool
<a
b) [a
a,a
aforall a. Num a => a -> a -> a
+a
size..] forall a. [a] -> [a] -> [a]
++ [a
b]
      where
        a :: a
a = (forall a b. (RealFrac a, Integral b) => a -> b
floor   (a
minV forall a. Fractional a => a -> a -> a
/ forall a b. (Integral a, Num b) => a -> b
fromIntegral a
size)) forall a. Num a => a -> a -> a
* a
size
        b :: a
b = (forall a b. (RealFrac a, Integral b) => a -> b
ceiling (b
maxV forall a. Fractional a => a -> a -> a
/ forall a b. (Integral a, Num b) => a -> b
fromIntegral a
size)) forall a. Num a => a -> a -> a
* a
size