Run ormolu and Add formatter to GitHub actions (#3)

* Run ormolu formatter

* Add ormolu formatter to GitHub actions

Author: rasheedja

.github/workflows/haskell.yml

@@ -10,6 +10,13 @@ permissions:
   contents: read
 
 jobs:
+  ormolu:
+
+    runs-on: ubuntu-latest
+  
+    steps:
+      - uses: actions/checkout@v3
+      - uses: haskell-actions/run-ormolu@v11
   build:
 
     runs-on: ubuntu-latest

Setup.hs

@@ -1,2 +1,3 @@
 import Distribution.Simple
+
 main = defaultMain

src/Linear/Simplex/Prettify.hs

@@ -1,39 +1,37 @@
-{-|
-Module      : Linear.Simplex.Prettify
-Description : Prettifier for "Linear.Simplex.Types" types
-Copyright   : (c) Junaid Rasheed, 2020-2022
-License     : BSD-3
-Maintainer  : [email protected]
-Stability   : experimental
-
-Converts "Linear.Simplex.Types" types into human-readable 'String's 
--}
+-- |
+-- Module      : Linear.Simplex.Prettify
+-- Description : Prettifier for "Linear.Simplex.Types" types
+-- Copyright   : (c) Junaid Rasheed, 2020-2022
+-- License     : BSD-3
+-- Maintainer  : [email protected]
+-- Stability   : experimental
+--
+-- Converts "Linear.Simplex.Types" types into human-readable 'String's
 module Linear.Simplex.Prettify where
 
-import Linear.Simplex.Types as T
 import Data.Ratio
+import Linear.Simplex.Types as T
 
--- |Convert a 'VarConstMap' into a human-readable 'String'
+-- | Convert a 'VarConstMap' into a human-readable 'String'
 prettyShowVarConstMap :: VarConstMap -> String
 prettyShowVarConstMap [] = ""
-prettyShowVarConstMap [(v, c)]  = prettyShowRational c ++ " * x" ++ show v ++ ""
+prettyShowVarConstMap [(v, c)] = prettyShowRational c ++ " * x" ++ show v ++ ""
   where
-    prettyShowRational r = 
+    prettyShowRational r =
       if r < 0
         then "(" ++ r' ++ ")"
         else r'
       where
         r' = if denominator r == 1 then show (numerator r) else show (numerator r) ++ " / " ++ show (numerator r)
-
 prettyShowVarConstMap ((v, c) : vcs) = prettyShowVarConstMap [(v, c)] ++ " + " ++ prettyShowVarConstMap vcs
 
--- |Convert a 'PolyConstraint' into a human-readable 'String'
+-- | Convert a 'PolyConstraint' into a human-readable 'String'
 prettyShowPolyConstraint :: PolyConstraint -> String
 prettyShowPolyConstraint (LEQ vcm r) = prettyShowVarConstMap vcm ++ " <= " ++ show r
 prettyShowPolyConstraint (GEQ vcm r) = prettyShowVarConstMap vcm ++ " >= " ++ show r
-prettyShowPolyConstraint (T.EQ vcm r)  = prettyShowVarConstMap vcm ++ " == " ++ show r
+prettyShowPolyConstraint (T.EQ vcm r) = prettyShowVarConstMap vcm ++ " == " ++ show r
 
--- |Convert an 'ObjectiveFunction' into a human-readable 'String'
+-- | Convert an 'ObjectiveFunction' into a human-readable 'String'
 prettyShowObjectiveFunction :: ObjectiveFunction -> String
 prettyShowObjectiveFunction (Min vcm) = "min: " ++ prettyShowVarConstMap vcm
 prettyShowObjectiveFunction (Max vcm) = "max: " ++ prettyShowVarConstMap vcm

src/Linear/Simplex/Simplex.hs

@@ -1,46 +1,46 @@
-{-|
-Module      : Linear.Simplex.Types
-Description : Custom types
-Copyright   : (c) Junaid Rasheed, 2020-2022
-License     : BSD-3
-Maintainer  : [email protected]
-Stability   : experimental
--}
+-- |
+-- Module      : Linear.Simplex.Types
+-- Description : Custom types
+-- Copyright   : (c) Junaid Rasheed, 2020-2022
+-- License     : BSD-3
+-- Maintainer  : [email protected]
+-- Stability   : experimental
 module Linear.Simplex.Types where
 
--- |List of 'Integer' variables with their 'Rational' coefficients.
--- There is an implicit addition between elements in this list.
--- Users must only provide positive integer variables.
--- 
--- Example: [(2, 3), (6, (-1), (2, 1))] is equivalent to 3x2 + (-x6) + x2.  
+-- | List of 'Integer' variables with their 'Rational' coefficients.
+--  There is an implicit addition between elements in this list.
+--  Users must only provide positive integer variables.
+--
+--  Example: [(2, 3), (6, (-1), (2, 1))] is equivalent to 3x2 + (-x6) + x2.
 type VarConstMap = [(Integer, Rational)]
 
--- |For specifying constraints in a system.
--- The LHS is a 'VarConstMap', and the RHS, is a 'Rational' number.
--- LEQ [(1, 2), (2, 1)] 3.5 is equivalent to 2x1 + x2 <= 3.5.
--- Users must only provide positive integer variables.
--- 
--- Example: LEQ [(2, 3), (6, (-1), (2, 1))] 12.3 is equivalent to 3x2 + (-x6) + x2 <= 12.3.
-data PolyConstraint =
-  LEQ VarConstMap Rational      | 
-  GEQ VarConstMap Rational      | 
-  EQ VarConstMap Rational       deriving (Show, Eq);
+-- | For specifying constraints in a system.
+--  The LHS is a 'VarConstMap', and the RHS, is a 'Rational' number.
+--  LEQ [(1, 2), (2, 1)] 3.5 is equivalent to 2x1 + x2 <= 3.5.
+--  Users must only provide positive integer variables.
+--
+--  Example: LEQ [(2, 3), (6, (-1), (2, 1))] 12.3 is equivalent to 3x2 + (-x6) + x2 <= 12.3.
+data PolyConstraint
+  = LEQ VarConstMap Rational
+  | GEQ VarConstMap Rational
+  | EQ VarConstMap Rational
+  deriving (Show, Eq)
 
--- |Create an objective function.
--- We can either 'Max'imize or 'Min'imize a 'VarConstMap'.
+-- | Create an objective function.
+--  We can either 'Max'imize or 'Min'imize a 'VarConstMap'.
 data ObjectiveFunction = Max VarConstMap | Min VarConstMap deriving (Show, Eq)
 
--- |A 'Tableau' of equations.
--- Each pair in the list is a row. 
--- The first item in the pair specifies which 'Integer' variable is basic in the equation.
--- The second item in the pair is an equation.
--- The 'VarConstMap' in the second equation is a list of variables with their coefficients.
--- The RHS of the equation is a 'Rational' constant.
+-- | A 'Tableau' of equations.
+--  Each pair in the list is a row.
+--  The first item in the pair specifies which 'Integer' variable is basic in the equation.
+--  The second item in the pair is an equation.
+--  The 'VarConstMap' in the second equation is a list of variables with their coefficients.
+--  The RHS of the equation is a 'Rational' constant.
 type Tableau = [(Integer, (VarConstMap, Rational))]
 
--- |Type representing equations. 
--- Each pair in the list is one equation.
--- The first item of the pair is the basic variable, and is on the LHS of the equation with a coefficient of one.
--- The RHS is represented using a `VarConstMap`.
--- The integer variable -1 is used to represent a 'Rational' on the RHS
+-- | Type representing equations.
+--  Each pair in the list is one equation.
+--  The first item of the pair is the basic variable, and is on the LHS of the equation with a coefficient of one.
+--  The RHS is represented using a `VarConstMap`.
+--  The integer variable -1 is used to represent a 'Rational' on the RHS
 type DictionaryForm = [(Integer, VarConstMap)]

src/Linear/Simplex/Types.hs

@@ -1,152 +1,144 @@
 {-# LANGUAGE LambdaCase #-}
 
-{-|
-Module      : Linear.Simplex.Util
-Description : Helper functions
-Copyright   : (c) Junaid Rasheed, 2020-2022
-License     : BSD-3
-Maintainer  : [email protected]
-Stability   : experimental
-
-Helper functions for performing the two-phase simplex method.
--}
+-- |
+-- Module      : Linear.Simplex.Util
+-- Description : Helper functions
+-- Copyright   : (c) Junaid Rasheed, 2020-2022
+-- License     : BSD-3
+-- Maintainer  : [email protected]
+-- Stability   : experimental
+--
+-- Helper functions for performing the two-phase simplex method.
 module Linear.Simplex.Util where
 
-import Prelude hiding (EQ);
-import Linear.Simplex.Types
-import Data.List
 import Data.Bifunctor
+import Data.List
+import Linear.Simplex.Types
+import Prelude hiding (EQ)
 
--- |Is the given 'ObjectiveFunction' to be 'Max'imized?
+-- | Is the given 'ObjectiveFunction' to be 'Max'imized?
 isMax :: ObjectiveFunction -> Bool
 isMax (Max _) = True
 isMax (Min _) = False
 
--- |Extract the objective ('VarConstMap') from an 'ObjectiveFunction'
+-- | Extract the objective ('VarConstMap') from an 'ObjectiveFunction'
 getObjective :: ObjectiveFunction -> VarConstMap
 getObjective (Max o) = o
 getObjective (Min o) = o
 
--- |Simplifies a system of 'PolyConstraint's by first calling 'simplifyPolyConstraint', 
--- then reducing 'LEQ' and 'GEQ' with same LHS and RHS (and other similar situations) into 'EQ',
--- and finally removing duplicate elements using 'nub'.
+-- | Simplifies a system of 'PolyConstraint's by first calling 'simplifyPolyConstraint',
+--  then reducing 'LEQ' and 'GEQ' with same LHS and RHS (and other similar situations) into 'EQ',
+--  and finally removing duplicate elements using 'nub'.
 simplifySystem :: [PolyConstraint] -> [PolyConstraint]
 simplifySystem = nub . reduceSystem . map simplifyPolyConstraint
   where
     reduceSystem :: [PolyConstraint] -> [PolyConstraint]
     reduceSystem [] = []
     -- Reduce LEQ with matching GEQ and EQ into EQ
     reduceSystem ((LEQ lhs rhs) : pcs) =
-      let
-        matchingConstraints =
-          filter
-          (\case
-            GEQ lhs' rhs' -> lhs == lhs' && rhs == rhs'
-            EQ  lhs' rhs' -> lhs == lhs' && rhs == rhs'
-            _             -> False
-          )
-          pcs
-      in
-        if null matchingConstraints
-          then LEQ lhs rhs : reduceSystem pcs
-          else EQ lhs rhs  : reduceSystem (pcs \\ matchingConstraints)
+      let matchingConstraints =
+            filter
+              ( \case
+                  GEQ lhs' rhs' -> lhs == lhs' && rhs == rhs'
+                  EQ lhs' rhs' -> lhs == lhs' && rhs == rhs'
+                  _ -> False
+              )
+              pcs
+       in if null matchingConstraints
+            then LEQ lhs rhs : reduceSystem pcs
+            else EQ lhs rhs : reduceSystem (pcs \\ matchingConstraints)
     -- Reduce GEQ with matching LEQ and EQ into EQ
     reduceSystem ((GEQ lhs rhs) : pcs) =
-      let
-        matchingConstraints =
-          filter
-          (\case
-            LEQ lhs' rhs' -> lhs == lhs' && rhs == rhs'
-            EQ  lhs' rhs' -> lhs == lhs' && rhs == rhs'
-            _             -> False
-          )
-          pcs
-      in
-        if null matchingConstraints
-          then GEQ lhs rhs : reduceSystem pcs
-          else EQ lhs rhs  : reduceSystem (pcs \\ matchingConstraints)
+      let matchingConstraints =
+            filter
+              ( \case
+                  LEQ lhs' rhs' -> lhs == lhs' && rhs == rhs'
+                  EQ lhs' rhs' -> lhs == lhs' && rhs == rhs'
+                  _ -> False
+              )
+              pcs
+       in if null matchingConstraints
+            then GEQ lhs rhs : reduceSystem pcs
+            else EQ lhs rhs : reduceSystem (pcs \\ matchingConstraints)
     -- Reduce EQ with matching LEQ and GEQ into EQ
     reduceSystem ((EQ lhs rhs) : pcs) =
-      let
-        matchingConstraints =
-          filter
-          (\case
-            LEQ lhs' rhs' -> lhs == lhs' && rhs == rhs'
-            GEQ  lhs' rhs' -> lhs == lhs' && rhs == rhs'
-            _             -> False
-          )
-          pcs
-      in
-        if null matchingConstraints
-          then EQ lhs rhs : reduceSystem pcs
-          else EQ lhs rhs : reduceSystem (pcs \\ matchingConstraints)
+      let matchingConstraints =
+            filter
+              ( \case
+                  LEQ lhs' rhs' -> lhs == lhs' && rhs == rhs'
+                  GEQ lhs' rhs' -> lhs == lhs' && rhs == rhs'
+                  _ -> False
+              )
+              pcs
+       in if null matchingConstraints
+            then EQ lhs rhs : reduceSystem pcs
+            else EQ lhs rhs : reduceSystem (pcs \\ matchingConstraints)
 
--- |Simplify an 'ObjectiveFunction' by first 'sort'ing and then calling 'foldSumVarConstMap' on the 'VarConstMap'.
+-- | Simplify an 'ObjectiveFunction' by first 'sort'ing and then calling 'foldSumVarConstMap' on the 'VarConstMap'.
 simplifyObjectiveFunction :: ObjectiveFunction -> ObjectiveFunction
 simplifyObjectiveFunction (Max varConstMap) = Max (foldSumVarConstMap (sort varConstMap))
 simplifyObjectiveFunction (Min varConstMap) = Min (foldSumVarConstMap (sort varConstMap))
 
--- |Simplify a 'PolyConstraint' by first 'sort'ing and then calling 'foldSumVarConstMap' on the 'VarConstMap'. 
+-- | Simplify a 'PolyConstraint' by first 'sort'ing and then calling 'foldSumVarConstMap' on the 'VarConstMap'.
 simplifyPolyConstraint :: PolyConstraint -> PolyConstraint
 simplifyPolyConstraint (LEQ varConstMap rhs) = LEQ (foldSumVarConstMap (sort varConstMap)) rhs
 simplifyPolyConstraint (GEQ varConstMap rhs) = GEQ (foldSumVarConstMap (sort varConstMap)) rhs
-simplifyPolyConstraint (EQ varConstMap rhs)  = EQ (foldSumVarConstMap (sort varConstMap)) rhs
+simplifyPolyConstraint (EQ varConstMap rhs) = EQ (foldSumVarConstMap (sort varConstMap)) rhs
 
--- |Add a sorted list of 'VarConstMap's, folding where the variables are equal
+-- | Add a sorted list of 'VarConstMap's, folding where the variables are equal
 foldSumVarConstMap :: [(Integer, Rational)] -> [(Integer, Rational)]
-foldSumVarConstMap []                          = []
-foldSumVarConstMap [(v, c)]                    = [(v, c)]
+foldSumVarConstMap [] = []
+foldSumVarConstMap [(v, c)] = [(v, c)]
 foldSumVarConstMap ((v1, c1) : (v2, c2) : vcm) =
   if v1 == v2
-    then 
+    then
       let newC = c1 + c2
-      in
-        if newC == 0
-          then foldSumVarConstMap vcm
-          else foldSumVarConstMap $ (v1, c1 + c2) : vcm
+       in if newC == 0
+            then foldSumVarConstMap vcm
+            else foldSumVarConstMap $ (v1, c1 + c2) : vcm
     else (v1, c1) : foldSumVarConstMap ((v2, c2) : vcm)
 
--- |Get a map of the value of every 'Integer' variable in a 'Tableau'
+-- | Get a map of the value of every 'Integer' variable in a 'Tableau'
 displayTableauResults :: Tableau -> [(Integer, Rational)]
 displayTableauResults = map (\(basicVar, (_, rhs)) -> (basicVar, rhs))
 
--- |Get a map of the value of every 'Integer' variable in a 'DictionaryForm'
+-- | Get a map of the value of every 'Integer' variable in a 'DictionaryForm'
 displayDictionaryResults :: DictionaryForm -> [(Integer, Rational)]
-displayDictionaryResults dict = displayTableauResults$ dictionaryFormToTableau dict
+displayDictionaryResults dict = displayTableauResults $ dictionaryFormToTableau dict
 
--- |Map the given 'Integer' variable to the given 'ObjectiveFunction', for entering into 'DictionaryForm'.
+-- | Map the given 'Integer' variable to the given 'ObjectiveFunction', for entering into 'DictionaryForm'.
 createObjectiveDict :: ObjectiveFunction -> Integer -> (Integer, VarConstMap)
 createObjectiveDict (Max obj) objectiveVar = (objectiveVar, obj)
 createObjectiveDict (Min obj) objectiveVar = (objectiveVar, map (second negate) obj)
 
--- |Converts a 'Tableau' to 'DictionaryForm'.
--- We do this by isolating the basic variable on the LHS, ending up with all non basic variables and a 'Rational' constant on the RHS.
--- (-1) is used to represent the rational constant.
+-- | Converts a 'Tableau' to 'DictionaryForm'.
+--  We do this by isolating the basic variable on the LHS, ending up with all non basic variables and a 'Rational' constant on the RHS.
+--  (-1) is used to represent the rational constant.
 tableauInDictionaryForm :: Tableau -> DictionaryForm
-tableauInDictionaryForm []                      = []
-tableauInDictionaryForm ((basicVar, (vcm, r)) : rows)  =
+tableauInDictionaryForm [] = []
+tableauInDictionaryForm ((basicVar, (vcm, r)) : rows) =
   (basicVar, (-1, r / basicCoeff) : map (\(v, c) -> (v, negate c / basicCoeff)) nonBasicVars) : tableauInDictionaryForm rows
   where
     basicCoeff = if null basicVars then 1 else snd $ head basicVars
     (basicVars, nonBasicVars) = partition (\(v, _) -> v == basicVar) vcm
 
--- |Converts a 'DictionaryForm' to a 'Tableau'.
--- This is done by moving all non-basic variables from the right to the left.
--- The rational constant (represented by the 'Integer' variable -1) stays on the right.
--- The basic variables will have a coefficient of 1 in the 'Tableau'.
+-- | Converts a 'DictionaryForm' to a 'Tableau'.
+--  This is done by moving all non-basic variables from the right to the left.
+--  The rational constant (represented by the 'Integer' variable -1) stays on the right.
+--  The basic variables will have a coefficient of 1 in the 'Tableau'.
 dictionaryFormToTableau :: DictionaryForm -> Tableau
 dictionaryFormToTableau [] = []
-dictionaryFormToTableau ((basicVar, row) : rows) = 
-    (basicVar, ((basicVar, 1) : map (second negate) nonBasicVars, r)) : dictionaryFormToTableau rows
+dictionaryFormToTableau ((basicVar, row) : rows) =
+  (basicVar, ((basicVar, 1) : map (second negate) nonBasicVars, r)) : dictionaryFormToTableau rows
   where
-    (rationalConstant, nonBasicVars) = partition (\(v,_) -> v == (-1)) row
+    (rationalConstant, nonBasicVars) = partition (\(v, _) -> v == (-1)) row
     r = if null rationalConstant then 0 else (snd . head) rationalConstant -- If there is no rational constant found in the right side, the rational constant is 0.
 
--- |If this function is given 'Nothing', return 'Nothing'.
--- Otherwise, we 'lookup' the 'Integer' given in the first item of the pair in the map given in the second item of the pair.
--- This is typically used to extract the value of the 'ObjectiveFunction' after calling 'Linear.Simplex.Simplex.twoPhaseSimplex'. 
+-- | If this function is given 'Nothing', return 'Nothing'.
+--  Otherwise, we 'lookup' the 'Integer' given in the first item of the pair in the map given in the second item of the pair.
+--  This is typically used to extract the value of the 'ObjectiveFunction' after calling 'Linear.Simplex.Simplex.twoPhaseSimplex'.
 extractObjectiveValue :: Maybe (Integer, [(Integer, Rational)]) -> Maybe Rational
-extractObjectiveValue Nothing                  = Nothing
+extractObjectiveValue Nothing = Nothing
 extractObjectiveValue (Just (objVar, results)) =
   case lookup objVar results of
     Nothing -> error "Objective not found in results when extracting objective value"