-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A lightweight plotting library, exporting to SVG
--   
--   A lightweight plotting library, exporting to SVG
@package plot-light
@version 0.1.2


-- | `plot-light` provides functionality for rendering vector graphics in
--   SVG format. It is geared in particular towards scientific plotting,
--   and it is termed "light" because it only requires a few common Haskell
--   dependencies and no external libraries.
--   
--   <h2>Usage</h2>
--   
--   To use this project you just need <tt>import
--   Graphics.Rendering.Plot.Light</tt>. If GHC complains of name clashes
--   you can import the module in "qualified" form.
--   
--   If you wish to try out the examples in this page, you will need to
--   have these additional import statements:
--   
--   <pre>
--   import Text.Blaze.Svg.Renderer.String (renderSvg)
--   </pre>
--   
--   <pre>
--   import qualified Data.Colour.Names as C
--   </pre>
module Graphics.Rendering.Plot.Light

-- | A rectangle, defined by its anchor point coordinates and side lengths
--   
--   <pre>
--   &gt; putStrLn $ renderSvg $ rect (Point 100 200) 30 60 2 Nothing (Just C.aquamarine)
--   &lt;rect x="100.0" y="200.0" width="30.0" height="60.0" fill="#7fffd4" stroke="none" stroke-width="2.0" /&gt;
--   </pre>
rect :: (Show a, RealFrac a) => Point a -> a -> a -> a -> Maybe (Colour Double) -> Maybe (Colour Double) -> Svg

-- | A rectangle, defined by its center coordinates and side lengths
--   
--   <pre>
--   &gt; putStrLn $ renderSvg $ rectCentered (Point 20 30) 15 30 (Just C.blue) (Just C.red)
--   &lt;g transform="translate(12.5 15.0)"&gt;&lt;rect width="15.0" height="30.0" fill="#ff0000" stroke="#0000ff" /&gt;&lt;/g&gt;
--   </pre>
rectCentered :: (Show a, RealFrac a) => Point a -> a -> a -> a -> Maybe (Colour Double) -> Maybe (Colour Double) -> Svg

-- | A circle
--   
--   <pre>
--   &gt; putStrLn $ renderSvg $ circle (Point 20 30) 15 (Just C.blue) (Just C.red)
--   &lt;circle cx="20.0" cy="30.0" r="15.0" fill="#ff0000" stroke="#0000ff" /&gt;
--   </pre>
circle :: (Real a1, Real a) => Point a1 -> a -> a -> Maybe (Colour Double) -> Maybe (Colour Double) -> Svg

-- | Line segment between two <a>Point</a>s
--   
--   <pre>
--   &gt; putStrLn $ renderSvg $ line (Point 0 0) (Point 1 1) 0.1 Continuous C.blueviolet
--   &lt;line x1="0.0" y1="0.0" x2="1.0" y2="1.0" stroke="#8a2be2" stroke-width="0.1" /&gt;
--   </pre>
--   
--   <pre>
--   &gt; putStrLn $ renderSvg (line (Point 0 0) (Point 1 1) 0.1 (Dashed [0.2, 0.3]) C.blueviolet)
--   &lt;line x1="0.0" y1="0.0" x2="1.0" y2="1.0" stroke="#8a2be2" stroke-width="0.1" stroke-dasharray="0.2, 0.3" /&gt;
--   </pre>
line :: (Show a, RealFrac a) => Point a -> Point a -> a -> LineStroke_ a -> Colour Double -> Svg

-- | <a>text</a> renders text onto the SVG canvas
--   
--   <h3>Conventions</h3>
--   
--   The <a>Point</a> argument <tt>p</tt> refers to the <i>lower-left</i>
--   corner of the text box.
--   
--   The text box can be rotated by <tt>rot</tt> degrees around <tt>p</tt>
--   and then anchored at either its beginning, middle or end to <tt>p</tt>
--   with the <a>TextAnchor_</a> flag.
--   
--   The user can supply an additional <a>V2</a> displacement which will be
--   applied <i>after</i> rotation and anchoring and refers to the rotated
--   text box frame.
--   
--   <pre>
--   &gt; putStrLn $ renderSvg $ text (-45) C.green TAEnd "blah" (V2 (- 10) 0) (Point 250 0)
--   &lt;text x="-10.0" y="0.0" transform="translate(250.0 0.0)rotate(-45.0)" fill="#008000" text-anchor="end"&gt;blah&lt;/text&gt;
--   </pre>
text :: (Show a, Real a) => a -> Int -> Colour Double -> TextAnchor_ -> Text -> V2 a -> Point a -> Svg

-- | Polyline (piecewise straight line)
--   
--   <pre>
--   &gt; putStrLn $ renderSvg (polyline [Point 100 50, Point 120 20, Point 230 50] 4 (Dashed [3, 5]) Round C.blueviolet)
--   &lt;polyline points="100.0,50.0 120.0,20.0 230.0,50.0" fill="none" stroke="#8a2be2" stroke-width="4.0" stroke-linejoin="round" stroke-dasharray="3.0, 5.0" /&gt;
--   </pre>
polyline :: (Foldable t, Show a1, Show a, RealFrac a, RealFrac a1) => t (Point a) -> a1 -> LineStroke_ a -> StrokeLineJoin_ -> Colour Double -> Svg

-- | A filled polyline
--   
--   <pre>
--   &gt; putStrLn $ renderSvg $ filledPolyline C.coral 0.3 [(Point 0 1), (Point 10 40), Point 34 50, Point 30 5]
--   &lt;polyline points="0,1 10,40 34,50 30,5" fill="#ff7f50" fill-opacity="0.3" /&gt;
--   </pre>
filledPolyline :: (Foldable t, Show a, Real o) => Colour Double -> o -> t (Point a) -> Svg

-- | A filled band of colour, given the coordinates of its center line
--   
--   This element can be used to overlay uncertainty ranges (e.g. the first
--   standard deviation) associated with a given data series.
filledBand :: (Foldable t, Real o, Show a) => Colour Double -> o -> (LabeledPoint l a -> a) -> (LabeledPoint l a -> a) -> t (LabeledPoint l a) -> Svg

-- | A <a>candlestick</a> glyph for time series plots. This is a type of
--   box glyph, commonly used in plotting financial time series.
--   
--   Some financial market quantities such as currency exchange rates are
--   aggregated over some time period (e.g. a day) and summarized by
--   various quantities, for example opening and closing rates, as well as
--   maximum and minimum over the period.
--   
--   By convention, the <a>candlestick</a> colour depends on the derivative
--   sign of one such quantity (e.g. it is green if the market closes
--   higher than it opened, and red otherwise).
candlestick :: (Show a, RealFrac a) => (LabeledPoint l a -> Bool) -> (LabeledPoint l a -> a) -> (LabeledPoint l a -> a) -> (LabeledPoint l a -> a) -> (LabeledPoint l a -> a) -> a -> a -> Colour Double -> Colour Double -> Colour Double -> LabeledPoint l a -> Svg

-- | <a>toPlot</a> performs a number of related operations:
--   
--   <ul>
--   <li>Maps the dataset to the figure frame</li>
--   <li>Renders the X, Y axes</li>
--   <li>Renders the transformed dataset onto the newly created plot
--   canvas</li>
--   </ul>
toPlot :: (Functor t, Foldable t, Show a, RealFrac a) => FigureData a -> (l -> Text) -> (l -> Text) -> a -> a -> a -> Colour Double -> Maybe (t (LabeledPoint l a)) -> Maybe (t (LabeledPoint l a)) -> (t (LabeledPoint l a) -> Svg) -> t (LabeledPoint l a) -> Svg

-- | Figure data
data FigureData a
FigureData :: a -> a -> a -> a -> a -> a -> Int -> FigureData a

-- | Figure width
[figWidth] :: FigureData a -> a

-- | Figure height
[figHeight] :: FigureData a -> a

-- | Left margin fraction (w.r.t figure width)
[figLeftMFrac] :: FigureData a -> a

-- | Right margin fraction (w.r.t figure width)
[figRightMFrac] :: FigureData a -> a

-- | Top margin fraction (w.r.t figure height)
[figTopMFrac] :: FigureData a -> a

-- | Bottom margin fraction (w.r.t figure height)
[figBottomMFrac] :: FigureData a -> a

-- | Tick label font size
[figLabelFontSize] :: FigureData a -> Int

-- | Specify a continuous or dashed stroke
data LineStroke_ a
Continuous :: LineStroke_ a
Dashed :: [a] -> LineStroke_ a

-- | Specify the type of connection between line segments
data StrokeLineJoin_
Miter :: StrokeLineJoin_
Round :: StrokeLineJoin_
Bevel :: StrokeLineJoin_
Inherit :: StrokeLineJoin_

-- | Specify at which end should the text be anchored to its current point
data TextAnchor_
TAStart :: TextAnchor_
TAMiddle :: TextAnchor_
TAEnd :: TextAnchor_

-- | Create the SVG header from a <a>Frame</a>
svgHeader :: Real a => Frame a -> Svg -> Svg

-- | A frame, i.e. a bounding box for objects
data Frame a
Frame :: Point a -> Point a -> Frame a
[_fpmin] :: Frame a -> Point a
[_fpmax] :: Frame a -> Point a

-- | A <a>Point</a> defines a point in R2
data Point a
Point :: a -> a -> Point a
[_px] :: Point a -> a
[_py] :: Point a -> a

-- | A <a>LabeledPoint</a> carries a "label" (i.e. any additional
--   information such as a text tag, or any other data structure), in
--   addition to position information. Data points on a plot are
--   <a>LabeledPoint</a>s.
data LabeledPoint l a
LabeledPoint :: Point a -> l -> LabeledPoint l a
[_lp] :: LabeledPoint l a -> Point a
[_lplabel] :: LabeledPoint l a -> l
labelPoint :: (Point a -> l) -> Point a -> LabeledPoint l a
data Axis
X :: Axis
Y :: Axis

-- | V2 is a vector in R^2
data V2 a
V2 :: a -> a -> V2 a

-- | A Mat2 can be seen as a linear operator that acts on points in the
--   plane
data Mat2 a
Mat2 :: a -> a -> a -> a -> Mat2 a

-- | Diagonal matrices in R2 behave as scaling transformations
data DiagMat2 a
DMat2 :: a -> a -> DiagMat2 a

-- | Create a diagonal matrix
diagMat2 :: Num a => a -> a -> DiagMat2 a

-- | The origin of the axes, point (0, 0)
origin :: Num a => Point a

-- | X-aligned unit vector
e1 :: Num a => V2 a

-- | Y-aligned unit vector
e2 :: Num a => V2 a

-- | Euclidean (L^2) norm
norm2 :: (Hermitian v, Floating n, n ~ (InnerProduct v)) => v -> n

-- | Normalize a V2 w.r.t. its Euclidean norm
normalize2 :: (InnerProduct v ~ Scalar v, Floating (Scalar v), Hermitian v) => v -> v

-- | Create a V2 <tt>v</tt> from two endpoints p1, p2. That is <tt>v</tt>
--   can be seen as pointing from <tt>p1</tt> to <tt>p2</tt>
v2fromEndpoints :: Num a => Point a -> Point a -> V2 a

-- | Build a <a>V2</a> v from a <a>Point</a> p (i.e. assuming v points from
--   the origin (0,0) to p)
v2fromPoint :: Num a => Point a -> V2 a

-- | Move a point along a vector
movePoint :: Num a => V2 a -> Point a -> Point a

-- | Move a <a>LabeledPoint</a> along a vector
moveLabeledPointV2 :: Num a => V2 a -> LabeledPoint l a -> LabeledPoint l a

-- | Create a V2 <tt>v</tt> from two endpoints p1, p2. That is <tt>v</tt>
--   can be seen as pointing from <tt>p1</tt> to <tt>p2</tt>
(-.) :: Num a => Point a -> Point a -> V2 a

-- | Move point to the SVG frame of reference (for which the origing is a
--   the top-left corner of the screen)
toSvgFrame :: Fractional a => Frame a -> Frame a -> Bool -> Point a -> Point a

-- | Move LabeledPoint to the SVG frame of reference (uses
--   <a>toSvgFrame</a> )
toSvgFrameLP :: Fractional a => Frame a -> Frame a -> Bool -> LabeledPoint l a -> LabeledPoint l a

-- | `pointRange n p q` returns a list of `n+1` equi-spaced <a>Point</a>s
--   between <tt>p</tt> and <tt>q</tt> (i.e. the input points are included
--   as the first and last points in the list)
pointRange :: (Fractional a, Integral n) => n -> Point a -> Point a -> [Point a]

-- | Given two frames <tt>F1</tt> and <tt>F2</tt>, returns a function
--   <tt>f</tt> that maps an arbitrary vector <tt>v</tt> contained within
--   <tt>F1</tt> onto one contained within <tt>F2</tt>.
--   
--   This function is composed of three affine maps :
--   
--   <ol>
--   <li>map <tt>v</tt> into a vector <tt>v01</tt> that points within the
--   unit square,</li>
--   <li>map <tt>v01</tt> onto <tt>v01'</tt>. This transformation serves to
--   e.g. flip the dataset along the y axis (since the origin of the SVG
--   canvas is the top-left corner of the screen). If this is not needed
--   one can just supply the identity matrix and the zero vector,</li>
--   <li>map <tt>v01'</tt> onto the target frame <tt>F2</tt>.</li>
--   </ol>
--   
--   NB: we do not check that <tt>v</tt> is actually contained within the
--   <tt>F1</tt>, nor that <tt>v01'</tt> is still contained within [0,1] x
--   [0, 1]. This has to be supplied correctly by the user.
frameToFrame :: Fractional a => Frame a -> Frame a -> Bool -> Bool -> V2 a -> V2 a

-- | Create a <a>Frame</a> from a container of <a>Point</a>s <tt>P</tt>,
--   i.e. construct two points <tt>p1</tt> and <tt>p2</tt> such that :
--   
--   p1 := inf(x,y) P p2 := sup(x,y) P
frameFromPoints :: (Ord a, Foldable t, Functor t) => t (Point a) -> Frame a
mkFrame :: Point a -> Point a -> Frame a

-- | Build a frame rooted at the origin (0, 0)
mkFrameOrigin :: Num a => a -> a -> Frame a

-- | The <a>width</a> is the extent in the <tt>x</tt> direction and
--   <a>height</a> is the extent in the <tt>y</tt> direction
width :: Num a => Frame a -> a

-- | The <a>width</a> is the extent in the <tt>x</tt> direction and
--   <a>height</a> is the extent in the <tt>y</tt> direction
height :: Num a => Frame a -> a

-- | Additive group :
--   
--   <pre>
--   v ^+^ zero == zero ^+^ v == v
--   </pre>
--   
--   <pre>
--   v ^-^ v == zero
--   </pre>
class AdditiveGroup v

-- | Identity element
zero :: AdditiveGroup v => v

-- | Group action ("sum")
(^+^) :: AdditiveGroup v => v -> v -> v

-- | Inverse group action ("subtraction")
(^-^) :: AdditiveGroup v => v -> v -> v

-- | Vector space : multiplication by a scalar quantity
class AdditiveGroup v => VectorSpace v where type Scalar v :: * where {
    type family Scalar v :: *;
}

-- | Scalar multiplication
(.*) :: VectorSpace v => Scalar v -> v -> v

-- | Hermitian space : inner product
class VectorSpace v => Hermitian v where type InnerProduct v :: * where {
    type family InnerProduct v :: *;
}

-- | Inner product
(<.>) :: Hermitian v => v -> v -> InnerProduct v

-- | Linear maps, i.e. linear transformations of vectors
class Hermitian v => LinearMap m v

-- | Matrix action, i.e. linear transformation of a vector
(#>) :: LinearMap m v => m -> v -> v

-- | Multiplicative matrix semigroup ("multiplying" two matrices together)
class MultiplicativeSemigroup m

-- | Matrix product
(##) :: MultiplicativeSemigroup m => m -> m -> m

-- | The class of invertible linear transformations
class LinearMap m v => MatrixGroup m v

-- | Inverse matrix action on a vector
(<\>) :: MatrixGroup m v => m -> v -> v

-- | Numerical equality
class Eps a

-- | Comparison within numerical precision
(~=) :: Eps a => a -> a -> Bool