{-# LANGUAGE NoImplicitPrelude #-}
module Algebra.ZeroTestable where
import qualified Algebra.Additive as Additive
import Data.Int (Int, Int8, Int16, Int32, Int64, )
import Data.Word (Word, Word8, Word16, Word32, Word64, )
-- import qualified Prelude as P
import Prelude(Int,Integer,Float,Double)
import PreludeBase
{- |
Maybe the naming should be according to Algebra.Unit:
Algebra.Zero as module name, and @query@ as method name.
-}
class C a where
isZero :: a -> Bool
{- |
Checks if a number is the zero element.
This test is not possible for all 'Additive.C' types,
since e.g. a function type does not belong to Eq.
isZero is possible for some types where (==zero) fails
because there is no unique zero.
Examples are
vector (the length of the zero vector is unknown),
physical values (the unit of a zero quantity is unknown),
residue class (the modulus is unknown).
-}
defltIsZero :: (Eq a, Additive.C a) => a -> Bool
defltIsZero = (Additive.zero==)
{-* Instances for atomic types -}
instance C Integer where isZero = defltIsZero
instance C Float where isZero = defltIsZero
instance C Double where isZero = defltIsZero
instance C Int where isZero = defltIsZero
instance C Int8 where isZero = defltIsZero
instance C Int16 where isZero = defltIsZero
instance C Int32 where isZero = defltIsZero
instance C Int64 where isZero = defltIsZero
instance C Word where isZero = defltIsZero
instance C Word8 where isZero = defltIsZero
instance C Word16 where isZero = defltIsZero
instance C Word32 where isZero = defltIsZero
instance C Word64 where isZero = defltIsZero
{-* Instances for composed types -}
instance (C v0, C v1) => C (v0, v1) where
isZero (x0,x1) = isZero x0 && isZero x1
instance (C v0, C v1, C v2) => C (v0, v1, v2) where
isZero (x0,x1,x2) = isZero x0 && isZero x1 && isZero x2
instance (C v) => C [v] where
isZero = all isZero