Switch to fourmolu (#6)

* Switch to fourmolu

+ Mainly for leading commas

* Add .vscode to .gitignore

Author: rasheedja

.github/workflows/haskell.yml

@@ -11,13 +11,13 @@ permissions:
   contents: read
 
 jobs:
-  ormolu:
+  fourmolu:
 
     runs-on: ubuntu-latest
 
     steps:
       - uses: actions/checkout@v3
-      - uses: haskell-actions/run-ormolu@v11
+      - uses: haskell-actions/run-fourmolu@v7
   build:
     name: GHC ${{ matrix.ghc-version }} on ${{ matrix.os }}
     runs-on: ${{ matrix.os }}

.gitignore

@@ -1,3 +1,4 @@
 .stack-work/
 *~
 dist-*/
+.vscode/*

fourmolu.yaml

@@ -0,0 +1,16 @@
+indentation: 2
+column-limit: none
+function-arrows: trailing
+comma-style: leading
+import-export-style: diff-friendly
+indent-wheres: true
+record-brace-space: true
+newlines-between-decls: 1
+haddock-style: multi-line
+haddock-style-module:
+let-style: auto
+in-style: right-align
+single-constraint-parens: always
+unicode: never
+respectful: true
+fixities: []

src/Linear/Simplex/Prettify.hs

@@ -1,12 +1,13 @@
--- |
--- 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 Data.Ratio

src/Linear/Simplex/Simplex.hs

@@ -1,15 +1,16 @@
--- |
--- Module      : Linear.Simplex.Simplex
--- Description : Implements the twoPhaseSimplex method
--- Copyright   : (c) Junaid Rasheed, 2020-2022
--- License     : BSD-3
--- Maintainer  : [email protected]
--- Stability   : experimental
---
--- Module implementing the two-phase simplex method.
--- 'findFeasibleSolution' performs phase one of the two-phase simplex method.
--- 'optimizeFeasibleSystem' performs phase two of the two-phase simplex method.
--- 'twoPhaseSimplex' performs both phases of the two-phase simplex method.
+{- |
+Module      : Linear.Simplex.Simplex
+Description : Implements the twoPhaseSimplex method
+Copyright   : (c) Junaid Rasheed, 2020-2022
+License     : BSD-3
+Maintainer  : [email protected]
+Stability   : experimental
+
+Module implementing the two-phase simplex method.
+'findFeasibleSolution' performs phase one of the two-phase simplex method.
+'optimizeFeasibleSystem' performs phase two of the two-phase simplex method.
+'twoPhaseSimplex' performs both phases of the two-phase simplex method.
+-}
 module Linear.Simplex.Simplex (findFeasibleSolution, optimizeFeasibleSystem, twoPhaseSimplex) where
 
 import Data.Bifunctor
@@ -24,10 +25,11 @@ import Prelude hiding (EQ)
 
 trace s a = a
 
--- | Find a feasible solution for the given system of 'PolyConstraint's by performing the first phase of the two-phase simplex method
---  All 'Integer' variables in the 'PolyConstraint' must be positive.
---  If the system is infeasible, return 'Nothing'
---  Otherwise, return the feasible system in 'DictionaryForm' as well as a list of slack variables, a list artificial variables, and the objective variable.
+{- | Find a feasible solution for the given system of 'PolyConstraint's by performing the first phase of the two-phase simplex method
+ All 'Integer' variables in the 'PolyConstraint' must be positive.
+ If the system is infeasible, return 'Nothing'
+ Otherwise, return the feasible system in 'DictionaryForm' as well as a list of slack variables, a list artificial variables, and the objective variable.
+-}
 findFeasibleSolution :: [PolyConstraint] -> Maybe (DictionaryForm, [Integer], [Integer], Integer)
 findFeasibleSolution unsimplifiedSystem =
   if null artificialVars -- No artificial vars, we have a feasible system
@@ -137,11 +139,12 @@ findFeasibleSolution unsimplifiedSystem =
         negatedSum = foldSumVarConstMap ((sort . concat) negatedRows)
         negatedSumWithoutArtificialVars = filter (\(v, _) -> v `notElem` artificialVars) negatedSum
 
--- | Optimize a feasible system by performing the second phase of the two-phase simplex method.
---  We first pass an 'ObjectiveFunction'.
---  Then, the feasible system in 'DictionaryForm' as well as a list of slack variables, a list artificial variables, and the objective variable.
---  Returns a pair with the first item being the 'Integer' variable equal to the 'ObjectiveFunction'
---  and the second item being a map of the values of all 'Integer' variables appearing in the system, including the 'ObjectiveFunction'.
+{- | Optimize a feasible system by performing the second phase of the two-phase simplex method.
+ We first pass an 'ObjectiveFunction'.
+ Then, the feasible system in 'DictionaryForm' as well as a list of slack variables, a list artificial variables, and the objective variable.
+ Returns a pair with the first item being the 'Integer' variable equal to the 'ObjectiveFunction'
+ and the second item being a map of the values of all 'Integer' variables appearing in the system, including the 'ObjectiveFunction'.
+-}
 optimizeFeasibleSystem :: ObjectiveFunction -> DictionaryForm -> [Integer] -> [Integer] -> Integer -> Maybe (Integer, [(Integer, Rational)])
 optimizeFeasibleSystem unsimplifiedObjFunction phase1Dict slackVars artificialVars objectiveVar =
   if null artificialVars
@@ -152,8 +155,8 @@ optimizeFeasibleSystem unsimplifiedObjFunction phase1Dict slackVars artificialVa
 
     displayResults :: Tableau -> (Integer, [(Integer, Rational)])
     displayResults tableau =
-      ( objectiveVar,
-        case objFunction of
+      ( objectiveVar
+      , case objFunction of
           Max _ ->
             map
               (second snd)
@@ -176,10 +179,11 @@ optimizeFeasibleSystem unsimplifiedObjFunction phase1Dict slackVars artificialVa
 
     phase2ObjFunction = if isMax objFunction then Max phase2Objective else Min phase2Objective
 
--- | Perform the two phase simplex method with a given 'ObjectiveFunction' a system of 'PolyConstraint's.
---  Assumes the 'ObjectiveFunction' and 'PolyConstraint' is not empty.
---  Returns a pair with the first item being the 'Integer' variable equal to the 'ObjectiveFunction'
---  and the second item being a map of the values of all 'Integer' variables appearing in the system, including the 'ObjectiveFunction'.
+{- | Perform the two phase simplex method with a given 'ObjectiveFunction' a system of 'PolyConstraint's.
+ Assumes the 'ObjectiveFunction' and 'PolyConstraint' is not empty.
+ Returns a pair with the first item being the 'Integer' variable equal to the 'ObjectiveFunction'
+ and the second item being a map of the values of all 'Integer' variables appearing in the system, including the 'ObjectiveFunction'.
+-}
 twoPhaseSimplex :: ObjectiveFunction -> [PolyConstraint] -> Maybe (Integer, [(Integer, Rational)])
 twoPhaseSimplex objFunction unsimplifiedSystem =
   case findFeasibleSolution unsimplifiedSystem of

src/Linear/Simplex/Types.hs

@@ -1,46 +1,52 @@
--- |
--- 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.
+{- | 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/Util.hs

@@ -1,12 +1,13 @@
--- |
--- 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 Data.Bifunctor
@@ -24,9 +25,10 @@ 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
@@ -109,9 +111,10 @@ 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) =
@@ -120,10 +123,11 @@ tableauInDictionaryForm ((basicVar, (vcm, r)) : rows) =
     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) =
@@ -132,9 +136,10 @@ dictionaryFormToTableau ((basicVar, row) : rows) =
     (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 (Just (objVar, results)) =