Untitled

.gitignore

@@ -0,0 +1,3 @@
+*.hi
+*.o
+*~

Angles.hs

@@ -0,0 +1,99 @@
+module Angles where
+
+import Data.List
+import Data.Maybe
+import Data.Function (on)
+
+data (Ord a) => Pair a = Pair a a
+
+makePair x y | x<y   = Pair x y
+             | otherwise = Pair y x
+makePairL [x,y] = makePair x y
+
+getPair (Pair x y) = [x,y]
+
+instance (Show a,Ord a) => Show (Pair a) where
+  show (Pair x y) = show (x,y)
+
+instance (Ord a,Eq a) => Eq (Pair a) where
+  (Pair x1 y1) == (Pair x2 y2) =
+    ((x1==x2) && (y1==y2)) || ((x1==y2) && (y1==x2))
+
+pairs l = map makePairL [x | x <- subsequences l, length x == 2]
+
+pairsMany ls = foldl1 union $ map pairs ls
+
+layerPairs order pairs = reverse res where
+  (res,_) = foldl filterPairsWith ([],pairs) order
+  filterPairsWith (lps,ps) e = (lps',ps') where
+    lps' = newLayer:lps
+    (newLayer,ps') = partition ((elem e).getPair) ps
+
+layerPairs' order = (convertLayers order) . (layerPairs order)
+
+convertLayers order layers =
+  map (\(x,ps) -> (x,[y | p <- ps, y <- getPair p, y/=x])) $ zip order layers
+
+convertLayers' layers' = (order,layers) where
+  (order,_) = unzip layers'
+  layers = map (\(e,l) -> map (makePair e) l) layers'
+
+closeLayers' ls = res where
+  (res,_) = foldl closeLayer ([],[]) $ reverse ls where
+    closeLayer (clsdLs,fromPrev) (n,ps) =
+      ((n,ps'):clsdLs,fromCur) where
+        ps' = union ps fromPrev
+        fromCur | null ps' = []
+                | otherwise = n:ps'
+
+closeLayers order layers =
+  snd $ convertLayers' $ closeLayers' $ convertLayers order layers
+
+scoreOrder order pairs =
+  sum $ map (\(x,y) -> x^p*y) $ zip [0..] $ map length layrs where
+    layrs = layerPairs order pairs
+    p = length order
+
+anglesOrder order pairs =
+  sum $ map length $ closeLayers order $ layerPairs order pairs
+
+optimalOrder n pairs = (m,angleMin) where
+  m = minimumBy (compare `on` (\(x,_,_) -> x)) scoredOrders
+  scoredOrders = zip3 scores orders angles
+  scores = map (flip scoreOrder pairs) orders
+  angles = map (flip anglesOrder pairs) orders
+  orders = permutations [1..n]
+  angleMin = minimum angles
+
+layer (Pair x y) order =
+  (min `on` fromJust) (elemIndex x order) (elemIndex y order)
+
+cosP p@(Pair x y) n pairs =
+  (i,prjs) where
+    Just i = lookup p thetas
+    thetas = zip (concat clsdLayers) [1..]
+    clsdLayers = closeLayers order $ layerPairs order pairs
+    ((_,order,_),_) = optimalOrder n pairs
+    prjs = map (\e -> (fromJust $ lookup (Pair e x) thetas,
+                       fromJust $ lookup (Pair e y) thetas)) upperLs
+    upperLs = take (layer p order) order
+
+strCos i = "x_" ++ show i
+strSin i = "y_" ++ show i
+
+stringifyCos (i,prjs) =
+  (concatMap strOnePrj prjs) ++ strCos i ++ closingBrcts where
+    strOnePrj (x,y) = strCos x ++ "*" ++ strCos y ++ "+" ++
+                      strSin x ++ "*" ++ strSin y ++ "*("
+    closingBrcts = replicate (length prjs) ')'
+
+-- Jacobian for coordinate transformation
+jacobian n pairs = zip [1..] ls where
+  ls = concatMap (\(n,l) -> replicate (length l) n) nmbrdLayers
+  nmbrdLayers = zip [0..] clsdLayers
+  clsdLayers = closeLayers order $ layerPairs order pairs
+  ((_,order,_),_) = optimalOrder n pairs
+
+stringifyJ [] = "1"
+stringifyJ as = intercalate "*" $ map strOne as where
+  strOne (a,n) = "y_" ++ show a ++ "**(d-" ++ show (n+2) ++ ")"

Diagram.hs

@@ -0,0 +1,85 @@
+module Diagram where
+
+import Data.Graph.Inductive
+import Control.Monad
+
+import Graph hiding (dMuSquare)
+import LinComb
+import Theory
+import Theory.Phi3
+import Moment
+import Angles
+
+data DExp = Diagram Diagram
+          | DElement DElement deriving (Show)
+
+getDElement (DElement e) = e
+actOnElement f = (fmap getDElement) . f . DElement
+
+dMu2 :: DExp -> LinComb Rational DExp
+dMu2 (Diagram d) = fmap Diagram $ graphMap mapChain (actOnElement dMu2) d
+dMu2 (DElement ((DVertex,_),_)) = LC [] -- FIXME! I'd like to use 0 or mzero here
+dMu2 (DElement (p@(DProp,_),mods)) = return $ DElement (p,"dMu2":mods)
+
+dP :: DExp -> LinComb Rational DExp
+dP (Diagram d) = fmap Diagram $ graphMap mapChain (actOnElement dP) d
+dP (DElement ((t,m),mods)) | m `hasMoment` 0 = return $ DElement ((t,m),"dP":mods)
+                           | otherwise = LC []
+
+dAn :: Int -> DExp -> LinComb Rational DExp
+dAn n (Diagram d) = fmap Diagram $ graphMap mapChain (actOnElement $ dAn n) d
+dAn n (DElement ((t,m),mods)) | m `isStretchedBy` n = return $ DElement ((t,m),("dA_" ++ show n):mods)
+                              | otherwise = LC []
+
+zeroP :: DExp -> LinComb Rational DExp
+zeroP (Diagram d) = fmap Diagram $ graphMap mapAll (actOnElement zeroP) d
+zeroP (DElement ((t,m),mods)) | "dP" `elem` mods = return $ DElement ((t,m),"zeroP":mods)
+                              | otherwise = return $ DElement ((t,m `removeMoment` 0),mods)
+
+unStretch :: Int -> DExp -> LinComb Rational DExp
+unStretch n (Diagram d) = fmap Diagram $ graphMap mapAll (actOnElement $ unStretch n) d
+unStretch n (DElement ((t,m),mods)) = return $ DElement ((t,m `momentUnStretch` n),mods)
+
+-- power for functions. TODO: Find correct place for me
+power f 0 = id
+power f n = foldl1 (.) $ replicate n f
+
+-- and monadic version
+powerM f 0 = return
+powerM f n = foldl1 (>=>) $ replicate n f
+
+diagramHandleExtMoment th d = return d >>= (powerM dP n) >>= zeroP where
+  n = -diagramDivIndex th d'
+  Diagram d' = d
+
+diagramAllMomentPairs d = pairsMany ls where
+  ls = map (filter (/=0)) ls' -- we will handle ext moment separately
+  ls' = map ((\(_,x,_) -> x).unzip3.moments) ms
+  ms = (map (\(_,INode ((_,m),_)) -> m) $ labNodes d') ++
+       (map (\(_,_,((_,m),_)) -> m) $ labEdges d')
+  d' = delNode 0 d
+
+diagramSignSubgraphsDivIndices th d =
+  zip [1..] (map (diagramDivIndex th) (signSubgraphs th d))
+
+diagramUnStretchUnneeded th d = unStretchOp d where
+  unStretchOp = foldl (>=>) return $ map unStretch idxs
+  idxs = [x | (x,i) <- diagramSignSubgraphsDivIndices th d', i<0]
+  Diagram d' = d
+
+diagramAOps th d =
+  [(x,i) | (x,i) <- diagramSignSubgraphsDivIndices th d', i>=0] where
+    Diagram d' = d
+
+diagramSymbolize d n pairs = graphSymbolize d' n pairs where
+  Diagram d' = d
+
+diagramPutDots th d =
+  (diagramHandleExtMoment th $ Diagram d') >>= dMu2 >>= (diagramUnStretchUnneeded th) where
+    n = nrLoops d
+    pairs = diagramAllMomentPairs d'
+    d' = diagramStretchMoments th $ diagramAddMoments th d
+
+diagramExpandADiffs th d = aDiffs (diagramAOps th d) d where
+  aDiffs [] = return
+  aDiffs ops = foldl1 (>=>) $ map (\(n,k) -> powerM (dAn n) (k+1)) ops