Merge pull request #11 from anttih/psc-0.9-updates

Update deps for psc 0.9.1 and make changes for new class hierarchy

Author: anttih

bower.json

@@ -13,11 +13,11 @@
     "output"
   ],
   "dependencies": {
-    "purescript-integers": "~0.2.1"
+    "purescript-integers": "^1.0.0"
   },
   "devDependencies": {
-    "purescript-console": "^0.1.0",
-    "purescript-prelude": "^0.1.0",
-    "purescript-strongcheck": "~0.14.7"
+    "purescript-console": "^1.0.0",
+    "purescript-prelude": "^1.0.0",
+    "purescript-strongcheck": "^1.0.0"
   }
 }

src/Data/Ratio.purs

@@ -1,7 +1,6 @@
 module Data.Ratio where
 
-import Prelude (class Num, class DivisionRing, class ModuloSemiring, class
-               Ring, class Semiring, (*), zero, (-), (+), one)
+import Prelude
 
 data Ratio a = Ratio a a
 
@@ -14,13 +13,14 @@ instance semiringRatio :: (Semiring a) => Semiring (Ratio a) where
 instance ringRatio :: (Ring a) => Ring (Ratio a) where
   sub (Ratio a b) (Ratio c d) = Ratio ((a * d) - (b * c)) (b * d)
 
-instance moduloSemiringRatio :: (Ring a, ModuloSemiring a) => ModuloSemiring (Ratio a) where
-  mod _ _ = zero
-  div (Ratio a b) (Ratio c d) = Ratio (a * d) (b * c)
+instance commutativeRingRatio :: (CommutativeRing a) => CommutativeRing (Ratio a)
 
-instance divisionRingRatio :: (DivisionRing a) => DivisionRing (Ratio a)
+instance euclideanRingRatio :: (CommutativeRing a, Semiring a) => EuclideanRing (Ratio a) where
+  degree _ = 1
+  div (Ratio a b) (Ratio c d) = Ratio (a * d) (b * c)
+  mod _ _ = zero
 
-instance numRatio :: (Num a) => Num (Ratio a)
+instance fieldRatio :: (Field a) => Field (Ratio a)
 
 numerator :: forall a. Ratio a -> a
 numerator (Ratio a _) = a

src/Data/Rational.purs

@@ -13,7 +13,7 @@ import Data.Ratio (Ratio(Ratio))
 newtype Rational = Rational (Ratio Int)
 
 instance showRational :: Show Rational where
-  show (Rational (Ratio a b)) = show a ++ " % " ++ show b
+  show (Rational (Ratio a b)) = show a <> " % " <> show b
 
 instance eqRational :: Eq Rational where
   eq x y = eq' (reduce x) (reduce y)
@@ -26,21 +26,22 @@ instance ordRational :: Ord Rational where
   compare _ _ = GT
 
 instance semiringRational :: Semiring Rational where
-  one = Rational $ one
+  one = Rational one
   mul (Rational a) (Rational b) = reduce $ Rational $ a `mul` b
-  zero = Rational $ zero
+  zero = Rational zero
   add (Rational a) (Rational b) = reduce $ Rational $ a `add` b
 
 instance ringRational :: Ring Rational where
   sub (Rational a) (Rational b) = reduce $ Rational $ a `sub` b
 
-instance moduloSemiringRational :: ModuloSemiring Rational where
-  mod _ _ = zero
-  div (Rational a) (Rational b) = reduce $ Rational $ a `div` b
+instance commutativeRingRational :: CommutativeRing Rational
 
-instance divisionRingRational :: DivisionRing Rational
+instance euclideanRingRational :: EuclideanRing Rational where
+  degree (Rational a) = degree a
+  div (Rational a) (Rational b) = Rational $ a `div` b
+  mod _ _ = Rational zero
 
-instance numRational :: Num Rational
+instance fieldRational :: Field Rational
 
 infixl 7 rational as %
 

test/Main.purs

@@ -6,7 +6,8 @@ import Control.Monad.Eff.Console (CONSOLE, log)
 import Control.Monad.Eff.Random (RANDOM)
 import Control.Monad.Eff.Exception (EXCEPTION)
 import Data.Rational (Rational, (%))
-import Test.StrongCheck (class Arbitrary, Result, quickCheck, (===))
+import Test.StrongCheck (Result, quickCheck, (===))
+import Test.StrongCheck.Arbitrary (class Arbitrary)
 import Test.StrongCheck.Gen (chooseInt, suchThat)
 
 
@@ -16,15 +17,15 @@ instance arbitraryTestRational :: Arbitrary TestRational where
   arbitrary = do
     a <- chooseInt (-99.0) 99.0
     b <- suchThat (chooseInt (-99.0) 99.0) (_ /= 0)
-    return $ TestRational $ a % b
+    pure $ TestRational $ a % b
 
 newtype TestRatNonZero = TestRatNonZero Rational
 
 instance arbitraryTestRatNonZero :: Arbitrary TestRatNonZero where
   arbitrary = do
     a <- suchThat (chooseInt (-99.0) 99.0) (_ /= 0)
     b <- suchThat (chooseInt (-99.0) 99.0) (_ /= 0)
-    return $ TestRatNonZero $ a % b
+    pure $ TestRatNonZero $ a % b
 
 main :: forall eff. Eff (console :: CONSOLE, random :: RANDOM, err :: EXCEPTION | eff) Unit
 main = do
@@ -49,13 +50,13 @@ main = do
   log "Checking 'Annihilation' law for Semiring"
   quickCheck annihilation
 
+  log "Checking 'Additive inverse' law for Ring"
+  quickCheck additiveInverse
+
   log "Checking 'Remainder' law for MuduloSemiring"
   quickCheck remainder
 
-  log "Checking 'Multiplicative inverse' law for DivisionRing"
-  quickCheck multiplicativeInverse
-
-  log "Checking 'Commutative multiplication' law for Num"
+  log "Checking 'Commutative multiplication' law for CommutativeRing"
   quickCheck commutativeMultiplication
 
   log "Checking 'Reflexivity' law for Ord"
@@ -65,6 +66,15 @@ main = do
   log "Checking 'Transitivity' law for Ord"
   quickCheck ordTransitivity
 
+  log "Checking 'Integral domain' law for EuclideanRing"
+  quickCheck integralDomain
+
+  log "Checking 'Multiplicative Euclidean function' law for EuclideanRing"
+  quickCheck multiplicativeEuclideanFunction
+
+  log "Checking 'Non-zero multiplicative inverse' law for Field"
+  quickCheck multiplicativeInverse
+
     where
 
     identity :: TestRational -> Result
@@ -94,6 +104,9 @@ main = do
     annihilation :: TestRational -> Boolean
     annihilation (TestRational a) = zero * a == a * zero && zero == a * zero
 
+    additiveInverse :: TestRational -> Boolean
+    additiveInverse (TestRational a) = a - a == (zero - a) + a && a - a == zero
+
     ordReflexivity :: TestRational -> Boolean
     ordReflexivity (TestRational a) = a <= a
 
@@ -103,11 +116,16 @@ main = do
     remainder :: TestRatNonZero -> TestRatNonZero -> Result
     remainder (TestRatNonZero a) (TestRatNonZero b) = a / b * b + (a `mod` b) === a
 
-    multiplicativeInverse :: TestRatNonZero -> Result
-    multiplicativeInverse (TestRatNonZero x) = (one / x) * x === one
-
     commutativeMultiplication :: TestRational -> TestRational -> Result
     commutativeMultiplication (TestRational a) (TestRational b) = a * b === b * a
 
     ordTransitivity :: TestRational -> TestRational -> TestRational -> Boolean
     ordTransitivity (TestRational a) (TestRational b) (TestRational c) = if a <= b && b <= c then a <= c else true
+
+    integralDomain :: TestRatNonZero -> TestRatNonZero -> Boolean
+    integralDomain (TestRatNonZero a) (TestRatNonZero b) = a * b /= zero
+
+    multiplicativeEuclideanFunction :: TestRatNonZero -> TestRatNonZero -> Boolean
+    multiplicativeEuclideanFunction (TestRatNonZero a) (TestRatNonZero b) = a == (a / b) * b + (a `mod` b)
+    multiplicativeInverse :: TestRational -> TestRational -> Boolean
+    multiplicativeInverse (TestRational a) (TestRational b) = a `mod` b == zero