sc

Author: jarredbarber

app/Main.hs

@@ -1,6 +1,10 @@
 module Main where
 
 import Lib
+import qualified SComplex as SC
+
+square = SC.fromList [[1,2,3], [2,3,4]]
+faces = SC.faces square 2
 
 main :: IO ()
-main = someFunc
+main = putStrLn $ show faces

package.yaml

@@ -2,8 +2,8 @@ name:                DiscreteDifferentialGeometry
 version:             0.1.0.0
 github:              "githubuser/DiscreteDifferentialGeometry"
 license:             BSD3
-author:              "Author name here"
-maintainer:          "example@example.com"
+author:              "Jarred Barber"
+maintainer:          "jpb5082@gmail.com"
 copyright:           "2020 Author name here"
 
 extra-source-files:
@@ -21,6 +21,7 @@ description:         Please see the README on GitHub at <https://github.com/gith
 
 dependencies:
 - base >= 4.7 && < 5
+- containers
 
 library:
   source-dirs: src

src/SComplex.hs

@@ -1,5 +1,6 @@
 {-# LANGUAGE TypeSynonymInstances #-}
-module SComplex where
+module SComplex (Simplex, SComplex, boundary, empty, insert, fromList, union, faces, star)
+where
 
 import qualified Data.Map.Strict as Map
 import qualified Data.Set as Set
@@ -35,23 +36,32 @@ iterateBoundary s =
     b ++ (>>=) b iterateBoundary
 
 -- A simplical complex is a collection of simplices, plus all of their boundaries
-data SimplicalComplex a = SimplicalComplex { parents::Map.Map (Simplex a) (Set.Set (Simplex a)) }
+data SComplex a = SComplex { parents::Map.Map (Simplex a) (Set.Set (Simplex a)) }
   deriving (Show)
 
-empty = SimplicalComplex {parents=Map.empty}
+empty = SComplex { parents=Map.empty }
 
-insert :: (Ord a) => Simplex a -> SimplicalComplex a -> SimplicalComplex a
+insert :: (Ord a) => Simplex a -> SComplex a -> SComplex a
 insert [] sc = sc
 insert s sc =
   let b = boundary s
-      sc' = foldl (\x y -> insert y x) sc b
+      sc' = foldl (flip insert) sc b
       inserter m k =
         Map.insertWith Set.union k (Set.singleton s) m
   in
     -- sc' has all of the children of s inserted properly.
     -- Now, let's link up the direct children with s
-    SimplicalComplex { parents=Map.insert s Set.empty $ foldl inserter (parents sc') b}
+    SComplex { parents=Map.insert s Set.empty $ foldl inserter (parents sc') b }
 
-fromList :: (Ord a) => [Simplex a] -> SimplicalComplex a
-fromList = foldl (\x y -> insert y x) $ empty
+fromList :: (Ord a, Foldable t) => t (Simplex a) -> SComplex a
+fromList = foldl (flip insert) empty
 
+union :: (Ord a) => SComplex a -> SComplex a -> SComplex a
+union sc1 sc2 =
+  foldl (flip insert) sc1 (Map.keys $ parents sc2)
+
+faces :: SComplex a -> Int -> [Simplex a]
+faces sc o = filter ((==) o . length) $ Map.keys . parents $ sc
+
+star :: (Ord a) => SComplex a -> Simplex a -> Maybe [Simplex a]
+star sc s = fmap Set.toList $ Map.lookup s $ parents sc