-- | Multivariate compact monomials where the variable set 
-- looks like @{x_1, x_2, ... , x_N}@. 
--
-- This is very similar to the \"Indexed\" version, but should have much more
-- compact in-memory representation (which is useful in case of large or many 
-- polynomials, and should be in theory also faster, because of cache friendlyness)
--

{-# LANGUAGE CPP, BangPatterns, TypeFamilies, DataKinds, KindSignatures, ScopedTypeVariables #-}
module Math.Algebra.Polynomial.Monomial.Compact where

--------------------------------------------------------------------------------

import Data.List
import Data.Word

import Data.Array.Unboxed  -- used only by compactFromList

#if MIN_VERSION_base(4,11,0)        
import Data.Semigroup
import Data.Monoid
#else
import Data.Monoid
#endif

import Data.Typeable
import GHC.TypeLits
import Data.Proxy

import Data.Foldable as F 

import qualified Data.Vector.Compact.WordVec as V

import Math.Algebra.Polynomial.Class
import Math.Algebra.Polynomial.Pretty
import Math.Algebra.Polynomial.Misc

import Math.Algebra.Polynomial.Monomial.Indexed ( XS , xsFromExponents , xsToExponents )

--------------------------------------------------------------------------------
-- * Monomials

-- | Monomials of the variables @x1,x2,...,xn@. The internal representation is a
-- compact vector of the exponents.
--
-- The type is indexed by the /name/ of the variables, and then the /number/ of variables.
--
-- Note that we assume here that the internal vector has length @n@.
newtype Compact (var :: Symbol) (n :: Nat) 
  = Compact V.WordVec 
  deriving (Compact var n -> Compact var n -> Bool
(Compact var n -> Compact var n -> Bool)
-> (Compact var n -> Compact var n -> Bool) -> Eq (Compact var n)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (var :: Symbol) (n :: Nat).
Compact var n -> Compact var n -> Bool
/= :: Compact var n -> Compact var n -> Bool
$c/= :: forall (var :: Symbol) (n :: Nat).
Compact var n -> Compact var n -> Bool
== :: Compact var n -> Compact var n -> Bool
$c== :: forall (var :: Symbol) (n :: Nat).
Compact var n -> Compact var n -> Bool
Eq,Int -> Compact var n -> ShowS
[Compact var n] -> ShowS
Compact var n -> String
(Int -> Compact var n -> ShowS)
-> (Compact var n -> String)
-> ([Compact var n] -> ShowS)
-> Show (Compact var n)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (var :: Symbol) (n :: Nat). Int -> Compact var n -> ShowS
forall (var :: Symbol) (n :: Nat). [Compact var n] -> ShowS
forall (var :: Symbol) (n :: Nat). Compact var n -> String
showList :: [Compact var n] -> ShowS
$cshowList :: forall (var :: Symbol) (n :: Nat). [Compact var n] -> ShowS
show :: Compact var n -> String
$cshow :: forall (var :: Symbol) (n :: Nat). Compact var n -> String
showsPrec :: Int -> Compact var n -> ShowS
$cshowsPrec :: forall (var :: Symbol) (n :: Nat). Int -> Compact var n -> ShowS
Show,Typeable)

--------------------------------------------------------------------------------

-- note: this must be a monomial ordering!
instance Ord (Compact var n) where 
  compare :: Compact var n -> Compact var n -> Ordering
compare (Compact WordVec
a) (Compact WordVec
b) = WordVec -> WordVec -> Ordering
forall a. Ord a => a -> a -> Ordering
compare WordVec
a WordVec
b

instance KnownNat n => Semigroup (Compact var n) where
  <> :: Compact var n -> Compact var n -> Compact var n
(<>) = Compact var n -> Compact var n -> Compact var n
forall (n :: Nat) (var :: Symbol).
KnownNat n =>
Compact var n -> Compact var n -> Compact var n
mulCompact

instance KnownNat n => Monoid (Compact var n) where
  mempty :: Compact var n
mempty  = Compact var n
forall (n :: Nat) (var :: Symbol). KnownNat n => Compact var n
emptyCompact
  mappend :: Compact var n -> Compact var n -> Compact var n
mappend = Compact var n -> Compact var n -> Compact var n
forall (n :: Nat) (var :: Symbol).
KnownNat n =>
Compact var n -> Compact var n -> Compact var n
mulCompact

instance KnownSymbol var => Pretty (Compact var n) where 
  pretty :: Compact var n -> String
pretty Compact var n
monom =   
    case [ Integer -> Word -> String
showXPow Integer
i Word
e | (Integer
i,Word
e) <- [Integer] -> [Word] -> [(Integer, Word)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Integer
1..] [Word]
es , Word
e Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
/= Word
0 ] of 
      [] -> String
"(1)"
      [String]
xs -> String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
intercalate String
"*" [String]
xs
    where
      es :: [Word]
es = Compact var n -> [Word]
forall (var :: Symbol) (n :: Nat). Compact var n -> [Word]
compactToWordExpoList Compact var n
monom
      v :: String
v  = Compact var n -> String
forall (var :: Symbol) (n :: Nat).
KnownSymbol var =>
Compact var n -> String
compactVar Compact var n
monom
      showXPow :: Integer -> Word -> String
showXPow !Integer
i !Word
e = case Word
e of
        Word
0 -> String
"1"
        Word
1 -> String
v String -> ShowS
forall a. [a] -> [a] -> [a]
++ Integer -> String
forall a. Show a => a -> String
show Integer
i
        Word
_ -> String
v String -> ShowS
forall a. [a] -> [a] -> [a]
++ Integer -> String
forall a. Show a => a -> String
show Integer
i String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"^" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Word -> String
forall a. Show a => a -> String
show Word
e

-- | Name of the variables
compactVar :: KnownSymbol var => Compact var n -> String
compactVar :: Compact var n -> String
compactVar = Proxy var -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal (Proxy var -> String)
-> (Compact var n -> Proxy var) -> Compact var n -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compact var n -> Proxy var
forall (var :: Symbol) (n :: Nat). Compact var n -> Proxy var
varProxy where
  varProxy :: Compact var n -> Proxy var
  varProxy :: Compact var n -> Proxy var
varProxy Compact var n
_ = Proxy var
forall k (t :: k). Proxy t
Proxy

-- | Number of variables
nOfCompact :: KnownNat n => Compact var n -> Int
nOfCompact :: Compact var n -> Int
nOfCompact = Integer -> Int
forall a. Num a => Integer -> a
fromInteger (Integer -> Int)
-> (Compact var n -> Integer) -> Compact var n -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy n -> Integer
forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (Proxy n -> Integer)
-> (Compact var n -> Proxy n) -> Compact var n -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compact var n -> Proxy n
forall (var :: Symbol) (n :: Nat). Compact var n -> Proxy n
natProxy where
  natProxy :: Compact var n -> Proxy n
  natProxy :: Compact var n -> Proxy n
natProxy Compact var n
_ = Proxy n
forall k (t :: k). Proxy t
Proxy

--------------------------------------------------------------------------------
-- * Conversion

-- | from @(variable,exponent)@ pairs
compactFromList :: KnownNat n => [(Index,Int)] -> Compact v n
compactFromList :: [(Index, Int)] -> Compact v n
compactFromList [(Index, Int)]
list = Compact v n
xs where
  xs :: Compact v n
xs  = WordVec -> Compact v n
forall (var :: Symbol) (n :: Nat). WordVec -> Compact var n
Compact (WordVec -> Compact v n) -> WordVec -> Compact v n
forall a b. (a -> b) -> a -> b
$ [Word] -> WordVec
V.fromList {- n -} (UArray Int Word -> [Word]
forall (a :: * -> * -> *) e i. (IArray a e, Ix i) => a i e -> [e]
elems UArray Int Word
arr)
  arr :: UArray Int Word
arr = (Word -> Word -> Word)
-> Word -> (Int, Int) -> [(Int, Word)] -> UArray Int Word
forall (a :: * -> * -> *) e i e'.
(IArray a e, Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(i, e')] -> a i e
accumArray Word -> Word -> Word
forall a. Num a => a -> a -> a
(+) Word
0 (Int
1,Int
n) [(Int, Word)]
list' :: UArray Int Word
  n :: Int
n   = Compact v n -> Int
forall (n :: Nat) (var :: Symbol).
KnownNat n =>
Compact var n -> Int
nOfCompact Compact v n
xs
  list' :: [(Int, Word)]
list' = ((Index, Int) -> (Int, Word)) -> [(Index, Int)] -> [(Int, Word)]
forall a b. (a -> b) -> [a] -> [b]
map (Index, Int) -> (Int, Word)
f [(Index, Int)]
list :: [(Int,Word)]
  f :: (Index, Int) -> (Int, Word)
f (Index Int
j , Int
e)
    | Int
j Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
1      = String -> (Int, Word)
forall a. HasCallStack => String -> a
error String
"compactFromList: index out of bounds (too small)"
    | Int
j Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
n      = String -> (Int, Word)
forall a. HasCallStack => String -> a
error String
"compactFromList: index out of bounds (too big)"
    | Int
e Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0      = String -> (Int, Word)
forall a. HasCallStack => String -> a
error String
"compactFromList: negative exponent"
    | Bool
otherwise  = (Int
j,Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
e)
  
-- | to @(variable,exponent)@ pairs
compactToList :: Compact v n -> [(Index,Int)]
compactToList :: Compact v n -> [(Index, Int)]
compactToList (Compact WordVec
vec) = ((Index, Int) -> Bool) -> [(Index, Int)] -> [(Index, Int)]
forall a. (a -> Bool) -> [a] -> [a]
filter (Index, Int) -> Bool
forall a a. (Ord a, Num a) => (a, a) -> Bool
cond ([(Index, Int)] -> [(Index, Int)])
-> [(Index, Int)] -> [(Index, Int)]
forall a b. (a -> b) -> a -> b
$ (Int -> Word -> (Index, Int)) -> [Int] -> [Word] -> [(Index, Int)]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Int -> Word -> (Index, Int)
forall a b. (Integral a, Num b) => Int -> a -> (Index, b)
f [Int
1..] (WordVec -> [Word]
V.toList WordVec
vec) where
  f :: Int -> a -> (Index, b)
f Int
j a
e = (Int -> Index
Index Int
j, a -> b
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
e)
  cond :: (a, a) -> Bool
cond (a
_,a
e) = a
e a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
0

-- | from @Word@ exponent list
compactFromWordExpoList :: KnownNat n => [Word] -> Compact var n
compactFromWordExpoList :: [Word] -> Compact var n
compactFromWordExpoList [Word]
ws = Compact var n
cpt where
  n :: Int
n   = Compact var n -> Int
forall (n :: Nat) (var :: Symbol).
KnownNat n =>
Compact var n -> Int
nOfCompact Compact var n
cpt
  cpt :: Compact var n
cpt = WordVec -> Compact var n
forall (var :: Symbol) (n :: Nat). WordVec -> Compact var n
Compact WordVec
vec
  vec :: WordVec
vec = [Word] -> WordVec
V.fromList {- n -} (Int -> [Word] -> [Word]
forall a. Int -> [a] -> [a]
take Int
n ([Word]
ws [Word] -> [Word] -> [Word]
forall a. [a] -> [a] -> [a]
++ Word -> [Word]
forall a. a -> [a]
repeat Word
0))

-- | to @Word@ exponent list
compactToWordExpoList :: Compact var n -> [Word]
compactToWordExpoList :: Compact var n -> [Word]
compactToWordExpoList (Compact WordVec
vec) = WordVec -> [Word]
V.toList WordVec
vec

-- | from @Int@ exponent list
compactFromExponents :: KnownNat n => [Int] -> Compact v n
compactFromExponents :: [Int] -> Compact v n
compactFromExponents = [Word] -> Compact v n
forall (n :: Nat) (var :: Symbol).
KnownNat n =>
[Word] -> Compact var n
compactFromWordExpoList ([Word] -> Compact v n)
-> ([Int] -> [Word]) -> [Int] -> Compact v n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Word) -> [Int] -> [Word]
forall a b. (a -> b) -> [a] -> [b]
map Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral

-- | to @Int@ exponent list
compactToExponents :: KnownNat n => Compact v n -> [Int]
compactToExponents :: Compact v n -> [Int]
compactToExponents = (Word -> Int) -> [Word] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map Word -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Word] -> [Int])
-> (Compact v n -> [Word]) -> Compact v n -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compact v n -> [Word]
forall (var :: Symbol) (n :: Nat). Compact var n -> [Word]
compactToWordExpoList

-- | from 'XS' exponent list
compactFromXS :: KnownNat n => XS v n -> Compact v n 
compactFromXS :: XS v n -> Compact v n
compactFromXS = [Int] -> Compact v n
forall (n :: Nat) (v :: Symbol). KnownNat n => [Int] -> Compact v n
compactFromExponents ([Int] -> Compact v n)
-> (XS v n -> [Int]) -> XS v n -> Compact v n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XS v n -> [Int]
forall (n :: Nat) (v :: Symbol). KnownNat n => XS v n -> [Int]
xsToExponents

-- | to 'XS' exponent list
compactToXS :: KnownNat n => Compact v n -> XS v n
compactToXS :: Compact v n -> XS v n
compactToXS = [Int] -> XS v n
forall (n :: Nat) (v :: Symbol). KnownNat n => [Int] -> XS v n
xsFromExponents ([Int] -> XS v n)
-> (Compact v n -> [Int]) -> Compact v n -> XS v n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compact v n -> [Int]
forall (n :: Nat) (v :: Symbol). KnownNat n => Compact v n -> [Int]
compactToExponents

--------------------------------------------------------------------------------
-- * empty (all zero exponents)

emptyCompact :: KnownNat n => Compact v n
emptyCompact :: Compact v n
emptyCompact = Compact v n
forall (var :: Symbol). Compact var n
xs where 
  xs :: Compact var n
xs = WordVec -> Compact var n
forall (var :: Symbol) (n :: Nat). WordVec -> Compact var n
Compact (WordVec -> Compact var n) -> WordVec -> Compact var n
forall a b. (a -> b) -> a -> b
$ Shape -> [Word] -> WordVec
V.fromList' (Int -> Int -> Shape
V.Shape Int
n Int
4) (Int -> Word -> [Word]
forall a. Int -> a -> [a]
replicate Int
n (Word
0::Word))
  n :: Int
n  = Compact var n -> Int
forall (n :: Nat) (var :: Symbol).
KnownNat n =>
Compact var n -> Int
nOfCompact Compact var n
xs

isEmptyCompact :: Compact v n -> Bool
isEmptyCompact :: Compact v n -> Bool
isEmptyCompact monom :: Compact v n
monom@(Compact WordVec
vec) = (WordVec -> Word
V.maximum WordVec
vec Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
== Word
0)
  -- all (==0) (compactToWordExpoList monom)

--------------------------------------------------------------------------------
-- * normalization

isNormalCompact :: KnownNat n => Compact v n -> Bool
isNormalCompact :: Compact v n -> Bool
isNormalCompact cpt :: Compact v n
cpt@(Compact WordVec
vec) = Compact v n -> Int
forall (n :: Nat) (var :: Symbol).
KnownNat n =>
Compact var n -> Int
nOfCompact Compact v n
cpt Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== WordVec -> Int
V.vecLen WordVec
vec

--------------------------------------------------------------------------------
-- * creation

variableCompact :: KnownNat n => Index -> Compact v n 
variableCompact :: Index -> Compact v n
variableCompact Index
idx = Index -> Int -> Compact v n
forall (n :: Nat) (v :: Symbol).
KnownNat n =>
Index -> Int -> Compact v n
singletonCompact Index
idx Int
1

singletonCompact :: KnownNat n => Index -> Int -> Compact v n 
singletonCompact :: Index -> Int -> Compact v n
singletonCompact (Index Int
j) Int
e0
  | Int
j Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
1     = String -> Compact v n
forall a. HasCallStack => String -> a
error String
"singletonCompact: index out of bounds (too small)"
  | Int
j Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
n     = String -> Compact v n
forall a. HasCallStack => String -> a
error String
"singletonCompact: index out of bounds (too big)"
  | Word
e Word -> Word -> Bool
forall a. Ord a => a -> a -> Bool
< Word
0     = String -> Compact v n
forall a. HasCallStack => String -> a
error String
"singletonCompact: negative exponent"
  | Bool
otherwise = Compact v n
cpt
  where
    e :: Word
e    = Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
e0 :: Word
    list :: [Word]
list = Int -> Word -> [Word]
forall a. Int -> a -> [a]
replicate (Int
jInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) Word
0 [Word] -> [Word] -> [Word]
forall a. [a] -> [a] -> [a]
++ Word
e Word -> [Word] -> [Word]
forall a. a -> [a] -> [a]
: Int -> Word -> [Word]
forall a. Int -> a -> [a]
replicate (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
j) Word
0
    n :: Int
n    = Compact v n -> Int
forall (n :: Nat) (var :: Symbol).
KnownNat n =>
Compact var n -> Int
nOfCompact Compact v n
cpt
    cpt :: Compact v n
cpt  = WordVec -> Compact v n
forall (var :: Symbol) (n :: Nat). WordVec -> Compact var n
Compact (WordVec -> Compact v n) -> WordVec -> Compact v n
forall a b. (a -> b) -> a -> b
$ Shape -> [Word] -> WordVec
V.fromList' (Int -> Int -> Shape
V.Shape Int
n (Word -> Int
V.bitsNeededFor Word
e)) [Word]
list

--------------------------------------------------------------------------------
-- * products

mulCompact :: KnownNat n => Compact v n -> Compact v n -> Compact v n
mulCompact :: Compact v n -> Compact v n -> Compact v n
mulCompact (Compact WordVec
vec1) (Compact WordVec
vec2) = WordVec -> Compact v n
forall (var :: Symbol) (n :: Nat). WordVec -> Compact var n
Compact (WordVec -> Compact v n) -> WordVec -> Compact v n
forall a b. (a -> b) -> a -> b
$ WordVec -> WordVec -> WordVec
V.add WordVec
vec1 WordVec
vec2

productCompact :: (KnownNat n, Foldable f) => f (Compact v n) -> Compact v n
productCompact :: f (Compact v n) -> Compact v n
productCompact = (Compact v n -> Compact v n -> Compact v n)
-> Compact v n -> f (Compact v n) -> Compact v n
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl' Compact v n -> Compact v n -> Compact v n
forall (n :: Nat) (var :: Symbol).
KnownNat n =>
Compact var n -> Compact var n -> Compact var n
mulCompact Compact v n
forall (n :: Nat) (var :: Symbol). KnownNat n => Compact var n
emptyCompact 

powCompact :: KnownNat n => Compact v n -> Int -> Compact v n
powCompact :: Compact v n -> Int -> Compact v n
powCompact (Compact WordVec
vec) Int
e 
  | Int
e Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0     = String -> Compact v n
forall a. HasCallStack => String -> a
error String
"powCompact: negative exponent"
  | Int
e Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0    = Compact v n
forall (n :: Nat) (var :: Symbol). KnownNat n => Compact var n
emptyCompact
  | Bool
otherwise = WordVec -> Compact v n
forall (var :: Symbol) (n :: Nat). WordVec -> Compact var n
Compact (WordVec -> Compact v n) -> WordVec -> Compact v n
forall a b. (a -> b) -> a -> b
$ Word -> WordVec -> WordVec
V.scale (Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
e) WordVec
vec
  
divCompact :: KnownNat n => Compact v n -> Compact v n -> Maybe (Compact v n)
divCompact :: Compact v n -> Compact v n -> Maybe (Compact v n)
divCompact (Compact WordVec
vec1) (Compact WordVec
vec2) = WordVec -> Compact v n
forall (var :: Symbol) (n :: Nat). WordVec -> Compact var n
Compact (WordVec -> Compact v n) -> Maybe WordVec -> Maybe (Compact v n)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WordVec -> WordVec -> Maybe WordVec
V.subtract WordVec
vec1 WordVec
vec2

--------------------------------------------------------------------------------
-- * degree

maxDegCompact :: Compact v n -> Int
maxDegCompact :: Compact v n -> Int
maxDegCompact (Compact WordVec
vec) = Word -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (WordVec -> Word
V.maximum WordVec
vec)

totalDegCompact :: Compact v n -> Int
totalDegCompact :: Compact v n -> Int
totalDegCompact (Compact WordVec
vec) = Word -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (WordVec -> Word
V.sum WordVec
vec)

--------------------------------------------------------------------------------
-- * differentiation

diffCompact :: Num c => Index -> Int -> Compact v n -> Maybe (Compact v n, c)
diffCompact :: Index -> Int -> Compact v n -> Maybe (Compact v n, c)
diffCompact = String -> Index -> Int -> Compact v n -> Maybe (Compact v n, c)
forall a. HasCallStack => String -> a
error String
"diffCompact: not implemented yet"

{-
diffCompact :: Num c => Index -> Int -> Compact v n -> Maybe (Compact v n, c)
diffCompact _         0 cpt          = Just (cpt,1)
diffCompact (Index j) k (Compact ba) =
  if k8 > m8
    then Nothing
    else Just (Compact ba' , fromInteger c) 
  where
    k8   = fromIntegral k :: Word8
    m8   = indexByteArray ba (j-1) :: Word8
    m    = fromIntegral m8 :: Int
    ba'  = byteArrayFromList $ change $ byteArrayToList ba
    c    = product [ fromIntegral (m - i) | i<-[0..k-1] ] :: Integer
    change = go 1 where
      go i (x:xs) = if i == j then (x-k8) : xs else x : go (i+1) xs
      go i []     = [] 
-}

--------------------------------------------------------------------------------

instance (KnownNat n, KnownSymbol v) => Monomial (Compact v n) where
  type VarM (Compact v n) = Index
  normalizeM :: Compact v n -> Compact v n
normalizeM = Compact v n -> Compact v n
forall a. a -> a
id
  isNormalM :: Compact v n -> Bool
isNormalM  = Compact v n -> Bool
forall (n :: Nat) (v :: Symbol). KnownNat n => Compact v n -> Bool
isNormalCompact
  fromListM :: [(VarM (Compact v n), Int)] -> Compact v n
fromListM  = [(VarM (Compact v n), Int)] -> Compact v n
forall (n :: Nat) (v :: Symbol).
KnownNat n =>
[(Index, Int)] -> Compact v n
compactFromList
  toListM :: Compact v n -> [(VarM (Compact v n), Int)]
toListM    = Compact v n -> [(VarM (Compact v n), Int)]
forall (v :: Symbol) (n :: Nat). Compact v n -> [(Index, Int)]
compactToList
  emptyM :: Compact v n
emptyM     = Compact v n
forall (n :: Nat) (var :: Symbol). KnownNat n => Compact var n
emptyCompact
  isEmptyM :: Compact v n -> Bool
isEmptyM   = Compact v n -> Bool
forall (v :: Symbol) (n :: Nat). Compact v n -> Bool
isEmptyCompact
  variableM :: VarM (Compact v n) -> Compact v n
variableM  = VarM (Compact v n) -> Compact v n
forall (n :: Nat) (v :: Symbol). KnownNat n => Index -> Compact v n
variableCompact
  singletonM :: VarM (Compact v n) -> Int -> Compact v n
singletonM = VarM (Compact v n) -> Int -> Compact v n
forall (n :: Nat) (v :: Symbol).
KnownNat n =>
Index -> Int -> Compact v n
singletonCompact
  mulM :: Compact v n -> Compact v n -> Compact v n
mulM       = Compact v n -> Compact v n -> Compact v n
forall (n :: Nat) (var :: Symbol).
KnownNat n =>
Compact var n -> Compact var n -> Compact var n
mulCompact
  divM :: Compact v n -> Compact v n -> Maybe (Compact v n)
divM       = Compact v n -> Compact v n -> Maybe (Compact v n)
forall (n :: Nat) (v :: Symbol).
KnownNat n =>
Compact v n -> Compact v n -> Maybe (Compact v n)
divCompact
  productM :: [Compact v n] -> Compact v n
productM   = [Compact v n] -> Compact v n
forall (n :: Nat) (f :: * -> *) (v :: Symbol).
(KnownNat n, Foldable f) =>
f (Compact v n) -> Compact v n
productCompact
  powM :: Compact v n -> Int -> Compact v n
powM       = Compact v n -> Int -> Compact v n
forall (n :: Nat) (v :: Symbol).
KnownNat n =>
Compact v n -> Int -> Compact v n
powCompact 
  maxDegM :: Compact v n -> Int
maxDegM    = Compact v n -> Int
forall (v :: Symbol) (n :: Nat). Compact v n -> Int
maxDegCompact              
  totalDegM :: Compact v n -> Int
totalDegM  = Compact v n -> Int
forall (v :: Symbol) (n :: Nat). Compact v n -> Int
totalDegCompact
  diffM :: VarM (Compact v n) -> Int -> Compact v n -> Maybe (Compact v n, c)
diffM      = VarM (Compact v n) -> Int -> Compact v n -> Maybe (Compact v n, c)
forall c (v :: Symbol) (n :: Nat).
Num c =>
Index -> Int -> Compact v n -> Maybe (Compact v n, c)
diffCompact
 
  evalM :: (VarM (Compact v n) -> c) -> Compact v n -> c
evalM      = String -> (Index -> c) -> Compact v n -> c
forall a. HasCallStack => String -> a
error String
"Compact/evalM: not yet implemented"
  varSubsM :: (VarM (Compact v n) -> VarM (Compact v n))
-> Compact v n -> Compact v n
varSubsM   = String -> (Index -> Index) -> Compact v n -> Compact v n
forall a. HasCallStack => String -> a
error String
"Compact/varSubsM: not yet implemented"
  termSubsM :: (VarM (Compact v n) -> Maybe c)
-> (Compact v n, c) -> (Compact v n, c)
termSubsM  = String
-> (Index -> Maybe c) -> (Compact v n, c) -> (Compact v n, c)
forall a. HasCallStack => String -> a
error String
"Compact/termSubsM: not yet implemented"

--------------------------------------------------------------------------------