{-# OPTIONS_GHC -fno-warn-orphans #-} {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE FlexibleInstances #-} {- FIXME: Rationale for -fno-warn-orphans: * The orphan instances can't be put into Numeric.NonNegative.Wrapper since that's in another package. * We had to spread the instance declarations over the modules defining the typeclasses instantiated. Do we want that? * We could define the DiscreteMap as newtype. -} {- | DiscreteMap was originally intended as a type class that unifies Map and Array. One should be able to simply choose between - Map for sparse arrays - Array for full arrays. However, the Edison package provides the class AssocX which already exists for that purpose. Currently I use this module for some numeric instances of Data.Map. -} module MathObj.DiscreteMap where import qualified Algebra.NormedSpace.Sum as NormedSum import qualified Algebra.NormedSpace.Euclidean as NormedEuc import qualified Algebra.NormedSpace.Maximum as NormedMax import qualified Algebra.VectorSpace as VectorSpace import qualified Algebra.Module as Module import qualified Algebra.Vector as Vector import qualified Algebra.Algebraic as Algebraic import qualified Algebra.Additive as Additive import Algebra.Module ((*>)) import Algebra.Additive (zero,(+),negate) import qualified Data.Map as Map import Data.Map (Map) import qualified Prelude as P import PreludeBase -- FIXME: Should this be implemented by isZero? -- | Remove all zero values from the map. strip :: (Ord i, Eq v, Additive.C v) => Map i v -> Map i v strip = Map.filter (zero /=) --strip = Map.filter (((0 /=) .) . (flip const)) instance (Ord i, Eq v, Additive.C v) => Additive.C (Map i v) where zero = Map.empty (+) = (strip.). Map.unionWith (+) --(+) y x = strip (Map.unionWith (+) y x) (-) x y = (+) x (negate y) {- won't work because Map.unionWith won't negate a value from y if no x value corresponds to it (-) x y = strip (Map.unionWith sub x y) -} negate = fmap negate instance Ord i => Vector.C (Map i) where zero = Map.empty (<+>) = Map.unionWith (+) -- requires Eq instance for expo -- expo *> x = if expo == zero then zero else Vector.functorScale expo x (*>) = Vector.functorScale instance (Ord i, Eq a, Eq v, Module.C a v) => Module.C a (Map i v) where -- (*>) 0 = \_ -> zero -- (*>) expo = fmap ((*>) expo) (*>) expo x = if expo == zero then zero else fmap (expo *>) x instance (Ord i, Eq a, Eq v, VectorSpace.C a v) => VectorSpace.C a (Map i v) instance (Ord i, Eq a, Eq v, NormedSum.C a v) => NormedSum.C a (Map i v) where norm = foldl (+) zero . map NormedSum.norm . Map.elems instance (Ord i, Eq a, Eq v, NormedEuc.Sqr a v) => NormedEuc.Sqr a (Map i v) where normSqr = foldl (+) zero . map NormedEuc.normSqr . Map.elems instance (Ord i, Eq a, Eq v, Algebraic.C a, NormedEuc.Sqr a v) => NormedEuc.C a (Map i v) where norm = NormedEuc.defltNorm instance (Ord i, Eq a, Eq v, NormedMax.C a v) => NormedMax.C a (Map i v) where norm = foldl max zero . map NormedMax.norm . Map.elems