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


-- | Numbers that are range representations
--   
--   Numbers that represent ranges of all sorts.
@package numhask-range
@version 0.1.0


-- | A <a>Space</a> represents a continuous interval of a type a. The
--   <a>interval</a> package is an alternative approach.
module NumHask.Space
class (Eq (Element s), Ord (Element s), Field (Element s)) => Space s where type Element s :: * type Grid s :: * mid s = (lower s + upper s) / (one + one) width s = upper s - lower s singular s = lower s == upper s element a s = a >= lower s && a <= upper s contains s0 s1 = lower s0 <= lower s1 && upper s0 >= upper s1 space = foldr (\ a x -> x `union` singleton a) nul project s0 s1 p = ((p - lower s0) / (upper s0 - lower s0)) * (upper s1 - lower s1) + lower s1 where {
    type family Element s :: *;
    type family Grid s :: *;
}

-- | lower boundary of space
lower :: Space s => s -> Element s

-- | upper boundary of space
upper :: Space s => s -> Element s

-- | mid-point of the space
mid :: Space s => s -> Element s

-- | distance between boundaries
width :: Space s => s -> Element s

-- | singleton space
singleton :: Space s => Element s -> s

-- | zero-width test
singular :: Space s => s -> Bool

-- | determine whether an a is in the space
element :: Space s => Element s -> s -> Bool

-- | is a space contained within another?
contains :: Space s => s -> s -> Bool

-- | convex hull
union :: Space s => s -> s -> s

-- | null space, which can be interpreted as mempty
nul :: Space s => s

-- | the containing space of a Foldable
space :: (Space s, Foldable f) => f (Element s) -> s

-- | project a data point from an old range to a new range
--   
--   project o n (lower o) == lower n
--   
--   project o n (upper o) == upper n
--   
--   project a a == id
project :: Space s => s -> s -> Element s -> Element s

-- | create equally-spaced <tt>a</tt>s from a space
grid :: Space s => Pos -> s -> Grid s -> [Element s]

-- | create equally-spaced `Space a`s from a space
gridSpace :: Space s => s -> Grid s -> [s]

-- | Pos suggests where data points are placed on a grid across a range.
--   Pos can also be thought about as whether the lower and upper points on
--   the range are open or closed (plus the mid-point as an extra option).
data Pos
OuterPos :: Pos
InnerPos :: Pos
LowerPos :: Pos
UpperPos :: Pos
MidPos :: Pos
instance GHC.Classes.Eq NumHask.Space.Pos


-- | 'Range -0.5 0.5 :: Range Double' is a 1-dimensional instance of a
--   'Space Double' from -0.5 to 0.5 on the Double number line.
--   
--   The instances chosen for <a>Range</a> are conducive to Charting.
--   Specifically:
--   
--   <ul>
--   <li>a Range is polymorphic, with the main constraint being 'Ord
--   a'</li>
--   <li><a>Additive</a> and <a>Multiplicative</a> instances define numeric
--   manipulation rather than relying on the <a>Num</a> class in base.</li>
--   <li>'(+)' and '(&lt;&gt;)' are defined as the convex hull of two
--   ranges (compare the interval package approach for + of `fmap (+)`).
--   <a>zero</a> and <a>mempty</a> are defined as `Range infinity
--   neginfinity`. This arrangement targets a neat definition for
--   conversion of a foldable into a range via a very neat `foldMap
--   singleton`. An additional benefit is that Ranges are additively
--   idempotent (a + a = a).</li>
--   <li>The starting point for understanding Range multiplication is the
--   diagrams <a>unitSquare</a>. Restricting consideration to
--   one-dimension, a natural <a>one</a> Range is `Range -0.5 0.5`, which
--   uniquely satisfies the equations:</li>
--   </ul>
--   
--   `mid one == zero` `width one == one`
--   
--   where the right zero and one refer to the underlying type.
module NumHask.Range

-- | Range is a newtype wrapped (a,a) tuple
newtype Range a
Range' :: (a, a) -> Range a

-- | A tuple is the preferred concrete implementation of a Range, due to
--   many libraries having substantial optimizations for tuples already (eg
--   <tt>Vector</tt>). 'Pattern Synonyms' allow us to recover a constructor
--   without the need for tuple syntax. &gt;&gt;&gt; Range 0 1 Range 0 1

-- | turn a range into n <tt>a</tt>s pleasing to human sense and
--   sensibility the <tt>a</tt>s may well lie outside the original range as
--   a result
gridSensible :: (Fractional a, Ord a, FromInteger a, QuotientField a, ExpField a) => Pos -> Range a -> Int -> [a]
instance GHC.Generics.Generic (NumHask.Range.Range a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (NumHask.Range.Range a)
instance GHC.Show.Show a => GHC.Show.Show (NumHask.Range.Range a)
instance Data.Functor.Classes.Eq1 NumHask.Range.Range
instance Data.Functor.Classes.Show1 NumHask.Range.Range
instance GHC.Base.Functor NumHask.Range.Range
instance Data.Functor.Bind.Class.Apply NumHask.Range.Range
instance GHC.Base.Applicative NumHask.Range.Range
instance GHC.Base.Monad NumHask.Range.Range
instance Data.Foldable.Foldable NumHask.Range.Range
instance Data.Semigroup.Foldable.Class.Foldable1 NumHask.Range.Range
instance Data.Traversable.Traversable NumHask.Range.Range
instance Data.Semigroup.Traversable.Class.Traversable1 NumHask.Range.Range
instance Data.Distributive.Distributive NumHask.Range.Range
instance Data.Functor.Rep.Representable NumHask.Range.Range
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (NumHask.Range.Range a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (NumHask.Range.Range a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Field.BoundedField a, NumHask.Algebra.Integral.FromInteger a) => NumHask.Algebra.Multiplicative.MultiplicativeMagma (NumHask.Range.Range a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Field.BoundedField a, NumHask.Algebra.Integral.FromInteger a) => NumHask.Algebra.Multiplicative.MultiplicativeUnital (NumHask.Range.Range a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Integral.FromInteger a, NumHask.Algebra.Field.BoundedField a) => NumHask.Algebra.Multiplicative.MultiplicativeAssociative (NumHask.Range.Range a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Integral.FromInteger a, NumHask.Algebra.Field.BoundedField a) => NumHask.Algebra.Multiplicative.MultiplicativeInvertible (NumHask.Range.Range a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Field.BoundedField a, NumHask.Algebra.Integral.FromInteger a) => NumHask.Algebra.Multiplicative.MultiplicativeCommutative (NumHask.Range.Range a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Field.BoundedField a, NumHask.Algebra.Integral.FromInteger a) => NumHask.Algebra.Multiplicative.Multiplicative (NumHask.Range.Range a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Field.BoundedField a, NumHask.Algebra.Integral.FromInteger a) => NumHask.Algebra.Multiplicative.MultiplicativeGroup (NumHask.Range.Range a)
instance (NumHask.Algebra.Additive.AdditiveInvertible a, NumHask.Algebra.Field.BoundedField a, GHC.Classes.Ord a, NumHask.Algebra.Integral.FromInteger a) => NumHask.Algebra.Metric.Signed (NumHask.Range.Range a)
instance NumHask.Algebra.Additive.AdditiveGroup a => NumHask.Algebra.Metric.Normed (NumHask.Range.Range a) a
instance (GHC.Classes.Ord a, NumHask.Algebra.Additive.AdditiveGroup a) => NumHask.Algebra.Metric.Metric (NumHask.Range.Range a) a
instance (GHC.Classes.Ord a, NumHask.Algebra.Field.BoundedField a, NumHask.Algebra.Integral.FromInteger a) => NumHask.Space.Space (NumHask.Range.Range a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Field.BoundedField a, NumHask.Algebra.Integral.FromInteger a) => GHC.Base.Monoid (NumHask.Range.Range a)

module NumHask.Pair

-- | A Pair
--   
--   <pre>
--   &gt;&gt;&gt; fmap (+1) (Pair 1 2)
--   Pair 2 3
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; pure one :: Pair Int
--   Pair 1 1
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; (*) &lt;$&gt; Pair 1 2 &lt;*&gt; pure 2
--   Pair 2 4
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; foldr (++) [] (Pair [1,2] [3])
--   [1,2,3]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Pair "a" "pair" &lt;&gt; pure " " &lt;&gt; Pair "string" "mappend"
--   Pair "a string" "pair mappend"
--   </pre>
--   
--   | numerics &gt;&gt;&gt; Pair 0 1 + zero Pair 0 1
--   
--   <pre>
--   &gt;&gt;&gt; Pair 0 1 + Pair 2 3
--   Pair 2 4
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Pair 1 1 - one
--   Pair 0 0
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Pair 0 1 * one
--   Pair 0 1
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Pair 0 1 / one
--   Pair 0.0 1.0
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Pair 11 12 `mod` (pure 6)
--   Pair 5 0
--   </pre>
--   
--   | module &gt;&gt;&gt; Pair 1 2 .+ 3 Pair 4 5
--   
--   | representations &gt;&gt;&gt; distribute [Pair 1 2, Pair 3 4] Pair
--   [1,3] [2,4]
--   
--   <pre>
--   &gt;&gt;&gt; index (Pair 'l' 'r') LPair
--   'l'
--   </pre>
--   
--   A pair of a's, implemented as a tuple, but api represented as a Pair
--   of a's.
newtype Pair a
Pair' :: (a, a) -> Pair a
instance GHC.Generics.Generic (NumHask.Pair.Pair a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (NumHask.Pair.Pair a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (NumHask.Pair.Pair a)
instance GHC.Show.Show a => GHC.Show.Show (NumHask.Pair.Pair a)
instance GHC.Base.Functor NumHask.Pair.Pair
instance Data.Functor.Classes.Eq1 NumHask.Pair.Pair
instance Data.Functor.Classes.Show1 NumHask.Pair.Pair
instance Data.Functor.Bind.Class.Apply NumHask.Pair.Pair
instance GHC.Base.Applicative NumHask.Pair.Pair
instance GHC.Base.Monad NumHask.Pair.Pair
instance Data.Foldable.Foldable NumHask.Pair.Pair
instance Data.Semigroup.Foldable.Class.Foldable1 NumHask.Pair.Pair
instance Data.Traversable.Traversable NumHask.Pair.Pair
instance Data.Semigroup.Traversable.Class.Traversable1 NumHask.Pair.Pair
instance GHC.Base.Monoid a => GHC.Base.Monoid (NumHask.Pair.Pair a)
instance Data.Distributive.Distributive NumHask.Pair.Pair
instance Data.Functor.Rep.Representable NumHask.Pair.Pair
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (NumHask.Pair.Pair a)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (NumHask.Pair.Pair a)
instance NumHask.Algebra.Additive.AdditiveMagma a => NumHask.Algebra.Additive.AdditiveMagma (NumHask.Pair.Pair a)
instance NumHask.Algebra.Additive.AdditiveUnital a => NumHask.Algebra.Additive.AdditiveUnital (NumHask.Pair.Pair a)
instance NumHask.Algebra.Additive.AdditiveMagma a => NumHask.Algebra.Additive.AdditiveAssociative (NumHask.Pair.Pair a)
instance NumHask.Algebra.Additive.AdditiveMagma a => NumHask.Algebra.Additive.AdditiveCommutative (NumHask.Pair.Pair a)
instance NumHask.Algebra.Additive.AdditiveUnital a => NumHask.Algebra.Additive.Additive (NumHask.Pair.Pair a)
instance NumHask.Algebra.Additive.AdditiveInvertible a => NumHask.Algebra.Additive.AdditiveInvertible (NumHask.Pair.Pair a)
instance (NumHask.Algebra.Additive.AdditiveUnital a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Additive.AdditiveGroup (NumHask.Pair.Pair a)
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma a => NumHask.Algebra.Multiplicative.MultiplicativeMagma (NumHask.Pair.Pair a)
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital a => NumHask.Algebra.Multiplicative.MultiplicativeUnital (NumHask.Pair.Pair a)
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma a => NumHask.Algebra.Multiplicative.MultiplicativeAssociative (NumHask.Pair.Pair a)
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma a => NumHask.Algebra.Multiplicative.MultiplicativeCommutative (NumHask.Pair.Pair a)
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital a => NumHask.Algebra.Multiplicative.Multiplicative (NumHask.Pair.Pair a)
instance NumHask.Algebra.Multiplicative.MultiplicativeInvertible a => NumHask.Algebra.Multiplicative.MultiplicativeInvertible (NumHask.Pair.Pair a)
instance (NumHask.Algebra.Multiplicative.MultiplicativeUnital a, NumHask.Algebra.Multiplicative.MultiplicativeInvertible a) => NumHask.Algebra.Multiplicative.MultiplicativeGroup (NumHask.Pair.Pair a)
instance NumHask.Algebra.Integral.Integral a => NumHask.Algebra.Integral.Integral (NumHask.Pair.Pair a)
instance NumHask.Algebra.Metric.Signed a => NumHask.Algebra.Metric.Signed (NumHask.Pair.Pair a)
instance (NumHask.Algebra.Field.ExpField a, NumHask.Algebra.Additive.AdditiveGroup a, NumHask.Algebra.Multiplicative.MultiplicativeUnital a) => NumHask.Algebra.Metric.Normed (NumHask.Pair.Pair a) a
instance NumHask.Algebra.Metric.Epsilon a => NumHask.Algebra.Metric.Epsilon (NumHask.Pair.Pair a)
instance NumHask.Algebra.Field.ExpField a => NumHask.Algebra.Metric.Metric (NumHask.Pair.Pair a) a
instance (NumHask.Algebra.Additive.AdditiveGroup a, NumHask.Algebra.Distribution.Distribution a) => NumHask.Algebra.Distribution.Distribution (NumHask.Pair.Pair a)
instance NumHask.Algebra.Ring.Ring a => NumHask.Algebra.Ring.Ring (NumHask.Pair.Pair a)
instance (NumHask.Algebra.Additive.AdditiveGroup a, NumHask.Algebra.Ring.Semiring a) => NumHask.Algebra.Ring.Semiring (NumHask.Pair.Pair a)
instance NumHask.Algebra.Ring.CRing a => NumHask.Algebra.Ring.CRing (NumHask.Pair.Pair a)
instance NumHask.Algebra.Field.Field a => NumHask.Algebra.Field.Field (NumHask.Pair.Pair a)
instance NumHask.Algebra.Field.ExpField a => NumHask.Algebra.Field.ExpField (NumHask.Pair.Pair a)
instance NumHask.Algebra.Field.BoundedField a => NumHask.Algebra.Field.BoundedField (NumHask.Pair.Pair a)

module NumHask.Rect

-- | a two-dimensional plane, implemented as a composite of a <a>Pair</a>
--   of <a>Range</a>s.
newtype Rect a
Rect' :: (Compose Pair Range a) -> Rect a
corners :: (FromInteger a, BoundedField a, Ord a) => Rect a -> [Pair a]

-- | project a Rect from an old Rect range to a new one
projectRect :: (FromInteger a, Ord a, BoundedField a) => Rect a -> Rect a -> Rect a -> Rect a
instance Data.Traversable.Traversable NumHask.Rect.Rect
instance Data.Semigroup.Foldable.Class.Foldable1 NumHask.Rect.Rect
instance Data.Foldable.Foldable NumHask.Rect.Rect
instance GHC.Base.Applicative NumHask.Rect.Rect
instance Data.Functor.Bind.Class.Apply NumHask.Rect.Rect
instance GHC.Base.Functor NumHask.Rect.Rect
instance GHC.Classes.Eq a => GHC.Classes.Eq (NumHask.Rect.Rect a)
instance GHC.Show.Show a => GHC.Show.Show (NumHask.Rect.Rect a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Field.BoundedField a, NumHask.Algebra.Integral.FromInteger a) => NumHask.Algebra.Multiplicative.MultiplicativeMagma (NumHask.Rect.Rect a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Field.BoundedField a, NumHask.Algebra.Integral.FromInteger a) => NumHask.Algebra.Multiplicative.MultiplicativeUnital (NumHask.Rect.Rect a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Integral.FromInteger a, NumHask.Algebra.Field.BoundedField a) => NumHask.Algebra.Multiplicative.MultiplicativeAssociative (NumHask.Rect.Rect a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Field.BoundedField a, NumHask.Algebra.Integral.FromInteger a) => NumHask.Algebra.Multiplicative.MultiplicativeCommutative (NumHask.Rect.Rect a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Field.BoundedField a, NumHask.Algebra.Integral.FromInteger a) => NumHask.Algebra.Multiplicative.Multiplicative (NumHask.Rect.Rect a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Integral.FromInteger a, NumHask.Algebra.Field.BoundedField a) => NumHask.Algebra.Multiplicative.MultiplicativeInvertible (NumHask.Rect.Rect a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Field.BoundedField a, NumHask.Algebra.Integral.FromInteger a) => NumHask.Algebra.Multiplicative.MultiplicativeGroup (NumHask.Rect.Rect a)
instance (NumHask.Algebra.Additive.AdditiveInvertible a, NumHask.Algebra.Field.BoundedField a, GHC.Classes.Ord a, NumHask.Algebra.Integral.FromInteger a) => NumHask.Algebra.Metric.Signed (NumHask.Rect.Rect a)
instance NumHask.Algebra.Additive.AdditiveGroup a => NumHask.Algebra.Metric.Normed (NumHask.Rect.Rect a) (NumHask.Pair.Pair a)
instance Data.Distributive.Distributive NumHask.Rect.Rect
instance Data.Functor.Rep.Representable NumHask.Rect.Rect
instance (NumHask.Algebra.Integral.FromInteger a, GHC.Classes.Ord a, NumHask.Algebra.Field.BoundedField a) => NumHask.Space.Space (NumHask.Rect.Rect a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Field.BoundedField a, NumHask.Algebra.Integral.FromInteger a) => GHC.Base.Monoid (NumHask.Rect.Rect a)