numhask-range 0.1.2 → 0.1.3.0

raw patch · 6 files changed

+156/−42 lines, 6 filesdep −tasty-quickcheckdep ~QuickCheckdep ~adjunctionsdep ~distributivePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies removed: tasty-quickcheck

Dependency ranges changed: QuickCheck, adjunctions, distributive, protolude, semigroupoids

API changes (from Hackage documentation)

Files

• numhask-range.cabal +31/−31
• src/NumHask/Range.hs +4/−1
• src/NumHask/RangeD.hs +75/−0
• src/NumHask/Space.hs +20/−2
• stack.yaml +3/−6
• test/test.hs +23/−2

@@ -3,60 +3,60 @@ -- see: https://github.com/sol/hpack  name:           numhask-range-version:        0.1.2+version:        0.1.3.0 synopsis:       Numbers that are range representations description:    Numbers that represent ranges of all sorts. category:       project homepage:       https://github.com/tonyday567/numhask-range#readme bug-reports:    https://github.com/tonyday567/numhask-range/issues-license:        BSD3-license-file:   LICENSE author:         Tony Day maintainer:     tonyday567@gmail.com copyright:      Tony Day+license:        BSD3+license-file:   LICENSE build-type:     Simple cabal-version:  >= 1.10  extra-source-files:-  readme.md-  stack.yaml+    readme.md+    stack.yaml  source-repository head   type: git   location: https://github.com/tonyday567/numhask-range  library-  default-language: Haskell2010   hs-source-dirs:-    src+      src+  default-extensions: DeriveGeneric DeriveTraversable FlexibleContexts InstanceSigs MultiParamTypeClasses NegativeLiterals NoImplicitPrelude OverloadedStrings PatternSynonyms TypeFamilies UnicodeSyntax+  build-depends:+      numhask >=0.1.3+    , base >=4.7 && <4.11+    , protolude+    , QuickCheck+    , adjunctions+    , distributive+    , semigroupoids   exposed-modules:-    NumHask.Space-    NumHask.Range-    NumHask.Rect-    NumHask.Pair+      NumHask.Space+      NumHask.Range+      NumHask.RangeD+      NumHask.Rect+      NumHask.Pair   other-modules:-    Paths_numhask_range-  build-depends:-    numhask >=0.1.3,-    base >=4.7 && <4.11,-    protolude >=0.1.8 && <0.3,-    QuickCheck >=2.8 && <3,-    adjunctions >=4.3 && <5,-    distributive >=0.5 && <0.6,-    semigroupoids >=5.1 && <6-  default-extensions: DeriveGeneric DeriveTraversable FlexibleContexts InstanceSigs MultiParamTypeClasses NegativeLiterals NoImplicitPrelude OverloadedStrings PatternSynonyms TypeFamilies UnicodeSyntax+      Paths_numhask_range+  default-language: Haskell2010  test-suite test-  default-language: Haskell2010   type: exitcode-stdio-1.0-  hs-source-dirs:-    test   main-is: test.hs-  build-depends:-    numhask >=0.1.3,-    base >=4.7 && <5,-    doctest,-    numhask-range,-    tasty,-    tasty-quickcheck+  hs-source-dirs:+      test   default-extensions: DeriveGeneric DeriveTraversable FlexibleContexts InstanceSigs MultiParamTypeClasses NegativeLiterals NoImplicitPrelude OverloadedStrings PatternSynonyms TypeFamilies UnicodeSyntax+  build-depends:+      numhask >=0.1.3+    , base >=4.7 && <5+    , doctest+    , numhask-range+    , tasty+  default-language: Haskell2010

@@ -169,7 +169,7 @@  -- | times may well be some sort of affine projection lurking under the hood instance (FromInteger a, Ord a, BoundedField a) => MultiplicativeMagma (Range a) where-    times a b = Range (m - r/two) (m + r/two)+    times a b = bool (Range (m - r/two) (m + r/two)) zero (a == zero || b == zero)         where           m = mid a + mid b           r = width a * width b@@ -297,3 +297,6 @@  instance Singleton Range where     singleton a = Range a a++instance (Ord a, BoundedField a, FromInteger a) => Ord (Range a) where+    (<=) a b = lower (abs a) <= lower (abs b)

@@ -0,0 +1,75 @@+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE DeriveGeneric #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE InstanceSigs #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE PatternSynonyms #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}+{-# OPTIONS_GHC -Wall #-}+#if ( __GLASGOW_HASKELL__ < 820 )+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}+{-# OPTIONS_GHC -fno-warn-unrecognised-pragmas #-}+#endif++-- | representation of a possibly discontinuous range+module NumHask.RangeD+  ( RangeD(..)+  , normalise+  ) where++import NumHask.Prelude as P+import NumHask.Space+import NumHask.Range++import Test.QuickCheck.Arbitrary (Arbitrary(..))++newtype RangeD a = RangeD [Range a]+  deriving (Eq, Generic, Show, Functor, Foldable, Traversable, Arbitrary)++instance NFData a => NFData (RangeD a)++normalise :: (Ord (Range a), Ord a, BoundedField a, FromInteger a) =>+    RangeD a -> RangeD a+normalise (RangeD rs) = RangeD $ reverse $ foldl' step [] (sort rs)+  where+    step [] a = [a]+    step (x:xs) a = (a `unify` x) <> xs++    unify a b = bool (bool [a,b] [b,a] (a<b)) [a + b] (a `intersects` b)++instance (FromInteger a, Ord a, BoundedField a) => AdditiveMagma (RangeD a) where+    plus (RangeD l0) (RangeD l1) = normalise $ RangeD $ l0 <> l1++instance (FromInteger a, Ord a, BoundedField a) => AdditiveUnital (RangeD a) where+    zero = RangeD []++instance (FromInteger a, Ord a, BoundedField a) => AdditiveAssociative (RangeD a)++instance (FromInteger a, Ord a, BoundedField a) => AdditiveInvertible (RangeD a) where+    negate (RangeD rs) = normalise $ RangeD $ negate <$> rs++instance (FromInteger a, Ord a, BoundedField a) => AdditiveCommutative (RangeD a)+instance (FromInteger a, Ord a, BoundedField a) => Additive (RangeD a)+instance (FromInteger a, Ord a, BoundedField a) => AdditiveGroup (RangeD a)++-- | times may well be some sort of affine projection lurking under the hood+instance (FromInteger a, Ord a, BoundedField a) => MultiplicativeMagma (RangeD a) where+    times (RangeD a) (RangeD b) = normalise $ RangeD $ times <$> a <*> b++instance (FromInteger a, Ord a, BoundedField a) => MultiplicativeUnital (RangeD a) where+    one = RangeD [one]++instance (FromInteger a, Ord a, BoundedField a) => MultiplicativeAssociative (RangeD a)++instance (FromInteger a, Ord a, BoundedField a) => MultiplicativeInvertible (RangeD a) where+    recip (RangeD rs) = normalise $ RangeD $ recip <$> rs++instance (FromInteger a, Ord a, BoundedField a) => MultiplicativeCommutative (RangeD a)+instance (FromInteger a, Ord a, BoundedField a) => Multiplicative (RangeD a)+instance (FromInteger a, Ord a, BoundedField a) => MultiplicativeGroup (RangeD a)++

@@ -44,7 +44,25 @@     element a s = a >= lower s && a <= upper s     -- | is a space contained within another?     contains :: s -> s -> Bool-    contains s0 s1 = lower s0 <= lower s1 && upper s0 >= upper s1+    contains s0 s1 =+        ( lower s0 <= lower s1 &&+          upper s0 >= upper s1) ||+        ( lower s1 <= lower s0 &&+          upper s1 >= upper s0)+    -- | do two spaces intersect?+    disjoint :: s -> s -> Bool+    disjoint s0 s1 =+        ( lower s0 < lower s1 &&+          lower s0 < upper s1 &&+          upper s0 < lower s1 &&+          upper s0 < upper s1) ||+        ( lower s0 > lower s1 &&+          lower s0 > upper s1 &&+          upper s0 > lower s1 &&+          upper s0 > upper s1)+    -- | do two spaces intersect?+    intersects :: s -> s -> Bool+    intersects s0 s1 = not $ disjoint s0 s1     -- | convex hull     union :: s -> s -> s     -- | null space, which can be interpreted as mempty@@ -63,4 +81,4 @@     gridSpace :: 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 | InnerPos | LowerPos | UpperPos | MidPos deriving (Eq)+data Pos = OuterPos | InnerPos | LowerPos | UpperPos | MidPos deriving (Show, Generic, Eq)

@@ -1,9 +1,6 @@-resolver: nightly-2017-11-07+resolver: nightly-2017-12-27  packages:-  - '.'+  - . -extra-deps:-  #- git: https://github.com/tonyday567/numhask.git-  #  commit: c7300b5f2a56554f3948d7c5aacb7ac8ed924e31-  - numhask-0.1.3+extra-deps: []

@@ -14,8 +14,7 @@ import NumHask.Laws  import Test.DocTest-import Test.Tasty (TestName, TestTree, defaultMain, testGroup)-import Test.Tasty.QuickCheck+import Test.Tasty (defaultMain, testGroup)  main :: IO () main = do@@ -220,3 +219,25 @@            n < abs (size a) ||            n < abs (size b) || n < abs (size c) || (a + b) * c ≈ a * c + b * c))   ]++semiringFuzzyLaws ::+     ( Ord a+     , Semiring a+     , Epsilon a+     , Eq a)+  => [Law a]+semiringFuzzyLaws = additiveLaws <> distributionFuzzyLaws++distributionFuzzyLaws :: (Epsilon a, Eq a, Distribution a) => [Law a]+distributionFuzzyLaws =+  [ ( "left annihilation: a * zero == zero"+    , Unary (\a -> a `times` zero == zero))+  , ( "right annihilation: zero * a == zero"+    , Unary (\a -> zero `times` a == zero))+  , ( "left distributivity: a * (b + c) ≈ a * b + a * c"+    , Ternary (\a b c -> a `times` (b + c) ≈ a `times` b + a `times` c))+  , ( "right distributivity: (a + b) * c ≈ a * c + b * c"+    , Ternary (\a b c -> (a + b) `times` c ≈ a `times` c + b `times` c))+  ]++