module Math.Operad.MapOperad where
import qualified Math.Operad.Map as Map
import Math.Operad.Map (Map)
import Data.Maybe
import Math.Operad.OrderedTree
import Math.Operad.PPrint
newtype (Ord a, Show a, TreeOrdering t) => OperadElement a n t = OE (Map a t n) deriving (Eq, Ord, Show, Read)
instance (Ord a, Show a, Show n, TreeOrdering t) => PPrint (OperadElement a n t) where
pp (OE m) = if str == "" then "0" else str
where str = Map.foldWithKey (\k a result -> result ++ "\n+" ++ show a ++ "*" ++ pp k) "" m
extractMap :: (Ord a, Show a, TreeOrdering t) => OperadElement a n t -> Map a t n
extractMap (OE m) = m
instance (Ord a, Show a, Num n, TreeOrdering t) => Num (OperadElement a n t) where
(OE m) + (OE n) = OE $ Map.filter (/=0) $ Map.unionWith (+) m n
negate on = (1).*.on
(OE m) * (OE n) = OE $ Map.filter (/=0) $ Map.intersectionWith (*) m n
abs _ = undefined
signum _ = undefined
fromInteger _ = undefined
(.*.) :: (Ord a, Show a, Eq n, Show n, Num n, TreeOrdering t) => n -> OperadElement a n t -> OperadElement a n t
nn .*. (OE m) = OE $ Map.map (nn*) m
mapMonomials :: (Show a, Ord a, Show b, Ord b, Num n, TreeOrdering s, TreeOrdering t) =>
(OrderedTree a s -> OrderedTree b t) -> OperadElement a n s -> OperadElement b n t
mapMonomials f (OE m) = OE $ Map.mapKeysWith (+) f m
foldMonomials :: (Show a, Ord a, Num n, TreeOrdering t) =>
((OrderedTree a t,n) -> [b] -> [b]) -> OperadElement a n t -> [b]
foldMonomials f (OE m) = Map.foldWithKey (curry f) [] m
fromList :: (TreeOrdering t, Show a, Ord a, Num n) => [(OrderedTree a t,n)] -> OperadElement a n t
fromList = OE . Map.filter (/=0) . Map.fromListWith (+)
toList :: (TreeOrdering t, Show a, Ord a) => OperadElement a n t -> [(OrderedTree a t, n)]
toList (OE m) = Map.toList m
oe :: (Ord a, Show a, TreeOrdering t, Num n) => [(OrderedTree a t, n)] -> OperadElement a n t
oe = fromList
oet :: (Ord a, Show a, TreeOrdering t, Num n) => DecoratedTree a -> OperadElement a n t
oet dect = oe $ [(OT dect ordering, 1)]
oek :: (Ord a, Show a, TreeOrdering t, Num n) => DecoratedTree a -> n -> OperadElement a n t
oek dect n = oe $ [(OT dect ordering, n)]
zero :: (Ord a, Show a, TreeOrdering t, Num n) => OperadElement a n t
zero = oe [(ot $ leaf 1, 0)]
isZero :: (Ord a, Show a, TreeOrdering t, Num n) => OperadElement a n t -> Bool
isZero (OE m) = Map.null $ Map.filter (/=0) m
leadingTerm :: (Ord a, Show a, TreeOrdering t, Num n) => OperadElement a n t -> (OrderedTree a t, n)
leadingTerm (OE om) = fromMaybe (ot (leaf 0), 0) $ do
((m,c),_) <- Map.maxViewWithKey om
return (m,c)
leadingOMonomial :: (Ord a, Show a, TreeOrdering t, Num n) => OperadElement a n t -> OrderedTree a t
leadingOMonomial = fst . leadingTerm
leadingMonomial :: (Ord a, Show a, TreeOrdering t, Num n) => OperadElement a n t -> DecoratedTree a
leadingMonomial = dt .leadingOMonomial
leadingCoefficient :: (Ord a, Show a, TreeOrdering t, Num n) => OperadElement a n t -> n
leadingCoefficient = snd . leadingTerm
getTrees :: (TreeOrdering t, Show a, Ord a) => OperadElement a n t -> [OrderedTree a t]
getTrees (OE m) = Map.keys m