{-# LINE 1 "src/Math/Programming/Glpk/Header.hsc" #-}
-- | Low-level bindings to the GLPK library.
--
-- Functions and enums wrapped directly from @glpk.h@ are
-- undocumented; refer to the official documentation distributed with
-- GLPK for details.
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Math.Programming.Glpk.Header
  ( -- * Helper types

    -- ** Control parameters
    --
    -- $control-parameters
    BasisFactorizationControlParameters (..)
  , SimplexMethodControlParameters (..)
  , InteriorPointControlParameters (..)
  , MIPControlParameters (..)
  , MPSControlParameters (..)
  , CplexLPFormatControlParameters (..)
  , GlpkCutAttribute (..)
  , GlpkUserCutType (..)

    -- ** GLPK arrays
    --
    -- $arrays
  , GlpkArray (..)
  , mallocGlpkArray
  , allocaGlpkArray
  , initGlpkArray
  , FixedLength (..)
  , FixedLengthArray (..)

    -- ** Low-level and phantom types
  , GlpkInt (..)
  , Problem
  , GlpkColumn
  , GlpkRow
  , GlpkNodeIndex
  , GlpkTree
  , MathProgWorkspace
  , Row
  , Column
  , MathProgResult (..)

    -- ** Undocumented and unused structures
  , Unused (..)
  , BfcpFooBar
  , SmcpFooBar
  , IptcpFooBar
  , IocpFooBar
  , AttrFooBar
  , MpscpFooBar
  , CpxcpFooBar

    -- * GLPK API

    -- ** Enums
  , GlpkMajorVersion
  , glpkMajorVersion
  , GlpkMinorVersion
  , glpkMinorVersion
  , GlpkDirection
  , glpkMin
  , glpkMax
  , GlpkVariableType (..)
  , glpkContinuous
  , glpkInteger
  , glpkBinary
  , GlpkConstraintType
  , glpkFree
  , glpkGT
  , glpkLT
  , glpkBounded
  , glpkFixed
  , GlpkVariableStatus
  , glpkBasic
  , glpkNonBasicLower
  , glpkNonBasicUpper
  , glpkNonBasicFree
  , glpkNonBasicFixed
  , GlpkScaling
  , glpkGeometricMeanScaling
  , glpkEquilibrationScaling
  , glpkPowerOfTwoScaling
  , glpkSkipScaling
  , glpkAutoScaling
  , GlpkSolutionType
  , glpkBasicSolution
  , glpkInteriorPointSolution
  , glpkMIPSolution
  , GlpkSolutionStatus
  , glpkOptimal
  , glpkFeasible
  , glpkInfeasible
  , glpkNoFeasible
  , glpkUnbounded
  , glpkUndefined
  , GlpkMessageLevel
  , glpkMessageOff
  , glpkMessageError
  , glpkMessageOn
  , glpkMessageAll
  , glpkMessageDebug
  , GlpkSimplexMethod
  , glpkPrimalSimplex
  , glpkDualSimplex
  , glpkDualPSimplex
  , GlpkPricing
  , glpkTextbookPricing
  , glpkStandardPricing
  , glpkProjectedSteepestEdge
  , GlpkRatioTest
  , glpkStandardRatioTest
  , glpkHarrisTwoPassRatioTest
  , GlpkPreCholeskyOrdering
  , glpkNatural
  , glpkQuotientMinimumDegree
  , glpkApproximateMinimumDegree
  , glpkSymmetricApproximateMinimumDegree
  , GlpkBranchingTechnique
  , glpkFirstFractional
  , glpkLastFractional
  , glpkMostFractional
  , glpkDriebeckTomlin
  , glpkHybridPseudoCost
  , GlpkBacktrackingTechnique
  , glpkDepthFirstSearch
  , glpkBreadthFirstSearch
  , glpkBestLocalBound
  , glpkBestProjectionHeuristic
  , GlpkPreProcessingTechnique
  , glpkPreProcessNone
  , glpkPreProcessRoot
  , glpkPreProcessAll
  , GlpkFeasibilityPump
  , glpkFeasibilityPumpOn
  , glpkFeasibilityPumpOff
  , GlpkProximitySearch
  , glpkProximitySearchOn
  , glpkProximitySearchOff
  , GlpkGomoryCuts
  , glpkGomoryCutsOn
  , glpkGomoryCutsOff
  , GlpkMIRCuts
  , glpkMIRCutsOn
  , glpkMIRCutsOff
  , GlpkCoverCuts
  , glpkCoverCutsOn
  , glpkCoverCutsOff
  , GlpkCliqueCuts
  , glpkCliqueCutsOn
  , glpkCliqueCutsOff
  , GlpkPresolve
  , glpkPresolveOn
  , glpkPresolveOff
  , GlpkBinarization
  , glpkBinarizationOn
  , glpkBinarizationOff
  , GlpkSimpleRounding
  , glpkSimpleRoundingOn
  , glpkSimpleRoundingOff
  , GlpkConstraintOrigin
  , glpkRegularConstraint
  , glpkLazyConstraint
  , glpkCuttingPlaneConstraint
  , GlpkCutType
  , glpkGomoryCut
  , glpkMIRCut
  , glpkCoverCut
  , glpkCliqueCut
  , GlpkControl
  , glpkOn
  , glpkOff
  , GlpkCallbackReason
  , glpkSubproblemSelection
  , glpkPreprocessing
  , glpkRowGeneration
  , glpkHeuristicSolution
  , glpkCutGeneration
  , glpkBranching
  , glpkNewIncumbent
  , GlpkBranchOption
  , glpkBranchUp
  , glpkBranchDown
  , glpkBranchAuto
  , GlpkFactorizationResult
  , glpkFactorizationSuccess
  , glpkFactorizationBadBasis
  , glpkFactorizationSingular
  , glpkFactorizationIllConditioned
  , GlpkSimplexStatus
  , glpkSimplexSuccess
  , glpkSimplexBadBasis
  , glpkSimplexSingular
  , glpkSimplexIllConditioned
  , glpkSimplexBadBound
  , glpkSimplexFailure
  , glpkSimplexDualLowerLimitFailure
  , glpkSimplexDualUpperLimitFailure
  , glpkSimplexIterationLimit
  , glpkSimplexTimeLimit
  , glpkSimplexPrimalInfeasible
  , glpkSimplexDualInfeasible
  , GlpkMIPStatus
  , glpkMIPSuccess
  , glpkMIPBadBound
  , glpkMIPNoBasis
  , glpkMIPPrimalInfeasible
  , glpkMIPDualInfeasible
  , glpkMIPFailure
  , glpkMIPRelativeGap
  , glpkMIPTimeLimit
  , glpkMIPStopped
  , GlpkInteriorPointStatus
  , glpkInteriorPointSuccess
  , glpkInteriorPointFailure
  , glpkInteriorPointNoConvergence
  , glpkInteriorPointIterationLimit
  , glpkInteriorPointNumericalInstability
  , GlpkKKTCheck
  , glpkKKTPrimalEquality
  , glpkKKTPrimalBound
  , glpkKKTDualEquality
  , glpkKKTDualBound
  , GlpkMPSFormat
  , glpkMPSAncient
  , glpkMPSDeck
  , glpkMPSModern
  , GlpkFactorizationType
  , glpkLUForrestTomlin
  , glpkLUSchurCompBartelsGolub
  , glpkLUSchurGivensRotation
  , glpkBTSchurBartelsGolub
  , glpkBTSchurGivensRotation

  -- ** Functions
  , glp_create_prob
  , glp_delete_prob
  , glp_set_prob_name
  , glp_set_obj_name
  , glp_set_obj_dir
  , glp_add_rows
  , glp_add_cols
  , glp_set_row_name
  , glp_set_col_name
  , glp_set_row_bnds
  , glp_set_col_bnds
  , glp_set_obj_coef
  , glp_set_mat_row
  , glp_set_mat_col
  , glp_load_matrix
  , glp_check_dup
  , glp_sort_matrix
  , glp_del_rows
  , glp_del_cols
  , glp_copy_prob
  , glp_erase_prob
  , glp_get_prob_name
  , glp_get_obj_name
  , glp_get_obj_dir
  , glp_get_num_rows
  , glp_get_num_cols
  , glp_get_row_name
  , glp_get_col_name
  , glp_get_row_type
  , glp_get_row_lb
  , glp_get_row_ub
  , glp_get_col_type
  , glp_get_col_lb
  , glp_get_col_ub
  , glp_get_obj_coef
  , glp_get_num_nz
  , glp_get_mat_row
  , glp_get_mat_col
  , glp_create_index
  , glp_delete_index
  , glp_find_row
  , glp_find_col
  , glp_set_rii
  , glp_get_rii
  , glp_set_sjj
  , glp_get_sjj
  , glp_scale_prob
  , glp_unscale_prob
  , glp_set_row_stat
  , glp_set_col_stat
  , glp_std_basis
  , glp_adv_basis
  , glp_cpx_basis
  , glp_simplex
  , glp_exact
  , glp_init_smcp
  , glp_get_status
  , glp_get_prim_stat
  , glp_get_dual_stat
  , glp_get_obj_val
  , glp_get_row_stat
  , glp_get_col_stat
  , glp_get_row_prim
  , glp_get_row_dual
  , glp_get_col_prim
  , glp_get_col_dual
  , glp_get_unbnd_ray
  , glp_get_bfcp
  , glp_set_bfcp
  , glp_interior
  , glp_init_iptcp
  , glp_ipt_status
  , glp_intopt
  , glp_mip_status
  , glp_mip_obj_val
  , glp_mip_row_val
  , glp_mip_col_val
  , glp_check_kkt
  , glp_print_sol
  , glp_read_sol
  , glp_write_sol
  , glp_print_ranges
  , glp_print_ipt
  , glp_read_ipt
  , glp_write_ipt
  , glp_print_mip
  , glp_read_mip
  , glp_write_mip
  , glp_bf_exists
  , glp_factorize
  , glp_bf_updated
  , glp_get_bhead
  , glp_get_row_bind
  , glp_get_col_bind
  , glp_ftran
  , glp_btran
  , glp_warm_up
  , glp_eval_tab_row
  , glp_eval_tab_col
  , glp_transform_row
  , glp_transform_col
  , glp_prim_rtest
  , glp_dual_rtest
  , glp_analyze_bound
  , glp_analyze_coef
  , glp_init_iocp
  , glp_ipt_obj_val
  , glp_ipt_row_prim
  , glp_ipt_row_dual
  , glp_ipt_col_prim
  , glp_ipt_col_dual
  , glp_ios_reason
  , glp_ios_get_prob
  , glp_ios_tree_size
  , glp_ios_curr_node
  , glp_ios_next_node
  , glp_ios_prev_node
  , glp_ios_up_node
  , glp_ios_node_level
  , glp_ios_node_bound
  , glp_ios_best_node
  , glp_ios_mip_gap
  , glp_ios_node_data
  , glp_ios_row_attr
  , glp_ios_pool_size
  , glp_ios_add_row
  , glp_ios_del_row
  , glp_ios_clear_pool
  , glp_ios_can_branch
  , glp_ios_branch_upon
  , glp_ios_select_node
  , glp_ios_heur_sol
  , glp_ios_terminate
  , glp_set_col_kind
  , glp_get_col_kind
  , glp_get_num_int
  , glp_get_num_bin
  , glp_init_mpscp
  , glp_read_mps
  , glp_write_mps
  , glp_init_cpxcp
  , glp_read_lp
  , glp_write_lp
  , glp_read_prob
  , glp_write_prob
  , glp_mpl_alloc_wksp
  , glp_mpl_free_wksp
  , glp_mpl_init_rand
  , glp_mpl_read_model
  , glp_mpl_read_data
  , glp_mpl_generate
  , glp_mpl_build_prob
  , glp_mpl_postsolve
  , glp_read_cnfstat
  , glp_write_cnfstat
  , glp_minisat1
  , glp_intfeas1
  , glp_init_env
  , glp_free_env
  , glp_version
  , glp_config
  , glp_term_out
  , glp_term_hook
  , glp_error_hook
  -- ** Helper functions
  , mkHaskellErrorHook
  , mkHaskellTermHook
  , mkHaskellMIPCallback
  ) where

import Data.Typeable
import GHC.Generics (Generic)
import Foreign.C
import Foreign.Marshal.Array
import Foreign.Ptr
import Foreign.Storable
import Foreign.Storable.Generic



-- Low-level and phantom types

-- | A phantom type representing a problem in GLPK.
data Problem

-- | Phantom type used to denote data as being a column.
data GlpkColumn

-- | Phantom type used to denote data as being a row.
data GlpkRow

-- | Phantom type used to denote data as being a node index.
data GlpkNodeIndex

-- | Phantom type indicating the data stored in MIP callbacks.
data GlpkTree a

-- | Phantom type used to denote pointers to workspaces.
data MathProgWorkspace

-- | Wrapper around 'CInt' values, tagged with a phantom type to help
-- track what it refers to.
newtype GlpkInt a
  = GlpkInt { forall a. GlpkInt a -> CInt
fromGlpkInt :: CInt }
  deriving
    ( Int -> GlpkInt a
GlpkInt a -> Int
GlpkInt a -> [GlpkInt a]
GlpkInt a -> GlpkInt a
GlpkInt a -> GlpkInt a -> [GlpkInt a]
GlpkInt a -> GlpkInt a -> GlpkInt a -> [GlpkInt a]
(GlpkInt a -> GlpkInt a)
-> (GlpkInt a -> GlpkInt a)
-> (Int -> GlpkInt a)
-> (GlpkInt a -> Int)
-> (GlpkInt a -> [GlpkInt a])
-> (GlpkInt a -> GlpkInt a -> [GlpkInt a])
-> (GlpkInt a -> GlpkInt a -> [GlpkInt a])
-> (GlpkInt a -> GlpkInt a -> GlpkInt a -> [GlpkInt a])
-> Enum (GlpkInt a)
forall a. Int -> GlpkInt a
forall a. GlpkInt a -> Int
forall a. GlpkInt a -> [GlpkInt a]
forall a. GlpkInt a -> GlpkInt a
forall a. GlpkInt a -> GlpkInt a -> [GlpkInt a]
forall a. GlpkInt a -> GlpkInt a -> GlpkInt a -> [GlpkInt a]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: GlpkInt a -> GlpkInt a -> GlpkInt a -> [GlpkInt a]
$cenumFromThenTo :: forall a. GlpkInt a -> GlpkInt a -> GlpkInt a -> [GlpkInt a]
enumFromTo :: GlpkInt a -> GlpkInt a -> [GlpkInt a]
$cenumFromTo :: forall a. GlpkInt a -> GlpkInt a -> [GlpkInt a]
enumFromThen :: GlpkInt a -> GlpkInt a -> [GlpkInt a]
$cenumFromThen :: forall a. GlpkInt a -> GlpkInt a -> [GlpkInt a]
enumFrom :: GlpkInt a -> [GlpkInt a]
$cenumFrom :: forall a. GlpkInt a -> [GlpkInt a]
fromEnum :: GlpkInt a -> Int
$cfromEnum :: forall a. GlpkInt a -> Int
toEnum :: Int -> GlpkInt a
$ctoEnum :: forall a. Int -> GlpkInt a
pred :: GlpkInt a -> GlpkInt a
$cpred :: forall a. GlpkInt a -> GlpkInt a
succ :: GlpkInt a -> GlpkInt a
$csucc :: forall a. GlpkInt a -> GlpkInt a
Enum
    , GlpkInt a -> GlpkInt a -> Bool
(GlpkInt a -> GlpkInt a -> Bool)
-> (GlpkInt a -> GlpkInt a -> Bool) -> Eq (GlpkInt a)
forall a. GlpkInt a -> GlpkInt a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkInt a -> GlpkInt a -> Bool
$c/= :: forall a. GlpkInt a -> GlpkInt a -> Bool
== :: GlpkInt a -> GlpkInt a -> Bool
$c== :: forall a. GlpkInt a -> GlpkInt a -> Bool
Eq
    , Enum (GlpkInt a)
Real (GlpkInt a)
Real (GlpkInt a)
-> Enum (GlpkInt a)
-> (GlpkInt a -> GlpkInt a -> GlpkInt a)
-> (GlpkInt a -> GlpkInt a -> GlpkInt a)
-> (GlpkInt a -> GlpkInt a -> GlpkInt a)
-> (GlpkInt a -> GlpkInt a -> GlpkInt a)
-> (GlpkInt a -> GlpkInt a -> (GlpkInt a, GlpkInt a))
-> (GlpkInt a -> GlpkInt a -> (GlpkInt a, GlpkInt a))
-> (GlpkInt a -> Integer)
-> Integral (GlpkInt a)
GlpkInt a -> Integer
GlpkInt a -> GlpkInt a -> (GlpkInt a, GlpkInt a)
GlpkInt a -> GlpkInt a -> GlpkInt a
forall a. Enum (GlpkInt a)
forall {a}. Real (GlpkInt a)
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
forall a. GlpkInt a -> Integer
forall a. GlpkInt a -> GlpkInt a -> (GlpkInt a, GlpkInt a)
forall a. GlpkInt a -> GlpkInt a -> GlpkInt a
toInteger :: GlpkInt a -> Integer
$ctoInteger :: forall a. GlpkInt a -> Integer
divMod :: GlpkInt a -> GlpkInt a -> (GlpkInt a, GlpkInt a)
$cdivMod :: forall a. GlpkInt a -> GlpkInt a -> (GlpkInt a, GlpkInt a)
quotRem :: GlpkInt a -> GlpkInt a -> (GlpkInt a, GlpkInt a)
$cquotRem :: forall a. GlpkInt a -> GlpkInt a -> (GlpkInt a, GlpkInt a)
mod :: GlpkInt a -> GlpkInt a -> GlpkInt a
$cmod :: forall a. GlpkInt a -> GlpkInt a -> GlpkInt a
div :: GlpkInt a -> GlpkInt a -> GlpkInt a
$cdiv :: forall a. GlpkInt a -> GlpkInt a -> GlpkInt a
rem :: GlpkInt a -> GlpkInt a -> GlpkInt a
$crem :: forall a. GlpkInt a -> GlpkInt a -> GlpkInt a
quot :: GlpkInt a -> GlpkInt a -> GlpkInt a
$cquot :: forall a. GlpkInt a -> GlpkInt a -> GlpkInt a
Integral
    , Integer -> GlpkInt a
GlpkInt a -> GlpkInt a
GlpkInt a -> GlpkInt a -> GlpkInt a
(GlpkInt a -> GlpkInt a -> GlpkInt a)
-> (GlpkInt a -> GlpkInt a -> GlpkInt a)
-> (GlpkInt a -> GlpkInt a -> GlpkInt a)
-> (GlpkInt a -> GlpkInt a)
-> (GlpkInt a -> GlpkInt a)
-> (GlpkInt a -> GlpkInt a)
-> (Integer -> GlpkInt a)
-> Num (GlpkInt a)
forall a. Integer -> GlpkInt a
forall a. GlpkInt a -> GlpkInt a
forall a. GlpkInt a -> GlpkInt a -> GlpkInt a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> GlpkInt a
$cfromInteger :: forall a. Integer -> GlpkInt a
signum :: GlpkInt a -> GlpkInt a
$csignum :: forall a. GlpkInt a -> GlpkInt a
abs :: GlpkInt a -> GlpkInt a
$cabs :: forall a. GlpkInt a -> GlpkInt a
negate :: GlpkInt a -> GlpkInt a
$cnegate :: forall a. GlpkInt a -> GlpkInt a
* :: GlpkInt a -> GlpkInt a -> GlpkInt a
$c* :: forall a. GlpkInt a -> GlpkInt a -> GlpkInt a
- :: GlpkInt a -> GlpkInt a -> GlpkInt a
$c- :: forall a. GlpkInt a -> GlpkInt a -> GlpkInt a
+ :: GlpkInt a -> GlpkInt a -> GlpkInt a
$c+ :: forall a. GlpkInt a -> GlpkInt a -> GlpkInt a
Num
    , Eq (GlpkInt a)
Eq (GlpkInt a)
-> (GlpkInt a -> GlpkInt a -> Ordering)
-> (GlpkInt a -> GlpkInt a -> Bool)
-> (GlpkInt a -> GlpkInt a -> Bool)
-> (GlpkInt a -> GlpkInt a -> Bool)
-> (GlpkInt a -> GlpkInt a -> Bool)
-> (GlpkInt a -> GlpkInt a -> GlpkInt a)
-> (GlpkInt a -> GlpkInt a -> GlpkInt a)
-> Ord (GlpkInt a)
GlpkInt a -> GlpkInt a -> Bool
GlpkInt a -> GlpkInt a -> Ordering
GlpkInt a -> GlpkInt a -> GlpkInt a
forall a. Eq (GlpkInt a)
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. GlpkInt a -> GlpkInt a -> Bool
forall a. GlpkInt a -> GlpkInt a -> Ordering
forall a. GlpkInt a -> GlpkInt a -> GlpkInt a
min :: GlpkInt a -> GlpkInt a -> GlpkInt a
$cmin :: forall a. GlpkInt a -> GlpkInt a -> GlpkInt a
max :: GlpkInt a -> GlpkInt a -> GlpkInt a
$cmax :: forall a. GlpkInt a -> GlpkInt a -> GlpkInt a
>= :: GlpkInt a -> GlpkInt a -> Bool
$c>= :: forall a. GlpkInt a -> GlpkInt a -> Bool
> :: GlpkInt a -> GlpkInt a -> Bool
$c> :: forall a. GlpkInt a -> GlpkInt a -> Bool
<= :: GlpkInt a -> GlpkInt a -> Bool
$c<= :: forall a. GlpkInt a -> GlpkInt a -> Bool
< :: GlpkInt a -> GlpkInt a -> Bool
$c< :: forall a. GlpkInt a -> GlpkInt a -> Bool
compare :: GlpkInt a -> GlpkInt a -> Ordering
$ccompare :: forall a. GlpkInt a -> GlpkInt a -> Ordering
Ord
    , ReadPrec [GlpkInt a]
ReadPrec (GlpkInt a)
Int -> ReadS (GlpkInt a)
ReadS [GlpkInt a]
(Int -> ReadS (GlpkInt a))
-> ReadS [GlpkInt a]
-> ReadPrec (GlpkInt a)
-> ReadPrec [GlpkInt a]
-> Read (GlpkInt a)
forall a. ReadPrec [GlpkInt a]
forall a. ReadPrec (GlpkInt a)
forall a. Int -> ReadS (GlpkInt a)
forall a. ReadS [GlpkInt a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkInt a]
$creadListPrec :: forall a. ReadPrec [GlpkInt a]
readPrec :: ReadPrec (GlpkInt a)
$creadPrec :: forall a. ReadPrec (GlpkInt a)
readList :: ReadS [GlpkInt a]
$creadList :: forall a. ReadS [GlpkInt a]
readsPrec :: Int -> ReadS (GlpkInt a)
$creadsPrec :: forall a. Int -> ReadS (GlpkInt a)
Read
    , Num (GlpkInt a)
Ord (GlpkInt a)
Num (GlpkInt a)
-> Ord (GlpkInt a) -> (GlpkInt a -> Rational) -> Real (GlpkInt a)
GlpkInt a -> Rational
forall a. Num (GlpkInt a)
forall a. Ord (GlpkInt a)
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
forall a. GlpkInt a -> Rational
toRational :: GlpkInt a -> Rational
$ctoRational :: forall a. GlpkInt a -> Rational
Real
    , Int -> GlpkInt a -> ShowS
[GlpkInt a] -> ShowS
GlpkInt a -> String
(Int -> GlpkInt a -> ShowS)
-> (GlpkInt a -> String)
-> ([GlpkInt a] -> ShowS)
-> Show (GlpkInt a)
forall a. Int -> GlpkInt a -> ShowS
forall a. [GlpkInt a] -> ShowS
forall a. GlpkInt a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkInt a] -> ShowS
$cshowList :: forall a. [GlpkInt a] -> ShowS
show :: GlpkInt a -> String
$cshow :: forall a. GlpkInt a -> String
showsPrec :: Int -> GlpkInt a -> ShowS
$cshowsPrec :: forall a. Int -> GlpkInt a -> ShowS
Show
    , Ptr (GlpkInt a) -> IO (GlpkInt a)
Ptr (GlpkInt a) -> Int -> IO (GlpkInt a)
Ptr (GlpkInt a) -> Int -> GlpkInt a -> IO ()
Ptr (GlpkInt a) -> GlpkInt a -> IO ()
GlpkInt a -> Int
(GlpkInt a -> Int)
-> (GlpkInt a -> Int)
-> (Ptr (GlpkInt a) -> Int -> IO (GlpkInt a))
-> (Ptr (GlpkInt a) -> Int -> GlpkInt a -> IO ())
-> (forall b. Ptr b -> Int -> IO (GlpkInt a))
-> (forall b. Ptr b -> Int -> GlpkInt a -> IO ())
-> (Ptr (GlpkInt a) -> IO (GlpkInt a))
-> (Ptr (GlpkInt a) -> GlpkInt a -> IO ())
-> Storable (GlpkInt a)
forall b. Ptr b -> Int -> IO (GlpkInt a)
forall b. Ptr b -> Int -> GlpkInt a -> IO ()
forall a. Ptr (GlpkInt a) -> IO (GlpkInt a)
forall a. Ptr (GlpkInt a) -> Int -> IO (GlpkInt a)
forall a. Ptr (GlpkInt a) -> Int -> GlpkInt a -> IO ()
forall a. Ptr (GlpkInt a) -> GlpkInt a -> IO ()
forall a. GlpkInt a -> Int
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
forall a b. Ptr b -> Int -> IO (GlpkInt a)
forall a b. Ptr b -> Int -> GlpkInt a -> IO ()
poke :: Ptr (GlpkInt a) -> GlpkInt a -> IO ()
$cpoke :: forall a. Ptr (GlpkInt a) -> GlpkInt a -> IO ()
peek :: Ptr (GlpkInt a) -> IO (GlpkInt a)
$cpeek :: forall a. Ptr (GlpkInt a) -> IO (GlpkInt a)
pokeByteOff :: forall b. Ptr b -> Int -> GlpkInt a -> IO ()
$cpokeByteOff :: forall a b. Ptr b -> Int -> GlpkInt a -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO (GlpkInt a)
$cpeekByteOff :: forall a b. Ptr b -> Int -> IO (GlpkInt a)
pokeElemOff :: Ptr (GlpkInt a) -> Int -> GlpkInt a -> IO ()
$cpokeElemOff :: forall a. Ptr (GlpkInt a) -> Int -> GlpkInt a -> IO ()
peekElemOff :: Ptr (GlpkInt a) -> Int -> IO (GlpkInt a)
$cpeekElemOff :: forall a. Ptr (GlpkInt a) -> Int -> IO (GlpkInt a)
alignment :: GlpkInt a -> Int
$calignment :: forall a. GlpkInt a -> Int
sizeOf :: GlpkInt a -> Int
$csizeOf :: forall a. GlpkInt a -> Int
Storable
    )

-- | Convenient alias for rows.
type Row = GlpkInt GlpkRow

-- | Convenient alias for columns.
type Column = GlpkInt GlpkColumn

-- GLPK Arrays

-- $arrays
--
-- GLPK uses a 1-based indexing for arrays. This is accomplished by
-- ignoring the 0th entry.

-- | An array whose data begins at index 1
newtype GlpkArray a
  = GlpkArray { forall a. GlpkArray a -> Ptr a
fromGlpkArray :: Ptr a }
  deriving
    ( GlpkArray a -> GlpkArray a -> Bool
(GlpkArray a -> GlpkArray a -> Bool)
-> (GlpkArray a -> GlpkArray a -> Bool) -> Eq (GlpkArray a)
forall a. GlpkArray a -> GlpkArray a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkArray a -> GlpkArray a -> Bool
$c/= :: forall a. GlpkArray a -> GlpkArray a -> Bool
== :: GlpkArray a -> GlpkArray a -> Bool
$c== :: forall a. GlpkArray a -> GlpkArray a -> Bool
Eq
    , Eq (GlpkArray a)
Eq (GlpkArray a)
-> (GlpkArray a -> GlpkArray a -> Ordering)
-> (GlpkArray a -> GlpkArray a -> Bool)
-> (GlpkArray a -> GlpkArray a -> Bool)
-> (GlpkArray a -> GlpkArray a -> Bool)
-> (GlpkArray a -> GlpkArray a -> Bool)
-> (GlpkArray a -> GlpkArray a -> GlpkArray a)
-> (GlpkArray a -> GlpkArray a -> GlpkArray a)
-> Ord (GlpkArray a)
GlpkArray a -> GlpkArray a -> Bool
GlpkArray a -> GlpkArray a -> Ordering
GlpkArray a -> GlpkArray a -> GlpkArray a
forall a. Eq (GlpkArray a)
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. GlpkArray a -> GlpkArray a -> Bool
forall a. GlpkArray a -> GlpkArray a -> Ordering
forall a. GlpkArray a -> GlpkArray a -> GlpkArray a
min :: GlpkArray a -> GlpkArray a -> GlpkArray a
$cmin :: forall a. GlpkArray a -> GlpkArray a -> GlpkArray a
max :: GlpkArray a -> GlpkArray a -> GlpkArray a
$cmax :: forall a. GlpkArray a -> GlpkArray a -> GlpkArray a
>= :: GlpkArray a -> GlpkArray a -> Bool
$c>= :: forall a. GlpkArray a -> GlpkArray a -> Bool
> :: GlpkArray a -> GlpkArray a -> Bool
$c> :: forall a. GlpkArray a -> GlpkArray a -> Bool
<= :: GlpkArray a -> GlpkArray a -> Bool
$c<= :: forall a. GlpkArray a -> GlpkArray a -> Bool
< :: GlpkArray a -> GlpkArray a -> Bool
$c< :: forall a. GlpkArray a -> GlpkArray a -> Bool
compare :: GlpkArray a -> GlpkArray a -> Ordering
$ccompare :: forall a. GlpkArray a -> GlpkArray a -> Ordering
Ord
    , Int -> GlpkArray a -> ShowS
[GlpkArray a] -> ShowS
GlpkArray a -> String
(Int -> GlpkArray a -> ShowS)
-> (GlpkArray a -> String)
-> ([GlpkArray a] -> ShowS)
-> Show (GlpkArray a)
forall a. Int -> GlpkArray a -> ShowS
forall a. [GlpkArray a] -> ShowS
forall a. GlpkArray a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkArray a] -> ShowS
$cshowList :: forall a. [GlpkArray a] -> ShowS
show :: GlpkArray a -> String
$cshow :: forall a. GlpkArray a -> String
showsPrec :: Int -> GlpkArray a -> ShowS
$cshowsPrec :: forall a. Int -> GlpkArray a -> ShowS
Show
    , Ptr (GlpkArray a) -> IO (GlpkArray a)
Ptr (GlpkArray a) -> Int -> IO (GlpkArray a)
Ptr (GlpkArray a) -> Int -> GlpkArray a -> IO ()
Ptr (GlpkArray a) -> GlpkArray a -> IO ()
GlpkArray a -> Int
(GlpkArray a -> Int)
-> (GlpkArray a -> Int)
-> (Ptr (GlpkArray a) -> Int -> IO (GlpkArray a))
-> (Ptr (GlpkArray a) -> Int -> GlpkArray a -> IO ())
-> (forall b. Ptr b -> Int -> IO (GlpkArray a))
-> (forall b. Ptr b -> Int -> GlpkArray a -> IO ())
-> (Ptr (GlpkArray a) -> IO (GlpkArray a))
-> (Ptr (GlpkArray a) -> GlpkArray a -> IO ())
-> Storable (GlpkArray a)
forall b. Ptr b -> Int -> IO (GlpkArray a)
forall b. Ptr b -> Int -> GlpkArray a -> IO ()
forall a. Ptr (GlpkArray a) -> IO (GlpkArray a)
forall a. Ptr (GlpkArray a) -> Int -> IO (GlpkArray a)
forall a. Ptr (GlpkArray a) -> Int -> GlpkArray a -> IO ()
forall a. Ptr (GlpkArray a) -> GlpkArray a -> IO ()
forall a. GlpkArray a -> Int
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
forall a b. Ptr b -> Int -> IO (GlpkArray a)
forall a b. Ptr b -> Int -> GlpkArray a -> IO ()
poke :: Ptr (GlpkArray a) -> GlpkArray a -> IO ()
$cpoke :: forall a. Ptr (GlpkArray a) -> GlpkArray a -> IO ()
peek :: Ptr (GlpkArray a) -> IO (GlpkArray a)
$cpeek :: forall a. Ptr (GlpkArray a) -> IO (GlpkArray a)
pokeByteOff :: forall b. Ptr b -> Int -> GlpkArray a -> IO ()
$cpokeByteOff :: forall a b. Ptr b -> Int -> GlpkArray a -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO (GlpkArray a)
$cpeekByteOff :: forall a b. Ptr b -> Int -> IO (GlpkArray a)
pokeElemOff :: Ptr (GlpkArray a) -> Int -> GlpkArray a -> IO ()
$cpokeElemOff :: forall a. Ptr (GlpkArray a) -> Int -> GlpkArray a -> IO ()
peekElemOff :: Ptr (GlpkArray a) -> Int -> IO (GlpkArray a)
$cpeekElemOff :: forall a. Ptr (GlpkArray a) -> Int -> IO (GlpkArray a)
alignment :: GlpkArray a -> Int
$calignment :: forall a. GlpkArray a -> Int
sizeOf :: GlpkArray a -> Int
$csizeOf :: forall a. GlpkArray a -> Int
Storable
    )

-- | A type used to represent an unused or undocumented struct member.
newtype Unused a
  = Unused { forall a. Unused a -> a
fromUnused :: a }
  deriving
    ( Int -> Unused a
Unused a -> Int
Unused a -> [Unused a]
Unused a -> Unused a
Unused a -> Unused a -> [Unused a]
Unused a -> Unused a -> Unused a -> [Unused a]
(Unused a -> Unused a)
-> (Unused a -> Unused a)
-> (Int -> Unused a)
-> (Unused a -> Int)
-> (Unused a -> [Unused a])
-> (Unused a -> Unused a -> [Unused a])
-> (Unused a -> Unused a -> [Unused a])
-> (Unused a -> Unused a -> Unused a -> [Unused a])
-> Enum (Unused a)
forall a. Enum a => Int -> Unused a
forall a. Enum a => Unused a -> Int
forall a. Enum a => Unused a -> [Unused a]
forall a. Enum a => Unused a -> Unused a
forall a. Enum a => Unused a -> Unused a -> [Unused a]
forall a. Enum a => Unused a -> Unused a -> Unused a -> [Unused a]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Unused a -> Unused a -> Unused a -> [Unused a]
$cenumFromThenTo :: forall a. Enum a => Unused a -> Unused a -> Unused a -> [Unused a]
enumFromTo :: Unused a -> Unused a -> [Unused a]
$cenumFromTo :: forall a. Enum a => Unused a -> Unused a -> [Unused a]
enumFromThen :: Unused a -> Unused a -> [Unused a]
$cenumFromThen :: forall a. Enum a => Unused a -> Unused a -> [Unused a]
enumFrom :: Unused a -> [Unused a]
$cenumFrom :: forall a. Enum a => Unused a -> [Unused a]
fromEnum :: Unused a -> Int
$cfromEnum :: forall a. Enum a => Unused a -> Int
toEnum :: Int -> Unused a
$ctoEnum :: forall a. Enum a => Int -> Unused a
pred :: Unused a -> Unused a
$cpred :: forall a. Enum a => Unused a -> Unused a
succ :: Unused a -> Unused a
$csucc :: forall a. Enum a => Unused a -> Unused a
Enum
    , Unused a -> Unused a -> Bool
(Unused a -> Unused a -> Bool)
-> (Unused a -> Unused a -> Bool) -> Eq (Unused a)
forall a. Eq a => Unused a -> Unused a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Unused a -> Unused a -> Bool
$c/= :: forall a. Eq a => Unused a -> Unused a -> Bool
== :: Unused a -> Unused a -> Bool
$c== :: forall a. Eq a => Unused a -> Unused a -> Bool
Eq
    , Unused a -> Int
(Unused a -> Int)
-> (Unused a -> Int)
-> (forall b. Ptr b -> Int -> IO (Unused a))
-> (forall b. Ptr b -> Int -> Unused a -> IO ())
-> GStorable (Unused a)
forall b. Ptr b -> Int -> IO (Unused a)
forall b. Ptr b -> Int -> Unused a -> IO ()
forall a. GStorable a => Unused a -> Int
forall a b. GStorable a => Ptr b -> Int -> IO (Unused a)
forall a b. GStorable a => Ptr b -> Int -> Unused a -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> GStorable a
gpokeByteOff :: forall b. Ptr b -> Int -> Unused a -> IO ()
$cgpokeByteOff :: forall a b. GStorable a => Ptr b -> Int -> Unused a -> IO ()
gpeekByteOff :: forall b. Ptr b -> Int -> IO (Unused a)
$cgpeekByteOff :: forall a b. GStorable a => Ptr b -> Int -> IO (Unused a)
galignment :: Unused a -> Int
$cgalignment :: forall a. GStorable a => Unused a -> Int
gsizeOf :: Unused a -> Int
$cgsizeOf :: forall a. GStorable a => Unused a -> Int
GStorable
    , Eq (Unused a)
Eq (Unused a)
-> (Unused a -> Unused a -> Ordering)
-> (Unused a -> Unused a -> Bool)
-> (Unused a -> Unused a -> Bool)
-> (Unused a -> Unused a -> Bool)
-> (Unused a -> Unused a -> Bool)
-> (Unused a -> Unused a -> Unused a)
-> (Unused a -> Unused a -> Unused a)
-> Ord (Unused a)
Unused a -> Unused a -> Bool
Unused a -> Unused a -> Ordering
Unused a -> Unused a -> Unused a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Unused a)
forall a. Ord a => Unused a -> Unused a -> Bool
forall a. Ord a => Unused a -> Unused a -> Ordering
forall a. Ord a => Unused a -> Unused a -> Unused a
min :: Unused a -> Unused a -> Unused a
$cmin :: forall a. Ord a => Unused a -> Unused a -> Unused a
max :: Unused a -> Unused a -> Unused a
$cmax :: forall a. Ord a => Unused a -> Unused a -> Unused a
>= :: Unused a -> Unused a -> Bool
$c>= :: forall a. Ord a => Unused a -> Unused a -> Bool
> :: Unused a -> Unused a -> Bool
$c> :: forall a. Ord a => Unused a -> Unused a -> Bool
<= :: Unused a -> Unused a -> Bool
$c<= :: forall a. Ord a => Unused a -> Unused a -> Bool
< :: Unused a -> Unused a -> Bool
$c< :: forall a. Ord a => Unused a -> Unused a -> Bool
compare :: Unused a -> Unused a -> Ordering
$ccompare :: forall a. Ord a => Unused a -> Unused a -> Ordering
Ord
    , ReadPrec [Unused a]
ReadPrec (Unused a)
Int -> ReadS (Unused a)
ReadS [Unused a]
(Int -> ReadS (Unused a))
-> ReadS [Unused a]
-> ReadPrec (Unused a)
-> ReadPrec [Unused a]
-> Read (Unused a)
forall a. Read a => ReadPrec [Unused a]
forall a. Read a => ReadPrec (Unused a)
forall a. Read a => Int -> ReadS (Unused a)
forall a. Read a => ReadS [Unused a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Unused a]
$creadListPrec :: forall a. Read a => ReadPrec [Unused a]
readPrec :: ReadPrec (Unused a)
$creadPrec :: forall a. Read a => ReadPrec (Unused a)
readList :: ReadS [Unused a]
$creadList :: forall a. Read a => ReadS [Unused a]
readsPrec :: Int -> ReadS (Unused a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Unused a)
Read
    , Int -> Unused a -> ShowS
[Unused a] -> ShowS
Unused a -> String
(Int -> Unused a -> ShowS)
-> (Unused a -> String) -> ([Unused a] -> ShowS) -> Show (Unused a)
forall a. Show a => Int -> Unused a -> ShowS
forall a. Show a => [Unused a] -> ShowS
forall a. Show a => Unused a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Unused a] -> ShowS
$cshowList :: forall a. Show a => [Unused a] -> ShowS
show :: Unused a -> String
$cshow :: forall a. Show a => Unused a -> String
showsPrec :: Int -> Unused a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Unused a -> ShowS
Show
    , Ptr (Unused a) -> IO (Unused a)
Ptr (Unused a) -> Int -> IO (Unused a)
Ptr (Unused a) -> Int -> Unused a -> IO ()
Ptr (Unused a) -> Unused a -> IO ()
Unused a -> Int
(Unused a -> Int)
-> (Unused a -> Int)
-> (Ptr (Unused a) -> Int -> IO (Unused a))
-> (Ptr (Unused a) -> Int -> Unused a -> IO ())
-> (forall b. Ptr b -> Int -> IO (Unused a))
-> (forall b. Ptr b -> Int -> Unused a -> IO ())
-> (Ptr (Unused a) -> IO (Unused a))
-> (Ptr (Unused a) -> Unused a -> IO ())
-> Storable (Unused a)
forall b. Ptr b -> Int -> IO (Unused a)
forall b. Ptr b -> Int -> Unused a -> IO ()
forall a. Storable a => Ptr (Unused a) -> IO (Unused a)
forall a. Storable a => Ptr (Unused a) -> Int -> IO (Unused a)
forall a. Storable a => Ptr (Unused a) -> Int -> Unused a -> IO ()
forall a. Storable a => Ptr (Unused a) -> Unused a -> IO ()
forall a. Storable a => Unused a -> Int
forall a b. Storable a => Ptr b -> Int -> IO (Unused a)
forall a b. Storable a => Ptr b -> Int -> Unused a -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr (Unused a) -> Unused a -> IO ()
$cpoke :: forall a. Storable a => Ptr (Unused a) -> Unused a -> IO ()
peek :: Ptr (Unused a) -> IO (Unused a)
$cpeek :: forall a. Storable a => Ptr (Unused a) -> IO (Unused a)
pokeByteOff :: forall b. Ptr b -> Int -> Unused a -> IO ()
$cpokeByteOff :: forall a b. Storable a => Ptr b -> Int -> Unused a -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO (Unused a)
$cpeekByteOff :: forall a b. Storable a => Ptr b -> Int -> IO (Unused a)
pokeElemOff :: Ptr (Unused a) -> Int -> Unused a -> IO ()
$cpokeElemOff :: forall a. Storable a => Ptr (Unused a) -> Int -> Unused a -> IO ()
peekElemOff :: Ptr (Unused a) -> Int -> IO (Unused a)
$cpeekElemOff :: forall a. Storable a => Ptr (Unused a) -> Int -> IO (Unused a)
alignment :: Unused a -> Int
$calignment :: forall a. Storable a => Unused a -> Int
sizeOf :: Unused a -> Int
$csizeOf :: forall a. Storable a => Unused a -> Int
Storable
    )

-- | The class of arrays of fixed length.
class FixedLength a where
  fixedLength :: a -> Int

-- | A type representing fixed-length array members of structs.
newtype FixedLengthArray a b
  = FixedLengthArray { forall a b. FixedLengthArray a b -> [b]
fromFixedLengthArray :: [b] }
  deriving
    ( FixedLengthArray a b -> FixedLengthArray a b -> Bool
(FixedLengthArray a b -> FixedLengthArray a b -> Bool)
-> (FixedLengthArray a b -> FixedLengthArray a b -> Bool)
-> Eq (FixedLengthArray a b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b.
Eq b =>
FixedLengthArray a b -> FixedLengthArray a b -> Bool
/= :: FixedLengthArray a b -> FixedLengthArray a b -> Bool
$c/= :: forall a b.
Eq b =>
FixedLengthArray a b -> FixedLengthArray a b -> Bool
== :: FixedLengthArray a b -> FixedLengthArray a b -> Bool
$c== :: forall a b.
Eq b =>
FixedLengthArray a b -> FixedLengthArray a b -> Bool
Eq
    , Eq (FixedLengthArray a b)
Eq (FixedLengthArray a b)
-> (FixedLengthArray a b -> FixedLengthArray a b -> Ordering)
-> (FixedLengthArray a b -> FixedLengthArray a b -> Bool)
-> (FixedLengthArray a b -> FixedLengthArray a b -> Bool)
-> (FixedLengthArray a b -> FixedLengthArray a b -> Bool)
-> (FixedLengthArray a b -> FixedLengthArray a b -> Bool)
-> (FixedLengthArray a b
    -> FixedLengthArray a b -> FixedLengthArray a b)
-> (FixedLengthArray a b
    -> FixedLengthArray a b -> FixedLengthArray a b)
-> Ord (FixedLengthArray a b)
FixedLengthArray a b -> FixedLengthArray a b -> Bool
FixedLengthArray a b -> FixedLengthArray a b -> Ordering
FixedLengthArray a b
-> FixedLengthArray a b -> FixedLengthArray a b
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a} {b}. Ord b => Eq (FixedLengthArray a b)
forall a b.
Ord b =>
FixedLengthArray a b -> FixedLengthArray a b -> Bool
forall a b.
Ord b =>
FixedLengthArray a b -> FixedLengthArray a b -> Ordering
forall a b.
Ord b =>
FixedLengthArray a b
-> FixedLengthArray a b -> FixedLengthArray a b
min :: FixedLengthArray a b
-> FixedLengthArray a b -> FixedLengthArray a b
$cmin :: forall a b.
Ord b =>
FixedLengthArray a b
-> FixedLengthArray a b -> FixedLengthArray a b
max :: FixedLengthArray a b
-> FixedLengthArray a b -> FixedLengthArray a b
$cmax :: forall a b.
Ord b =>
FixedLengthArray a b
-> FixedLengthArray a b -> FixedLengthArray a b
>= :: FixedLengthArray a b -> FixedLengthArray a b -> Bool
$c>= :: forall a b.
Ord b =>
FixedLengthArray a b -> FixedLengthArray a b -> Bool
> :: FixedLengthArray a b -> FixedLengthArray a b -> Bool
$c> :: forall a b.
Ord b =>
FixedLengthArray a b -> FixedLengthArray a b -> Bool
<= :: FixedLengthArray a b -> FixedLengthArray a b -> Bool
$c<= :: forall a b.
Ord b =>
FixedLengthArray a b -> FixedLengthArray a b -> Bool
< :: FixedLengthArray a b -> FixedLengthArray a b -> Bool
$c< :: forall a b.
Ord b =>
FixedLengthArray a b -> FixedLengthArray a b -> Bool
compare :: FixedLengthArray a b -> FixedLengthArray a b -> Ordering
$ccompare :: forall a b.
Ord b =>
FixedLengthArray a b -> FixedLengthArray a b -> Ordering
Ord
    , ReadPrec [FixedLengthArray a b]
ReadPrec (FixedLengthArray a b)
Int -> ReadS (FixedLengthArray a b)
ReadS [FixedLengthArray a b]
(Int -> ReadS (FixedLengthArray a b))
-> ReadS [FixedLengthArray a b]
-> ReadPrec (FixedLengthArray a b)
-> ReadPrec [FixedLengthArray a b]
-> Read (FixedLengthArray a b)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall a b. Read b => ReadPrec [FixedLengthArray a b]
forall a b. Read b => ReadPrec (FixedLengthArray a b)
forall a b. Read b => Int -> ReadS (FixedLengthArray a b)
forall a b. Read b => ReadS [FixedLengthArray a b]
readListPrec :: ReadPrec [FixedLengthArray a b]
$creadListPrec :: forall a b. Read b => ReadPrec [FixedLengthArray a b]
readPrec :: ReadPrec (FixedLengthArray a b)
$creadPrec :: forall a b. Read b => ReadPrec (FixedLengthArray a b)
readList :: ReadS [FixedLengthArray a b]
$creadList :: forall a b. Read b => ReadS [FixedLengthArray a b]
readsPrec :: Int -> ReadS (FixedLengthArray a b)
$creadsPrec :: forall a b. Read b => Int -> ReadS (FixedLengthArray a b)
Read
    , Int -> FixedLengthArray a b -> ShowS
[FixedLengthArray a b] -> ShowS
FixedLengthArray a b -> String
(Int -> FixedLengthArray a b -> ShowS)
-> (FixedLengthArray a b -> String)
-> ([FixedLengthArray a b] -> ShowS)
-> Show (FixedLengthArray a b)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a b. Show b => Int -> FixedLengthArray a b -> ShowS
forall a b. Show b => [FixedLengthArray a b] -> ShowS
forall a b. Show b => FixedLengthArray a b -> String
showList :: [FixedLengthArray a b] -> ShowS
$cshowList :: forall a b. Show b => [FixedLengthArray a b] -> ShowS
show :: FixedLengthArray a b -> String
$cshow :: forall a b. Show b => FixedLengthArray a b -> String
showsPrec :: Int -> FixedLengthArray a b -> ShowS
$cshowsPrec :: forall a b. Show b => Int -> FixedLengthArray a b -> ShowS
Show
    )

instance (FixedLength a, Storable b) => GStorable (FixedLengthArray a b) where
  gsizeOf :: FixedLengthArray a b -> Int
gsizeOf FixedLengthArray a b
_ = (a -> Int
forall a. FixedLength a => a -> Int
fixedLength (a
forall a. HasCallStack => a
undefined :: a)) Int -> Int -> Int
forall a. Num a => a -> a -> a
* (b -> Int
forall a. Storable a => a -> Int
sizeOf (b
forall a. HasCallStack => a
undefined :: b))

  galignment :: FixedLengthArray a b -> Int
galignment FixedLengthArray a b
_ = b -> Int
forall a. Storable a => a -> Int
alignment (b
forall a. HasCallStack => a
undefined :: b)

  gpeekByteOff :: forall b. Ptr b -> Int -> IO (FixedLengthArray a b)
gpeekByteOff Ptr b
ptr Int
offset
    = [b] -> FixedLengthArray a b
forall a b. [b] -> FixedLengthArray a b
FixedLengthArray ([b] -> FixedLengthArray a b)
-> IO [b] -> IO (FixedLengthArray a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Ptr b -> IO [b]
forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
arrayLength (Ptr b -> Int -> Ptr b
forall a b. Ptr a -> Int -> Ptr b
plusPtr Ptr b
ptr Int
offset)
    where
      arrayLength :: Int
arrayLength = a -> Int
forall a. FixedLength a => a -> Int
fixedLength (a
forall a. HasCallStack => a
undefined :: a)

  gpokeByteOff :: forall b. Ptr b -> Int -> FixedLengthArray a b -> IO ()
gpokeByteOff Ptr b
ptr Int
offset (FixedLengthArray [b]
array)
    = Ptr b -> [b] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray (Ptr b -> Int -> Ptr b
forall a b. Ptr a -> Int -> Ptr b
plusPtr Ptr b
ptr Int
offset) [b]
array

-- | Create a new 'GlpkArray'.
mallocGlpkArray :: (Storable a) => [a] -> IO (GlpkArray a)
mallocGlpkArray :: forall a. Storable a => [a] -> IO (GlpkArray a)
mallocGlpkArray [a]
xs = do
  Ptr a
array <- Int -> IO (Ptr a)
forall a. Storable a => Int -> IO (Ptr a)
mallocArray (Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
xs)
  [a] -> Ptr a -> IO (GlpkArray a)
forall a. Storable a => [a] -> Ptr a -> IO (GlpkArray a)
initGlpkArray [a]
xs Ptr a
array

-- | Run a computation with a temporary 'GlpkArray'.
allocaGlpkArray :: (Storable a) => [a] -> (GlpkArray a -> IO b) -> IO b
allocaGlpkArray :: forall a b. Storable a => [a] -> (GlpkArray a -> IO b) -> IO b
allocaGlpkArray [a]
xs GlpkArray a -> IO b
f
  = Int -> (Ptr a -> IO b) -> IO b
forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray (Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
xs) ((Ptr a -> IO b) -> IO b) -> (Ptr a -> IO b) -> IO b
forall a b. (a -> b) -> a -> b
$ \Ptr a
array -> [a] -> Ptr a -> IO (GlpkArray a)
forall a. Storable a => [a] -> Ptr a -> IO (GlpkArray a)
initGlpkArray [a]
xs Ptr a
array IO (GlpkArray a) -> (GlpkArray a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= GlpkArray a -> IO b
f

-- | Set the contents of a 'GlpkArray' from a list.
initGlpkArray :: (Storable a) => [a] -> Ptr a -> IO (GlpkArray a)
initGlpkArray :: forall a. Storable a => [a] -> Ptr a -> IO (GlpkArray a)
initGlpkArray [a]
xs Ptr a
array =
  let
    elemSize :: Int
    elemSize :: Int
elemSize = a -> Int
forall a. Storable a => a -> Int
sizeOf ([a] -> a
forall a. [a] -> a
head [a]
xs)
  in do
    Ptr a -> [a] -> IO ()
forall a. Storable a => Ptr a -> [a] -> IO ()
pokeArray (Ptr a -> Int -> Ptr a
forall a b. Ptr a -> Int -> Ptr b
plusPtr Ptr a
array Int
elemSize) [a]
xs
    GlpkArray a -> IO (GlpkArray a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr a -> GlpkArray a
forall a. Ptr a -> GlpkArray a
GlpkArray Ptr a
array)

-- Control parameters

-- $control-parameters
--
-- These structures wrap the low-level control structures used to
-- change the behavior of various solver functions. You will likely
-- want to utilize these.

data BasisFactorizationControlParameters
  = BasisFactorizationControlParameters
    { BasisFactorizationControlParameters -> Unused GlpkMessageLevel
bfcpMessageLevel :: Unused GlpkMessageLevel
    , BasisFactorizationControlParameters -> GlpkFactorizationType
bfcpType :: GlpkFactorizationType
    , BasisFactorizationControlParameters -> Unused CInt
bfcpLUSize :: Unused CInt
    , BasisFactorizationControlParameters -> CDouble
bfcpPivotTolerance :: CDouble
    , BasisFactorizationControlParameters -> CInt
bfcpPivotLimit :: CInt
    , BasisFactorizationControlParameters -> GlpkControl
bfcpSuhl :: GlpkControl
    , BasisFactorizationControlParameters -> CDouble
bfcpEpsilonTolerance :: CDouble
    , BasisFactorizationControlParameters -> Unused CDouble
bfcpMaxGro :: Unused CDouble
    , BasisFactorizationControlParameters -> CInt
bfcpNfsMax :: CInt
    , BasisFactorizationControlParameters -> Unused CDouble
bfcpUpdateTolerance :: Unused CDouble
    , BasisFactorizationControlParameters -> CInt
bfcpNrsMax :: CInt
    , BasisFactorizationControlParameters -> Unused CInt
bfcpRsSize :: Unused CInt
    , BasisFactorizationControlParameters
-> Unused (FixedLengthArray BfcpFooBar CDouble)
bfcpFooBar :: Unused (FixedLengthArray BfcpFooBar CDouble)
    }
  deriving
    ( BasisFactorizationControlParameters
-> BasisFactorizationControlParameters -> Bool
(BasisFactorizationControlParameters
 -> BasisFactorizationControlParameters -> Bool)
-> (BasisFactorizationControlParameters
    -> BasisFactorizationControlParameters -> Bool)
-> Eq BasisFactorizationControlParameters
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BasisFactorizationControlParameters
-> BasisFactorizationControlParameters -> Bool
$c/= :: BasisFactorizationControlParameters
-> BasisFactorizationControlParameters -> Bool
== :: BasisFactorizationControlParameters
-> BasisFactorizationControlParameters -> Bool
$c== :: BasisFactorizationControlParameters
-> BasisFactorizationControlParameters -> Bool
Eq
    , (forall x.
 BasisFactorizationControlParameters
 -> Rep BasisFactorizationControlParameters x)
-> (forall x.
    Rep BasisFactorizationControlParameters x
    -> BasisFactorizationControlParameters)
-> Generic BasisFactorizationControlParameters
forall x.
Rep BasisFactorizationControlParameters x
-> BasisFactorizationControlParameters
forall x.
BasisFactorizationControlParameters
-> Rep BasisFactorizationControlParameters x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep BasisFactorizationControlParameters x
-> BasisFactorizationControlParameters
$cfrom :: forall x.
BasisFactorizationControlParameters
-> Rep BasisFactorizationControlParameters x
Generic
    , Int -> BasisFactorizationControlParameters -> ShowS
[BasisFactorizationControlParameters] -> ShowS
BasisFactorizationControlParameters -> String
(Int -> BasisFactorizationControlParameters -> ShowS)
-> (BasisFactorizationControlParameters -> String)
-> ([BasisFactorizationControlParameters] -> ShowS)
-> Show BasisFactorizationControlParameters
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BasisFactorizationControlParameters] -> ShowS
$cshowList :: [BasisFactorizationControlParameters] -> ShowS
show :: BasisFactorizationControlParameters -> String
$cshow :: BasisFactorizationControlParameters -> String
showsPrec :: Int -> BasisFactorizationControlParameters -> ShowS
$cshowsPrec :: Int -> BasisFactorizationControlParameters -> ShowS
Show
    )

instance GStorable BasisFactorizationControlParameters

data SimplexMethodControlParameters
  = SimplexMethodControlParameters
    { SimplexMethodControlParameters -> GlpkMessageLevel
smcpMessageLevel :: GlpkMessageLevel
    , SimplexMethodControlParameters -> GlpkSimplexMethod
smcpMethod :: GlpkSimplexMethod
    , SimplexMethodControlParameters -> GlpkPricing
smcpPricing :: GlpkPricing
    , SimplexMethodControlParameters -> GlpkRatioTest
smcpRatioTest :: GlpkRatioTest
    , SimplexMethodControlParameters -> Double
smcpPrimalFeasibilityTolerance :: Double
    , SimplexMethodControlParameters -> Double
smcpDualFeasibilityTolerance :: Double
    , SimplexMethodControlParameters -> Double
smcpPivotTolerance :: Double
    , SimplexMethodControlParameters -> Double
smcpLowerObjectiveLimit :: Double
    , SimplexMethodControlParameters -> Double
smcpUpperObjectiveLimit :: Double
    , SimplexMethodControlParameters -> CInt
smcpIterationLimit :: CInt
    , SimplexMethodControlParameters -> CInt
smcpTimeLimitMillis :: CInt
    , SimplexMethodControlParameters -> CInt
smcpOutputFrequencyMillis :: CInt
    , SimplexMethodControlParameters -> CInt
smcpOutputDelayMillis :: CInt
    , SimplexMethodControlParameters -> GlpkPresolve
smcpPresolve :: GlpkPresolve
    , SimplexMethodControlParameters -> Unused CInt
smcpExcl :: Unused CInt
    , SimplexMethodControlParameters -> Unused CInt
smcpShift :: Unused CInt
    , SimplexMethodControlParameters -> Unused CInt
smcpAOrN :: Unused CInt
    , SimplexMethodControlParameters
-> Unused (FixedLengthArray SmcpFooBar CDouble)
smcpFooBar :: Unused (FixedLengthArray SmcpFooBar CDouble)
    }
  deriving
    ( SimplexMethodControlParameters
-> SimplexMethodControlParameters -> Bool
(SimplexMethodControlParameters
 -> SimplexMethodControlParameters -> Bool)
-> (SimplexMethodControlParameters
    -> SimplexMethodControlParameters -> Bool)
-> Eq SimplexMethodControlParameters
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SimplexMethodControlParameters
-> SimplexMethodControlParameters -> Bool
$c/= :: SimplexMethodControlParameters
-> SimplexMethodControlParameters -> Bool
== :: SimplexMethodControlParameters
-> SimplexMethodControlParameters -> Bool
$c== :: SimplexMethodControlParameters
-> SimplexMethodControlParameters -> Bool
Eq
    , (forall x.
 SimplexMethodControlParameters
 -> Rep SimplexMethodControlParameters x)
-> (forall x.
    Rep SimplexMethodControlParameters x
    -> SimplexMethodControlParameters)
-> Generic SimplexMethodControlParameters
forall x.
Rep SimplexMethodControlParameters x
-> SimplexMethodControlParameters
forall x.
SimplexMethodControlParameters
-> Rep SimplexMethodControlParameters x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep SimplexMethodControlParameters x
-> SimplexMethodControlParameters
$cfrom :: forall x.
SimplexMethodControlParameters
-> Rep SimplexMethodControlParameters x
Generic
    , Int -> SimplexMethodControlParameters -> ShowS
[SimplexMethodControlParameters] -> ShowS
SimplexMethodControlParameters -> String
(Int -> SimplexMethodControlParameters -> ShowS)
-> (SimplexMethodControlParameters -> String)
-> ([SimplexMethodControlParameters] -> ShowS)
-> Show SimplexMethodControlParameters
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SimplexMethodControlParameters] -> ShowS
$cshowList :: [SimplexMethodControlParameters] -> ShowS
show :: SimplexMethodControlParameters -> String
$cshow :: SimplexMethodControlParameters -> String
showsPrec :: Int -> SimplexMethodControlParameters -> ShowS
$cshowsPrec :: Int -> SimplexMethodControlParameters -> ShowS
Show
    )

instance GStorable SimplexMethodControlParameters

data InteriorPointControlParameters
  = InteriorPointControlParameters
    { InteriorPointControlParameters -> GlpkMessageLevel
iptcpMessageLevel :: GlpkMessageLevel
    , InteriorPointControlParameters -> GlpkPreCholeskyOrdering
iptcpOrderingAlgorithm :: GlpkPreCholeskyOrdering
    , InteriorPointControlParameters
-> Unused (FixedLengthArray IptcpFooBar CDouble)
iptcpFooBar :: Unused (FixedLengthArray IptcpFooBar CDouble)
    }
  deriving
    ( InteriorPointControlParameters
-> InteriorPointControlParameters -> Bool
(InteriorPointControlParameters
 -> InteriorPointControlParameters -> Bool)
-> (InteriorPointControlParameters
    -> InteriorPointControlParameters -> Bool)
-> Eq InteriorPointControlParameters
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InteriorPointControlParameters
-> InteriorPointControlParameters -> Bool
$c/= :: InteriorPointControlParameters
-> InteriorPointControlParameters -> Bool
== :: InteriorPointControlParameters
-> InteriorPointControlParameters -> Bool
$c== :: InteriorPointControlParameters
-> InteriorPointControlParameters -> Bool
Eq
    , (forall x.
 InteriorPointControlParameters
 -> Rep InteriorPointControlParameters x)
-> (forall x.
    Rep InteriorPointControlParameters x
    -> InteriorPointControlParameters)
-> Generic InteriorPointControlParameters
forall x.
Rep InteriorPointControlParameters x
-> InteriorPointControlParameters
forall x.
InteriorPointControlParameters
-> Rep InteriorPointControlParameters x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep InteriorPointControlParameters x
-> InteriorPointControlParameters
$cfrom :: forall x.
InteriorPointControlParameters
-> Rep InteriorPointControlParameters x
Generic
    , Int -> InteriorPointControlParameters -> ShowS
[InteriorPointControlParameters] -> ShowS
InteriorPointControlParameters -> String
(Int -> InteriorPointControlParameters -> ShowS)
-> (InteriorPointControlParameters -> String)
-> ([InteriorPointControlParameters] -> ShowS)
-> Show InteriorPointControlParameters
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InteriorPointControlParameters] -> ShowS
$cshowList :: [InteriorPointControlParameters] -> ShowS
show :: InteriorPointControlParameters -> String
$cshow :: InteriorPointControlParameters -> String
showsPrec :: Int -> InteriorPointControlParameters -> ShowS
$cshowsPrec :: Int -> InteriorPointControlParameters -> ShowS
Show
    )

instance GStorable InteriorPointControlParameters

data MIPControlParameters a
  = MIPControlParameters
    { forall a. MIPControlParameters a -> GlpkMessageLevel
iocpMessageLevel :: GlpkMessageLevel
    , forall a. MIPControlParameters a -> GlpkBranchingTechnique
iocpBranchingTechnique :: GlpkBranchingTechnique
    , forall a. MIPControlParameters a -> GlpkBacktrackingTechnique
iocpBacktrackingTechnique :: GlpkBacktrackingTechnique
    , forall a. MIPControlParameters a -> CDouble
iocpAbsoluteFeasibilityTolerance :: CDouble
    , forall a. MIPControlParameters a -> CDouble
iocpRelativeObjectiveTolerance :: CDouble
    , forall a. MIPControlParameters a -> CInt
iocpTimeLimitMillis :: CInt
    , forall a. MIPControlParameters a -> CInt
iocpOutputFrequencyMillis :: CInt
    , forall a. MIPControlParameters a -> CInt
iocpOutputDelayMillis :: CInt
    , forall a.
MIPControlParameters a
-> FunPtr (Ptr (GlpkTree a) -> Ptr a -> IO ())
iocpCallback :: FunPtr (Ptr (GlpkTree a) -> Ptr a -> IO ())
    , forall a. MIPControlParameters a -> Ptr a
iocpNodeData :: Ptr a
    , forall a. MIPControlParameters a -> CInt
iocpNodeDataSize :: CInt
    , forall a. MIPControlParameters a -> GlpkPreProcessingTechnique
iocpPreprocessingTechnique :: GlpkPreProcessingTechnique
    , forall a. MIPControlParameters a -> CDouble
iocpRelativeMIPGap :: CDouble
    , forall a. MIPControlParameters a -> GlpkMIRCuts
iocpMIRCuts :: GlpkMIRCuts
    , forall a. MIPControlParameters a -> GlpkGomoryCuts
iocpGormoryCuts :: GlpkGomoryCuts
    , forall a. MIPControlParameters a -> GlpkCoverCuts
iocpCoverCuts :: GlpkCoverCuts
    , forall a. MIPControlParameters a -> GlpkCliqueCuts
iocpCliqueCuts :: GlpkCliqueCuts
    , forall a. MIPControlParameters a -> GlpkPresolve
iocpPresolve :: GlpkPresolve
    , forall a. MIPControlParameters a -> GlpkBinarization
iocpBinarization :: GlpkBinarization
    , forall a. MIPControlParameters a -> GlpkFeasibilityPump
iocpFeasibilityPump :: GlpkFeasibilityPump
    , forall a. MIPControlParameters a -> GlpkProximitySearch
iocpProximitySearch :: GlpkProximitySearch
    , forall a. MIPControlParameters a -> CInt
iocpProximityTimeLimitMillis :: CInt
    , forall a. MIPControlParameters a -> GlpkSimpleRounding
iocpSimpleRounding :: GlpkSimpleRounding
    , forall a. MIPControlParameters a -> Unused CInt
iocpUseExistingSolution :: Unused CInt
    , forall a. MIPControlParameters a -> Unused (Ptr CChar)
iocpNewSolutionFileName :: Unused (Ptr CChar)
    , forall a. MIPControlParameters a -> Unused CInt
iocpUseAlienSolver :: Unused CInt
    , forall a. MIPControlParameters a -> Unused CInt
iocpUseLongStepDual :: Unused CInt
    , forall a.
MIPControlParameters a
-> Unused (FixedLengthArray IocpFooBar CDouble)
iocpFooBar :: Unused (FixedLengthArray IocpFooBar CDouble)
    }
  deriving
    ( MIPControlParameters a -> MIPControlParameters a -> Bool
(MIPControlParameters a -> MIPControlParameters a -> Bool)
-> (MIPControlParameters a -> MIPControlParameters a -> Bool)
-> Eq (MIPControlParameters a)
forall a. MIPControlParameters a -> MIPControlParameters a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MIPControlParameters a -> MIPControlParameters a -> Bool
$c/= :: forall a. MIPControlParameters a -> MIPControlParameters a -> Bool
== :: MIPControlParameters a -> MIPControlParameters a -> Bool
$c== :: forall a. MIPControlParameters a -> MIPControlParameters a -> Bool
Eq
    , (forall x.
 MIPControlParameters a -> Rep (MIPControlParameters a) x)
-> (forall x.
    Rep (MIPControlParameters a) x -> MIPControlParameters a)
-> Generic (MIPControlParameters a)
forall x. Rep (MIPControlParameters a) x -> MIPControlParameters a
forall x. MIPControlParameters a -> Rep (MIPControlParameters a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x.
Rep (MIPControlParameters a) x -> MIPControlParameters a
forall a x.
MIPControlParameters a -> Rep (MIPControlParameters a) x
$cto :: forall a x.
Rep (MIPControlParameters a) x -> MIPControlParameters a
$cfrom :: forall a x.
MIPControlParameters a -> Rep (MIPControlParameters a) x
Generic
    , Int -> MIPControlParameters a -> ShowS
[MIPControlParameters a] -> ShowS
MIPControlParameters a -> String
(Int -> MIPControlParameters a -> ShowS)
-> (MIPControlParameters a -> String)
-> ([MIPControlParameters a] -> ShowS)
-> Show (MIPControlParameters a)
forall a. Int -> MIPControlParameters a -> ShowS
forall a. [MIPControlParameters a] -> ShowS
forall a. MIPControlParameters a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MIPControlParameters a] -> ShowS
$cshowList :: forall a. [MIPControlParameters a] -> ShowS
show :: MIPControlParameters a -> String
$cshow :: forall a. MIPControlParameters a -> String
showsPrec :: Int -> MIPControlParameters a -> ShowS
$cshowsPrec :: forall a. Int -> MIPControlParameters a -> ShowS
Show
    )

instance GStorable (MIPControlParameters a)

data GlpkCutAttribute
  = GlpkCutAttribute
    { GlpkCutAttribute -> CInt
attrLevel :: CInt
    , GlpkCutAttribute -> GlpkConstraintOrigin
attrContraintOrigin :: GlpkConstraintOrigin
    , GlpkCutAttribute -> GlpkCutType
attrCutType :: GlpkCutType
    , GlpkCutAttribute -> Unused (FixedLengthArray AttrFooBar CDouble)
attrFooBar :: Unused (FixedLengthArray AttrFooBar CDouble)
    }
  deriving
    ( GlpkCutAttribute -> GlpkCutAttribute -> Bool
(GlpkCutAttribute -> GlpkCutAttribute -> Bool)
-> (GlpkCutAttribute -> GlpkCutAttribute -> Bool)
-> Eq GlpkCutAttribute
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkCutAttribute -> GlpkCutAttribute -> Bool
$c/= :: GlpkCutAttribute -> GlpkCutAttribute -> Bool
== :: GlpkCutAttribute -> GlpkCutAttribute -> Bool
$c== :: GlpkCutAttribute -> GlpkCutAttribute -> Bool
Eq
    , (forall x. GlpkCutAttribute -> Rep GlpkCutAttribute x)
-> (forall x. Rep GlpkCutAttribute x -> GlpkCutAttribute)
-> Generic GlpkCutAttribute
forall x. Rep GlpkCutAttribute x -> GlpkCutAttribute
forall x. GlpkCutAttribute -> Rep GlpkCutAttribute x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GlpkCutAttribute x -> GlpkCutAttribute
$cfrom :: forall x. GlpkCutAttribute -> Rep GlpkCutAttribute x
Generic
    , Int -> GlpkCutAttribute -> ShowS
[GlpkCutAttribute] -> ShowS
GlpkCutAttribute -> String
(Int -> GlpkCutAttribute -> ShowS)
-> (GlpkCutAttribute -> String)
-> ([GlpkCutAttribute] -> ShowS)
-> Show GlpkCutAttribute
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkCutAttribute] -> ShowS
$cshowList :: [GlpkCutAttribute] -> ShowS
show :: GlpkCutAttribute -> String
$cshow :: GlpkCutAttribute -> String
showsPrec :: Int -> GlpkCutAttribute -> ShowS
$cshowsPrec :: Int -> GlpkCutAttribute -> ShowS
Show
    )

instance GStorable GlpkCutAttribute

newtype GlpkUserCutType
  = GlpkUserCutType { GlpkUserCutType -> CInt
fromGlpkUserCutType :: CInt }
  deriving
    ( Int -> GlpkUserCutType
GlpkUserCutType -> Int
GlpkUserCutType -> [GlpkUserCutType]
GlpkUserCutType -> GlpkUserCutType
GlpkUserCutType -> GlpkUserCutType -> [GlpkUserCutType]
GlpkUserCutType
-> GlpkUserCutType -> GlpkUserCutType -> [GlpkUserCutType]
(GlpkUserCutType -> GlpkUserCutType)
-> (GlpkUserCutType -> GlpkUserCutType)
-> (Int -> GlpkUserCutType)
-> (GlpkUserCutType -> Int)
-> (GlpkUserCutType -> [GlpkUserCutType])
-> (GlpkUserCutType -> GlpkUserCutType -> [GlpkUserCutType])
-> (GlpkUserCutType -> GlpkUserCutType -> [GlpkUserCutType])
-> (GlpkUserCutType
    -> GlpkUserCutType -> GlpkUserCutType -> [GlpkUserCutType])
-> Enum GlpkUserCutType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: GlpkUserCutType
-> GlpkUserCutType -> GlpkUserCutType -> [GlpkUserCutType]
$cenumFromThenTo :: GlpkUserCutType
-> GlpkUserCutType -> GlpkUserCutType -> [GlpkUserCutType]
enumFromTo :: GlpkUserCutType -> GlpkUserCutType -> [GlpkUserCutType]
$cenumFromTo :: GlpkUserCutType -> GlpkUserCutType -> [GlpkUserCutType]
enumFromThen :: GlpkUserCutType -> GlpkUserCutType -> [GlpkUserCutType]
$cenumFromThen :: GlpkUserCutType -> GlpkUserCutType -> [GlpkUserCutType]
enumFrom :: GlpkUserCutType -> [GlpkUserCutType]
$cenumFrom :: GlpkUserCutType -> [GlpkUserCutType]
fromEnum :: GlpkUserCutType -> Int
$cfromEnum :: GlpkUserCutType -> Int
toEnum :: Int -> GlpkUserCutType
$ctoEnum :: Int -> GlpkUserCutType
pred :: GlpkUserCutType -> GlpkUserCutType
$cpred :: GlpkUserCutType -> GlpkUserCutType
succ :: GlpkUserCutType -> GlpkUserCutType
$csucc :: GlpkUserCutType -> GlpkUserCutType
Enum
    , GlpkUserCutType -> GlpkUserCutType -> Bool
(GlpkUserCutType -> GlpkUserCutType -> Bool)
-> (GlpkUserCutType -> GlpkUserCutType -> Bool)
-> Eq GlpkUserCutType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkUserCutType -> GlpkUserCutType -> Bool
$c/= :: GlpkUserCutType -> GlpkUserCutType -> Bool
== :: GlpkUserCutType -> GlpkUserCutType -> Bool
$c== :: GlpkUserCutType -> GlpkUserCutType -> Bool
Eq
    , Eq GlpkUserCutType
Eq GlpkUserCutType
-> (GlpkUserCutType -> GlpkUserCutType -> Ordering)
-> (GlpkUserCutType -> GlpkUserCutType -> Bool)
-> (GlpkUserCutType -> GlpkUserCutType -> Bool)
-> (GlpkUserCutType -> GlpkUserCutType -> Bool)
-> (GlpkUserCutType -> GlpkUserCutType -> Bool)
-> (GlpkUserCutType -> GlpkUserCutType -> GlpkUserCutType)
-> (GlpkUserCutType -> GlpkUserCutType -> GlpkUserCutType)
-> Ord GlpkUserCutType
GlpkUserCutType -> GlpkUserCutType -> Bool
GlpkUserCutType -> GlpkUserCutType -> Ordering
GlpkUserCutType -> GlpkUserCutType -> GlpkUserCutType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkUserCutType -> GlpkUserCutType -> GlpkUserCutType
$cmin :: GlpkUserCutType -> GlpkUserCutType -> GlpkUserCutType
max :: GlpkUserCutType -> GlpkUserCutType -> GlpkUserCutType
$cmax :: GlpkUserCutType -> GlpkUserCutType -> GlpkUserCutType
>= :: GlpkUserCutType -> GlpkUserCutType -> Bool
$c>= :: GlpkUserCutType -> GlpkUserCutType -> Bool
> :: GlpkUserCutType -> GlpkUserCutType -> Bool
$c> :: GlpkUserCutType -> GlpkUserCutType -> Bool
<= :: GlpkUserCutType -> GlpkUserCutType -> Bool
$c<= :: GlpkUserCutType -> GlpkUserCutType -> Bool
< :: GlpkUserCutType -> GlpkUserCutType -> Bool
$c< :: GlpkUserCutType -> GlpkUserCutType -> Bool
compare :: GlpkUserCutType -> GlpkUserCutType -> Ordering
$ccompare :: GlpkUserCutType -> GlpkUserCutType -> Ordering
Ord
    , ReadPrec [GlpkUserCutType]
ReadPrec GlpkUserCutType
Int -> ReadS GlpkUserCutType
ReadS [GlpkUserCutType]
(Int -> ReadS GlpkUserCutType)
-> ReadS [GlpkUserCutType]
-> ReadPrec GlpkUserCutType
-> ReadPrec [GlpkUserCutType]
-> Read GlpkUserCutType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkUserCutType]
$creadListPrec :: ReadPrec [GlpkUserCutType]
readPrec :: ReadPrec GlpkUserCutType
$creadPrec :: ReadPrec GlpkUserCutType
readList :: ReadS [GlpkUserCutType]
$creadList :: ReadS [GlpkUserCutType]
readsPrec :: Int -> ReadS GlpkUserCutType
$creadsPrec :: Int -> ReadS GlpkUserCutType
Read
    , Int -> GlpkUserCutType -> ShowS
[GlpkUserCutType] -> ShowS
GlpkUserCutType -> String
(Int -> GlpkUserCutType -> ShowS)
-> (GlpkUserCutType -> String)
-> ([GlpkUserCutType] -> ShowS)
-> Show GlpkUserCutType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkUserCutType] -> ShowS
$cshowList :: [GlpkUserCutType] -> ShowS
show :: GlpkUserCutType -> String
$cshow :: GlpkUserCutType -> String
showsPrec :: Int -> GlpkUserCutType -> ShowS
$cshowsPrec :: Int -> GlpkUserCutType -> ShowS
Show
    , Ptr GlpkUserCutType -> IO GlpkUserCutType
Ptr GlpkUserCutType -> Int -> IO GlpkUserCutType
Ptr GlpkUserCutType -> Int -> GlpkUserCutType -> IO ()
Ptr GlpkUserCutType -> GlpkUserCutType -> IO ()
GlpkUserCutType -> Int
(GlpkUserCutType -> Int)
-> (GlpkUserCutType -> Int)
-> (Ptr GlpkUserCutType -> Int -> IO GlpkUserCutType)
-> (Ptr GlpkUserCutType -> Int -> GlpkUserCutType -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkUserCutType)
-> (forall b. Ptr b -> Int -> GlpkUserCutType -> IO ())
-> (Ptr GlpkUserCutType -> IO GlpkUserCutType)
-> (Ptr GlpkUserCutType -> GlpkUserCutType -> IO ())
-> Storable GlpkUserCutType
forall b. Ptr b -> Int -> IO GlpkUserCutType
forall b. Ptr b -> Int -> GlpkUserCutType -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkUserCutType -> GlpkUserCutType -> IO ()
$cpoke :: Ptr GlpkUserCutType -> GlpkUserCutType -> IO ()
peek :: Ptr GlpkUserCutType -> IO GlpkUserCutType
$cpeek :: Ptr GlpkUserCutType -> IO GlpkUserCutType
pokeByteOff :: forall b. Ptr b -> Int -> GlpkUserCutType -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkUserCutType -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkUserCutType
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkUserCutType
pokeElemOff :: Ptr GlpkUserCutType -> Int -> GlpkUserCutType -> IO ()
$cpokeElemOff :: Ptr GlpkUserCutType -> Int -> GlpkUserCutType -> IO ()
peekElemOff :: Ptr GlpkUserCutType -> Int -> IO GlpkUserCutType
$cpeekElemOff :: Ptr GlpkUserCutType -> Int -> IO GlpkUserCutType
alignment :: GlpkUserCutType -> Int
$calignment :: GlpkUserCutType -> Int
sizeOf :: GlpkUserCutType -> Int
$csizeOf :: GlpkUserCutType -> Int
Storable
    , Typeable
    )

data MPSControlParameters
  = MPSControlParameters
    { MPSControlParameters -> CInt
mpscpBlank :: CInt
    , MPSControlParameters -> Ptr CChar
mpscpObjectiveName :: CString
    , MPSControlParameters -> CDouble
mpscpZeroTolerance :: CDouble
    , MPSControlParameters
-> Unused (FixedLengthArray MpscpFooBar CDouble)
mpscpFooBar :: Unused (FixedLengthArray MpscpFooBar CDouble)
    }
  deriving
    ( MPSControlParameters -> MPSControlParameters -> Bool
(MPSControlParameters -> MPSControlParameters -> Bool)
-> (MPSControlParameters -> MPSControlParameters -> Bool)
-> Eq MPSControlParameters
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MPSControlParameters -> MPSControlParameters -> Bool
$c/= :: MPSControlParameters -> MPSControlParameters -> Bool
== :: MPSControlParameters -> MPSControlParameters -> Bool
$c== :: MPSControlParameters -> MPSControlParameters -> Bool
Eq
    , (forall x. MPSControlParameters -> Rep MPSControlParameters x)
-> (forall x. Rep MPSControlParameters x -> MPSControlParameters)
-> Generic MPSControlParameters
forall x. Rep MPSControlParameters x -> MPSControlParameters
forall x. MPSControlParameters -> Rep MPSControlParameters x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MPSControlParameters x -> MPSControlParameters
$cfrom :: forall x. MPSControlParameters -> Rep MPSControlParameters x
Generic
    , Int -> MPSControlParameters -> ShowS
[MPSControlParameters] -> ShowS
MPSControlParameters -> String
(Int -> MPSControlParameters -> ShowS)
-> (MPSControlParameters -> String)
-> ([MPSControlParameters] -> ShowS)
-> Show MPSControlParameters
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MPSControlParameters] -> ShowS
$cshowList :: [MPSControlParameters] -> ShowS
show :: MPSControlParameters -> String
$cshow :: MPSControlParameters -> String
showsPrec :: Int -> MPSControlParameters -> ShowS
$cshowsPrec :: Int -> MPSControlParameters -> ShowS
Show
    )

instance GStorable MPSControlParameters

data CplexLPFormatControlParameters
  = CplexLPFormatControlParameters
    { CplexLPFormatControlParameters
-> Unused (FixedLengthArray CpxcpFooBar CDouble)
cpxcpFooBar :: Unused (FixedLengthArray CpxcpFooBar CDouble)
    }
  deriving
    ( CplexLPFormatControlParameters
-> CplexLPFormatControlParameters -> Bool
(CplexLPFormatControlParameters
 -> CplexLPFormatControlParameters -> Bool)
-> (CplexLPFormatControlParameters
    -> CplexLPFormatControlParameters -> Bool)
-> Eq CplexLPFormatControlParameters
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CplexLPFormatControlParameters
-> CplexLPFormatControlParameters -> Bool
$c/= :: CplexLPFormatControlParameters
-> CplexLPFormatControlParameters -> Bool
== :: CplexLPFormatControlParameters
-> CplexLPFormatControlParameters -> Bool
$c== :: CplexLPFormatControlParameters
-> CplexLPFormatControlParameters -> Bool
Eq
    , (forall x.
 CplexLPFormatControlParameters
 -> Rep CplexLPFormatControlParameters x)
-> (forall x.
    Rep CplexLPFormatControlParameters x
    -> CplexLPFormatControlParameters)
-> Generic CplexLPFormatControlParameters
forall x.
Rep CplexLPFormatControlParameters x
-> CplexLPFormatControlParameters
forall x.
CplexLPFormatControlParameters
-> Rep CplexLPFormatControlParameters x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CplexLPFormatControlParameters x
-> CplexLPFormatControlParameters
$cfrom :: forall x.
CplexLPFormatControlParameters
-> Rep CplexLPFormatControlParameters x
Generic
    , Int -> CplexLPFormatControlParameters -> ShowS
[CplexLPFormatControlParameters] -> ShowS
CplexLPFormatControlParameters -> String
(Int -> CplexLPFormatControlParameters -> ShowS)
-> (CplexLPFormatControlParameters -> String)
-> ([CplexLPFormatControlParameters] -> ShowS)
-> Show CplexLPFormatControlParameters
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CplexLPFormatControlParameters] -> ShowS
$cshowList :: [CplexLPFormatControlParameters] -> ShowS
show :: CplexLPFormatControlParameters -> String
$cshow :: CplexLPFormatControlParameters -> String
showsPrec :: Int -> CplexLPFormatControlParameters -> ShowS
$cshowsPrec :: Int -> CplexLPFormatControlParameters -> ShowS
Show
    )

instance GStorable CplexLPFormatControlParameters

newtype MathProgResult
  = MathProgResult { MathProgResult -> CInt
fromMathProgResult :: CInt }
  deriving
    ( Int -> MathProgResult
MathProgResult -> Int
MathProgResult -> [MathProgResult]
MathProgResult -> MathProgResult
MathProgResult -> MathProgResult -> [MathProgResult]
MathProgResult
-> MathProgResult -> MathProgResult -> [MathProgResult]
(MathProgResult -> MathProgResult)
-> (MathProgResult -> MathProgResult)
-> (Int -> MathProgResult)
-> (MathProgResult -> Int)
-> (MathProgResult -> [MathProgResult])
-> (MathProgResult -> MathProgResult -> [MathProgResult])
-> (MathProgResult -> MathProgResult -> [MathProgResult])
-> (MathProgResult
    -> MathProgResult -> MathProgResult -> [MathProgResult])
-> Enum MathProgResult
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: MathProgResult
-> MathProgResult -> MathProgResult -> [MathProgResult]
$cenumFromThenTo :: MathProgResult
-> MathProgResult -> MathProgResult -> [MathProgResult]
enumFromTo :: MathProgResult -> MathProgResult -> [MathProgResult]
$cenumFromTo :: MathProgResult -> MathProgResult -> [MathProgResult]
enumFromThen :: MathProgResult -> MathProgResult -> [MathProgResult]
$cenumFromThen :: MathProgResult -> MathProgResult -> [MathProgResult]
enumFrom :: MathProgResult -> [MathProgResult]
$cenumFrom :: MathProgResult -> [MathProgResult]
fromEnum :: MathProgResult -> Int
$cfromEnum :: MathProgResult -> Int
toEnum :: Int -> MathProgResult
$ctoEnum :: Int -> MathProgResult
pred :: MathProgResult -> MathProgResult
$cpred :: MathProgResult -> MathProgResult
succ :: MathProgResult -> MathProgResult
$csucc :: MathProgResult -> MathProgResult
Enum
    , MathProgResult -> MathProgResult -> Bool
(MathProgResult -> MathProgResult -> Bool)
-> (MathProgResult -> MathProgResult -> Bool) -> Eq MathProgResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MathProgResult -> MathProgResult -> Bool
$c/= :: MathProgResult -> MathProgResult -> Bool
== :: MathProgResult -> MathProgResult -> Bool
$c== :: MathProgResult -> MathProgResult -> Bool
Eq
    , Eq MathProgResult
Eq MathProgResult
-> (MathProgResult -> MathProgResult -> Ordering)
-> (MathProgResult -> MathProgResult -> Bool)
-> (MathProgResult -> MathProgResult -> Bool)
-> (MathProgResult -> MathProgResult -> Bool)
-> (MathProgResult -> MathProgResult -> Bool)
-> (MathProgResult -> MathProgResult -> MathProgResult)
-> (MathProgResult -> MathProgResult -> MathProgResult)
-> Ord MathProgResult
MathProgResult -> MathProgResult -> Bool
MathProgResult -> MathProgResult -> Ordering
MathProgResult -> MathProgResult -> MathProgResult
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MathProgResult -> MathProgResult -> MathProgResult
$cmin :: MathProgResult -> MathProgResult -> MathProgResult
max :: MathProgResult -> MathProgResult -> MathProgResult
$cmax :: MathProgResult -> MathProgResult -> MathProgResult
>= :: MathProgResult -> MathProgResult -> Bool
$c>= :: MathProgResult -> MathProgResult -> Bool
> :: MathProgResult -> MathProgResult -> Bool
$c> :: MathProgResult -> MathProgResult -> Bool
<= :: MathProgResult -> MathProgResult -> Bool
$c<= :: MathProgResult -> MathProgResult -> Bool
< :: MathProgResult -> MathProgResult -> Bool
$c< :: MathProgResult -> MathProgResult -> Bool
compare :: MathProgResult -> MathProgResult -> Ordering
$ccompare :: MathProgResult -> MathProgResult -> Ordering
Ord
    , ReadPrec [MathProgResult]
ReadPrec MathProgResult
Int -> ReadS MathProgResult
ReadS [MathProgResult]
(Int -> ReadS MathProgResult)
-> ReadS [MathProgResult]
-> ReadPrec MathProgResult
-> ReadPrec [MathProgResult]
-> Read MathProgResult
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MathProgResult]
$creadListPrec :: ReadPrec [MathProgResult]
readPrec :: ReadPrec MathProgResult
$creadPrec :: ReadPrec MathProgResult
readList :: ReadS [MathProgResult]
$creadList :: ReadS [MathProgResult]
readsPrec :: Int -> ReadS MathProgResult
$creadsPrec :: Int -> ReadS MathProgResult
Read
    , Int -> MathProgResult -> ShowS
[MathProgResult] -> ShowS
MathProgResult -> String
(Int -> MathProgResult -> ShowS)
-> (MathProgResult -> String)
-> ([MathProgResult] -> ShowS)
-> Show MathProgResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MathProgResult] -> ShowS
$cshowList :: [MathProgResult] -> ShowS
show :: MathProgResult -> String
$cshow :: MathProgResult -> String
showsPrec :: Int -> MathProgResult -> ShowS
$cshowsPrec :: Int -> MathProgResult -> ShowS
Show
    , Ptr MathProgResult -> IO MathProgResult
Ptr MathProgResult -> Int -> IO MathProgResult
Ptr MathProgResult -> Int -> MathProgResult -> IO ()
Ptr MathProgResult -> MathProgResult -> IO ()
MathProgResult -> Int
(MathProgResult -> Int)
-> (MathProgResult -> Int)
-> (Ptr MathProgResult -> Int -> IO MathProgResult)
-> (Ptr MathProgResult -> Int -> MathProgResult -> IO ())
-> (forall b. Ptr b -> Int -> IO MathProgResult)
-> (forall b. Ptr b -> Int -> MathProgResult -> IO ())
-> (Ptr MathProgResult -> IO MathProgResult)
-> (Ptr MathProgResult -> MathProgResult -> IO ())
-> Storable MathProgResult
forall b. Ptr b -> Int -> IO MathProgResult
forall b. Ptr b -> Int -> MathProgResult -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr MathProgResult -> MathProgResult -> IO ()
$cpoke :: Ptr MathProgResult -> MathProgResult -> IO ()
peek :: Ptr MathProgResult -> IO MathProgResult
$cpeek :: Ptr MathProgResult -> IO MathProgResult
pokeByteOff :: forall b. Ptr b -> Int -> MathProgResult -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> MathProgResult -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO MathProgResult
$cpeekByteOff :: forall b. Ptr b -> Int -> IO MathProgResult
pokeElemOff :: Ptr MathProgResult -> Int -> MathProgResult -> IO ()
$cpokeElemOff :: Ptr MathProgResult -> Int -> MathProgResult -> IO ()
peekElemOff :: Ptr MathProgResult -> Int -> IO MathProgResult
$cpeekElemOff :: Ptr MathProgResult -> Int -> IO MathProgResult
alignment :: MathProgResult -> Int
$calignment :: MathProgResult -> Int
sizeOf :: MathProgResult -> Int
$csizeOf :: MathProgResult -> Int
Storable
    , Typeable
    )


data BfcpFooBar

instance FixedLength BfcpFooBar where
  fixedLength :: BfcpFooBar -> Int
fixedLength BfcpFooBar
_ = Int
38

data SmcpFooBar

instance FixedLength SmcpFooBar where
  fixedLength :: SmcpFooBar -> Int
fixedLength SmcpFooBar
_ = Int
33

data IptcpFooBar

instance FixedLength IptcpFooBar where
  fixedLength :: IptcpFooBar -> Int
fixedLength IptcpFooBar
_ = Int
48

data IocpFooBar

instance FixedLength IocpFooBar where
  fixedLength :: IocpFooBar -> Int
fixedLength IocpFooBar
_ = Int
23

data AttrFooBar

instance FixedLength AttrFooBar where
  fixedLength :: AttrFooBar -> Int
fixedLength AttrFooBar
_ = Int
7

data MpscpFooBar

instance FixedLength MpscpFooBar where
  fixedLength :: MpscpFooBar -> Int
fixedLength MpscpFooBar
_ = Int
17

data CpxcpFooBar

instance FixedLength CpxcpFooBar where
  fixedLength :: CpxcpFooBar -> Int
fixedLength CpxcpFooBar
_ = Int
20

-- Enums

newtype GlpkMajorVersion
  = GlpkMajorVersion { GlpkMajorVersion -> CInt
fromGlpkMajorVersion :: CInt }
  deriving
    ( GlpkMajorVersion -> GlpkMajorVersion -> Bool
(GlpkMajorVersion -> GlpkMajorVersion -> Bool)
-> (GlpkMajorVersion -> GlpkMajorVersion -> Bool)
-> Eq GlpkMajorVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkMajorVersion -> GlpkMajorVersion -> Bool
$c/= :: GlpkMajorVersion -> GlpkMajorVersion -> Bool
== :: GlpkMajorVersion -> GlpkMajorVersion -> Bool
$c== :: GlpkMajorVersion -> GlpkMajorVersion -> Bool
Eq
    , Eq GlpkMajorVersion
Eq GlpkMajorVersion
-> (GlpkMajorVersion -> GlpkMajorVersion -> Ordering)
-> (GlpkMajorVersion -> GlpkMajorVersion -> Bool)
-> (GlpkMajorVersion -> GlpkMajorVersion -> Bool)
-> (GlpkMajorVersion -> GlpkMajorVersion -> Bool)
-> (GlpkMajorVersion -> GlpkMajorVersion -> Bool)
-> (GlpkMajorVersion -> GlpkMajorVersion -> GlpkMajorVersion)
-> (GlpkMajorVersion -> GlpkMajorVersion -> GlpkMajorVersion)
-> Ord GlpkMajorVersion
GlpkMajorVersion -> GlpkMajorVersion -> Bool
GlpkMajorVersion -> GlpkMajorVersion -> Ordering
GlpkMajorVersion -> GlpkMajorVersion -> GlpkMajorVersion
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkMajorVersion -> GlpkMajorVersion -> GlpkMajorVersion
$cmin :: GlpkMajorVersion -> GlpkMajorVersion -> GlpkMajorVersion
max :: GlpkMajorVersion -> GlpkMajorVersion -> GlpkMajorVersion
$cmax :: GlpkMajorVersion -> GlpkMajorVersion -> GlpkMajorVersion
>= :: GlpkMajorVersion -> GlpkMajorVersion -> Bool
$c>= :: GlpkMajorVersion -> GlpkMajorVersion -> Bool
> :: GlpkMajorVersion -> GlpkMajorVersion -> Bool
$c> :: GlpkMajorVersion -> GlpkMajorVersion -> Bool
<= :: GlpkMajorVersion -> GlpkMajorVersion -> Bool
$c<= :: GlpkMajorVersion -> GlpkMajorVersion -> Bool
< :: GlpkMajorVersion -> GlpkMajorVersion -> Bool
$c< :: GlpkMajorVersion -> GlpkMajorVersion -> Bool
compare :: GlpkMajorVersion -> GlpkMajorVersion -> Ordering
$ccompare :: GlpkMajorVersion -> GlpkMajorVersion -> Ordering
Ord
    , ReadPrec [GlpkMajorVersion]
ReadPrec GlpkMajorVersion
Int -> ReadS GlpkMajorVersion
ReadS [GlpkMajorVersion]
(Int -> ReadS GlpkMajorVersion)
-> ReadS [GlpkMajorVersion]
-> ReadPrec GlpkMajorVersion
-> ReadPrec [GlpkMajorVersion]
-> Read GlpkMajorVersion
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkMajorVersion]
$creadListPrec :: ReadPrec [GlpkMajorVersion]
readPrec :: ReadPrec GlpkMajorVersion
$creadPrec :: ReadPrec GlpkMajorVersion
readList :: ReadS [GlpkMajorVersion]
$creadList :: ReadS [GlpkMajorVersion]
readsPrec :: Int -> ReadS GlpkMajorVersion
$creadsPrec :: Int -> ReadS GlpkMajorVersion
Read
    , Int -> GlpkMajorVersion -> ShowS
[GlpkMajorVersion] -> ShowS
GlpkMajorVersion -> String
(Int -> GlpkMajorVersion -> ShowS)
-> (GlpkMajorVersion -> String)
-> ([GlpkMajorVersion] -> ShowS)
-> Show GlpkMajorVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkMajorVersion] -> ShowS
$cshowList :: [GlpkMajorVersion] -> ShowS
show :: GlpkMajorVersion -> String
$cshow :: GlpkMajorVersion -> String
showsPrec :: Int -> GlpkMajorVersion -> ShowS
$cshowsPrec :: Int -> GlpkMajorVersion -> ShowS
Show
    , Ptr GlpkMajorVersion -> IO GlpkMajorVersion
Ptr GlpkMajorVersion -> Int -> IO GlpkMajorVersion
Ptr GlpkMajorVersion -> Int -> GlpkMajorVersion -> IO ()
Ptr GlpkMajorVersion -> GlpkMajorVersion -> IO ()
GlpkMajorVersion -> Int
(GlpkMajorVersion -> Int)
-> (GlpkMajorVersion -> Int)
-> (Ptr GlpkMajorVersion -> Int -> IO GlpkMajorVersion)
-> (Ptr GlpkMajorVersion -> Int -> GlpkMajorVersion -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkMajorVersion)
-> (forall b. Ptr b -> Int -> GlpkMajorVersion -> IO ())
-> (Ptr GlpkMajorVersion -> IO GlpkMajorVersion)
-> (Ptr GlpkMajorVersion -> GlpkMajorVersion -> IO ())
-> Storable GlpkMajorVersion
forall b. Ptr b -> Int -> IO GlpkMajorVersion
forall b. Ptr b -> Int -> GlpkMajorVersion -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkMajorVersion -> GlpkMajorVersion -> IO ()
$cpoke :: Ptr GlpkMajorVersion -> GlpkMajorVersion -> IO ()
peek :: Ptr GlpkMajorVersion -> IO GlpkMajorVersion
$cpeek :: Ptr GlpkMajorVersion -> IO GlpkMajorVersion
pokeByteOff :: forall b. Ptr b -> Int -> GlpkMajorVersion -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkMajorVersion -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkMajorVersion
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkMajorVersion
pokeElemOff :: Ptr GlpkMajorVersion -> Int -> GlpkMajorVersion -> IO ()
$cpokeElemOff :: Ptr GlpkMajorVersion -> Int -> GlpkMajorVersion -> IO ()
peekElemOff :: Ptr GlpkMajorVersion -> Int -> IO GlpkMajorVersion
$cpeekElemOff :: Ptr GlpkMajorVersion -> Int -> IO GlpkMajorVersion
alignment :: GlpkMajorVersion -> Int
$calignment :: GlpkMajorVersion -> Int
sizeOf :: GlpkMajorVersion -> Int
$csizeOf :: GlpkMajorVersion -> Int
Storable
    , Typeable
    )

glpkMajorVersion  :: GlpkMajorVersion
glpkMajorVersion :: GlpkMajorVersion
glpkMajorVersion  = CInt -> GlpkMajorVersion
GlpkMajorVersion CInt
5

{-# LINE 773 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkMinorVersion
  = GlpkMinorVersion { GlpkMinorVersion -> CInt
fromGlpkMinorVersion :: CInt }
  deriving
    ( GlpkMinorVersion -> GlpkMinorVersion -> Bool
(GlpkMinorVersion -> GlpkMinorVersion -> Bool)
-> (GlpkMinorVersion -> GlpkMinorVersion -> Bool)
-> Eq GlpkMinorVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkMinorVersion -> GlpkMinorVersion -> Bool
$c/= :: GlpkMinorVersion -> GlpkMinorVersion -> Bool
== :: GlpkMinorVersion -> GlpkMinorVersion -> Bool
$c== :: GlpkMinorVersion -> GlpkMinorVersion -> Bool
Eq
    , Eq GlpkMinorVersion
Eq GlpkMinorVersion
-> (GlpkMinorVersion -> GlpkMinorVersion -> Ordering)
-> (GlpkMinorVersion -> GlpkMinorVersion -> Bool)
-> (GlpkMinorVersion -> GlpkMinorVersion -> Bool)
-> (GlpkMinorVersion -> GlpkMinorVersion -> Bool)
-> (GlpkMinorVersion -> GlpkMinorVersion -> Bool)
-> (GlpkMinorVersion -> GlpkMinorVersion -> GlpkMinorVersion)
-> (GlpkMinorVersion -> GlpkMinorVersion -> GlpkMinorVersion)
-> Ord GlpkMinorVersion
GlpkMinorVersion -> GlpkMinorVersion -> Bool
GlpkMinorVersion -> GlpkMinorVersion -> Ordering
GlpkMinorVersion -> GlpkMinorVersion -> GlpkMinorVersion
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkMinorVersion -> GlpkMinorVersion -> GlpkMinorVersion
$cmin :: GlpkMinorVersion -> GlpkMinorVersion -> GlpkMinorVersion
max :: GlpkMinorVersion -> GlpkMinorVersion -> GlpkMinorVersion
$cmax :: GlpkMinorVersion -> GlpkMinorVersion -> GlpkMinorVersion
>= :: GlpkMinorVersion -> GlpkMinorVersion -> Bool
$c>= :: GlpkMinorVersion -> GlpkMinorVersion -> Bool
> :: GlpkMinorVersion -> GlpkMinorVersion -> Bool
$c> :: GlpkMinorVersion -> GlpkMinorVersion -> Bool
<= :: GlpkMinorVersion -> GlpkMinorVersion -> Bool
$c<= :: GlpkMinorVersion -> GlpkMinorVersion -> Bool
< :: GlpkMinorVersion -> GlpkMinorVersion -> Bool
$c< :: GlpkMinorVersion -> GlpkMinorVersion -> Bool
compare :: GlpkMinorVersion -> GlpkMinorVersion -> Ordering
$ccompare :: GlpkMinorVersion -> GlpkMinorVersion -> Ordering
Ord
    , ReadPrec [GlpkMinorVersion]
ReadPrec GlpkMinorVersion
Int -> ReadS GlpkMinorVersion
ReadS [GlpkMinorVersion]
(Int -> ReadS GlpkMinorVersion)
-> ReadS [GlpkMinorVersion]
-> ReadPrec GlpkMinorVersion
-> ReadPrec [GlpkMinorVersion]
-> Read GlpkMinorVersion
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkMinorVersion]
$creadListPrec :: ReadPrec [GlpkMinorVersion]
readPrec :: ReadPrec GlpkMinorVersion
$creadPrec :: ReadPrec GlpkMinorVersion
readList :: ReadS [GlpkMinorVersion]
$creadList :: ReadS [GlpkMinorVersion]
readsPrec :: Int -> ReadS GlpkMinorVersion
$creadsPrec :: Int -> ReadS GlpkMinorVersion
Read
    , Int -> GlpkMinorVersion -> ShowS
[GlpkMinorVersion] -> ShowS
GlpkMinorVersion -> String
(Int -> GlpkMinorVersion -> ShowS)
-> (GlpkMinorVersion -> String)
-> ([GlpkMinorVersion] -> ShowS)
-> Show GlpkMinorVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkMinorVersion] -> ShowS
$cshowList :: [GlpkMinorVersion] -> ShowS
show :: GlpkMinorVersion -> String
$cshow :: GlpkMinorVersion -> String
showsPrec :: Int -> GlpkMinorVersion -> ShowS
$cshowsPrec :: Int -> GlpkMinorVersion -> ShowS
Show
    , Ptr GlpkMinorVersion -> IO GlpkMinorVersion
Ptr GlpkMinorVersion -> Int -> IO GlpkMinorVersion
Ptr GlpkMinorVersion -> Int -> GlpkMinorVersion -> IO ()
Ptr GlpkMinorVersion -> GlpkMinorVersion -> IO ()
GlpkMinorVersion -> Int
(GlpkMinorVersion -> Int)
-> (GlpkMinorVersion -> Int)
-> (Ptr GlpkMinorVersion -> Int -> IO GlpkMinorVersion)
-> (Ptr GlpkMinorVersion -> Int -> GlpkMinorVersion -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkMinorVersion)
-> (forall b. Ptr b -> Int -> GlpkMinorVersion -> IO ())
-> (Ptr GlpkMinorVersion -> IO GlpkMinorVersion)
-> (Ptr GlpkMinorVersion -> GlpkMinorVersion -> IO ())
-> Storable GlpkMinorVersion
forall b. Ptr b -> Int -> IO GlpkMinorVersion
forall b. Ptr b -> Int -> GlpkMinorVersion -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkMinorVersion -> GlpkMinorVersion -> IO ()
$cpoke :: Ptr GlpkMinorVersion -> GlpkMinorVersion -> IO ()
peek :: Ptr GlpkMinorVersion -> IO GlpkMinorVersion
$cpeek :: Ptr GlpkMinorVersion -> IO GlpkMinorVersion
pokeByteOff :: forall b. Ptr b -> Int -> GlpkMinorVersion -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkMinorVersion -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkMinorVersion
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkMinorVersion
pokeElemOff :: Ptr GlpkMinorVersion -> Int -> GlpkMinorVersion -> IO ()
$cpokeElemOff :: Ptr GlpkMinorVersion -> Int -> GlpkMinorVersion -> IO ()
peekElemOff :: Ptr GlpkMinorVersion -> Int -> IO GlpkMinorVersion
$cpeekElemOff :: Ptr GlpkMinorVersion -> Int -> IO GlpkMinorVersion
alignment :: GlpkMinorVersion -> Int
$calignment :: GlpkMinorVersion -> Int
sizeOf :: GlpkMinorVersion -> Int
$csizeOf :: GlpkMinorVersion -> Int
Storable
    , Typeable
    )

glpkMinorVersion  :: GlpkMinorVersion
glpkMinorVersion :: GlpkMinorVersion
glpkMinorVersion  = CInt -> GlpkMinorVersion
GlpkMinorVersion CInt
0

{-# LINE 790 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkDirection
  = GlpkDirection { GlpkDirection -> CInt
fromGlpkDirection :: CInt }
  deriving
    ( GlpkDirection -> GlpkDirection -> Bool
(GlpkDirection -> GlpkDirection -> Bool)
-> (GlpkDirection -> GlpkDirection -> Bool) -> Eq GlpkDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkDirection -> GlpkDirection -> Bool
$c/= :: GlpkDirection -> GlpkDirection -> Bool
== :: GlpkDirection -> GlpkDirection -> Bool
$c== :: GlpkDirection -> GlpkDirection -> Bool
Eq
    , Eq GlpkDirection
Eq GlpkDirection
-> (GlpkDirection -> GlpkDirection -> Ordering)
-> (GlpkDirection -> GlpkDirection -> Bool)
-> (GlpkDirection -> GlpkDirection -> Bool)
-> (GlpkDirection -> GlpkDirection -> Bool)
-> (GlpkDirection -> GlpkDirection -> Bool)
-> (GlpkDirection -> GlpkDirection -> GlpkDirection)
-> (GlpkDirection -> GlpkDirection -> GlpkDirection)
-> Ord GlpkDirection
GlpkDirection -> GlpkDirection -> Bool
GlpkDirection -> GlpkDirection -> Ordering
GlpkDirection -> GlpkDirection -> GlpkDirection
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkDirection -> GlpkDirection -> GlpkDirection
$cmin :: GlpkDirection -> GlpkDirection -> GlpkDirection
max :: GlpkDirection -> GlpkDirection -> GlpkDirection
$cmax :: GlpkDirection -> GlpkDirection -> GlpkDirection
>= :: GlpkDirection -> GlpkDirection -> Bool
$c>= :: GlpkDirection -> GlpkDirection -> Bool
> :: GlpkDirection -> GlpkDirection -> Bool
$c> :: GlpkDirection -> GlpkDirection -> Bool
<= :: GlpkDirection -> GlpkDirection -> Bool
$c<= :: GlpkDirection -> GlpkDirection -> Bool
< :: GlpkDirection -> GlpkDirection -> Bool
$c< :: GlpkDirection -> GlpkDirection -> Bool
compare :: GlpkDirection -> GlpkDirection -> Ordering
$ccompare :: GlpkDirection -> GlpkDirection -> Ordering
Ord
    , ReadPrec [GlpkDirection]
ReadPrec GlpkDirection
Int -> ReadS GlpkDirection
ReadS [GlpkDirection]
(Int -> ReadS GlpkDirection)
-> ReadS [GlpkDirection]
-> ReadPrec GlpkDirection
-> ReadPrec [GlpkDirection]
-> Read GlpkDirection
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkDirection]
$creadListPrec :: ReadPrec [GlpkDirection]
readPrec :: ReadPrec GlpkDirection
$creadPrec :: ReadPrec GlpkDirection
readList :: ReadS [GlpkDirection]
$creadList :: ReadS [GlpkDirection]
readsPrec :: Int -> ReadS GlpkDirection
$creadsPrec :: Int -> ReadS GlpkDirection
Read
    , Int -> GlpkDirection -> ShowS
[GlpkDirection] -> ShowS
GlpkDirection -> String
(Int -> GlpkDirection -> ShowS)
-> (GlpkDirection -> String)
-> ([GlpkDirection] -> ShowS)
-> Show GlpkDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkDirection] -> ShowS
$cshowList :: [GlpkDirection] -> ShowS
show :: GlpkDirection -> String
$cshow :: GlpkDirection -> String
showsPrec :: Int -> GlpkDirection -> ShowS
$cshowsPrec :: Int -> GlpkDirection -> ShowS
Show
    , Ptr GlpkDirection -> IO GlpkDirection
Ptr GlpkDirection -> Int -> IO GlpkDirection
Ptr GlpkDirection -> Int -> GlpkDirection -> IO ()
Ptr GlpkDirection -> GlpkDirection -> IO ()
GlpkDirection -> Int
(GlpkDirection -> Int)
-> (GlpkDirection -> Int)
-> (Ptr GlpkDirection -> Int -> IO GlpkDirection)
-> (Ptr GlpkDirection -> Int -> GlpkDirection -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkDirection)
-> (forall b. Ptr b -> Int -> GlpkDirection -> IO ())
-> (Ptr GlpkDirection -> IO GlpkDirection)
-> (Ptr GlpkDirection -> GlpkDirection -> IO ())
-> Storable GlpkDirection
forall b. Ptr b -> Int -> IO GlpkDirection
forall b. Ptr b -> Int -> GlpkDirection -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkDirection -> GlpkDirection -> IO ()
$cpoke :: Ptr GlpkDirection -> GlpkDirection -> IO ()
peek :: Ptr GlpkDirection -> IO GlpkDirection
$cpeek :: Ptr GlpkDirection -> IO GlpkDirection
pokeByteOff :: forall b. Ptr b -> Int -> GlpkDirection -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkDirection -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkDirection
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkDirection
pokeElemOff :: Ptr GlpkDirection -> Int -> GlpkDirection -> IO ()
$cpokeElemOff :: Ptr GlpkDirection -> Int -> GlpkDirection -> IO ()
peekElemOff :: Ptr GlpkDirection -> Int -> IO GlpkDirection
$cpeekElemOff :: Ptr GlpkDirection -> Int -> IO GlpkDirection
alignment :: GlpkDirection -> Int
$calignment :: GlpkDirection -> Int
sizeOf :: GlpkDirection -> Int
$csizeOf :: GlpkDirection -> Int
Storable
    , Typeable
    )

glpkMin  :: GlpkDirection
glpkMin :: GlpkDirection
glpkMin  = CInt -> GlpkDirection
GlpkDirection CInt
1
glpkMax  :: GlpkDirection
glpkMax :: GlpkDirection
glpkMax  = CInt -> GlpkDirection
GlpkDirection CInt
2

{-# LINE 808 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkVariableType
  = GlpkVariableType { GlpkVariableType -> CInt
fromGlpkVariableType :: CInt }
  deriving
    ( GlpkVariableType -> GlpkVariableType -> Bool
(GlpkVariableType -> GlpkVariableType -> Bool)
-> (GlpkVariableType -> GlpkVariableType -> Bool)
-> Eq GlpkVariableType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkVariableType -> GlpkVariableType -> Bool
$c/= :: GlpkVariableType -> GlpkVariableType -> Bool
== :: GlpkVariableType -> GlpkVariableType -> Bool
$c== :: GlpkVariableType -> GlpkVariableType -> Bool
Eq
    , Eq GlpkVariableType
Eq GlpkVariableType
-> (GlpkVariableType -> GlpkVariableType -> Ordering)
-> (GlpkVariableType -> GlpkVariableType -> Bool)
-> (GlpkVariableType -> GlpkVariableType -> Bool)
-> (GlpkVariableType -> GlpkVariableType -> Bool)
-> (GlpkVariableType -> GlpkVariableType -> Bool)
-> (GlpkVariableType -> GlpkVariableType -> GlpkVariableType)
-> (GlpkVariableType -> GlpkVariableType -> GlpkVariableType)
-> Ord GlpkVariableType
GlpkVariableType -> GlpkVariableType -> Bool
GlpkVariableType -> GlpkVariableType -> Ordering
GlpkVariableType -> GlpkVariableType -> GlpkVariableType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkVariableType -> GlpkVariableType -> GlpkVariableType
$cmin :: GlpkVariableType -> GlpkVariableType -> GlpkVariableType
max :: GlpkVariableType -> GlpkVariableType -> GlpkVariableType
$cmax :: GlpkVariableType -> GlpkVariableType -> GlpkVariableType
>= :: GlpkVariableType -> GlpkVariableType -> Bool
$c>= :: GlpkVariableType -> GlpkVariableType -> Bool
> :: GlpkVariableType -> GlpkVariableType -> Bool
$c> :: GlpkVariableType -> GlpkVariableType -> Bool
<= :: GlpkVariableType -> GlpkVariableType -> Bool
$c<= :: GlpkVariableType -> GlpkVariableType -> Bool
< :: GlpkVariableType -> GlpkVariableType -> Bool
$c< :: GlpkVariableType -> GlpkVariableType -> Bool
compare :: GlpkVariableType -> GlpkVariableType -> Ordering
$ccompare :: GlpkVariableType -> GlpkVariableType -> Ordering
Ord
    , ReadPrec [GlpkVariableType]
ReadPrec GlpkVariableType
Int -> ReadS GlpkVariableType
ReadS [GlpkVariableType]
(Int -> ReadS GlpkVariableType)
-> ReadS [GlpkVariableType]
-> ReadPrec GlpkVariableType
-> ReadPrec [GlpkVariableType]
-> Read GlpkVariableType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkVariableType]
$creadListPrec :: ReadPrec [GlpkVariableType]
readPrec :: ReadPrec GlpkVariableType
$creadPrec :: ReadPrec GlpkVariableType
readList :: ReadS [GlpkVariableType]
$creadList :: ReadS [GlpkVariableType]
readsPrec :: Int -> ReadS GlpkVariableType
$creadsPrec :: Int -> ReadS GlpkVariableType
Read
    , Int -> GlpkVariableType -> ShowS
[GlpkVariableType] -> ShowS
GlpkVariableType -> String
(Int -> GlpkVariableType -> ShowS)
-> (GlpkVariableType -> String)
-> ([GlpkVariableType] -> ShowS)
-> Show GlpkVariableType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkVariableType] -> ShowS
$cshowList :: [GlpkVariableType] -> ShowS
show :: GlpkVariableType -> String
$cshow :: GlpkVariableType -> String
showsPrec :: Int -> GlpkVariableType -> ShowS
$cshowsPrec :: Int -> GlpkVariableType -> ShowS
Show
    , Ptr GlpkVariableType -> IO GlpkVariableType
Ptr GlpkVariableType -> Int -> IO GlpkVariableType
Ptr GlpkVariableType -> Int -> GlpkVariableType -> IO ()
Ptr GlpkVariableType -> GlpkVariableType -> IO ()
GlpkVariableType -> Int
(GlpkVariableType -> Int)
-> (GlpkVariableType -> Int)
-> (Ptr GlpkVariableType -> Int -> IO GlpkVariableType)
-> (Ptr GlpkVariableType -> Int -> GlpkVariableType -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkVariableType)
-> (forall b. Ptr b -> Int -> GlpkVariableType -> IO ())
-> (Ptr GlpkVariableType -> IO GlpkVariableType)
-> (Ptr GlpkVariableType -> GlpkVariableType -> IO ())
-> Storable GlpkVariableType
forall b. Ptr b -> Int -> IO GlpkVariableType
forall b. Ptr b -> Int -> GlpkVariableType -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkVariableType -> GlpkVariableType -> IO ()
$cpoke :: Ptr GlpkVariableType -> GlpkVariableType -> IO ()
peek :: Ptr GlpkVariableType -> IO GlpkVariableType
$cpeek :: Ptr GlpkVariableType -> IO GlpkVariableType
pokeByteOff :: forall b. Ptr b -> Int -> GlpkVariableType -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkVariableType -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkVariableType
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkVariableType
pokeElemOff :: Ptr GlpkVariableType -> Int -> GlpkVariableType -> IO ()
$cpokeElemOff :: Ptr GlpkVariableType -> Int -> GlpkVariableType -> IO ()
peekElemOff :: Ptr GlpkVariableType -> Int -> IO GlpkVariableType
$cpeekElemOff :: Ptr GlpkVariableType -> Int -> IO GlpkVariableType
alignment :: GlpkVariableType -> Int
$calignment :: GlpkVariableType -> Int
sizeOf :: GlpkVariableType -> Int
$csizeOf :: GlpkVariableType -> Int
Storable
    , Typeable
    )

glpkContinuous  :: GlpkVariableType
glpkContinuous :: GlpkVariableType
glpkContinuous  = CInt -> GlpkVariableType
GlpkVariableType CInt
1
glpkInteger  :: GlpkVariableType
glpkInteger :: GlpkVariableType
glpkInteger  = CInt -> GlpkVariableType
GlpkVariableType CInt
2
glpkBinary  :: GlpkVariableType
glpkBinary :: GlpkVariableType
glpkBinary  = CInt -> GlpkVariableType
GlpkVariableType CInt
3

{-# LINE 827 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkConstraintType
  = GlpkConstraintType { GlpkConstraintType -> CInt
fromGlpkConstraintType :: CInt }
  deriving
    ( GlpkConstraintType -> GlpkConstraintType -> Bool
(GlpkConstraintType -> GlpkConstraintType -> Bool)
-> (GlpkConstraintType -> GlpkConstraintType -> Bool)
-> Eq GlpkConstraintType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkConstraintType -> GlpkConstraintType -> Bool
$c/= :: GlpkConstraintType -> GlpkConstraintType -> Bool
== :: GlpkConstraintType -> GlpkConstraintType -> Bool
$c== :: GlpkConstraintType -> GlpkConstraintType -> Bool
Eq
    , Eq GlpkConstraintType
Eq GlpkConstraintType
-> (GlpkConstraintType -> GlpkConstraintType -> Ordering)
-> (GlpkConstraintType -> GlpkConstraintType -> Bool)
-> (GlpkConstraintType -> GlpkConstraintType -> Bool)
-> (GlpkConstraintType -> GlpkConstraintType -> Bool)
-> (GlpkConstraintType -> GlpkConstraintType -> Bool)
-> (GlpkConstraintType -> GlpkConstraintType -> GlpkConstraintType)
-> (GlpkConstraintType -> GlpkConstraintType -> GlpkConstraintType)
-> Ord GlpkConstraintType
GlpkConstraintType -> GlpkConstraintType -> Bool
GlpkConstraintType -> GlpkConstraintType -> Ordering
GlpkConstraintType -> GlpkConstraintType -> GlpkConstraintType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkConstraintType -> GlpkConstraintType -> GlpkConstraintType
$cmin :: GlpkConstraintType -> GlpkConstraintType -> GlpkConstraintType
max :: GlpkConstraintType -> GlpkConstraintType -> GlpkConstraintType
$cmax :: GlpkConstraintType -> GlpkConstraintType -> GlpkConstraintType
>= :: GlpkConstraintType -> GlpkConstraintType -> Bool
$c>= :: GlpkConstraintType -> GlpkConstraintType -> Bool
> :: GlpkConstraintType -> GlpkConstraintType -> Bool
$c> :: GlpkConstraintType -> GlpkConstraintType -> Bool
<= :: GlpkConstraintType -> GlpkConstraintType -> Bool
$c<= :: GlpkConstraintType -> GlpkConstraintType -> Bool
< :: GlpkConstraintType -> GlpkConstraintType -> Bool
$c< :: GlpkConstraintType -> GlpkConstraintType -> Bool
compare :: GlpkConstraintType -> GlpkConstraintType -> Ordering
$ccompare :: GlpkConstraintType -> GlpkConstraintType -> Ordering
Ord
    , ReadPrec [GlpkConstraintType]
ReadPrec GlpkConstraintType
Int -> ReadS GlpkConstraintType
ReadS [GlpkConstraintType]
(Int -> ReadS GlpkConstraintType)
-> ReadS [GlpkConstraintType]
-> ReadPrec GlpkConstraintType
-> ReadPrec [GlpkConstraintType]
-> Read GlpkConstraintType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkConstraintType]
$creadListPrec :: ReadPrec [GlpkConstraintType]
readPrec :: ReadPrec GlpkConstraintType
$creadPrec :: ReadPrec GlpkConstraintType
readList :: ReadS [GlpkConstraintType]
$creadList :: ReadS [GlpkConstraintType]
readsPrec :: Int -> ReadS GlpkConstraintType
$creadsPrec :: Int -> ReadS GlpkConstraintType
Read
    , Int -> GlpkConstraintType -> ShowS
[GlpkConstraintType] -> ShowS
GlpkConstraintType -> String
(Int -> GlpkConstraintType -> ShowS)
-> (GlpkConstraintType -> String)
-> ([GlpkConstraintType] -> ShowS)
-> Show GlpkConstraintType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkConstraintType] -> ShowS
$cshowList :: [GlpkConstraintType] -> ShowS
show :: GlpkConstraintType -> String
$cshow :: GlpkConstraintType -> String
showsPrec :: Int -> GlpkConstraintType -> ShowS
$cshowsPrec :: Int -> GlpkConstraintType -> ShowS
Show
    , Ptr GlpkConstraintType -> IO GlpkConstraintType
Ptr GlpkConstraintType -> Int -> IO GlpkConstraintType
Ptr GlpkConstraintType -> Int -> GlpkConstraintType -> IO ()
Ptr GlpkConstraintType -> GlpkConstraintType -> IO ()
GlpkConstraintType -> Int
(GlpkConstraintType -> Int)
-> (GlpkConstraintType -> Int)
-> (Ptr GlpkConstraintType -> Int -> IO GlpkConstraintType)
-> (Ptr GlpkConstraintType -> Int -> GlpkConstraintType -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkConstraintType)
-> (forall b. Ptr b -> Int -> GlpkConstraintType -> IO ())
-> (Ptr GlpkConstraintType -> IO GlpkConstraintType)
-> (Ptr GlpkConstraintType -> GlpkConstraintType -> IO ())
-> Storable GlpkConstraintType
forall b. Ptr b -> Int -> IO GlpkConstraintType
forall b. Ptr b -> Int -> GlpkConstraintType -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkConstraintType -> GlpkConstraintType -> IO ()
$cpoke :: Ptr GlpkConstraintType -> GlpkConstraintType -> IO ()
peek :: Ptr GlpkConstraintType -> IO GlpkConstraintType
$cpeek :: Ptr GlpkConstraintType -> IO GlpkConstraintType
pokeByteOff :: forall b. Ptr b -> Int -> GlpkConstraintType -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkConstraintType -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkConstraintType
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkConstraintType
pokeElemOff :: Ptr GlpkConstraintType -> Int -> GlpkConstraintType -> IO ()
$cpokeElemOff :: Ptr GlpkConstraintType -> Int -> GlpkConstraintType -> IO ()
peekElemOff :: Ptr GlpkConstraintType -> Int -> IO GlpkConstraintType
$cpeekElemOff :: Ptr GlpkConstraintType -> Int -> IO GlpkConstraintType
alignment :: GlpkConstraintType -> Int
$calignment :: GlpkConstraintType -> Int
sizeOf :: GlpkConstraintType -> Int
$csizeOf :: GlpkConstraintType -> Int
Storable
    , Typeable
    )

glpkFree  :: GlpkConstraintType
glpkFree :: GlpkConstraintType
glpkFree  = CInt -> GlpkConstraintType
GlpkConstraintType CInt
1
glpkGT  :: GlpkConstraintType
glpkGT :: GlpkConstraintType
glpkGT  = CInt -> GlpkConstraintType
GlpkConstraintType CInt
2
glpkLT  :: GlpkConstraintType
glpkLT :: GlpkConstraintType
glpkLT  = CInt -> GlpkConstraintType
GlpkConstraintType CInt
3
glpkBounded  :: GlpkConstraintType
glpkBounded :: GlpkConstraintType
glpkBounded  = CInt -> GlpkConstraintType
GlpkConstraintType CInt
4
glpkFixed  :: GlpkConstraintType
glpkFixed :: GlpkConstraintType
glpkFixed  = CInt -> GlpkConstraintType
GlpkConstraintType CInt
5

{-# LINE 848 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkVariableStatus
  = GlpkVariableStatus { fromGlpkVariableStatus :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkBasic  :: GlpkVariableStatus
glpkBasic :: GlpkVariableStatus
glpkBasic  = CInt -> GlpkVariableStatus
GlpkVariableStatus CInt
1
glpkNonBasicLower  :: GlpkVariableStatus
glpkNonBasicLower :: GlpkVariableStatus
glpkNonBasicLower  = CInt -> GlpkVariableStatus
GlpkVariableStatus CInt
2
glpkNonBasicUpper  :: GlpkVariableStatus
glpkNonBasicUpper :: GlpkVariableStatus
glpkNonBasicUpper  = CInt -> GlpkVariableStatus
GlpkVariableStatus CInt
3
glpkNonBasicFree  :: GlpkVariableStatus
glpkNonBasicFree :: GlpkVariableStatus
glpkNonBasicFree  = CInt -> GlpkVariableStatus
GlpkVariableStatus CInt
4
glpkNonBasicFixed  :: GlpkVariableStatus
glpkNonBasicFixed :: GlpkVariableStatus
glpkNonBasicFixed  = CInt -> GlpkVariableStatus
GlpkVariableStatus CInt
5

{-# LINE 869 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkScaling
  = GlpkScaling { fromGlpkScaling :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkGeometricMeanScaling  :: GlpkScaling
glpkGeometricMeanScaling :: GlpkScaling
glpkGeometricMeanScaling  = CInt -> GlpkScaling
GlpkScaling CInt
1
glpkEquilibrationScaling  :: GlpkScaling
glpkEquilibrationScaling :: GlpkScaling
glpkEquilibrationScaling  = CInt -> GlpkScaling
GlpkScaling CInt
16
glpkPowerOfTwoScaling  :: GlpkScaling
glpkPowerOfTwoScaling :: GlpkScaling
glpkPowerOfTwoScaling  = CInt -> GlpkScaling
GlpkScaling CInt
32
glpkSkipScaling  :: GlpkScaling
glpkSkipScaling :: GlpkScaling
glpkSkipScaling  = CInt -> GlpkScaling
GlpkScaling CInt
64
glpkAutoScaling  :: GlpkScaling
glpkAutoScaling :: GlpkScaling
glpkAutoScaling  = CInt -> GlpkScaling
GlpkScaling CInt
128

{-# LINE 890 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkSolutionType
  = GlpkSolutionType { fromGlpkSolutionType :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkBasicSolution  :: GlpkSolutionType
glpkBasicSolution :: GlpkSolutionType
glpkBasicSolution  = CInt -> GlpkSolutionType
GlpkSolutionType CInt
1
glpkInteriorPointSolution  :: GlpkSolutionType
glpkInteriorPointSolution :: GlpkSolutionType
glpkInteriorPointSolution  = CInt -> GlpkSolutionType
GlpkSolutionType CInt
2
glpkMIPSolution  :: GlpkSolutionType
glpkMIPSolution :: GlpkSolutionType
glpkMIPSolution  = CInt -> GlpkSolutionType
GlpkSolutionType CInt
3

{-# LINE 909 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkSolutionStatus
  = GlpkSolutionStatus { GlpkSolutionStatus -> CInt
fromGlpkSolutionStatus :: CInt }
  deriving
    ( GlpkSolutionStatus -> GlpkSolutionStatus -> Bool
(GlpkSolutionStatus -> GlpkSolutionStatus -> Bool)
-> (GlpkSolutionStatus -> GlpkSolutionStatus -> Bool)
-> Eq GlpkSolutionStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkSolutionStatus -> GlpkSolutionStatus -> Bool
$c/= :: GlpkSolutionStatus -> GlpkSolutionStatus -> Bool
== :: GlpkSolutionStatus -> GlpkSolutionStatus -> Bool
$c== :: GlpkSolutionStatus -> GlpkSolutionStatus -> Bool
Eq
    , Eq GlpkSolutionStatus
Eq GlpkSolutionStatus
-> (GlpkSolutionStatus -> GlpkSolutionStatus -> Ordering)
-> (GlpkSolutionStatus -> GlpkSolutionStatus -> Bool)
-> (GlpkSolutionStatus -> GlpkSolutionStatus -> Bool)
-> (GlpkSolutionStatus -> GlpkSolutionStatus -> Bool)
-> (GlpkSolutionStatus -> GlpkSolutionStatus -> Bool)
-> (GlpkSolutionStatus -> GlpkSolutionStatus -> GlpkSolutionStatus)
-> (GlpkSolutionStatus -> GlpkSolutionStatus -> GlpkSolutionStatus)
-> Ord GlpkSolutionStatus
GlpkSolutionStatus -> GlpkSolutionStatus -> Bool
GlpkSolutionStatus -> GlpkSolutionStatus -> Ordering
GlpkSolutionStatus -> GlpkSolutionStatus -> GlpkSolutionStatus
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkSolutionStatus -> GlpkSolutionStatus -> GlpkSolutionStatus
$cmin :: GlpkSolutionStatus -> GlpkSolutionStatus -> GlpkSolutionStatus
max :: GlpkSolutionStatus -> GlpkSolutionStatus -> GlpkSolutionStatus
$cmax :: GlpkSolutionStatus -> GlpkSolutionStatus -> GlpkSolutionStatus
>= :: GlpkSolutionStatus -> GlpkSolutionStatus -> Bool
$c>= :: GlpkSolutionStatus -> GlpkSolutionStatus -> Bool
> :: GlpkSolutionStatus -> GlpkSolutionStatus -> Bool
$c> :: GlpkSolutionStatus -> GlpkSolutionStatus -> Bool
<= :: GlpkSolutionStatus -> GlpkSolutionStatus -> Bool
$c<= :: GlpkSolutionStatus -> GlpkSolutionStatus -> Bool
< :: GlpkSolutionStatus -> GlpkSolutionStatus -> Bool
$c< :: GlpkSolutionStatus -> GlpkSolutionStatus -> Bool
compare :: GlpkSolutionStatus -> GlpkSolutionStatus -> Ordering
$ccompare :: GlpkSolutionStatus -> GlpkSolutionStatus -> Ordering
Ord
    , ReadPrec [GlpkSolutionStatus]
ReadPrec GlpkSolutionStatus
Int -> ReadS GlpkSolutionStatus
ReadS [GlpkSolutionStatus]
(Int -> ReadS GlpkSolutionStatus)
-> ReadS [GlpkSolutionStatus]
-> ReadPrec GlpkSolutionStatus
-> ReadPrec [GlpkSolutionStatus]
-> Read GlpkSolutionStatus
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkSolutionStatus]
$creadListPrec :: ReadPrec [GlpkSolutionStatus]
readPrec :: ReadPrec GlpkSolutionStatus
$creadPrec :: ReadPrec GlpkSolutionStatus
readList :: ReadS [GlpkSolutionStatus]
$creadList :: ReadS [GlpkSolutionStatus]
readsPrec :: Int -> ReadS GlpkSolutionStatus
$creadsPrec :: Int -> ReadS GlpkSolutionStatus
Read
    , Int -> GlpkSolutionStatus -> ShowS
[GlpkSolutionStatus] -> ShowS
GlpkSolutionStatus -> String
(Int -> GlpkSolutionStatus -> ShowS)
-> (GlpkSolutionStatus -> String)
-> ([GlpkSolutionStatus] -> ShowS)
-> Show GlpkSolutionStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkSolutionStatus] -> ShowS
$cshowList :: [GlpkSolutionStatus] -> ShowS
show :: GlpkSolutionStatus -> String
$cshow :: GlpkSolutionStatus -> String
showsPrec :: Int -> GlpkSolutionStatus -> ShowS
$cshowsPrec :: Int -> GlpkSolutionStatus -> ShowS
Show
    , Ptr GlpkSolutionStatus -> IO GlpkSolutionStatus
Ptr GlpkSolutionStatus -> Int -> IO GlpkSolutionStatus
Ptr GlpkSolutionStatus -> Int -> GlpkSolutionStatus -> IO ()
Ptr GlpkSolutionStatus -> GlpkSolutionStatus -> IO ()
GlpkSolutionStatus -> Int
(GlpkSolutionStatus -> Int)
-> (GlpkSolutionStatus -> Int)
-> (Ptr GlpkSolutionStatus -> Int -> IO GlpkSolutionStatus)
-> (Ptr GlpkSolutionStatus -> Int -> GlpkSolutionStatus -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkSolutionStatus)
-> (forall b. Ptr b -> Int -> GlpkSolutionStatus -> IO ())
-> (Ptr GlpkSolutionStatus -> IO GlpkSolutionStatus)
-> (Ptr GlpkSolutionStatus -> GlpkSolutionStatus -> IO ())
-> Storable GlpkSolutionStatus
forall b. Ptr b -> Int -> IO GlpkSolutionStatus
forall b. Ptr b -> Int -> GlpkSolutionStatus -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkSolutionStatus -> GlpkSolutionStatus -> IO ()
$cpoke :: Ptr GlpkSolutionStatus -> GlpkSolutionStatus -> IO ()
peek :: Ptr GlpkSolutionStatus -> IO GlpkSolutionStatus
$cpeek :: Ptr GlpkSolutionStatus -> IO GlpkSolutionStatus
pokeByteOff :: forall b. Ptr b -> Int -> GlpkSolutionStatus -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkSolutionStatus -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkSolutionStatus
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkSolutionStatus
pokeElemOff :: Ptr GlpkSolutionStatus -> Int -> GlpkSolutionStatus -> IO ()
$cpokeElemOff :: Ptr GlpkSolutionStatus -> Int -> GlpkSolutionStatus -> IO ()
peekElemOff :: Ptr GlpkSolutionStatus -> Int -> IO GlpkSolutionStatus
$cpeekElemOff :: Ptr GlpkSolutionStatus -> Int -> IO GlpkSolutionStatus
alignment :: GlpkSolutionStatus -> Int
$calignment :: GlpkSolutionStatus -> Int
sizeOf :: GlpkSolutionStatus -> Int
$csizeOf :: GlpkSolutionStatus -> Int
Storable
    , Typeable
    )

glpkOptimal  :: GlpkSolutionStatus
glpkOptimal :: GlpkSolutionStatus
glpkOptimal  = CInt -> GlpkSolutionStatus
GlpkSolutionStatus CInt
5
glpkFeasible  :: GlpkSolutionStatus
glpkFeasible :: GlpkSolutionStatus
glpkFeasible  = CInt -> GlpkSolutionStatus
GlpkSolutionStatus CInt
2
glpkInfeasible  :: GlpkSolutionStatus
glpkInfeasible :: GlpkSolutionStatus
glpkInfeasible  = CInt -> GlpkSolutionStatus
GlpkSolutionStatus CInt
3
glpkNoFeasible  :: GlpkSolutionStatus
glpkNoFeasible :: GlpkSolutionStatus
glpkNoFeasible  = CInt -> GlpkSolutionStatus
GlpkSolutionStatus CInt
4
glpkUnbounded  :: GlpkSolutionStatus
glpkUnbounded :: GlpkSolutionStatus
glpkUnbounded  = CInt -> GlpkSolutionStatus
GlpkSolutionStatus CInt
6
glpkUndefined  :: GlpkSolutionStatus
glpkUndefined :: GlpkSolutionStatus
glpkUndefined  = CInt -> GlpkSolutionStatus
GlpkSolutionStatus CInt
1

{-# LINE 931 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkMessageLevel
  = GlpkMessageLevel { fromGlpkMessageLevel :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkMessageOff  :: GlpkMessageLevel
glpkMessageOff :: GlpkMessageLevel
glpkMessageOff  = CInt -> GlpkMessageLevel
GlpkMessageLevel CInt
0
glpkMessageError  :: GlpkMessageLevel
glpkMessageError :: GlpkMessageLevel
glpkMessageError  = CInt -> GlpkMessageLevel
GlpkMessageLevel CInt
1
glpkMessageOn  :: GlpkMessageLevel
glpkMessageOn :: GlpkMessageLevel
glpkMessageOn  = CInt -> GlpkMessageLevel
GlpkMessageLevel CInt
2
glpkMessageAll  :: GlpkMessageLevel
glpkMessageAll :: GlpkMessageLevel
glpkMessageAll  = CInt -> GlpkMessageLevel
GlpkMessageLevel CInt
3
glpkMessageDebug  :: GlpkMessageLevel
glpkMessageDebug :: GlpkMessageLevel
glpkMessageDebug  = CInt -> GlpkMessageLevel
GlpkMessageLevel CInt
4

{-# LINE 952 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkSimplexMethod
  = GlpkSimplexMethod { fromGlpkSimplexMethod :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkPrimalSimplex  :: GlpkSimplexMethod
glpkPrimalSimplex :: GlpkSimplexMethod
glpkPrimalSimplex  = CInt -> GlpkSimplexMethod
GlpkSimplexMethod CInt
1
glpkDualSimplex  :: GlpkSimplexMethod
glpkDualSimplex :: GlpkSimplexMethod
glpkDualSimplex  = CInt -> GlpkSimplexMethod
GlpkSimplexMethod CInt
3
glpkDualPSimplex  :: GlpkSimplexMethod
glpkDualPSimplex :: GlpkSimplexMethod
glpkDualPSimplex  = CInt -> GlpkSimplexMethod
GlpkSimplexMethod CInt
2

{-# LINE 971 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkPricing
  = GlpkPricing { GlpkPricing -> CInt
fromGlpkPricing :: CInt }
  deriving
    ( GlpkPricing -> GlpkPricing -> Bool
(GlpkPricing -> GlpkPricing -> Bool)
-> (GlpkPricing -> GlpkPricing -> Bool) -> Eq GlpkPricing
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkPricing -> GlpkPricing -> Bool
$c/= :: GlpkPricing -> GlpkPricing -> Bool
== :: GlpkPricing -> GlpkPricing -> Bool
$c== :: GlpkPricing -> GlpkPricing -> Bool
Eq
    , Eq GlpkPricing
Eq GlpkPricing
-> (GlpkPricing -> GlpkPricing -> Ordering)
-> (GlpkPricing -> GlpkPricing -> Bool)
-> (GlpkPricing -> GlpkPricing -> Bool)
-> (GlpkPricing -> GlpkPricing -> Bool)
-> (GlpkPricing -> GlpkPricing -> Bool)
-> (GlpkPricing -> GlpkPricing -> GlpkPricing)
-> (GlpkPricing -> GlpkPricing -> GlpkPricing)
-> Ord GlpkPricing
GlpkPricing -> GlpkPricing -> Bool
GlpkPricing -> GlpkPricing -> Ordering
GlpkPricing -> GlpkPricing -> GlpkPricing
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkPricing -> GlpkPricing -> GlpkPricing
$cmin :: GlpkPricing -> GlpkPricing -> GlpkPricing
max :: GlpkPricing -> GlpkPricing -> GlpkPricing
$cmax :: GlpkPricing -> GlpkPricing -> GlpkPricing
>= :: GlpkPricing -> GlpkPricing -> Bool
$c>= :: GlpkPricing -> GlpkPricing -> Bool
> :: GlpkPricing -> GlpkPricing -> Bool
$c> :: GlpkPricing -> GlpkPricing -> Bool
<= :: GlpkPricing -> GlpkPricing -> Bool
$c<= :: GlpkPricing -> GlpkPricing -> Bool
< :: GlpkPricing -> GlpkPricing -> Bool
$c< :: GlpkPricing -> GlpkPricing -> Bool
compare :: GlpkPricing -> GlpkPricing -> Ordering
$ccompare :: GlpkPricing -> GlpkPricing -> Ordering
Ord
    , ReadPrec [GlpkPricing]
ReadPrec GlpkPricing
Int -> ReadS GlpkPricing
ReadS [GlpkPricing]
(Int -> ReadS GlpkPricing)
-> ReadS [GlpkPricing]
-> ReadPrec GlpkPricing
-> ReadPrec [GlpkPricing]
-> Read GlpkPricing
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkPricing]
$creadListPrec :: ReadPrec [GlpkPricing]
readPrec :: ReadPrec GlpkPricing
$creadPrec :: ReadPrec GlpkPricing
readList :: ReadS [GlpkPricing]
$creadList :: ReadS [GlpkPricing]
readsPrec :: Int -> ReadS GlpkPricing
$creadsPrec :: Int -> ReadS GlpkPricing
Read
    , Int -> GlpkPricing -> ShowS
[GlpkPricing] -> ShowS
GlpkPricing -> String
(Int -> GlpkPricing -> ShowS)
-> (GlpkPricing -> String)
-> ([GlpkPricing] -> ShowS)
-> Show GlpkPricing
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkPricing] -> ShowS
$cshowList :: [GlpkPricing] -> ShowS
show :: GlpkPricing -> String
$cshow :: GlpkPricing -> String
showsPrec :: Int -> GlpkPricing -> ShowS
$cshowsPrec :: Int -> GlpkPricing -> ShowS
Show
    , Ptr GlpkPricing -> IO GlpkPricing
Ptr GlpkPricing -> Int -> IO GlpkPricing
Ptr GlpkPricing -> Int -> GlpkPricing -> IO ()
Ptr GlpkPricing -> GlpkPricing -> IO ()
GlpkPricing -> Int
(GlpkPricing -> Int)
-> (GlpkPricing -> Int)
-> (Ptr GlpkPricing -> Int -> IO GlpkPricing)
-> (Ptr GlpkPricing -> Int -> GlpkPricing -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkPricing)
-> (forall b. Ptr b -> Int -> GlpkPricing -> IO ())
-> (Ptr GlpkPricing -> IO GlpkPricing)
-> (Ptr GlpkPricing -> GlpkPricing -> IO ())
-> Storable GlpkPricing
forall b. Ptr b -> Int -> IO GlpkPricing
forall b. Ptr b -> Int -> GlpkPricing -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkPricing -> GlpkPricing -> IO ()
$cpoke :: Ptr GlpkPricing -> GlpkPricing -> IO ()
peek :: Ptr GlpkPricing -> IO GlpkPricing
$cpeek :: Ptr GlpkPricing -> IO GlpkPricing
pokeByteOff :: forall b. Ptr b -> Int -> GlpkPricing -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkPricing -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkPricing
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkPricing
pokeElemOff :: Ptr GlpkPricing -> Int -> GlpkPricing -> IO ()
$cpokeElemOff :: Ptr GlpkPricing -> Int -> GlpkPricing -> IO ()
peekElemOff :: Ptr GlpkPricing -> Int -> IO GlpkPricing
$cpeekElemOff :: Ptr GlpkPricing -> Int -> IO GlpkPricing
alignment :: GlpkPricing -> Int
$calignment :: GlpkPricing -> Int
sizeOf :: GlpkPricing -> Int
$csizeOf :: GlpkPricing -> Int
Storable
    , Typeable
    )

glpkTextbookPricing  :: GlpkPricing
glpkTextbookPricing :: GlpkPricing
glpkTextbookPricing  = CInt -> GlpkPricing
GlpkPricing CInt
17
glpkStandardPricing  :: GlpkPricing
glpkStandardPricing :: GlpkPricing
glpkStandardPricing  = CInt -> GlpkPricing
GlpkPricing CInt
17
glpkProjectedSteepestEdge  :: GlpkPricing
glpkProjectedSteepestEdge :: GlpkPricing
glpkProjectedSteepestEdge  = CInt -> GlpkPricing
GlpkPricing CInt
34

{-# LINE 990 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkRatioTest
  = GlpkRatioTest { GlpkRatioTest -> CInt
fromGlpkRatioTest :: CInt }
  deriving
    ( GlpkRatioTest -> GlpkRatioTest -> Bool
(GlpkRatioTest -> GlpkRatioTest -> Bool)
-> (GlpkRatioTest -> GlpkRatioTest -> Bool) -> Eq GlpkRatioTest
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkRatioTest -> GlpkRatioTest -> Bool
$c/= :: GlpkRatioTest -> GlpkRatioTest -> Bool
== :: GlpkRatioTest -> GlpkRatioTest -> Bool
$c== :: GlpkRatioTest -> GlpkRatioTest -> Bool
Eq
    , Eq GlpkRatioTest
Eq GlpkRatioTest
-> (GlpkRatioTest -> GlpkRatioTest -> Ordering)
-> (GlpkRatioTest -> GlpkRatioTest -> Bool)
-> (GlpkRatioTest -> GlpkRatioTest -> Bool)
-> (GlpkRatioTest -> GlpkRatioTest -> Bool)
-> (GlpkRatioTest -> GlpkRatioTest -> Bool)
-> (GlpkRatioTest -> GlpkRatioTest -> GlpkRatioTest)
-> (GlpkRatioTest -> GlpkRatioTest -> GlpkRatioTest)
-> Ord GlpkRatioTest
GlpkRatioTest -> GlpkRatioTest -> Bool
GlpkRatioTest -> GlpkRatioTest -> Ordering
GlpkRatioTest -> GlpkRatioTest -> GlpkRatioTest
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkRatioTest -> GlpkRatioTest -> GlpkRatioTest
$cmin :: GlpkRatioTest -> GlpkRatioTest -> GlpkRatioTest
max :: GlpkRatioTest -> GlpkRatioTest -> GlpkRatioTest
$cmax :: GlpkRatioTest -> GlpkRatioTest -> GlpkRatioTest
>= :: GlpkRatioTest -> GlpkRatioTest -> Bool
$c>= :: GlpkRatioTest -> GlpkRatioTest -> Bool
> :: GlpkRatioTest -> GlpkRatioTest -> Bool
$c> :: GlpkRatioTest -> GlpkRatioTest -> Bool
<= :: GlpkRatioTest -> GlpkRatioTest -> Bool
$c<= :: GlpkRatioTest -> GlpkRatioTest -> Bool
< :: GlpkRatioTest -> GlpkRatioTest -> Bool
$c< :: GlpkRatioTest -> GlpkRatioTest -> Bool
compare :: GlpkRatioTest -> GlpkRatioTest -> Ordering
$ccompare :: GlpkRatioTest -> GlpkRatioTest -> Ordering
Ord
    , ReadPrec [GlpkRatioTest]
ReadPrec GlpkRatioTest
Int -> ReadS GlpkRatioTest
ReadS [GlpkRatioTest]
(Int -> ReadS GlpkRatioTest)
-> ReadS [GlpkRatioTest]
-> ReadPrec GlpkRatioTest
-> ReadPrec [GlpkRatioTest]
-> Read GlpkRatioTest
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkRatioTest]
$creadListPrec :: ReadPrec [GlpkRatioTest]
readPrec :: ReadPrec GlpkRatioTest
$creadPrec :: ReadPrec GlpkRatioTest
readList :: ReadS [GlpkRatioTest]
$creadList :: ReadS [GlpkRatioTest]
readsPrec :: Int -> ReadS GlpkRatioTest
$creadsPrec :: Int -> ReadS GlpkRatioTest
Read
    , Int -> GlpkRatioTest -> ShowS
[GlpkRatioTest] -> ShowS
GlpkRatioTest -> String
(Int -> GlpkRatioTest -> ShowS)
-> (GlpkRatioTest -> String)
-> ([GlpkRatioTest] -> ShowS)
-> Show GlpkRatioTest
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkRatioTest] -> ShowS
$cshowList :: [GlpkRatioTest] -> ShowS
show :: GlpkRatioTest -> String
$cshow :: GlpkRatioTest -> String
showsPrec :: Int -> GlpkRatioTest -> ShowS
$cshowsPrec :: Int -> GlpkRatioTest -> ShowS
Show
    , Ptr GlpkRatioTest -> IO GlpkRatioTest
Ptr GlpkRatioTest -> Int -> IO GlpkRatioTest
Ptr GlpkRatioTest -> Int -> GlpkRatioTest -> IO ()
Ptr GlpkRatioTest -> GlpkRatioTest -> IO ()
GlpkRatioTest -> Int
(GlpkRatioTest -> Int)
-> (GlpkRatioTest -> Int)
-> (Ptr GlpkRatioTest -> Int -> IO GlpkRatioTest)
-> (Ptr GlpkRatioTest -> Int -> GlpkRatioTest -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkRatioTest)
-> (forall b. Ptr b -> Int -> GlpkRatioTest -> IO ())
-> (Ptr GlpkRatioTest -> IO GlpkRatioTest)
-> (Ptr GlpkRatioTest -> GlpkRatioTest -> IO ())
-> Storable GlpkRatioTest
forall b. Ptr b -> Int -> IO GlpkRatioTest
forall b. Ptr b -> Int -> GlpkRatioTest -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkRatioTest -> GlpkRatioTest -> IO ()
$cpoke :: Ptr GlpkRatioTest -> GlpkRatioTest -> IO ()
peek :: Ptr GlpkRatioTest -> IO GlpkRatioTest
$cpeek :: Ptr GlpkRatioTest -> IO GlpkRatioTest
pokeByteOff :: forall b. Ptr b -> Int -> GlpkRatioTest -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkRatioTest -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkRatioTest
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkRatioTest
pokeElemOff :: Ptr GlpkRatioTest -> Int -> GlpkRatioTest -> IO ()
$cpokeElemOff :: Ptr GlpkRatioTest -> Int -> GlpkRatioTest -> IO ()
peekElemOff :: Ptr GlpkRatioTest -> Int -> IO GlpkRatioTest
$cpeekElemOff :: Ptr GlpkRatioTest -> Int -> IO GlpkRatioTest
alignment :: GlpkRatioTest -> Int
$calignment :: GlpkRatioTest -> Int
sizeOf :: GlpkRatioTest -> Int
$csizeOf :: GlpkRatioTest -> Int
Storable
    , Typeable
    )

glpkStandardRatioTest  :: GlpkRatioTest
glpkStandardRatioTest :: GlpkRatioTest
glpkStandardRatioTest  = CInt -> GlpkRatioTest
GlpkRatioTest CInt
17
glpkHarrisTwoPassRatioTest  :: GlpkRatioTest
glpkHarrisTwoPassRatioTest :: GlpkRatioTest
glpkHarrisTwoPassRatioTest  = CInt -> GlpkRatioTest
GlpkRatioTest CInt
34

{-# LINE 1008 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkPreCholeskyOrdering
  = GlpkPreCholeskyOrdering { GlpkPreCholeskyOrdering -> CInt
fromGlpkPreCholeskyOrdering :: CInt }
  deriving
    ( GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool
(GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool)
-> (GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool)
-> Eq GlpkPreCholeskyOrdering
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool
$c/= :: GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool
== :: GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool
$c== :: GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool
Eq
    , Eq GlpkPreCholeskyOrdering
Eq GlpkPreCholeskyOrdering
-> (GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Ordering)
-> (GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool)
-> (GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool)
-> (GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool)
-> (GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool)
-> (GlpkPreCholeskyOrdering
    -> GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering)
-> (GlpkPreCholeskyOrdering
    -> GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering)
-> Ord GlpkPreCholeskyOrdering
GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool
GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Ordering
GlpkPreCholeskyOrdering
-> GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkPreCholeskyOrdering
-> GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering
$cmin :: GlpkPreCholeskyOrdering
-> GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering
max :: GlpkPreCholeskyOrdering
-> GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering
$cmax :: GlpkPreCholeskyOrdering
-> GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering
>= :: GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool
$c>= :: GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool
> :: GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool
$c> :: GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool
<= :: GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool
$c<= :: GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool
< :: GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool
$c< :: GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Bool
compare :: GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Ordering
$ccompare :: GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> Ordering
Ord
    , ReadPrec [GlpkPreCholeskyOrdering]
ReadPrec GlpkPreCholeskyOrdering
Int -> ReadS GlpkPreCholeskyOrdering
ReadS [GlpkPreCholeskyOrdering]
(Int -> ReadS GlpkPreCholeskyOrdering)
-> ReadS [GlpkPreCholeskyOrdering]
-> ReadPrec GlpkPreCholeskyOrdering
-> ReadPrec [GlpkPreCholeskyOrdering]
-> Read GlpkPreCholeskyOrdering
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkPreCholeskyOrdering]
$creadListPrec :: ReadPrec [GlpkPreCholeskyOrdering]
readPrec :: ReadPrec GlpkPreCholeskyOrdering
$creadPrec :: ReadPrec GlpkPreCholeskyOrdering
readList :: ReadS [GlpkPreCholeskyOrdering]
$creadList :: ReadS [GlpkPreCholeskyOrdering]
readsPrec :: Int -> ReadS GlpkPreCholeskyOrdering
$creadsPrec :: Int -> ReadS GlpkPreCholeskyOrdering
Read
    , Int -> GlpkPreCholeskyOrdering -> ShowS
[GlpkPreCholeskyOrdering] -> ShowS
GlpkPreCholeskyOrdering -> String
(Int -> GlpkPreCholeskyOrdering -> ShowS)
-> (GlpkPreCholeskyOrdering -> String)
-> ([GlpkPreCholeskyOrdering] -> ShowS)
-> Show GlpkPreCholeskyOrdering
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkPreCholeskyOrdering] -> ShowS
$cshowList :: [GlpkPreCholeskyOrdering] -> ShowS
show :: GlpkPreCholeskyOrdering -> String
$cshow :: GlpkPreCholeskyOrdering -> String
showsPrec :: Int -> GlpkPreCholeskyOrdering -> ShowS
$cshowsPrec :: Int -> GlpkPreCholeskyOrdering -> ShowS
Show
    , Ptr GlpkPreCholeskyOrdering -> IO GlpkPreCholeskyOrdering
Ptr GlpkPreCholeskyOrdering -> Int -> IO GlpkPreCholeskyOrdering
Ptr GlpkPreCholeskyOrdering
-> Int -> GlpkPreCholeskyOrdering -> IO ()
Ptr GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> IO ()
GlpkPreCholeskyOrdering -> Int
(GlpkPreCholeskyOrdering -> Int)
-> (GlpkPreCholeskyOrdering -> Int)
-> (Ptr GlpkPreCholeskyOrdering
    -> Int -> IO GlpkPreCholeskyOrdering)
-> (Ptr GlpkPreCholeskyOrdering
    -> Int -> GlpkPreCholeskyOrdering -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkPreCholeskyOrdering)
-> (forall b. Ptr b -> Int -> GlpkPreCholeskyOrdering -> IO ())
-> (Ptr GlpkPreCholeskyOrdering -> IO GlpkPreCholeskyOrdering)
-> (Ptr GlpkPreCholeskyOrdering
    -> GlpkPreCholeskyOrdering -> IO ())
-> Storable GlpkPreCholeskyOrdering
forall b. Ptr b -> Int -> IO GlpkPreCholeskyOrdering
forall b. Ptr b -> Int -> GlpkPreCholeskyOrdering -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> IO ()
$cpoke :: Ptr GlpkPreCholeskyOrdering -> GlpkPreCholeskyOrdering -> IO ()
peek :: Ptr GlpkPreCholeskyOrdering -> IO GlpkPreCholeskyOrdering
$cpeek :: Ptr GlpkPreCholeskyOrdering -> IO GlpkPreCholeskyOrdering
pokeByteOff :: forall b. Ptr b -> Int -> GlpkPreCholeskyOrdering -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkPreCholeskyOrdering -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkPreCholeskyOrdering
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkPreCholeskyOrdering
pokeElemOff :: Ptr GlpkPreCholeskyOrdering
-> Int -> GlpkPreCholeskyOrdering -> IO ()
$cpokeElemOff :: Ptr GlpkPreCholeskyOrdering
-> Int -> GlpkPreCholeskyOrdering -> IO ()
peekElemOff :: Ptr GlpkPreCholeskyOrdering -> Int -> IO GlpkPreCholeskyOrdering
$cpeekElemOff :: Ptr GlpkPreCholeskyOrdering -> Int -> IO GlpkPreCholeskyOrdering
alignment :: GlpkPreCholeskyOrdering -> Int
$calignment :: GlpkPreCholeskyOrdering -> Int
sizeOf :: GlpkPreCholeskyOrdering -> Int
$csizeOf :: GlpkPreCholeskyOrdering -> Int
Storable
    , Typeable
    )

glpkNatural  :: GlpkPreCholeskyOrdering
glpkNatural :: GlpkPreCholeskyOrdering
glpkNatural  = CInt -> GlpkPreCholeskyOrdering
GlpkPreCholeskyOrdering CInt
0
glpkQuotientMinimumDegree  :: GlpkPreCholeskyOrdering
glpkQuotientMinimumDegree :: GlpkPreCholeskyOrdering
glpkQuotientMinimumDegree  = CInt -> GlpkPreCholeskyOrdering
GlpkPreCholeskyOrdering CInt
1
glpkApproximateMinimumDegree  :: GlpkPreCholeskyOrdering
glpkApproximateMinimumDegree :: GlpkPreCholeskyOrdering
glpkApproximateMinimumDegree  = CInt -> GlpkPreCholeskyOrdering
GlpkPreCholeskyOrdering CInt
2
glpkSymmetricApproximateMinimumDegree  :: GlpkPreCholeskyOrdering
glpkSymmetricApproximateMinimumDegree :: GlpkPreCholeskyOrdering
glpkSymmetricApproximateMinimumDegree  = CInt -> GlpkPreCholeskyOrdering
GlpkPreCholeskyOrdering CInt
3

{-# LINE 1028 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkBranchingTechnique
  = GlpkBranchingTechnique { fromGlpkBranchingTechnique :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkFirstFractional  :: GlpkBranchingTechnique
glpkFirstFractional :: GlpkBranchingTechnique
glpkFirstFractional  = CInt -> GlpkBranchingTechnique
GlpkBranchingTechnique CInt
1
glpkLastFractional  :: GlpkBranchingTechnique
glpkLastFractional :: GlpkBranchingTechnique
glpkLastFractional  = CInt -> GlpkBranchingTechnique
GlpkBranchingTechnique CInt
2
glpkMostFractional  :: GlpkBranchingTechnique
glpkMostFractional :: GlpkBranchingTechnique
glpkMostFractional  = CInt -> GlpkBranchingTechnique
GlpkBranchingTechnique CInt
3
glpkDriebeckTomlin  :: GlpkBranchingTechnique
glpkDriebeckTomlin :: GlpkBranchingTechnique
glpkDriebeckTomlin  = CInt -> GlpkBranchingTechnique
GlpkBranchingTechnique CInt
4
glpkHybridPseudoCost  :: GlpkBranchingTechnique
glpkHybridPseudoCost :: GlpkBranchingTechnique
glpkHybridPseudoCost  = CInt -> GlpkBranchingTechnique
GlpkBranchingTechnique CInt
5

{-# LINE 1049 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkBacktrackingTechnique
  = GlpkBacktrackingTechnique { fromGlpkBacktrackingTechnique :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkDepthFirstSearch  :: GlpkBacktrackingTechnique
glpkDepthFirstSearch :: GlpkBacktrackingTechnique
glpkDepthFirstSearch  = CInt -> GlpkBacktrackingTechnique
GlpkBacktrackingTechnique CInt
1
glpkBreadthFirstSearch  :: GlpkBacktrackingTechnique
glpkBreadthFirstSearch :: GlpkBacktrackingTechnique
glpkBreadthFirstSearch  = CInt -> GlpkBacktrackingTechnique
GlpkBacktrackingTechnique CInt
2
glpkBestLocalBound  :: GlpkBacktrackingTechnique
glpkBestLocalBound :: GlpkBacktrackingTechnique
glpkBestLocalBound  = CInt -> GlpkBacktrackingTechnique
GlpkBacktrackingTechnique CInt
3
glpkBestProjectionHeuristic  :: GlpkBacktrackingTechnique
glpkBestProjectionHeuristic :: GlpkBacktrackingTechnique
glpkBestProjectionHeuristic  = CInt -> GlpkBacktrackingTechnique
GlpkBacktrackingTechnique CInt
4

{-# LINE 1069 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkPreProcessingTechnique
  = GlpkPreProcessingTechnique { fromGlpkPreProcessingTechnique :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkPreProcessNone  :: GlpkPreProcessingTechnique
glpkPreProcessNone :: GlpkPreProcessingTechnique
glpkPreProcessNone  = CInt -> GlpkPreProcessingTechnique
GlpkPreProcessingTechnique CInt
0
glpkPreProcessRoot  :: GlpkPreProcessingTechnique
glpkPreProcessRoot :: GlpkPreProcessingTechnique
glpkPreProcessRoot  = CInt -> GlpkPreProcessingTechnique
GlpkPreProcessingTechnique CInt
1
glpkPreProcessAll  :: GlpkPreProcessingTechnique
glpkPreProcessAll :: GlpkPreProcessingTechnique
glpkPreProcessAll  = CInt -> GlpkPreProcessingTechnique
GlpkPreProcessingTechnique CInt
2

{-# LINE 1088 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkFeasibilityPump
  = GlpkFeasibilityPump { GlpkFeasibilityPump -> CInt
fromGlpkFeasibilityPump :: CInt }
  deriving
    ( GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool
(GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool)
-> (GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool)
-> Eq GlpkFeasibilityPump
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool
$c/= :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool
== :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool
$c== :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool
Eq
    , Eq GlpkFeasibilityPump
Eq GlpkFeasibilityPump
-> (GlpkFeasibilityPump -> GlpkFeasibilityPump -> Ordering)
-> (GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool)
-> (GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool)
-> (GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool)
-> (GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool)
-> (GlpkFeasibilityPump
    -> GlpkFeasibilityPump -> GlpkFeasibilityPump)
-> (GlpkFeasibilityPump
    -> GlpkFeasibilityPump -> GlpkFeasibilityPump)
-> Ord GlpkFeasibilityPump
GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool
GlpkFeasibilityPump -> GlpkFeasibilityPump -> Ordering
GlpkFeasibilityPump -> GlpkFeasibilityPump -> GlpkFeasibilityPump
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> GlpkFeasibilityPump
$cmin :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> GlpkFeasibilityPump
max :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> GlpkFeasibilityPump
$cmax :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> GlpkFeasibilityPump
>= :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool
$c>= :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool
> :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool
$c> :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool
<= :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool
$c<= :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool
< :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool
$c< :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> Bool
compare :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> Ordering
$ccompare :: GlpkFeasibilityPump -> GlpkFeasibilityPump -> Ordering
Ord
    , ReadPrec [GlpkFeasibilityPump]
ReadPrec GlpkFeasibilityPump
Int -> ReadS GlpkFeasibilityPump
ReadS [GlpkFeasibilityPump]
(Int -> ReadS GlpkFeasibilityPump)
-> ReadS [GlpkFeasibilityPump]
-> ReadPrec GlpkFeasibilityPump
-> ReadPrec [GlpkFeasibilityPump]
-> Read GlpkFeasibilityPump
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkFeasibilityPump]
$creadListPrec :: ReadPrec [GlpkFeasibilityPump]
readPrec :: ReadPrec GlpkFeasibilityPump
$creadPrec :: ReadPrec GlpkFeasibilityPump
readList :: ReadS [GlpkFeasibilityPump]
$creadList :: ReadS [GlpkFeasibilityPump]
readsPrec :: Int -> ReadS GlpkFeasibilityPump
$creadsPrec :: Int -> ReadS GlpkFeasibilityPump
Read
    , Int -> GlpkFeasibilityPump -> ShowS
[GlpkFeasibilityPump] -> ShowS
GlpkFeasibilityPump -> String
(Int -> GlpkFeasibilityPump -> ShowS)
-> (GlpkFeasibilityPump -> String)
-> ([GlpkFeasibilityPump] -> ShowS)
-> Show GlpkFeasibilityPump
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkFeasibilityPump] -> ShowS
$cshowList :: [GlpkFeasibilityPump] -> ShowS
show :: GlpkFeasibilityPump -> String
$cshow :: GlpkFeasibilityPump -> String
showsPrec :: Int -> GlpkFeasibilityPump -> ShowS
$cshowsPrec :: Int -> GlpkFeasibilityPump -> ShowS
Show
    , Ptr GlpkFeasibilityPump -> IO GlpkFeasibilityPump
Ptr GlpkFeasibilityPump -> Int -> IO GlpkFeasibilityPump
Ptr GlpkFeasibilityPump -> Int -> GlpkFeasibilityPump -> IO ()
Ptr GlpkFeasibilityPump -> GlpkFeasibilityPump -> IO ()
GlpkFeasibilityPump -> Int
(GlpkFeasibilityPump -> Int)
-> (GlpkFeasibilityPump -> Int)
-> (Ptr GlpkFeasibilityPump -> Int -> IO GlpkFeasibilityPump)
-> (Ptr GlpkFeasibilityPump -> Int -> GlpkFeasibilityPump -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkFeasibilityPump)
-> (forall b. Ptr b -> Int -> GlpkFeasibilityPump -> IO ())
-> (Ptr GlpkFeasibilityPump -> IO GlpkFeasibilityPump)
-> (Ptr GlpkFeasibilityPump -> GlpkFeasibilityPump -> IO ())
-> Storable GlpkFeasibilityPump
forall b. Ptr b -> Int -> IO GlpkFeasibilityPump
forall b. Ptr b -> Int -> GlpkFeasibilityPump -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkFeasibilityPump -> GlpkFeasibilityPump -> IO ()
$cpoke :: Ptr GlpkFeasibilityPump -> GlpkFeasibilityPump -> IO ()
peek :: Ptr GlpkFeasibilityPump -> IO GlpkFeasibilityPump
$cpeek :: Ptr GlpkFeasibilityPump -> IO GlpkFeasibilityPump
pokeByteOff :: forall b. Ptr b -> Int -> GlpkFeasibilityPump -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkFeasibilityPump -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkFeasibilityPump
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkFeasibilityPump
pokeElemOff :: Ptr GlpkFeasibilityPump -> Int -> GlpkFeasibilityPump -> IO ()
$cpokeElemOff :: Ptr GlpkFeasibilityPump -> Int -> GlpkFeasibilityPump -> IO ()
peekElemOff :: Ptr GlpkFeasibilityPump -> Int -> IO GlpkFeasibilityPump
$cpeekElemOff :: Ptr GlpkFeasibilityPump -> Int -> IO GlpkFeasibilityPump
alignment :: GlpkFeasibilityPump -> Int
$calignment :: GlpkFeasibilityPump -> Int
sizeOf :: GlpkFeasibilityPump -> Int
$csizeOf :: GlpkFeasibilityPump -> Int
Storable
    , Typeable
    )

glpkFeasibilityPumpOn  :: GlpkFeasibilityPump
glpkFeasibilityPumpOn :: GlpkFeasibilityPump
glpkFeasibilityPumpOn  = CInt -> GlpkFeasibilityPump
GlpkFeasibilityPump CInt
1
glpkFeasibilityPumpOff  :: GlpkFeasibilityPump
glpkFeasibilityPumpOff :: GlpkFeasibilityPump
glpkFeasibilityPumpOff  = CInt -> GlpkFeasibilityPump
GlpkFeasibilityPump CInt
0

{-# LINE 1106 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkProximitySearch
  = GlpkProximitySearch { GlpkProximitySearch -> CInt
fromGlpkProximitySearch :: CInt }
  deriving
    ( GlpkProximitySearch -> GlpkProximitySearch -> Bool
(GlpkProximitySearch -> GlpkProximitySearch -> Bool)
-> (GlpkProximitySearch -> GlpkProximitySearch -> Bool)
-> Eq GlpkProximitySearch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkProximitySearch -> GlpkProximitySearch -> Bool
$c/= :: GlpkProximitySearch -> GlpkProximitySearch -> Bool
== :: GlpkProximitySearch -> GlpkProximitySearch -> Bool
$c== :: GlpkProximitySearch -> GlpkProximitySearch -> Bool
Eq
    , Eq GlpkProximitySearch
Eq GlpkProximitySearch
-> (GlpkProximitySearch -> GlpkProximitySearch -> Ordering)
-> (GlpkProximitySearch -> GlpkProximitySearch -> Bool)
-> (GlpkProximitySearch -> GlpkProximitySearch -> Bool)
-> (GlpkProximitySearch -> GlpkProximitySearch -> Bool)
-> (GlpkProximitySearch -> GlpkProximitySearch -> Bool)
-> (GlpkProximitySearch
    -> GlpkProximitySearch -> GlpkProximitySearch)
-> (GlpkProximitySearch
    -> GlpkProximitySearch -> GlpkProximitySearch)
-> Ord GlpkProximitySearch
GlpkProximitySearch -> GlpkProximitySearch -> Bool
GlpkProximitySearch -> GlpkProximitySearch -> Ordering
GlpkProximitySearch -> GlpkProximitySearch -> GlpkProximitySearch
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkProximitySearch -> GlpkProximitySearch -> GlpkProximitySearch
$cmin :: GlpkProximitySearch -> GlpkProximitySearch -> GlpkProximitySearch
max :: GlpkProximitySearch -> GlpkProximitySearch -> GlpkProximitySearch
$cmax :: GlpkProximitySearch -> GlpkProximitySearch -> GlpkProximitySearch
>= :: GlpkProximitySearch -> GlpkProximitySearch -> Bool
$c>= :: GlpkProximitySearch -> GlpkProximitySearch -> Bool
> :: GlpkProximitySearch -> GlpkProximitySearch -> Bool
$c> :: GlpkProximitySearch -> GlpkProximitySearch -> Bool
<= :: GlpkProximitySearch -> GlpkProximitySearch -> Bool
$c<= :: GlpkProximitySearch -> GlpkProximitySearch -> Bool
< :: GlpkProximitySearch -> GlpkProximitySearch -> Bool
$c< :: GlpkProximitySearch -> GlpkProximitySearch -> Bool
compare :: GlpkProximitySearch -> GlpkProximitySearch -> Ordering
$ccompare :: GlpkProximitySearch -> GlpkProximitySearch -> Ordering
Ord
    , ReadPrec [GlpkProximitySearch]
ReadPrec GlpkProximitySearch
Int -> ReadS GlpkProximitySearch
ReadS [GlpkProximitySearch]
(Int -> ReadS GlpkProximitySearch)
-> ReadS [GlpkProximitySearch]
-> ReadPrec GlpkProximitySearch
-> ReadPrec [GlpkProximitySearch]
-> Read GlpkProximitySearch
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkProximitySearch]
$creadListPrec :: ReadPrec [GlpkProximitySearch]
readPrec :: ReadPrec GlpkProximitySearch
$creadPrec :: ReadPrec GlpkProximitySearch
readList :: ReadS [GlpkProximitySearch]
$creadList :: ReadS [GlpkProximitySearch]
readsPrec :: Int -> ReadS GlpkProximitySearch
$creadsPrec :: Int -> ReadS GlpkProximitySearch
Read
    , Int -> GlpkProximitySearch -> ShowS
[GlpkProximitySearch] -> ShowS
GlpkProximitySearch -> String
(Int -> GlpkProximitySearch -> ShowS)
-> (GlpkProximitySearch -> String)
-> ([GlpkProximitySearch] -> ShowS)
-> Show GlpkProximitySearch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkProximitySearch] -> ShowS
$cshowList :: [GlpkProximitySearch] -> ShowS
show :: GlpkProximitySearch -> String
$cshow :: GlpkProximitySearch -> String
showsPrec :: Int -> GlpkProximitySearch -> ShowS
$cshowsPrec :: Int -> GlpkProximitySearch -> ShowS
Show
    , Ptr GlpkProximitySearch -> IO GlpkProximitySearch
Ptr GlpkProximitySearch -> Int -> IO GlpkProximitySearch
Ptr GlpkProximitySearch -> Int -> GlpkProximitySearch -> IO ()
Ptr GlpkProximitySearch -> GlpkProximitySearch -> IO ()
GlpkProximitySearch -> Int
(GlpkProximitySearch -> Int)
-> (GlpkProximitySearch -> Int)
-> (Ptr GlpkProximitySearch -> Int -> IO GlpkProximitySearch)
-> (Ptr GlpkProximitySearch -> Int -> GlpkProximitySearch -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkProximitySearch)
-> (forall b. Ptr b -> Int -> GlpkProximitySearch -> IO ())
-> (Ptr GlpkProximitySearch -> IO GlpkProximitySearch)
-> (Ptr GlpkProximitySearch -> GlpkProximitySearch -> IO ())
-> Storable GlpkProximitySearch
forall b. Ptr b -> Int -> IO GlpkProximitySearch
forall b. Ptr b -> Int -> GlpkProximitySearch -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkProximitySearch -> GlpkProximitySearch -> IO ()
$cpoke :: Ptr GlpkProximitySearch -> GlpkProximitySearch -> IO ()
peek :: Ptr GlpkProximitySearch -> IO GlpkProximitySearch
$cpeek :: Ptr GlpkProximitySearch -> IO GlpkProximitySearch
pokeByteOff :: forall b. Ptr b -> Int -> GlpkProximitySearch -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkProximitySearch -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkProximitySearch
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkProximitySearch
pokeElemOff :: Ptr GlpkProximitySearch -> Int -> GlpkProximitySearch -> IO ()
$cpokeElemOff :: Ptr GlpkProximitySearch -> Int -> GlpkProximitySearch -> IO ()
peekElemOff :: Ptr GlpkProximitySearch -> Int -> IO GlpkProximitySearch
$cpeekElemOff :: Ptr GlpkProximitySearch -> Int -> IO GlpkProximitySearch
alignment :: GlpkProximitySearch -> Int
$calignment :: GlpkProximitySearch -> Int
sizeOf :: GlpkProximitySearch -> Int
$csizeOf :: GlpkProximitySearch -> Int
Storable
    , Typeable
    )

glpkProximitySearchOn  :: GlpkProximitySearch
glpkProximitySearchOn :: GlpkProximitySearch
glpkProximitySearchOn  = CInt -> GlpkProximitySearch
GlpkProximitySearch CInt
1
glpkProximitySearchOff  :: GlpkProximitySearch
glpkProximitySearchOff :: GlpkProximitySearch
glpkProximitySearchOff  = CInt -> GlpkProximitySearch
GlpkProximitySearch CInt
0

{-# LINE 1124 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkGomoryCuts
  = GlpkGomoryCuts { GlpkGomoryCuts -> CInt
fromGlpkGomoryCuts :: CInt }
  deriving
    ( GlpkGomoryCuts -> GlpkGomoryCuts -> Bool
(GlpkGomoryCuts -> GlpkGomoryCuts -> Bool)
-> (GlpkGomoryCuts -> GlpkGomoryCuts -> Bool) -> Eq GlpkGomoryCuts
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkGomoryCuts -> GlpkGomoryCuts -> Bool
$c/= :: GlpkGomoryCuts -> GlpkGomoryCuts -> Bool
== :: GlpkGomoryCuts -> GlpkGomoryCuts -> Bool
$c== :: GlpkGomoryCuts -> GlpkGomoryCuts -> Bool
Eq
    , Eq GlpkGomoryCuts
Eq GlpkGomoryCuts
-> (GlpkGomoryCuts -> GlpkGomoryCuts -> Ordering)
-> (GlpkGomoryCuts -> GlpkGomoryCuts -> Bool)
-> (GlpkGomoryCuts -> GlpkGomoryCuts -> Bool)
-> (GlpkGomoryCuts -> GlpkGomoryCuts -> Bool)
-> (GlpkGomoryCuts -> GlpkGomoryCuts -> Bool)
-> (GlpkGomoryCuts -> GlpkGomoryCuts -> GlpkGomoryCuts)
-> (GlpkGomoryCuts -> GlpkGomoryCuts -> GlpkGomoryCuts)
-> Ord GlpkGomoryCuts
GlpkGomoryCuts -> GlpkGomoryCuts -> Bool
GlpkGomoryCuts -> GlpkGomoryCuts -> Ordering
GlpkGomoryCuts -> GlpkGomoryCuts -> GlpkGomoryCuts
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkGomoryCuts -> GlpkGomoryCuts -> GlpkGomoryCuts
$cmin :: GlpkGomoryCuts -> GlpkGomoryCuts -> GlpkGomoryCuts
max :: GlpkGomoryCuts -> GlpkGomoryCuts -> GlpkGomoryCuts
$cmax :: GlpkGomoryCuts -> GlpkGomoryCuts -> GlpkGomoryCuts
>= :: GlpkGomoryCuts -> GlpkGomoryCuts -> Bool
$c>= :: GlpkGomoryCuts -> GlpkGomoryCuts -> Bool
> :: GlpkGomoryCuts -> GlpkGomoryCuts -> Bool
$c> :: GlpkGomoryCuts -> GlpkGomoryCuts -> Bool
<= :: GlpkGomoryCuts -> GlpkGomoryCuts -> Bool
$c<= :: GlpkGomoryCuts -> GlpkGomoryCuts -> Bool
< :: GlpkGomoryCuts -> GlpkGomoryCuts -> Bool
$c< :: GlpkGomoryCuts -> GlpkGomoryCuts -> Bool
compare :: GlpkGomoryCuts -> GlpkGomoryCuts -> Ordering
$ccompare :: GlpkGomoryCuts -> GlpkGomoryCuts -> Ordering
Ord
    , ReadPrec [GlpkGomoryCuts]
ReadPrec GlpkGomoryCuts
Int -> ReadS GlpkGomoryCuts
ReadS [GlpkGomoryCuts]
(Int -> ReadS GlpkGomoryCuts)
-> ReadS [GlpkGomoryCuts]
-> ReadPrec GlpkGomoryCuts
-> ReadPrec [GlpkGomoryCuts]
-> Read GlpkGomoryCuts
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkGomoryCuts]
$creadListPrec :: ReadPrec [GlpkGomoryCuts]
readPrec :: ReadPrec GlpkGomoryCuts
$creadPrec :: ReadPrec GlpkGomoryCuts
readList :: ReadS [GlpkGomoryCuts]
$creadList :: ReadS [GlpkGomoryCuts]
readsPrec :: Int -> ReadS GlpkGomoryCuts
$creadsPrec :: Int -> ReadS GlpkGomoryCuts
Read
    , Int -> GlpkGomoryCuts -> ShowS
[GlpkGomoryCuts] -> ShowS
GlpkGomoryCuts -> String
(Int -> GlpkGomoryCuts -> ShowS)
-> (GlpkGomoryCuts -> String)
-> ([GlpkGomoryCuts] -> ShowS)
-> Show GlpkGomoryCuts
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkGomoryCuts] -> ShowS
$cshowList :: [GlpkGomoryCuts] -> ShowS
show :: GlpkGomoryCuts -> String
$cshow :: GlpkGomoryCuts -> String
showsPrec :: Int -> GlpkGomoryCuts -> ShowS
$cshowsPrec :: Int -> GlpkGomoryCuts -> ShowS
Show
    , Ptr GlpkGomoryCuts -> IO GlpkGomoryCuts
Ptr GlpkGomoryCuts -> Int -> IO GlpkGomoryCuts
Ptr GlpkGomoryCuts -> Int -> GlpkGomoryCuts -> IO ()
Ptr GlpkGomoryCuts -> GlpkGomoryCuts -> IO ()
GlpkGomoryCuts -> Int
(GlpkGomoryCuts -> Int)
-> (GlpkGomoryCuts -> Int)
-> (Ptr GlpkGomoryCuts -> Int -> IO GlpkGomoryCuts)
-> (Ptr GlpkGomoryCuts -> Int -> GlpkGomoryCuts -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkGomoryCuts)
-> (forall b. Ptr b -> Int -> GlpkGomoryCuts -> IO ())
-> (Ptr GlpkGomoryCuts -> IO GlpkGomoryCuts)
-> (Ptr GlpkGomoryCuts -> GlpkGomoryCuts -> IO ())
-> Storable GlpkGomoryCuts
forall b. Ptr b -> Int -> IO GlpkGomoryCuts
forall b. Ptr b -> Int -> GlpkGomoryCuts -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkGomoryCuts -> GlpkGomoryCuts -> IO ()
$cpoke :: Ptr GlpkGomoryCuts -> GlpkGomoryCuts -> IO ()
peek :: Ptr GlpkGomoryCuts -> IO GlpkGomoryCuts
$cpeek :: Ptr GlpkGomoryCuts -> IO GlpkGomoryCuts
pokeByteOff :: forall b. Ptr b -> Int -> GlpkGomoryCuts -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkGomoryCuts -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkGomoryCuts
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkGomoryCuts
pokeElemOff :: Ptr GlpkGomoryCuts -> Int -> GlpkGomoryCuts -> IO ()
$cpokeElemOff :: Ptr GlpkGomoryCuts -> Int -> GlpkGomoryCuts -> IO ()
peekElemOff :: Ptr GlpkGomoryCuts -> Int -> IO GlpkGomoryCuts
$cpeekElemOff :: Ptr GlpkGomoryCuts -> Int -> IO GlpkGomoryCuts
alignment :: GlpkGomoryCuts -> Int
$calignment :: GlpkGomoryCuts -> Int
sizeOf :: GlpkGomoryCuts -> Int
$csizeOf :: GlpkGomoryCuts -> Int
Storable
    , Typeable
    )

glpkGomoryCutsOn  :: GlpkGomoryCuts
glpkGomoryCutsOn :: GlpkGomoryCuts
glpkGomoryCutsOn  = CInt -> GlpkGomoryCuts
GlpkGomoryCuts CInt
1
glpkGomoryCutsOff  :: GlpkGomoryCuts
glpkGomoryCutsOff :: GlpkGomoryCuts
glpkGomoryCutsOff  = CInt -> GlpkGomoryCuts
GlpkGomoryCuts CInt
0

{-# LINE 1142 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkMIRCuts
  = GlpkMIRCuts { GlpkMIRCuts -> CInt
fromGlpkMIRCuts :: CInt }
  deriving
    ( GlpkMIRCuts -> GlpkMIRCuts -> Bool
(GlpkMIRCuts -> GlpkMIRCuts -> Bool)
-> (GlpkMIRCuts -> GlpkMIRCuts -> Bool) -> Eq GlpkMIRCuts
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkMIRCuts -> GlpkMIRCuts -> Bool
$c/= :: GlpkMIRCuts -> GlpkMIRCuts -> Bool
== :: GlpkMIRCuts -> GlpkMIRCuts -> Bool
$c== :: GlpkMIRCuts -> GlpkMIRCuts -> Bool
Eq
    , Eq GlpkMIRCuts
Eq GlpkMIRCuts
-> (GlpkMIRCuts -> GlpkMIRCuts -> Ordering)
-> (GlpkMIRCuts -> GlpkMIRCuts -> Bool)
-> (GlpkMIRCuts -> GlpkMIRCuts -> Bool)
-> (GlpkMIRCuts -> GlpkMIRCuts -> Bool)
-> (GlpkMIRCuts -> GlpkMIRCuts -> Bool)
-> (GlpkMIRCuts -> GlpkMIRCuts -> GlpkMIRCuts)
-> (GlpkMIRCuts -> GlpkMIRCuts -> GlpkMIRCuts)
-> Ord GlpkMIRCuts
GlpkMIRCuts -> GlpkMIRCuts -> Bool
GlpkMIRCuts -> GlpkMIRCuts -> Ordering
GlpkMIRCuts -> GlpkMIRCuts -> GlpkMIRCuts
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkMIRCuts -> GlpkMIRCuts -> GlpkMIRCuts
$cmin :: GlpkMIRCuts -> GlpkMIRCuts -> GlpkMIRCuts
max :: GlpkMIRCuts -> GlpkMIRCuts -> GlpkMIRCuts
$cmax :: GlpkMIRCuts -> GlpkMIRCuts -> GlpkMIRCuts
>= :: GlpkMIRCuts -> GlpkMIRCuts -> Bool
$c>= :: GlpkMIRCuts -> GlpkMIRCuts -> Bool
> :: GlpkMIRCuts -> GlpkMIRCuts -> Bool
$c> :: GlpkMIRCuts -> GlpkMIRCuts -> Bool
<= :: GlpkMIRCuts -> GlpkMIRCuts -> Bool
$c<= :: GlpkMIRCuts -> GlpkMIRCuts -> Bool
< :: GlpkMIRCuts -> GlpkMIRCuts -> Bool
$c< :: GlpkMIRCuts -> GlpkMIRCuts -> Bool
compare :: GlpkMIRCuts -> GlpkMIRCuts -> Ordering
$ccompare :: GlpkMIRCuts -> GlpkMIRCuts -> Ordering
Ord
    , ReadPrec [GlpkMIRCuts]
ReadPrec GlpkMIRCuts
Int -> ReadS GlpkMIRCuts
ReadS [GlpkMIRCuts]
(Int -> ReadS GlpkMIRCuts)
-> ReadS [GlpkMIRCuts]
-> ReadPrec GlpkMIRCuts
-> ReadPrec [GlpkMIRCuts]
-> Read GlpkMIRCuts
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkMIRCuts]
$creadListPrec :: ReadPrec [GlpkMIRCuts]
readPrec :: ReadPrec GlpkMIRCuts
$creadPrec :: ReadPrec GlpkMIRCuts
readList :: ReadS [GlpkMIRCuts]
$creadList :: ReadS [GlpkMIRCuts]
readsPrec :: Int -> ReadS GlpkMIRCuts
$creadsPrec :: Int -> ReadS GlpkMIRCuts
Read
    , Int -> GlpkMIRCuts -> ShowS
[GlpkMIRCuts] -> ShowS
GlpkMIRCuts -> String
(Int -> GlpkMIRCuts -> ShowS)
-> (GlpkMIRCuts -> String)
-> ([GlpkMIRCuts] -> ShowS)
-> Show GlpkMIRCuts
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkMIRCuts] -> ShowS
$cshowList :: [GlpkMIRCuts] -> ShowS
show :: GlpkMIRCuts -> String
$cshow :: GlpkMIRCuts -> String
showsPrec :: Int -> GlpkMIRCuts -> ShowS
$cshowsPrec :: Int -> GlpkMIRCuts -> ShowS
Show
    , Ptr GlpkMIRCuts -> IO GlpkMIRCuts
Ptr GlpkMIRCuts -> Int -> IO GlpkMIRCuts
Ptr GlpkMIRCuts -> Int -> GlpkMIRCuts -> IO ()
Ptr GlpkMIRCuts -> GlpkMIRCuts -> IO ()
GlpkMIRCuts -> Int
(GlpkMIRCuts -> Int)
-> (GlpkMIRCuts -> Int)
-> (Ptr GlpkMIRCuts -> Int -> IO GlpkMIRCuts)
-> (Ptr GlpkMIRCuts -> Int -> GlpkMIRCuts -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkMIRCuts)
-> (forall b. Ptr b -> Int -> GlpkMIRCuts -> IO ())
-> (Ptr GlpkMIRCuts -> IO GlpkMIRCuts)
-> (Ptr GlpkMIRCuts -> GlpkMIRCuts -> IO ())
-> Storable GlpkMIRCuts
forall b. Ptr b -> Int -> IO GlpkMIRCuts
forall b. Ptr b -> Int -> GlpkMIRCuts -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkMIRCuts -> GlpkMIRCuts -> IO ()
$cpoke :: Ptr GlpkMIRCuts -> GlpkMIRCuts -> IO ()
peek :: Ptr GlpkMIRCuts -> IO GlpkMIRCuts
$cpeek :: Ptr GlpkMIRCuts -> IO GlpkMIRCuts
pokeByteOff :: forall b. Ptr b -> Int -> GlpkMIRCuts -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkMIRCuts -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkMIRCuts
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkMIRCuts
pokeElemOff :: Ptr GlpkMIRCuts -> Int -> GlpkMIRCuts -> IO ()
$cpokeElemOff :: Ptr GlpkMIRCuts -> Int -> GlpkMIRCuts -> IO ()
peekElemOff :: Ptr GlpkMIRCuts -> Int -> IO GlpkMIRCuts
$cpeekElemOff :: Ptr GlpkMIRCuts -> Int -> IO GlpkMIRCuts
alignment :: GlpkMIRCuts -> Int
$calignment :: GlpkMIRCuts -> Int
sizeOf :: GlpkMIRCuts -> Int
$csizeOf :: GlpkMIRCuts -> Int
Storable
    , Typeable
    )

glpkMIRCutsOn  :: GlpkMIRCuts
glpkMIRCutsOn :: GlpkMIRCuts
glpkMIRCutsOn  = CInt -> GlpkMIRCuts
GlpkMIRCuts CInt
1
glpkMIRCutsOff  :: GlpkMIRCuts
glpkMIRCutsOff :: GlpkMIRCuts
glpkMIRCutsOff  = CInt -> GlpkMIRCuts
GlpkMIRCuts CInt
0

{-# LINE 1160 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkCoverCuts
  = GlpkCoverCuts { GlpkCoverCuts -> CInt
fromGlpkCoverCuts :: CInt }
  deriving
    ( GlpkCoverCuts -> GlpkCoverCuts -> Bool
(GlpkCoverCuts -> GlpkCoverCuts -> Bool)
-> (GlpkCoverCuts -> GlpkCoverCuts -> Bool) -> Eq GlpkCoverCuts
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkCoverCuts -> GlpkCoverCuts -> Bool
$c/= :: GlpkCoverCuts -> GlpkCoverCuts -> Bool
== :: GlpkCoverCuts -> GlpkCoverCuts -> Bool
$c== :: GlpkCoverCuts -> GlpkCoverCuts -> Bool
Eq
    , Eq GlpkCoverCuts
Eq GlpkCoverCuts
-> (GlpkCoverCuts -> GlpkCoverCuts -> Ordering)
-> (GlpkCoverCuts -> GlpkCoverCuts -> Bool)
-> (GlpkCoverCuts -> GlpkCoverCuts -> Bool)
-> (GlpkCoverCuts -> GlpkCoverCuts -> Bool)
-> (GlpkCoverCuts -> GlpkCoverCuts -> Bool)
-> (GlpkCoverCuts -> GlpkCoverCuts -> GlpkCoverCuts)
-> (GlpkCoverCuts -> GlpkCoverCuts -> GlpkCoverCuts)
-> Ord GlpkCoverCuts
GlpkCoverCuts -> GlpkCoverCuts -> Bool
GlpkCoverCuts -> GlpkCoverCuts -> Ordering
GlpkCoverCuts -> GlpkCoverCuts -> GlpkCoverCuts
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkCoverCuts -> GlpkCoverCuts -> GlpkCoverCuts
$cmin :: GlpkCoverCuts -> GlpkCoverCuts -> GlpkCoverCuts
max :: GlpkCoverCuts -> GlpkCoverCuts -> GlpkCoverCuts
$cmax :: GlpkCoverCuts -> GlpkCoverCuts -> GlpkCoverCuts
>= :: GlpkCoverCuts -> GlpkCoverCuts -> Bool
$c>= :: GlpkCoverCuts -> GlpkCoverCuts -> Bool
> :: GlpkCoverCuts -> GlpkCoverCuts -> Bool
$c> :: GlpkCoverCuts -> GlpkCoverCuts -> Bool
<= :: GlpkCoverCuts -> GlpkCoverCuts -> Bool
$c<= :: GlpkCoverCuts -> GlpkCoverCuts -> Bool
< :: GlpkCoverCuts -> GlpkCoverCuts -> Bool
$c< :: GlpkCoverCuts -> GlpkCoverCuts -> Bool
compare :: GlpkCoverCuts -> GlpkCoverCuts -> Ordering
$ccompare :: GlpkCoverCuts -> GlpkCoverCuts -> Ordering
Ord
    , ReadPrec [GlpkCoverCuts]
ReadPrec GlpkCoverCuts
Int -> ReadS GlpkCoverCuts
ReadS [GlpkCoverCuts]
(Int -> ReadS GlpkCoverCuts)
-> ReadS [GlpkCoverCuts]
-> ReadPrec GlpkCoverCuts
-> ReadPrec [GlpkCoverCuts]
-> Read GlpkCoverCuts
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkCoverCuts]
$creadListPrec :: ReadPrec [GlpkCoverCuts]
readPrec :: ReadPrec GlpkCoverCuts
$creadPrec :: ReadPrec GlpkCoverCuts
readList :: ReadS [GlpkCoverCuts]
$creadList :: ReadS [GlpkCoverCuts]
readsPrec :: Int -> ReadS GlpkCoverCuts
$creadsPrec :: Int -> ReadS GlpkCoverCuts
Read
    , Int -> GlpkCoverCuts -> ShowS
[GlpkCoverCuts] -> ShowS
GlpkCoverCuts -> String
(Int -> GlpkCoverCuts -> ShowS)
-> (GlpkCoverCuts -> String)
-> ([GlpkCoverCuts] -> ShowS)
-> Show GlpkCoverCuts
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkCoverCuts] -> ShowS
$cshowList :: [GlpkCoverCuts] -> ShowS
show :: GlpkCoverCuts -> String
$cshow :: GlpkCoverCuts -> String
showsPrec :: Int -> GlpkCoverCuts -> ShowS
$cshowsPrec :: Int -> GlpkCoverCuts -> ShowS
Show
    , Ptr GlpkCoverCuts -> IO GlpkCoverCuts
Ptr GlpkCoverCuts -> Int -> IO GlpkCoverCuts
Ptr GlpkCoverCuts -> Int -> GlpkCoverCuts -> IO ()
Ptr GlpkCoverCuts -> GlpkCoverCuts -> IO ()
GlpkCoverCuts -> Int
(GlpkCoverCuts -> Int)
-> (GlpkCoverCuts -> Int)
-> (Ptr GlpkCoverCuts -> Int -> IO GlpkCoverCuts)
-> (Ptr GlpkCoverCuts -> Int -> GlpkCoverCuts -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkCoverCuts)
-> (forall b. Ptr b -> Int -> GlpkCoverCuts -> IO ())
-> (Ptr GlpkCoverCuts -> IO GlpkCoverCuts)
-> (Ptr GlpkCoverCuts -> GlpkCoverCuts -> IO ())
-> Storable GlpkCoverCuts
forall b. Ptr b -> Int -> IO GlpkCoverCuts
forall b. Ptr b -> Int -> GlpkCoverCuts -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkCoverCuts -> GlpkCoverCuts -> IO ()
$cpoke :: Ptr GlpkCoverCuts -> GlpkCoverCuts -> IO ()
peek :: Ptr GlpkCoverCuts -> IO GlpkCoverCuts
$cpeek :: Ptr GlpkCoverCuts -> IO GlpkCoverCuts
pokeByteOff :: forall b. Ptr b -> Int -> GlpkCoverCuts -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkCoverCuts -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkCoverCuts
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkCoverCuts
pokeElemOff :: Ptr GlpkCoverCuts -> Int -> GlpkCoverCuts -> IO ()
$cpokeElemOff :: Ptr GlpkCoverCuts -> Int -> GlpkCoverCuts -> IO ()
peekElemOff :: Ptr GlpkCoverCuts -> Int -> IO GlpkCoverCuts
$cpeekElemOff :: Ptr GlpkCoverCuts -> Int -> IO GlpkCoverCuts
alignment :: GlpkCoverCuts -> Int
$calignment :: GlpkCoverCuts -> Int
sizeOf :: GlpkCoverCuts -> Int
$csizeOf :: GlpkCoverCuts -> Int
Storable
    , Typeable
    )

glpkCoverCutsOn  :: GlpkCoverCuts
glpkCoverCutsOn :: GlpkCoverCuts
glpkCoverCutsOn  = CInt -> GlpkCoverCuts
GlpkCoverCuts CInt
1
glpkCoverCutsOff  :: GlpkCoverCuts
glpkCoverCutsOff :: GlpkCoverCuts
glpkCoverCutsOff  = CInt -> GlpkCoverCuts
GlpkCoverCuts CInt
0

{-# LINE 1178 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkCliqueCuts
  = GlpkCliqueCuts { GlpkCliqueCuts -> CInt
fromGlpkCliqueCuts :: CInt }
  deriving
    ( GlpkCliqueCuts -> GlpkCliqueCuts -> Bool
(GlpkCliqueCuts -> GlpkCliqueCuts -> Bool)
-> (GlpkCliqueCuts -> GlpkCliqueCuts -> Bool) -> Eq GlpkCliqueCuts
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkCliqueCuts -> GlpkCliqueCuts -> Bool
$c/= :: GlpkCliqueCuts -> GlpkCliqueCuts -> Bool
== :: GlpkCliqueCuts -> GlpkCliqueCuts -> Bool
$c== :: GlpkCliqueCuts -> GlpkCliqueCuts -> Bool
Eq
    , Eq GlpkCliqueCuts
Eq GlpkCliqueCuts
-> (GlpkCliqueCuts -> GlpkCliqueCuts -> Ordering)
-> (GlpkCliqueCuts -> GlpkCliqueCuts -> Bool)
-> (GlpkCliqueCuts -> GlpkCliqueCuts -> Bool)
-> (GlpkCliqueCuts -> GlpkCliqueCuts -> Bool)
-> (GlpkCliqueCuts -> GlpkCliqueCuts -> Bool)
-> (GlpkCliqueCuts -> GlpkCliqueCuts -> GlpkCliqueCuts)
-> (GlpkCliqueCuts -> GlpkCliqueCuts -> GlpkCliqueCuts)
-> Ord GlpkCliqueCuts
GlpkCliqueCuts -> GlpkCliqueCuts -> Bool
GlpkCliqueCuts -> GlpkCliqueCuts -> Ordering
GlpkCliqueCuts -> GlpkCliqueCuts -> GlpkCliqueCuts
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkCliqueCuts -> GlpkCliqueCuts -> GlpkCliqueCuts
$cmin :: GlpkCliqueCuts -> GlpkCliqueCuts -> GlpkCliqueCuts
max :: GlpkCliqueCuts -> GlpkCliqueCuts -> GlpkCliqueCuts
$cmax :: GlpkCliqueCuts -> GlpkCliqueCuts -> GlpkCliqueCuts
>= :: GlpkCliqueCuts -> GlpkCliqueCuts -> Bool
$c>= :: GlpkCliqueCuts -> GlpkCliqueCuts -> Bool
> :: GlpkCliqueCuts -> GlpkCliqueCuts -> Bool
$c> :: GlpkCliqueCuts -> GlpkCliqueCuts -> Bool
<= :: GlpkCliqueCuts -> GlpkCliqueCuts -> Bool
$c<= :: GlpkCliqueCuts -> GlpkCliqueCuts -> Bool
< :: GlpkCliqueCuts -> GlpkCliqueCuts -> Bool
$c< :: GlpkCliqueCuts -> GlpkCliqueCuts -> Bool
compare :: GlpkCliqueCuts -> GlpkCliqueCuts -> Ordering
$ccompare :: GlpkCliqueCuts -> GlpkCliqueCuts -> Ordering
Ord
    , ReadPrec [GlpkCliqueCuts]
ReadPrec GlpkCliqueCuts
Int -> ReadS GlpkCliqueCuts
ReadS [GlpkCliqueCuts]
(Int -> ReadS GlpkCliqueCuts)
-> ReadS [GlpkCliqueCuts]
-> ReadPrec GlpkCliqueCuts
-> ReadPrec [GlpkCliqueCuts]
-> Read GlpkCliqueCuts
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkCliqueCuts]
$creadListPrec :: ReadPrec [GlpkCliqueCuts]
readPrec :: ReadPrec GlpkCliqueCuts
$creadPrec :: ReadPrec GlpkCliqueCuts
readList :: ReadS [GlpkCliqueCuts]
$creadList :: ReadS [GlpkCliqueCuts]
readsPrec :: Int -> ReadS GlpkCliqueCuts
$creadsPrec :: Int -> ReadS GlpkCliqueCuts
Read
    , Int -> GlpkCliqueCuts -> ShowS
[GlpkCliqueCuts] -> ShowS
GlpkCliqueCuts -> String
(Int -> GlpkCliqueCuts -> ShowS)
-> (GlpkCliqueCuts -> String)
-> ([GlpkCliqueCuts] -> ShowS)
-> Show GlpkCliqueCuts
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkCliqueCuts] -> ShowS
$cshowList :: [GlpkCliqueCuts] -> ShowS
show :: GlpkCliqueCuts -> String
$cshow :: GlpkCliqueCuts -> String
showsPrec :: Int -> GlpkCliqueCuts -> ShowS
$cshowsPrec :: Int -> GlpkCliqueCuts -> ShowS
Show
    , Ptr GlpkCliqueCuts -> IO GlpkCliqueCuts
Ptr GlpkCliqueCuts -> Int -> IO GlpkCliqueCuts
Ptr GlpkCliqueCuts -> Int -> GlpkCliqueCuts -> IO ()
Ptr GlpkCliqueCuts -> GlpkCliqueCuts -> IO ()
GlpkCliqueCuts -> Int
(GlpkCliqueCuts -> Int)
-> (GlpkCliqueCuts -> Int)
-> (Ptr GlpkCliqueCuts -> Int -> IO GlpkCliqueCuts)
-> (Ptr GlpkCliqueCuts -> Int -> GlpkCliqueCuts -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkCliqueCuts)
-> (forall b. Ptr b -> Int -> GlpkCliqueCuts -> IO ())
-> (Ptr GlpkCliqueCuts -> IO GlpkCliqueCuts)
-> (Ptr GlpkCliqueCuts -> GlpkCliqueCuts -> IO ())
-> Storable GlpkCliqueCuts
forall b. Ptr b -> Int -> IO GlpkCliqueCuts
forall b. Ptr b -> Int -> GlpkCliqueCuts -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkCliqueCuts -> GlpkCliqueCuts -> IO ()
$cpoke :: Ptr GlpkCliqueCuts -> GlpkCliqueCuts -> IO ()
peek :: Ptr GlpkCliqueCuts -> IO GlpkCliqueCuts
$cpeek :: Ptr GlpkCliqueCuts -> IO GlpkCliqueCuts
pokeByteOff :: forall b. Ptr b -> Int -> GlpkCliqueCuts -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkCliqueCuts -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkCliqueCuts
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkCliqueCuts
pokeElemOff :: Ptr GlpkCliqueCuts -> Int -> GlpkCliqueCuts -> IO ()
$cpokeElemOff :: Ptr GlpkCliqueCuts -> Int -> GlpkCliqueCuts -> IO ()
peekElemOff :: Ptr GlpkCliqueCuts -> Int -> IO GlpkCliqueCuts
$cpeekElemOff :: Ptr GlpkCliqueCuts -> Int -> IO GlpkCliqueCuts
alignment :: GlpkCliqueCuts -> Int
$calignment :: GlpkCliqueCuts -> Int
sizeOf :: GlpkCliqueCuts -> Int
$csizeOf :: GlpkCliqueCuts -> Int
Storable
    , Typeable
    )

glpkCliqueCutsOn  :: GlpkCliqueCuts
glpkCliqueCutsOn :: GlpkCliqueCuts
glpkCliqueCutsOn  = CInt -> GlpkCliqueCuts
GlpkCliqueCuts CInt
1
glpkCliqueCutsOff  :: GlpkCliqueCuts
glpkCliqueCutsOff :: GlpkCliqueCuts
glpkCliqueCutsOff  = CInt -> GlpkCliqueCuts
GlpkCliqueCuts CInt
0

{-# LINE 1196 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkPresolve
  = GlpkPresolve { GlpkPresolve -> CInt
fromGlpkPresolve :: CInt }
  deriving
    ( GlpkPresolve -> GlpkPresolve -> Bool
(GlpkPresolve -> GlpkPresolve -> Bool)
-> (GlpkPresolve -> GlpkPresolve -> Bool) -> Eq GlpkPresolve
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkPresolve -> GlpkPresolve -> Bool
$c/= :: GlpkPresolve -> GlpkPresolve -> Bool
== :: GlpkPresolve -> GlpkPresolve -> Bool
$c== :: GlpkPresolve -> GlpkPresolve -> Bool
Eq
    , Eq GlpkPresolve
Eq GlpkPresolve
-> (GlpkPresolve -> GlpkPresolve -> Ordering)
-> (GlpkPresolve -> GlpkPresolve -> Bool)
-> (GlpkPresolve -> GlpkPresolve -> Bool)
-> (GlpkPresolve -> GlpkPresolve -> Bool)
-> (GlpkPresolve -> GlpkPresolve -> Bool)
-> (GlpkPresolve -> GlpkPresolve -> GlpkPresolve)
-> (GlpkPresolve -> GlpkPresolve -> GlpkPresolve)
-> Ord GlpkPresolve
GlpkPresolve -> GlpkPresolve -> Bool
GlpkPresolve -> GlpkPresolve -> Ordering
GlpkPresolve -> GlpkPresolve -> GlpkPresolve
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkPresolve -> GlpkPresolve -> GlpkPresolve
$cmin :: GlpkPresolve -> GlpkPresolve -> GlpkPresolve
max :: GlpkPresolve -> GlpkPresolve -> GlpkPresolve
$cmax :: GlpkPresolve -> GlpkPresolve -> GlpkPresolve
>= :: GlpkPresolve -> GlpkPresolve -> Bool
$c>= :: GlpkPresolve -> GlpkPresolve -> Bool
> :: GlpkPresolve -> GlpkPresolve -> Bool
$c> :: GlpkPresolve -> GlpkPresolve -> Bool
<= :: GlpkPresolve -> GlpkPresolve -> Bool
$c<= :: GlpkPresolve -> GlpkPresolve -> Bool
< :: GlpkPresolve -> GlpkPresolve -> Bool
$c< :: GlpkPresolve -> GlpkPresolve -> Bool
compare :: GlpkPresolve -> GlpkPresolve -> Ordering
$ccompare :: GlpkPresolve -> GlpkPresolve -> Ordering
Ord
    , ReadPrec [GlpkPresolve]
ReadPrec GlpkPresolve
Int -> ReadS GlpkPresolve
ReadS [GlpkPresolve]
(Int -> ReadS GlpkPresolve)
-> ReadS [GlpkPresolve]
-> ReadPrec GlpkPresolve
-> ReadPrec [GlpkPresolve]
-> Read GlpkPresolve
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkPresolve]
$creadListPrec :: ReadPrec [GlpkPresolve]
readPrec :: ReadPrec GlpkPresolve
$creadPrec :: ReadPrec GlpkPresolve
readList :: ReadS [GlpkPresolve]
$creadList :: ReadS [GlpkPresolve]
readsPrec :: Int -> ReadS GlpkPresolve
$creadsPrec :: Int -> ReadS GlpkPresolve
Read
    , Int -> GlpkPresolve -> ShowS
[GlpkPresolve] -> ShowS
GlpkPresolve -> String
(Int -> GlpkPresolve -> ShowS)
-> (GlpkPresolve -> String)
-> ([GlpkPresolve] -> ShowS)
-> Show GlpkPresolve
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkPresolve] -> ShowS
$cshowList :: [GlpkPresolve] -> ShowS
show :: GlpkPresolve -> String
$cshow :: GlpkPresolve -> String
showsPrec :: Int -> GlpkPresolve -> ShowS
$cshowsPrec :: Int -> GlpkPresolve -> ShowS
Show
    , Ptr GlpkPresolve -> IO GlpkPresolve
Ptr GlpkPresolve -> Int -> IO GlpkPresolve
Ptr GlpkPresolve -> Int -> GlpkPresolve -> IO ()
Ptr GlpkPresolve -> GlpkPresolve -> IO ()
GlpkPresolve -> Int
(GlpkPresolve -> Int)
-> (GlpkPresolve -> Int)
-> (Ptr GlpkPresolve -> Int -> IO GlpkPresolve)
-> (Ptr GlpkPresolve -> Int -> GlpkPresolve -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkPresolve)
-> (forall b. Ptr b -> Int -> GlpkPresolve -> IO ())
-> (Ptr GlpkPresolve -> IO GlpkPresolve)
-> (Ptr GlpkPresolve -> GlpkPresolve -> IO ())
-> Storable GlpkPresolve
forall b. Ptr b -> Int -> IO GlpkPresolve
forall b. Ptr b -> Int -> GlpkPresolve -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkPresolve -> GlpkPresolve -> IO ()
$cpoke :: Ptr GlpkPresolve -> GlpkPresolve -> IO ()
peek :: Ptr GlpkPresolve -> IO GlpkPresolve
$cpeek :: Ptr GlpkPresolve -> IO GlpkPresolve
pokeByteOff :: forall b. Ptr b -> Int -> GlpkPresolve -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkPresolve -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkPresolve
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkPresolve
pokeElemOff :: Ptr GlpkPresolve -> Int -> GlpkPresolve -> IO ()
$cpokeElemOff :: Ptr GlpkPresolve -> Int -> GlpkPresolve -> IO ()
peekElemOff :: Ptr GlpkPresolve -> Int -> IO GlpkPresolve
$cpeekElemOff :: Ptr GlpkPresolve -> Int -> IO GlpkPresolve
alignment :: GlpkPresolve -> Int
$calignment :: GlpkPresolve -> Int
sizeOf :: GlpkPresolve -> Int
$csizeOf :: GlpkPresolve -> Int
Storable
    , Typeable
    )

glpkPresolveOn  :: GlpkPresolve
glpkPresolveOn :: GlpkPresolve
glpkPresolveOn  = CInt -> GlpkPresolve
GlpkPresolve CInt
1
glpkPresolveOff  :: GlpkPresolve
glpkPresolveOff :: GlpkPresolve
glpkPresolveOff  = CInt -> GlpkPresolve
GlpkPresolve CInt
0

{-# LINE 1214 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkBinarization
  = GlpkBinarization { GlpkBinarization -> CInt
fromGlpkBinarization :: CInt }
  deriving
    ( GlpkBinarization -> GlpkBinarization -> Bool
(GlpkBinarization -> GlpkBinarization -> Bool)
-> (GlpkBinarization -> GlpkBinarization -> Bool)
-> Eq GlpkBinarization
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkBinarization -> GlpkBinarization -> Bool
$c/= :: GlpkBinarization -> GlpkBinarization -> Bool
== :: GlpkBinarization -> GlpkBinarization -> Bool
$c== :: GlpkBinarization -> GlpkBinarization -> Bool
Eq
    , Eq GlpkBinarization
Eq GlpkBinarization
-> (GlpkBinarization -> GlpkBinarization -> Ordering)
-> (GlpkBinarization -> GlpkBinarization -> Bool)
-> (GlpkBinarization -> GlpkBinarization -> Bool)
-> (GlpkBinarization -> GlpkBinarization -> Bool)
-> (GlpkBinarization -> GlpkBinarization -> Bool)
-> (GlpkBinarization -> GlpkBinarization -> GlpkBinarization)
-> (GlpkBinarization -> GlpkBinarization -> GlpkBinarization)
-> Ord GlpkBinarization
GlpkBinarization -> GlpkBinarization -> Bool
GlpkBinarization -> GlpkBinarization -> Ordering
GlpkBinarization -> GlpkBinarization -> GlpkBinarization
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkBinarization -> GlpkBinarization -> GlpkBinarization
$cmin :: GlpkBinarization -> GlpkBinarization -> GlpkBinarization
max :: GlpkBinarization -> GlpkBinarization -> GlpkBinarization
$cmax :: GlpkBinarization -> GlpkBinarization -> GlpkBinarization
>= :: GlpkBinarization -> GlpkBinarization -> Bool
$c>= :: GlpkBinarization -> GlpkBinarization -> Bool
> :: GlpkBinarization -> GlpkBinarization -> Bool
$c> :: GlpkBinarization -> GlpkBinarization -> Bool
<= :: GlpkBinarization -> GlpkBinarization -> Bool
$c<= :: GlpkBinarization -> GlpkBinarization -> Bool
< :: GlpkBinarization -> GlpkBinarization -> Bool
$c< :: GlpkBinarization -> GlpkBinarization -> Bool
compare :: GlpkBinarization -> GlpkBinarization -> Ordering
$ccompare :: GlpkBinarization -> GlpkBinarization -> Ordering
Ord
    , ReadPrec [GlpkBinarization]
ReadPrec GlpkBinarization
Int -> ReadS GlpkBinarization
ReadS [GlpkBinarization]
(Int -> ReadS GlpkBinarization)
-> ReadS [GlpkBinarization]
-> ReadPrec GlpkBinarization
-> ReadPrec [GlpkBinarization]
-> Read GlpkBinarization
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkBinarization]
$creadListPrec :: ReadPrec [GlpkBinarization]
readPrec :: ReadPrec GlpkBinarization
$creadPrec :: ReadPrec GlpkBinarization
readList :: ReadS [GlpkBinarization]
$creadList :: ReadS [GlpkBinarization]
readsPrec :: Int -> ReadS GlpkBinarization
$creadsPrec :: Int -> ReadS GlpkBinarization
Read
    , Int -> GlpkBinarization -> ShowS
[GlpkBinarization] -> ShowS
GlpkBinarization -> String
(Int -> GlpkBinarization -> ShowS)
-> (GlpkBinarization -> String)
-> ([GlpkBinarization] -> ShowS)
-> Show GlpkBinarization
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkBinarization] -> ShowS
$cshowList :: [GlpkBinarization] -> ShowS
show :: GlpkBinarization -> String
$cshow :: GlpkBinarization -> String
showsPrec :: Int -> GlpkBinarization -> ShowS
$cshowsPrec :: Int -> GlpkBinarization -> ShowS
Show
    , Ptr GlpkBinarization -> IO GlpkBinarization
Ptr GlpkBinarization -> Int -> IO GlpkBinarization
Ptr GlpkBinarization -> Int -> GlpkBinarization -> IO ()
Ptr GlpkBinarization -> GlpkBinarization -> IO ()
GlpkBinarization -> Int
(GlpkBinarization -> Int)
-> (GlpkBinarization -> Int)
-> (Ptr GlpkBinarization -> Int -> IO GlpkBinarization)
-> (Ptr GlpkBinarization -> Int -> GlpkBinarization -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkBinarization)
-> (forall b. Ptr b -> Int -> GlpkBinarization -> IO ())
-> (Ptr GlpkBinarization -> IO GlpkBinarization)
-> (Ptr GlpkBinarization -> GlpkBinarization -> IO ())
-> Storable GlpkBinarization
forall b. Ptr b -> Int -> IO GlpkBinarization
forall b. Ptr b -> Int -> GlpkBinarization -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkBinarization -> GlpkBinarization -> IO ()
$cpoke :: Ptr GlpkBinarization -> GlpkBinarization -> IO ()
peek :: Ptr GlpkBinarization -> IO GlpkBinarization
$cpeek :: Ptr GlpkBinarization -> IO GlpkBinarization
pokeByteOff :: forall b. Ptr b -> Int -> GlpkBinarization -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkBinarization -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkBinarization
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkBinarization
pokeElemOff :: Ptr GlpkBinarization -> Int -> GlpkBinarization -> IO ()
$cpokeElemOff :: Ptr GlpkBinarization -> Int -> GlpkBinarization -> IO ()
peekElemOff :: Ptr GlpkBinarization -> Int -> IO GlpkBinarization
$cpeekElemOff :: Ptr GlpkBinarization -> Int -> IO GlpkBinarization
alignment :: GlpkBinarization -> Int
$calignment :: GlpkBinarization -> Int
sizeOf :: GlpkBinarization -> Int
$csizeOf :: GlpkBinarization -> Int
Storable
    , Typeable
    )

glpkBinarizationOn  :: GlpkBinarization
glpkBinarizationOn :: GlpkBinarization
glpkBinarizationOn  = CInt -> GlpkBinarization
GlpkBinarization CInt
1
glpkBinarizationOff  :: GlpkBinarization
glpkBinarizationOff :: GlpkBinarization
glpkBinarizationOff  = CInt -> GlpkBinarization
GlpkBinarization CInt
0

{-# LINE 1232 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkSimpleRounding
  = GlpkSimpleRounding { GlpkSimpleRounding -> CInt
fromGlpkSimpleRounding :: CInt }
  deriving
    ( GlpkSimpleRounding -> GlpkSimpleRounding -> Bool
(GlpkSimpleRounding -> GlpkSimpleRounding -> Bool)
-> (GlpkSimpleRounding -> GlpkSimpleRounding -> Bool)
-> Eq GlpkSimpleRounding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkSimpleRounding -> GlpkSimpleRounding -> Bool
$c/= :: GlpkSimpleRounding -> GlpkSimpleRounding -> Bool
== :: GlpkSimpleRounding -> GlpkSimpleRounding -> Bool
$c== :: GlpkSimpleRounding -> GlpkSimpleRounding -> Bool
Eq
    , Eq GlpkSimpleRounding
Eq GlpkSimpleRounding
-> (GlpkSimpleRounding -> GlpkSimpleRounding -> Ordering)
-> (GlpkSimpleRounding -> GlpkSimpleRounding -> Bool)
-> (GlpkSimpleRounding -> GlpkSimpleRounding -> Bool)
-> (GlpkSimpleRounding -> GlpkSimpleRounding -> Bool)
-> (GlpkSimpleRounding -> GlpkSimpleRounding -> Bool)
-> (GlpkSimpleRounding -> GlpkSimpleRounding -> GlpkSimpleRounding)
-> (GlpkSimpleRounding -> GlpkSimpleRounding -> GlpkSimpleRounding)
-> Ord GlpkSimpleRounding
GlpkSimpleRounding -> GlpkSimpleRounding -> Bool
GlpkSimpleRounding -> GlpkSimpleRounding -> Ordering
GlpkSimpleRounding -> GlpkSimpleRounding -> GlpkSimpleRounding
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkSimpleRounding -> GlpkSimpleRounding -> GlpkSimpleRounding
$cmin :: GlpkSimpleRounding -> GlpkSimpleRounding -> GlpkSimpleRounding
max :: GlpkSimpleRounding -> GlpkSimpleRounding -> GlpkSimpleRounding
$cmax :: GlpkSimpleRounding -> GlpkSimpleRounding -> GlpkSimpleRounding
>= :: GlpkSimpleRounding -> GlpkSimpleRounding -> Bool
$c>= :: GlpkSimpleRounding -> GlpkSimpleRounding -> Bool
> :: GlpkSimpleRounding -> GlpkSimpleRounding -> Bool
$c> :: GlpkSimpleRounding -> GlpkSimpleRounding -> Bool
<= :: GlpkSimpleRounding -> GlpkSimpleRounding -> Bool
$c<= :: GlpkSimpleRounding -> GlpkSimpleRounding -> Bool
< :: GlpkSimpleRounding -> GlpkSimpleRounding -> Bool
$c< :: GlpkSimpleRounding -> GlpkSimpleRounding -> Bool
compare :: GlpkSimpleRounding -> GlpkSimpleRounding -> Ordering
$ccompare :: GlpkSimpleRounding -> GlpkSimpleRounding -> Ordering
Ord
    , ReadPrec [GlpkSimpleRounding]
ReadPrec GlpkSimpleRounding
Int -> ReadS GlpkSimpleRounding
ReadS [GlpkSimpleRounding]
(Int -> ReadS GlpkSimpleRounding)
-> ReadS [GlpkSimpleRounding]
-> ReadPrec GlpkSimpleRounding
-> ReadPrec [GlpkSimpleRounding]
-> Read GlpkSimpleRounding
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkSimpleRounding]
$creadListPrec :: ReadPrec [GlpkSimpleRounding]
readPrec :: ReadPrec GlpkSimpleRounding
$creadPrec :: ReadPrec GlpkSimpleRounding
readList :: ReadS [GlpkSimpleRounding]
$creadList :: ReadS [GlpkSimpleRounding]
readsPrec :: Int -> ReadS GlpkSimpleRounding
$creadsPrec :: Int -> ReadS GlpkSimpleRounding
Read
    , Int -> GlpkSimpleRounding -> ShowS
[GlpkSimpleRounding] -> ShowS
GlpkSimpleRounding -> String
(Int -> GlpkSimpleRounding -> ShowS)
-> (GlpkSimpleRounding -> String)
-> ([GlpkSimpleRounding] -> ShowS)
-> Show GlpkSimpleRounding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkSimpleRounding] -> ShowS
$cshowList :: [GlpkSimpleRounding] -> ShowS
show :: GlpkSimpleRounding -> String
$cshow :: GlpkSimpleRounding -> String
showsPrec :: Int -> GlpkSimpleRounding -> ShowS
$cshowsPrec :: Int -> GlpkSimpleRounding -> ShowS
Show
    , Ptr GlpkSimpleRounding -> IO GlpkSimpleRounding
Ptr GlpkSimpleRounding -> Int -> IO GlpkSimpleRounding
Ptr GlpkSimpleRounding -> Int -> GlpkSimpleRounding -> IO ()
Ptr GlpkSimpleRounding -> GlpkSimpleRounding -> IO ()
GlpkSimpleRounding -> Int
(GlpkSimpleRounding -> Int)
-> (GlpkSimpleRounding -> Int)
-> (Ptr GlpkSimpleRounding -> Int -> IO GlpkSimpleRounding)
-> (Ptr GlpkSimpleRounding -> Int -> GlpkSimpleRounding -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkSimpleRounding)
-> (forall b. Ptr b -> Int -> GlpkSimpleRounding -> IO ())
-> (Ptr GlpkSimpleRounding -> IO GlpkSimpleRounding)
-> (Ptr GlpkSimpleRounding -> GlpkSimpleRounding -> IO ())
-> Storable GlpkSimpleRounding
forall b. Ptr b -> Int -> IO GlpkSimpleRounding
forall b. Ptr b -> Int -> GlpkSimpleRounding -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkSimpleRounding -> GlpkSimpleRounding -> IO ()
$cpoke :: Ptr GlpkSimpleRounding -> GlpkSimpleRounding -> IO ()
peek :: Ptr GlpkSimpleRounding -> IO GlpkSimpleRounding
$cpeek :: Ptr GlpkSimpleRounding -> IO GlpkSimpleRounding
pokeByteOff :: forall b. Ptr b -> Int -> GlpkSimpleRounding -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkSimpleRounding -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkSimpleRounding
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkSimpleRounding
pokeElemOff :: Ptr GlpkSimpleRounding -> Int -> GlpkSimpleRounding -> IO ()
$cpokeElemOff :: Ptr GlpkSimpleRounding -> Int -> GlpkSimpleRounding -> IO ()
peekElemOff :: Ptr GlpkSimpleRounding -> Int -> IO GlpkSimpleRounding
$cpeekElemOff :: Ptr GlpkSimpleRounding -> Int -> IO GlpkSimpleRounding
alignment :: GlpkSimpleRounding -> Int
$calignment :: GlpkSimpleRounding -> Int
sizeOf :: GlpkSimpleRounding -> Int
$csizeOf :: GlpkSimpleRounding -> Int
Storable
    , Typeable
    )

glpkSimpleRoundingOn  :: GlpkSimpleRounding
glpkSimpleRoundingOn :: GlpkSimpleRounding
glpkSimpleRoundingOn  = CInt -> GlpkSimpleRounding
GlpkSimpleRounding CInt
1
glpkSimpleRoundingOff  :: GlpkSimpleRounding
glpkSimpleRoundingOff :: GlpkSimpleRounding
glpkSimpleRoundingOff  = CInt -> GlpkSimpleRounding
GlpkSimpleRounding CInt
0

{-# LINE 1250 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkConstraintOrigin
  = GlpkConstraintOrigin { GlpkConstraintOrigin -> CInt
fromGlpkConstraintOrigin :: CInt }
  deriving
    ( GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool
(GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool)
-> (GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool)
-> Eq GlpkConstraintOrigin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool
$c/= :: GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool
== :: GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool
$c== :: GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool
Eq
    , (forall x. GlpkConstraintOrigin -> Rep GlpkConstraintOrigin x)
-> (forall x. Rep GlpkConstraintOrigin x -> GlpkConstraintOrigin)
-> Generic GlpkConstraintOrigin
forall x. Rep GlpkConstraintOrigin x -> GlpkConstraintOrigin
forall x. GlpkConstraintOrigin -> Rep GlpkConstraintOrigin x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GlpkConstraintOrigin x -> GlpkConstraintOrigin
$cfrom :: forall x. GlpkConstraintOrigin -> Rep GlpkConstraintOrigin x
Generic
    , Eq GlpkConstraintOrigin
Eq GlpkConstraintOrigin
-> (GlpkConstraintOrigin -> GlpkConstraintOrigin -> Ordering)
-> (GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool)
-> (GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool)
-> (GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool)
-> (GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool)
-> (GlpkConstraintOrigin
    -> GlpkConstraintOrigin -> GlpkConstraintOrigin)
-> (GlpkConstraintOrigin
    -> GlpkConstraintOrigin -> GlpkConstraintOrigin)
-> Ord GlpkConstraintOrigin
GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool
GlpkConstraintOrigin -> GlpkConstraintOrigin -> Ordering
GlpkConstraintOrigin
-> GlpkConstraintOrigin -> GlpkConstraintOrigin
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkConstraintOrigin
-> GlpkConstraintOrigin -> GlpkConstraintOrigin
$cmin :: GlpkConstraintOrigin
-> GlpkConstraintOrigin -> GlpkConstraintOrigin
max :: GlpkConstraintOrigin
-> GlpkConstraintOrigin -> GlpkConstraintOrigin
$cmax :: GlpkConstraintOrigin
-> GlpkConstraintOrigin -> GlpkConstraintOrigin
>= :: GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool
$c>= :: GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool
> :: GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool
$c> :: GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool
<= :: GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool
$c<= :: GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool
< :: GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool
$c< :: GlpkConstraintOrigin -> GlpkConstraintOrigin -> Bool
compare :: GlpkConstraintOrigin -> GlpkConstraintOrigin -> Ordering
$ccompare :: GlpkConstraintOrigin -> GlpkConstraintOrigin -> Ordering
Ord
    , ReadPrec [GlpkConstraintOrigin]
ReadPrec GlpkConstraintOrigin
Int -> ReadS GlpkConstraintOrigin
ReadS [GlpkConstraintOrigin]
(Int -> ReadS GlpkConstraintOrigin)
-> ReadS [GlpkConstraintOrigin]
-> ReadPrec GlpkConstraintOrigin
-> ReadPrec [GlpkConstraintOrigin]
-> Read GlpkConstraintOrigin
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkConstraintOrigin]
$creadListPrec :: ReadPrec [GlpkConstraintOrigin]
readPrec :: ReadPrec GlpkConstraintOrigin
$creadPrec :: ReadPrec GlpkConstraintOrigin
readList :: ReadS [GlpkConstraintOrigin]
$creadList :: ReadS [GlpkConstraintOrigin]
readsPrec :: Int -> ReadS GlpkConstraintOrigin
$creadsPrec :: Int -> ReadS GlpkConstraintOrigin
Read
    , Int -> GlpkConstraintOrigin -> ShowS
[GlpkConstraintOrigin] -> ShowS
GlpkConstraintOrigin -> String
(Int -> GlpkConstraintOrigin -> ShowS)
-> (GlpkConstraintOrigin -> String)
-> ([GlpkConstraintOrigin] -> ShowS)
-> Show GlpkConstraintOrigin
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkConstraintOrigin] -> ShowS
$cshowList :: [GlpkConstraintOrigin] -> ShowS
show :: GlpkConstraintOrigin -> String
$cshow :: GlpkConstraintOrigin -> String
showsPrec :: Int -> GlpkConstraintOrigin -> ShowS
$cshowsPrec :: Int -> GlpkConstraintOrigin -> ShowS
Show
    , Ptr GlpkConstraintOrigin -> IO GlpkConstraintOrigin
Ptr GlpkConstraintOrigin -> Int -> IO GlpkConstraintOrigin
Ptr GlpkConstraintOrigin -> Int -> GlpkConstraintOrigin -> IO ()
Ptr GlpkConstraintOrigin -> GlpkConstraintOrigin -> IO ()
GlpkConstraintOrigin -> Int
(GlpkConstraintOrigin -> Int)
-> (GlpkConstraintOrigin -> Int)
-> (Ptr GlpkConstraintOrigin -> Int -> IO GlpkConstraintOrigin)
-> (Ptr GlpkConstraintOrigin
    -> Int -> GlpkConstraintOrigin -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkConstraintOrigin)
-> (forall b. Ptr b -> Int -> GlpkConstraintOrigin -> IO ())
-> (Ptr GlpkConstraintOrigin -> IO GlpkConstraintOrigin)
-> (Ptr GlpkConstraintOrigin -> GlpkConstraintOrigin -> IO ())
-> Storable GlpkConstraintOrigin
forall b. Ptr b -> Int -> IO GlpkConstraintOrigin
forall b. Ptr b -> Int -> GlpkConstraintOrigin -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkConstraintOrigin -> GlpkConstraintOrigin -> IO ()
$cpoke :: Ptr GlpkConstraintOrigin -> GlpkConstraintOrigin -> IO ()
peek :: Ptr GlpkConstraintOrigin -> IO GlpkConstraintOrigin
$cpeek :: Ptr GlpkConstraintOrigin -> IO GlpkConstraintOrigin
pokeByteOff :: forall b. Ptr b -> Int -> GlpkConstraintOrigin -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkConstraintOrigin -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkConstraintOrigin
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkConstraintOrigin
pokeElemOff :: Ptr GlpkConstraintOrigin -> Int -> GlpkConstraintOrigin -> IO ()
$cpokeElemOff :: Ptr GlpkConstraintOrigin -> Int -> GlpkConstraintOrigin -> IO ()
peekElemOff :: Ptr GlpkConstraintOrigin -> Int -> IO GlpkConstraintOrigin
$cpeekElemOff :: Ptr GlpkConstraintOrigin -> Int -> IO GlpkConstraintOrigin
alignment :: GlpkConstraintOrigin -> Int
$calignment :: GlpkConstraintOrigin -> Int
sizeOf :: GlpkConstraintOrigin -> Int
$csizeOf :: GlpkConstraintOrigin -> Int
Storable
    , Typeable
    )

glpkRegularConstraint  :: GlpkConstraintOrigin
glpkRegularConstraint :: GlpkConstraintOrigin
glpkRegularConstraint  = CInt -> GlpkConstraintOrigin
GlpkConstraintOrigin CInt
0
glpkLazyConstraint  :: GlpkConstraintOrigin
glpkLazyConstraint :: GlpkConstraintOrigin
glpkLazyConstraint  = CInt -> GlpkConstraintOrigin
GlpkConstraintOrigin CInt
1
glpkCuttingPlaneConstraint  :: GlpkConstraintOrigin
glpkCuttingPlaneConstraint :: GlpkConstraintOrigin
glpkCuttingPlaneConstraint  = CInt -> GlpkConstraintOrigin
GlpkConstraintOrigin CInt
2

{-# LINE 1270 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkCutType
  = GlpkCutType { GlpkCutType -> CInt
fromGlpkCutType :: CInt }
  deriving
    ( GlpkCutType -> GlpkCutType -> Bool
(GlpkCutType -> GlpkCutType -> Bool)
-> (GlpkCutType -> GlpkCutType -> Bool) -> Eq GlpkCutType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkCutType -> GlpkCutType -> Bool
$c/= :: GlpkCutType -> GlpkCutType -> Bool
== :: GlpkCutType -> GlpkCutType -> Bool
$c== :: GlpkCutType -> GlpkCutType -> Bool
Eq
    , Eq GlpkCutType
Eq GlpkCutType
-> (GlpkCutType -> GlpkCutType -> Ordering)
-> (GlpkCutType -> GlpkCutType -> Bool)
-> (GlpkCutType -> GlpkCutType -> Bool)
-> (GlpkCutType -> GlpkCutType -> Bool)
-> (GlpkCutType -> GlpkCutType -> Bool)
-> (GlpkCutType -> GlpkCutType -> GlpkCutType)
-> (GlpkCutType -> GlpkCutType -> GlpkCutType)
-> Ord GlpkCutType
GlpkCutType -> GlpkCutType -> Bool
GlpkCutType -> GlpkCutType -> Ordering
GlpkCutType -> GlpkCutType -> GlpkCutType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkCutType -> GlpkCutType -> GlpkCutType
$cmin :: GlpkCutType -> GlpkCutType -> GlpkCutType
max :: GlpkCutType -> GlpkCutType -> GlpkCutType
$cmax :: GlpkCutType -> GlpkCutType -> GlpkCutType
>= :: GlpkCutType -> GlpkCutType -> Bool
$c>= :: GlpkCutType -> GlpkCutType -> Bool
> :: GlpkCutType -> GlpkCutType -> Bool
$c> :: GlpkCutType -> GlpkCutType -> Bool
<= :: GlpkCutType -> GlpkCutType -> Bool
$c<= :: GlpkCutType -> GlpkCutType -> Bool
< :: GlpkCutType -> GlpkCutType -> Bool
$c< :: GlpkCutType -> GlpkCutType -> Bool
compare :: GlpkCutType -> GlpkCutType -> Ordering
$ccompare :: GlpkCutType -> GlpkCutType -> Ordering
Ord
    , ReadPrec [GlpkCutType]
ReadPrec GlpkCutType
Int -> ReadS GlpkCutType
ReadS [GlpkCutType]
(Int -> ReadS GlpkCutType)
-> ReadS [GlpkCutType]
-> ReadPrec GlpkCutType
-> ReadPrec [GlpkCutType]
-> Read GlpkCutType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkCutType]
$creadListPrec :: ReadPrec [GlpkCutType]
readPrec :: ReadPrec GlpkCutType
$creadPrec :: ReadPrec GlpkCutType
readList :: ReadS [GlpkCutType]
$creadList :: ReadS [GlpkCutType]
readsPrec :: Int -> ReadS GlpkCutType
$creadsPrec :: Int -> ReadS GlpkCutType
Read
    , Int -> GlpkCutType -> ShowS
[GlpkCutType] -> ShowS
GlpkCutType -> String
(Int -> GlpkCutType -> ShowS)
-> (GlpkCutType -> String)
-> ([GlpkCutType] -> ShowS)
-> Show GlpkCutType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkCutType] -> ShowS
$cshowList :: [GlpkCutType] -> ShowS
show :: GlpkCutType -> String
$cshow :: GlpkCutType -> String
showsPrec :: Int -> GlpkCutType -> ShowS
$cshowsPrec :: Int -> GlpkCutType -> ShowS
Show
    , Ptr GlpkCutType -> IO GlpkCutType
Ptr GlpkCutType -> Int -> IO GlpkCutType
Ptr GlpkCutType -> Int -> GlpkCutType -> IO ()
Ptr GlpkCutType -> GlpkCutType -> IO ()
GlpkCutType -> Int
(GlpkCutType -> Int)
-> (GlpkCutType -> Int)
-> (Ptr GlpkCutType -> Int -> IO GlpkCutType)
-> (Ptr GlpkCutType -> Int -> GlpkCutType -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkCutType)
-> (forall b. Ptr b -> Int -> GlpkCutType -> IO ())
-> (Ptr GlpkCutType -> IO GlpkCutType)
-> (Ptr GlpkCutType -> GlpkCutType -> IO ())
-> Storable GlpkCutType
forall b. Ptr b -> Int -> IO GlpkCutType
forall b. Ptr b -> Int -> GlpkCutType -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkCutType -> GlpkCutType -> IO ()
$cpoke :: Ptr GlpkCutType -> GlpkCutType -> IO ()
peek :: Ptr GlpkCutType -> IO GlpkCutType
$cpeek :: Ptr GlpkCutType -> IO GlpkCutType
pokeByteOff :: forall b. Ptr b -> Int -> GlpkCutType -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkCutType -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkCutType
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkCutType
pokeElemOff :: Ptr GlpkCutType -> Int -> GlpkCutType -> IO ()
$cpokeElemOff :: Ptr GlpkCutType -> Int -> GlpkCutType -> IO ()
peekElemOff :: Ptr GlpkCutType -> Int -> IO GlpkCutType
$cpeekElemOff :: Ptr GlpkCutType -> Int -> IO GlpkCutType
alignment :: GlpkCutType -> Int
$calignment :: GlpkCutType -> Int
sizeOf :: GlpkCutType -> Int
$csizeOf :: GlpkCutType -> Int
Storable
    , Typeable
    )

glpkGomoryCut  :: GlpkCutType
glpkGomoryCut :: GlpkCutType
glpkGomoryCut  = CInt -> GlpkCutType
GlpkCutType CInt
1
glpkMIRCut  :: GlpkCutType
glpkMIRCut :: GlpkCutType
glpkMIRCut  = CInt -> GlpkCutType
GlpkCutType CInt
2
glpkCoverCut  :: GlpkCutType
glpkCoverCut :: GlpkCutType
glpkCoverCut  = CInt -> GlpkCutType
GlpkCutType CInt
3
glpkCliqueCut  :: GlpkCutType
glpkCliqueCut :: GlpkCutType
glpkCliqueCut  = CInt -> GlpkCutType
GlpkCutType CInt
4

{-# LINE 1290 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkControl
  = GlpkControl { fromGlpkControl :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkOn  :: GlpkControl
glpkOn :: GlpkControl
glpkOn  = CInt -> GlpkControl
GlpkControl CInt
1
glpkOff  :: GlpkControl
glpkOff :: GlpkControl
glpkOff  = CInt -> GlpkControl
GlpkControl CInt
0

{-# LINE 1308 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkCallbackReason
  = GlpkCallbackReason { GlpkCallbackReason -> CInt
fromGlpkCallbackReason :: CInt }
  deriving
    ( GlpkCallbackReason -> GlpkCallbackReason -> Bool
(GlpkCallbackReason -> GlpkCallbackReason -> Bool)
-> (GlpkCallbackReason -> GlpkCallbackReason -> Bool)
-> Eq GlpkCallbackReason
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkCallbackReason -> GlpkCallbackReason -> Bool
$c/= :: GlpkCallbackReason -> GlpkCallbackReason -> Bool
== :: GlpkCallbackReason -> GlpkCallbackReason -> Bool
$c== :: GlpkCallbackReason -> GlpkCallbackReason -> Bool
Eq
    , Eq GlpkCallbackReason
Eq GlpkCallbackReason
-> (GlpkCallbackReason -> GlpkCallbackReason -> Ordering)
-> (GlpkCallbackReason -> GlpkCallbackReason -> Bool)
-> (GlpkCallbackReason -> GlpkCallbackReason -> Bool)
-> (GlpkCallbackReason -> GlpkCallbackReason -> Bool)
-> (GlpkCallbackReason -> GlpkCallbackReason -> Bool)
-> (GlpkCallbackReason -> GlpkCallbackReason -> GlpkCallbackReason)
-> (GlpkCallbackReason -> GlpkCallbackReason -> GlpkCallbackReason)
-> Ord GlpkCallbackReason
GlpkCallbackReason -> GlpkCallbackReason -> Bool
GlpkCallbackReason -> GlpkCallbackReason -> Ordering
GlpkCallbackReason -> GlpkCallbackReason -> GlpkCallbackReason
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkCallbackReason -> GlpkCallbackReason -> GlpkCallbackReason
$cmin :: GlpkCallbackReason -> GlpkCallbackReason -> GlpkCallbackReason
max :: GlpkCallbackReason -> GlpkCallbackReason -> GlpkCallbackReason
$cmax :: GlpkCallbackReason -> GlpkCallbackReason -> GlpkCallbackReason
>= :: GlpkCallbackReason -> GlpkCallbackReason -> Bool
$c>= :: GlpkCallbackReason -> GlpkCallbackReason -> Bool
> :: GlpkCallbackReason -> GlpkCallbackReason -> Bool
$c> :: GlpkCallbackReason -> GlpkCallbackReason -> Bool
<= :: GlpkCallbackReason -> GlpkCallbackReason -> Bool
$c<= :: GlpkCallbackReason -> GlpkCallbackReason -> Bool
< :: GlpkCallbackReason -> GlpkCallbackReason -> Bool
$c< :: GlpkCallbackReason -> GlpkCallbackReason -> Bool
compare :: GlpkCallbackReason -> GlpkCallbackReason -> Ordering
$ccompare :: GlpkCallbackReason -> GlpkCallbackReason -> Ordering
Ord
    , ReadPrec [GlpkCallbackReason]
ReadPrec GlpkCallbackReason
Int -> ReadS GlpkCallbackReason
ReadS [GlpkCallbackReason]
(Int -> ReadS GlpkCallbackReason)
-> ReadS [GlpkCallbackReason]
-> ReadPrec GlpkCallbackReason
-> ReadPrec [GlpkCallbackReason]
-> Read GlpkCallbackReason
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkCallbackReason]
$creadListPrec :: ReadPrec [GlpkCallbackReason]
readPrec :: ReadPrec GlpkCallbackReason
$creadPrec :: ReadPrec GlpkCallbackReason
readList :: ReadS [GlpkCallbackReason]
$creadList :: ReadS [GlpkCallbackReason]
readsPrec :: Int -> ReadS GlpkCallbackReason
$creadsPrec :: Int -> ReadS GlpkCallbackReason
Read
    , Int -> GlpkCallbackReason -> ShowS
[GlpkCallbackReason] -> ShowS
GlpkCallbackReason -> String
(Int -> GlpkCallbackReason -> ShowS)
-> (GlpkCallbackReason -> String)
-> ([GlpkCallbackReason] -> ShowS)
-> Show GlpkCallbackReason
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkCallbackReason] -> ShowS
$cshowList :: [GlpkCallbackReason] -> ShowS
show :: GlpkCallbackReason -> String
$cshow :: GlpkCallbackReason -> String
showsPrec :: Int -> GlpkCallbackReason -> ShowS
$cshowsPrec :: Int -> GlpkCallbackReason -> ShowS
Show
    , Ptr GlpkCallbackReason -> IO GlpkCallbackReason
Ptr GlpkCallbackReason -> Int -> IO GlpkCallbackReason
Ptr GlpkCallbackReason -> Int -> GlpkCallbackReason -> IO ()
Ptr GlpkCallbackReason -> GlpkCallbackReason -> IO ()
GlpkCallbackReason -> Int
(GlpkCallbackReason -> Int)
-> (GlpkCallbackReason -> Int)
-> (Ptr GlpkCallbackReason -> Int -> IO GlpkCallbackReason)
-> (Ptr GlpkCallbackReason -> Int -> GlpkCallbackReason -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkCallbackReason)
-> (forall b. Ptr b -> Int -> GlpkCallbackReason -> IO ())
-> (Ptr GlpkCallbackReason -> IO GlpkCallbackReason)
-> (Ptr GlpkCallbackReason -> GlpkCallbackReason -> IO ())
-> Storable GlpkCallbackReason
forall b. Ptr b -> Int -> IO GlpkCallbackReason
forall b. Ptr b -> Int -> GlpkCallbackReason -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkCallbackReason -> GlpkCallbackReason -> IO ()
$cpoke :: Ptr GlpkCallbackReason -> GlpkCallbackReason -> IO ()
peek :: Ptr GlpkCallbackReason -> IO GlpkCallbackReason
$cpeek :: Ptr GlpkCallbackReason -> IO GlpkCallbackReason
pokeByteOff :: forall b. Ptr b -> Int -> GlpkCallbackReason -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkCallbackReason -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkCallbackReason
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkCallbackReason
pokeElemOff :: Ptr GlpkCallbackReason -> Int -> GlpkCallbackReason -> IO ()
$cpokeElemOff :: Ptr GlpkCallbackReason -> Int -> GlpkCallbackReason -> IO ()
peekElemOff :: Ptr GlpkCallbackReason -> Int -> IO GlpkCallbackReason
$cpeekElemOff :: Ptr GlpkCallbackReason -> Int -> IO GlpkCallbackReason
alignment :: GlpkCallbackReason -> Int
$calignment :: GlpkCallbackReason -> Int
sizeOf :: GlpkCallbackReason -> Int
$csizeOf :: GlpkCallbackReason -> Int
Storable
    , Typeable
    )

glpkSubproblemSelection  :: GlpkCallbackReason
glpkSubproblemSelection :: GlpkCallbackReason
glpkSubproblemSelection  = CInt -> GlpkCallbackReason
GlpkCallbackReason CInt
6
glpkPreprocessing  :: GlpkCallbackReason
glpkPreprocessing :: GlpkCallbackReason
glpkPreprocessing  = CInt -> GlpkCallbackReason
GlpkCallbackReason CInt
7
glpkRowGeneration  :: GlpkCallbackReason
glpkRowGeneration :: GlpkCallbackReason
glpkRowGeneration  = CInt -> GlpkCallbackReason
GlpkCallbackReason CInt
1
glpkHeuristicSolution  :: GlpkCallbackReason
glpkHeuristicSolution :: GlpkCallbackReason
glpkHeuristicSolution  = CInt -> GlpkCallbackReason
GlpkCallbackReason CInt
3
glpkCutGeneration  :: GlpkCallbackReason
glpkCutGeneration :: GlpkCallbackReason
glpkCutGeneration  = CInt -> GlpkCallbackReason
GlpkCallbackReason CInt
4
glpkBranching  :: GlpkCallbackReason
glpkBranching :: GlpkCallbackReason
glpkBranching  = CInt -> GlpkCallbackReason
GlpkCallbackReason CInt
5
glpkNewIncumbent  :: GlpkCallbackReason
glpkNewIncumbent :: GlpkCallbackReason
glpkNewIncumbent  = CInt -> GlpkCallbackReason
GlpkCallbackReason CInt
2

{-# LINE 1331 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkBranchOption
  = GlpkBranchOption { fromGlpkBranchOption :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkBranchUp  :: GlpkBranchOption
glpkBranchUp :: GlpkBranchOption
glpkBranchUp  = CInt -> GlpkBranchOption
GlpkBranchOption CInt
2
glpkBranchDown  :: GlpkBranchOption
glpkBranchDown :: GlpkBranchOption
glpkBranchDown  = CInt -> GlpkBranchOption
GlpkBranchOption CInt
1
glpkBranchAuto  :: GlpkBranchOption
glpkBranchAuto :: GlpkBranchOption
glpkBranchAuto  = CInt -> GlpkBranchOption
GlpkBranchOption CInt
0

{-# LINE 1350 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkFactorizationResult
  = GlpkFactorizationResult { GlpkFactorizationResult -> CInt
fromGlpkFactorizationResult :: CInt }
  deriving
    ( GlpkFactorizationResult -> GlpkFactorizationResult -> Bool
(GlpkFactorizationResult -> GlpkFactorizationResult -> Bool)
-> (GlpkFactorizationResult -> GlpkFactorizationResult -> Bool)
-> Eq GlpkFactorizationResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkFactorizationResult -> GlpkFactorizationResult -> Bool
$c/= :: GlpkFactorizationResult -> GlpkFactorizationResult -> Bool
== :: GlpkFactorizationResult -> GlpkFactorizationResult -> Bool
$c== :: GlpkFactorizationResult -> GlpkFactorizationResult -> Bool
Eq
    , Eq GlpkFactorizationResult
Eq GlpkFactorizationResult
-> (GlpkFactorizationResult -> GlpkFactorizationResult -> Ordering)
-> (GlpkFactorizationResult -> GlpkFactorizationResult -> Bool)
-> (GlpkFactorizationResult -> GlpkFactorizationResult -> Bool)
-> (GlpkFactorizationResult -> GlpkFactorizationResult -> Bool)
-> (GlpkFactorizationResult -> GlpkFactorizationResult -> Bool)
-> (GlpkFactorizationResult
    -> GlpkFactorizationResult -> GlpkFactorizationResult)
-> (GlpkFactorizationResult
    -> GlpkFactorizationResult -> GlpkFactorizationResult)
-> Ord GlpkFactorizationResult
GlpkFactorizationResult -> GlpkFactorizationResult -> Bool
GlpkFactorizationResult -> GlpkFactorizationResult -> Ordering
GlpkFactorizationResult
-> GlpkFactorizationResult -> GlpkFactorizationResult
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkFactorizationResult
-> GlpkFactorizationResult -> GlpkFactorizationResult
$cmin :: GlpkFactorizationResult
-> GlpkFactorizationResult -> GlpkFactorizationResult
max :: GlpkFactorizationResult
-> GlpkFactorizationResult -> GlpkFactorizationResult
$cmax :: GlpkFactorizationResult
-> GlpkFactorizationResult -> GlpkFactorizationResult
>= :: GlpkFactorizationResult -> GlpkFactorizationResult -> Bool
$c>= :: GlpkFactorizationResult -> GlpkFactorizationResult -> Bool
> :: GlpkFactorizationResult -> GlpkFactorizationResult -> Bool
$c> :: GlpkFactorizationResult -> GlpkFactorizationResult -> Bool
<= :: GlpkFactorizationResult -> GlpkFactorizationResult -> Bool
$c<= :: GlpkFactorizationResult -> GlpkFactorizationResult -> Bool
< :: GlpkFactorizationResult -> GlpkFactorizationResult -> Bool
$c< :: GlpkFactorizationResult -> GlpkFactorizationResult -> Bool
compare :: GlpkFactorizationResult -> GlpkFactorizationResult -> Ordering
$ccompare :: GlpkFactorizationResult -> GlpkFactorizationResult -> Ordering
Ord
    , ReadPrec [GlpkFactorizationResult]
ReadPrec GlpkFactorizationResult
Int -> ReadS GlpkFactorizationResult
ReadS [GlpkFactorizationResult]
(Int -> ReadS GlpkFactorizationResult)
-> ReadS [GlpkFactorizationResult]
-> ReadPrec GlpkFactorizationResult
-> ReadPrec [GlpkFactorizationResult]
-> Read GlpkFactorizationResult
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkFactorizationResult]
$creadListPrec :: ReadPrec [GlpkFactorizationResult]
readPrec :: ReadPrec GlpkFactorizationResult
$creadPrec :: ReadPrec GlpkFactorizationResult
readList :: ReadS [GlpkFactorizationResult]
$creadList :: ReadS [GlpkFactorizationResult]
readsPrec :: Int -> ReadS GlpkFactorizationResult
$creadsPrec :: Int -> ReadS GlpkFactorizationResult
Read
    , Int -> GlpkFactorizationResult -> ShowS
[GlpkFactorizationResult] -> ShowS
GlpkFactorizationResult -> String
(Int -> GlpkFactorizationResult -> ShowS)
-> (GlpkFactorizationResult -> String)
-> ([GlpkFactorizationResult] -> ShowS)
-> Show GlpkFactorizationResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkFactorizationResult] -> ShowS
$cshowList :: [GlpkFactorizationResult] -> ShowS
show :: GlpkFactorizationResult -> String
$cshow :: GlpkFactorizationResult -> String
showsPrec :: Int -> GlpkFactorizationResult -> ShowS
$cshowsPrec :: Int -> GlpkFactorizationResult -> ShowS
Show
    , Ptr GlpkFactorizationResult -> IO GlpkFactorizationResult
Ptr GlpkFactorizationResult -> Int -> IO GlpkFactorizationResult
Ptr GlpkFactorizationResult
-> Int -> GlpkFactorizationResult -> IO ()
Ptr GlpkFactorizationResult -> GlpkFactorizationResult -> IO ()
GlpkFactorizationResult -> Int
(GlpkFactorizationResult -> Int)
-> (GlpkFactorizationResult -> Int)
-> (Ptr GlpkFactorizationResult
    -> Int -> IO GlpkFactorizationResult)
-> (Ptr GlpkFactorizationResult
    -> Int -> GlpkFactorizationResult -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkFactorizationResult)
-> (forall b. Ptr b -> Int -> GlpkFactorizationResult -> IO ())
-> (Ptr GlpkFactorizationResult -> IO GlpkFactorizationResult)
-> (Ptr GlpkFactorizationResult
    -> GlpkFactorizationResult -> IO ())
-> Storable GlpkFactorizationResult
forall b. Ptr b -> Int -> IO GlpkFactorizationResult
forall b. Ptr b -> Int -> GlpkFactorizationResult -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkFactorizationResult -> GlpkFactorizationResult -> IO ()
$cpoke :: Ptr GlpkFactorizationResult -> GlpkFactorizationResult -> IO ()
peek :: Ptr GlpkFactorizationResult -> IO GlpkFactorizationResult
$cpeek :: Ptr GlpkFactorizationResult -> IO GlpkFactorizationResult
pokeByteOff :: forall b. Ptr b -> Int -> GlpkFactorizationResult -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkFactorizationResult -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkFactorizationResult
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkFactorizationResult
pokeElemOff :: Ptr GlpkFactorizationResult
-> Int -> GlpkFactorizationResult -> IO ()
$cpokeElemOff :: Ptr GlpkFactorizationResult
-> Int -> GlpkFactorizationResult -> IO ()
peekElemOff :: Ptr GlpkFactorizationResult -> Int -> IO GlpkFactorizationResult
$cpeekElemOff :: Ptr GlpkFactorizationResult -> Int -> IO GlpkFactorizationResult
alignment :: GlpkFactorizationResult -> Int
$calignment :: GlpkFactorizationResult -> Int
sizeOf :: GlpkFactorizationResult -> Int
$csizeOf :: GlpkFactorizationResult -> Int
Storable
    , Typeable
    )

glpkFactorizationSuccess  :: GlpkFactorizationResult
glpkFactorizationSuccess :: GlpkFactorizationResult
glpkFactorizationSuccess  = CInt -> GlpkFactorizationResult
GlpkFactorizationResult CInt
0
glpkFactorizationBadBasis  :: GlpkFactorizationResult
glpkFactorizationBadBasis :: GlpkFactorizationResult
glpkFactorizationBadBasis  = CInt -> GlpkFactorizationResult
GlpkFactorizationResult CInt
1
glpkFactorizationSingular  :: GlpkFactorizationResult
glpkFactorizationSingular :: GlpkFactorizationResult
glpkFactorizationSingular  = CInt -> GlpkFactorizationResult
GlpkFactorizationResult CInt
2
glpkFactorizationIllConditioned  :: GlpkFactorizationResult
glpkFactorizationIllConditioned :: GlpkFactorizationResult
glpkFactorizationIllConditioned  = CInt -> GlpkFactorizationResult
GlpkFactorizationResult CInt
3

{-# LINE 1370 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkSimplexStatus
  = GlpkSimplexStatus { fromGlpkSimplexStatus :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkSimplexSuccess  :: GlpkSimplexStatus
glpkSimplexSuccess :: GlpkSimplexStatus
glpkSimplexSuccess  = CInt -> GlpkSimplexStatus
GlpkSimplexStatus CInt
0
glpkSimplexBadBasis  :: GlpkSimplexStatus
glpkSimplexBadBasis :: GlpkSimplexStatus
glpkSimplexBadBasis  = CInt -> GlpkSimplexStatus
GlpkSimplexStatus CInt
1
glpkSimplexSingular  :: GlpkSimplexStatus
glpkSimplexSingular :: GlpkSimplexStatus
glpkSimplexSingular  = CInt -> GlpkSimplexStatus
GlpkSimplexStatus CInt
2
glpkSimplexIllConditioned  :: GlpkSimplexStatus
glpkSimplexIllConditioned :: GlpkSimplexStatus
glpkSimplexIllConditioned  = CInt -> GlpkSimplexStatus
GlpkSimplexStatus CInt
3
glpkSimplexBadBound  :: GlpkSimplexStatus
glpkSimplexBadBound :: GlpkSimplexStatus
glpkSimplexBadBound  = CInt -> GlpkSimplexStatus
GlpkSimplexStatus CInt
4
glpkSimplexFailure  :: GlpkSimplexStatus
glpkSimplexFailure :: GlpkSimplexStatus
glpkSimplexFailure  = CInt -> GlpkSimplexStatus
GlpkSimplexStatus CInt
5
glpkSimplexDualLowerLimitFailure  :: GlpkSimplexStatus
glpkSimplexDualLowerLimitFailure :: GlpkSimplexStatus
glpkSimplexDualLowerLimitFailure  = CInt -> GlpkSimplexStatus
GlpkSimplexStatus CInt
6
glpkSimplexDualUpperLimitFailure  :: GlpkSimplexStatus
glpkSimplexDualUpperLimitFailure :: GlpkSimplexStatus
glpkSimplexDualUpperLimitFailure  = CInt -> GlpkSimplexStatus
GlpkSimplexStatus CInt
7
glpkSimplexIterationLimit  :: GlpkSimplexStatus
glpkSimplexIterationLimit :: GlpkSimplexStatus
glpkSimplexIterationLimit  = CInt -> GlpkSimplexStatus
GlpkSimplexStatus CInt
8
glpkSimplexTimeLimit  :: GlpkSimplexStatus
glpkSimplexTimeLimit :: GlpkSimplexStatus
glpkSimplexTimeLimit  = CInt -> GlpkSimplexStatus
GlpkSimplexStatus CInt
9
glpkSimplexPrimalInfeasible  :: GlpkSimplexStatus
glpkSimplexPrimalInfeasible :: GlpkSimplexStatus
glpkSimplexPrimalInfeasible  = CInt -> GlpkSimplexStatus
GlpkSimplexStatus CInt
10
glpkSimplexDualInfeasible  :: GlpkSimplexStatus
glpkSimplexDualInfeasible :: GlpkSimplexStatus
glpkSimplexDualInfeasible  = CInt -> GlpkSimplexStatus
GlpkSimplexStatus CInt
11

{-# LINE 1398 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkMIPStatus
  = GlpkMIPStatus { fromGlpkMIPStatus :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkMIPSuccess  :: GlpkMIPStatus
glpkMIPSuccess :: GlpkMIPStatus
glpkMIPSuccess  = CInt -> GlpkMIPStatus
GlpkMIPStatus CInt
0
glpkMIPBadBound  :: GlpkMIPStatus
glpkMIPBadBound :: GlpkMIPStatus
glpkMIPBadBound  = CInt -> GlpkMIPStatus
GlpkMIPStatus CInt
4
glpkMIPNoBasis  :: GlpkMIPStatus
glpkMIPNoBasis :: GlpkMIPStatus
glpkMIPNoBasis  = CInt -> GlpkMIPStatus
GlpkMIPStatus CInt
12
glpkMIPPrimalInfeasible  :: GlpkMIPStatus
glpkMIPPrimalInfeasible :: GlpkMIPStatus
glpkMIPPrimalInfeasible  = CInt -> GlpkMIPStatus
GlpkMIPStatus CInt
10
glpkMIPDualInfeasible  :: GlpkMIPStatus
glpkMIPDualInfeasible :: GlpkMIPStatus
glpkMIPDualInfeasible  = CInt -> GlpkMIPStatus
GlpkMIPStatus CInt
11
glpkMIPFailure  :: GlpkMIPStatus
glpkMIPFailure :: GlpkMIPStatus
glpkMIPFailure  = CInt -> GlpkMIPStatus
GlpkMIPStatus CInt
5
glpkMIPRelativeGap  :: GlpkMIPStatus
glpkMIPRelativeGap :: GlpkMIPStatus
glpkMIPRelativeGap  = CInt -> GlpkMIPStatus
GlpkMIPStatus CInt
14
glpkMIPTimeLimit  :: GlpkMIPStatus
glpkMIPTimeLimit :: GlpkMIPStatus
glpkMIPTimeLimit  = CInt -> GlpkMIPStatus
GlpkMIPStatus CInt
9
glpkMIPStopped  :: GlpkMIPStatus
glpkMIPStopped :: GlpkMIPStatus
glpkMIPStopped  = CInt -> GlpkMIPStatus
GlpkMIPStatus CInt
13

{-# LINE 1423 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkInteriorPointStatus
  = GlpkInteriorPointStatus { fromGlpkInteriorPointStatus :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkInteriorPointSuccess  :: GlpkInteriorPointStatus
glpkInteriorPointSuccess :: GlpkInteriorPointStatus
glpkInteriorPointSuccess  = CInt -> GlpkInteriorPointStatus
GlpkInteriorPointStatus CInt
0
glpkInteriorPointFailure  :: GlpkInteriorPointStatus
glpkInteriorPointFailure :: GlpkInteriorPointStatus
glpkInteriorPointFailure  = CInt -> GlpkInteriorPointStatus
GlpkInteriorPointStatus CInt
5
glpkInteriorPointNoConvergence  :: GlpkInteriorPointStatus
glpkInteriorPointNoConvergence :: GlpkInteriorPointStatus
glpkInteriorPointNoConvergence  = CInt -> GlpkInteriorPointStatus
GlpkInteriorPointStatus CInt
16
glpkInteriorPointIterationLimit  :: GlpkInteriorPointStatus
glpkInteriorPointIterationLimit :: GlpkInteriorPointStatus
glpkInteriorPointIterationLimit  = CInt -> GlpkInteriorPointStatus
GlpkInteriorPointStatus CInt
8
glpkInteriorPointNumericalInstability  :: GlpkInteriorPointStatus
glpkInteriorPointNumericalInstability :: GlpkInteriorPointStatus
glpkInteriorPointNumericalInstability  = CInt -> GlpkInteriorPointStatus
GlpkInteriorPointStatus CInt
17

{-# LINE 1444 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkKKTCheck
  = GlpkKKTCheck { fromGlpkKKTCheck :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkKKTPrimalEquality  :: GlpkKKTCheck
glpkKKTPrimalEquality :: GlpkKKTCheck
glpkKKTPrimalEquality  = CInt -> GlpkKKTCheck
GlpkKKTCheck CInt
1
glpkKKTPrimalBound  :: GlpkKKTCheck
glpkKKTPrimalBound :: GlpkKKTCheck
glpkKKTPrimalBound  = CInt -> GlpkKKTCheck
GlpkKKTCheck CInt
2
glpkKKTDualEquality  :: GlpkKKTCheck
glpkKKTDualEquality :: GlpkKKTCheck
glpkKKTDualEquality  = CInt -> GlpkKKTCheck
GlpkKKTCheck CInt
3
glpkKKTDualBound  :: GlpkKKTCheck
glpkKKTDualBound :: GlpkKKTCheck
glpkKKTDualBound  = CInt -> GlpkKKTCheck
GlpkKKTCheck CInt
4

{-# LINE 1464 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkMPSFormat
  = GlpkMPSFormat { fromGlpkMPSFormat :: CInt }
  deriving
    ( Eq
    , Ord
    , Read
    , Show
    , Storable
    , Typeable
    )

glpkMPSAncient  :: GlpkMPSFormat
glpkMPSAncient :: GlpkMPSFormat
glpkMPSAncient  = CInt -> GlpkMPSFormat
GlpkMPSFormat CInt
1
glpkMPSDeck  :: GlpkMPSFormat
glpkMPSDeck :: GlpkMPSFormat
glpkMPSDeck  = CInt -> GlpkMPSFormat
GlpkMPSFormat CInt
1
glpkMPSModern  :: GlpkMPSFormat
glpkMPSModern :: GlpkMPSFormat
glpkMPSModern  = CInt -> GlpkMPSFormat
GlpkMPSFormat CInt
2

{-# LINE 1483 "src/Math/Programming/Glpk/Header.hsc" #-}

newtype GlpkFactorizationType
  = GlpkFactorizationType { GlpkFactorizationType -> CInt
fromGlpkFactorizationType :: CInt }
  deriving
    ( GlpkFactorizationType -> GlpkFactorizationType -> Bool
(GlpkFactorizationType -> GlpkFactorizationType -> Bool)
-> (GlpkFactorizationType -> GlpkFactorizationType -> Bool)
-> Eq GlpkFactorizationType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlpkFactorizationType -> GlpkFactorizationType -> Bool
$c/= :: GlpkFactorizationType -> GlpkFactorizationType -> Bool
== :: GlpkFactorizationType -> GlpkFactorizationType -> Bool
$c== :: GlpkFactorizationType -> GlpkFactorizationType -> Bool
Eq
    , Eq GlpkFactorizationType
Eq GlpkFactorizationType
-> (GlpkFactorizationType -> GlpkFactorizationType -> Ordering)
-> (GlpkFactorizationType -> GlpkFactorizationType -> Bool)
-> (GlpkFactorizationType -> GlpkFactorizationType -> Bool)
-> (GlpkFactorizationType -> GlpkFactorizationType -> Bool)
-> (GlpkFactorizationType -> GlpkFactorizationType -> Bool)
-> (GlpkFactorizationType
    -> GlpkFactorizationType -> GlpkFactorizationType)
-> (GlpkFactorizationType
    -> GlpkFactorizationType -> GlpkFactorizationType)
-> Ord GlpkFactorizationType
GlpkFactorizationType -> GlpkFactorizationType -> Bool
GlpkFactorizationType -> GlpkFactorizationType -> Ordering
GlpkFactorizationType
-> GlpkFactorizationType -> GlpkFactorizationType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GlpkFactorizationType
-> GlpkFactorizationType -> GlpkFactorizationType
$cmin :: GlpkFactorizationType
-> GlpkFactorizationType -> GlpkFactorizationType
max :: GlpkFactorizationType
-> GlpkFactorizationType -> GlpkFactorizationType
$cmax :: GlpkFactorizationType
-> GlpkFactorizationType -> GlpkFactorizationType
>= :: GlpkFactorizationType -> GlpkFactorizationType -> Bool
$c>= :: GlpkFactorizationType -> GlpkFactorizationType -> Bool
> :: GlpkFactorizationType -> GlpkFactorizationType -> Bool
$c> :: GlpkFactorizationType -> GlpkFactorizationType -> Bool
<= :: GlpkFactorizationType -> GlpkFactorizationType -> Bool
$c<= :: GlpkFactorizationType -> GlpkFactorizationType -> Bool
< :: GlpkFactorizationType -> GlpkFactorizationType -> Bool
$c< :: GlpkFactorizationType -> GlpkFactorizationType -> Bool
compare :: GlpkFactorizationType -> GlpkFactorizationType -> Ordering
$ccompare :: GlpkFactorizationType -> GlpkFactorizationType -> Ordering
Ord
    , ReadPrec [GlpkFactorizationType]
ReadPrec GlpkFactorizationType
Int -> ReadS GlpkFactorizationType
ReadS [GlpkFactorizationType]
(Int -> ReadS GlpkFactorizationType)
-> ReadS [GlpkFactorizationType]
-> ReadPrec GlpkFactorizationType
-> ReadPrec [GlpkFactorizationType]
-> Read GlpkFactorizationType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GlpkFactorizationType]
$creadListPrec :: ReadPrec [GlpkFactorizationType]
readPrec :: ReadPrec GlpkFactorizationType
$creadPrec :: ReadPrec GlpkFactorizationType
readList :: ReadS [GlpkFactorizationType]
$creadList :: ReadS [GlpkFactorizationType]
readsPrec :: Int -> ReadS GlpkFactorizationType
$creadsPrec :: Int -> ReadS GlpkFactorizationType
Read
    , Int -> GlpkFactorizationType -> ShowS
[GlpkFactorizationType] -> ShowS
GlpkFactorizationType -> String
(Int -> GlpkFactorizationType -> ShowS)
-> (GlpkFactorizationType -> String)
-> ([GlpkFactorizationType] -> ShowS)
-> Show GlpkFactorizationType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GlpkFactorizationType] -> ShowS
$cshowList :: [GlpkFactorizationType] -> ShowS
show :: GlpkFactorizationType -> String
$cshow :: GlpkFactorizationType -> String
showsPrec :: Int -> GlpkFactorizationType -> ShowS
$cshowsPrec :: Int -> GlpkFactorizationType -> ShowS
Show
    , Ptr GlpkFactorizationType -> IO GlpkFactorizationType
Ptr GlpkFactorizationType -> Int -> IO GlpkFactorizationType
Ptr GlpkFactorizationType -> Int -> GlpkFactorizationType -> IO ()
Ptr GlpkFactorizationType -> GlpkFactorizationType -> IO ()
GlpkFactorizationType -> Int
(GlpkFactorizationType -> Int)
-> (GlpkFactorizationType -> Int)
-> (Ptr GlpkFactorizationType -> Int -> IO GlpkFactorizationType)
-> (Ptr GlpkFactorizationType
    -> Int -> GlpkFactorizationType -> IO ())
-> (forall b. Ptr b -> Int -> IO GlpkFactorizationType)
-> (forall b. Ptr b -> Int -> GlpkFactorizationType -> IO ())
-> (Ptr GlpkFactorizationType -> IO GlpkFactorizationType)
-> (Ptr GlpkFactorizationType -> GlpkFactorizationType -> IO ())
-> Storable GlpkFactorizationType
forall b. Ptr b -> Int -> IO GlpkFactorizationType
forall b. Ptr b -> Int -> GlpkFactorizationType -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr GlpkFactorizationType -> GlpkFactorizationType -> IO ()
$cpoke :: Ptr GlpkFactorizationType -> GlpkFactorizationType -> IO ()
peek :: Ptr GlpkFactorizationType -> IO GlpkFactorizationType
$cpeek :: Ptr GlpkFactorizationType -> IO GlpkFactorizationType
pokeByteOff :: forall b. Ptr b -> Int -> GlpkFactorizationType -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> GlpkFactorizationType -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO GlpkFactorizationType
$cpeekByteOff :: forall b. Ptr b -> Int -> IO GlpkFactorizationType
pokeElemOff :: Ptr GlpkFactorizationType -> Int -> GlpkFactorizationType -> IO ()
$cpokeElemOff :: Ptr GlpkFactorizationType -> Int -> GlpkFactorizationType -> IO ()
peekElemOff :: Ptr GlpkFactorizationType -> Int -> IO GlpkFactorizationType
$cpeekElemOff :: Ptr GlpkFactorizationType -> Int -> IO GlpkFactorizationType
alignment :: GlpkFactorizationType -> Int
$calignment :: GlpkFactorizationType -> Int
sizeOf :: GlpkFactorizationType -> Int
$csizeOf :: GlpkFactorizationType -> Int
Storable
    , Typeable
    )

glpkLUForrestTomlin  :: GlpkFactorizationType
glpkLUForrestTomlin :: GlpkFactorizationType
glpkLUForrestTomlin  = CInt -> GlpkFactorizationType
GlpkFactorizationType CInt
1
glpkLUSchurCompBartelsGolub  :: GlpkFactorizationType
glpkLUSchurCompBartelsGolub :: GlpkFactorizationType
glpkLUSchurCompBartelsGolub  = CInt -> GlpkFactorizationType
GlpkFactorizationType CInt
2
glpkLUSchurGivensRotation  :: GlpkFactorizationType
glpkLUSchurGivensRotation :: GlpkFactorizationType
glpkLUSchurGivensRotation  = CInt -> GlpkFactorizationType
GlpkFactorizationType CInt
3
glpkBTSchurBartelsGolub  :: GlpkFactorizationType
glpkBTSchurBartelsGolub :: GlpkFactorizationType
glpkBTSchurBartelsGolub  = CInt -> GlpkFactorizationType
GlpkFactorizationType CInt
18
glpkBTSchurGivensRotation  :: GlpkFactorizationType
glpkBTSchurGivensRotation :: GlpkFactorizationType
glpkBTSchurGivensRotation  = CInt -> GlpkFactorizationType
GlpkFactorizationType CInt
19

{-# LINE 1504 "src/Math/Programming/Glpk/Header.hsc" #-}

-- Functions

foreign import ccall "glp_create_prob" glp_create_prob
  :: IO (Ptr Problem)
  -- ^ The allocated problem instance

foreign import ccall "glp_delete_prob" glp_delete_prob
  :: Ptr Problem
  -- ^ The problem instance
  -> IO ()

foreign import ccall "glp_set_prob_name" glp_set_prob_name
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The problem name
  -> IO ()

foreign import ccall "glp_set_obj_name" glp_set_obj_name
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The objective name
  -> IO ()

foreign import ccall "glp_set_obj_dir" glp_set_obj_dir
  :: Ptr Problem
  -- ^ The problem instance
  -> GlpkDirection
  -- ^ Whether the problem is a minimization or maximization problem
  -> IO ()

foreign import ccall "glp_add_rows" glp_add_rows
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -- ^ The number of constraints to add
  -> IO Row
  -- ^ The index of the first new constraint added

foreign import ccall "glp_add_cols" glp_add_cols
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -- ^ The number of variables to add
  -> IO Column
  -- ^ The index of the first new variable added

foreign import ccall "glp_set_row_name" glp_set_row_name
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The constraint being named
  -> CString
  -- ^ The name of the constraint
  -> IO ()

foreign import ccall "glp_set_col_name" glp_set_col_name
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable being named
  -> CString
  -- ^ The name of the variable
  -> IO ()

foreign import ccall "glp_set_row_bnds" glp_set_row_bnds
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The constraint being bounded
  -> GlpkConstraintType
  -- ^ The type of constraint
  -> CDouble
  -- ^ The lower bound
  -> CDouble
  -- ^ The upper bound
  -> IO ()

foreign import ccall "glp_set_col_bnds" glp_set_col_bnds
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable being bounded
  -> GlpkConstraintType
  -- ^ The type of constraint
  -> CDouble
  -- ^ The lower bound
  -> CDouble
  -- ^ The upper bound
  -> IO ()

foreign import ccall "glp_set_obj_coef" glp_set_obj_coef
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable
  -> CDouble
  -- ^ The objective coefficient
  -> IO ()

foreign import ccall "glp_set_mat_row" glp_set_mat_row
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The constraint being modified
  -> CInt
  -- ^ The number of variables being set
  -> GlpkArray Column
  -- ^ The variables being set
  -> GlpkArray CDouble
  -- ^ The variable coefficients
  -> IO ()

foreign import ccall "glp_set_mat_col" glp_set_mat_col
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable being modified
  -> CInt
  -- ^ The number of coefficients being set
  -> Ptr Row
  -- ^ The constraints being modified
  -> GlpkArray CDouble
  -- ^ The variable coefficients
  -> IO ()

foreign import ccall "glp_load_matrix" glp_load_matrix
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -- ^ The number of nonzero elements to be loaded
  -> GlpkArray Row
  -- ^ The constraint indices
  -> GlpkArray Column
  -- ^ The variable indices
  -> GlpkArray CDouble
  -- ^ The coefficients
  -> IO ()

foreign import ccall "glp_check_dup" glp_check_dup
  :: CInt
  -- ^ The number of rows in the matrix
  -> CInt
  -- ^ The number of columns in the matrix
  -> CInt
  -- ^ The number of nonzeros in the matrix
  -> GlpkArray CInt
  -- ^ The rows being checked
  -> GlpkArray CInt
  -- ^ The columns being checked
  -> CInt

foreign import ccall "glp_sort_matrix" glp_sort_matrix
  :: Ptr Problem
  -- ^ The problem instance
  -> IO ()

foreign import ccall "glp_del_rows" glp_del_rows
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -- ^ The number of constraints to delete
  -> GlpkArray Row
  -- ^ The indices of the constraints to delete
  -> IO ()

foreign import ccall "glp_del_cols" glp_del_cols
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -- ^ The number of variables to delete
  -> GlpkArray Column
  -- ^ The indices of the variables to delete
  -> IO ()

foreign import ccall "glp_copy_prob" glp_copy_prob
  :: Ptr Problem
  -- ^ The destination problem instance
  -> Ptr Problem
  -- ^ The problem instance to be copied
  -> GlpkControl
  -- ^ Whether to copy symbolic names
  -> IO ()

foreign import ccall "glp_erase_prob" glp_erase_prob
  :: Ptr Problem
  -- ^ The problem instance
  -> IO ()

foreign import ccall "glp_get_prob_name" glp_get_prob_name
  :: Ptr Problem
  -- ^ The problem instance
  -> IO CString
  -- ^ The name of the problem

foreign import ccall "glp_get_obj_name" glp_get_obj_name
  :: Ptr Problem
  -- ^ The problem instance
  -> IO CString
  -- ^ The name of the objective

foreign import ccall "glp_get_obj_dir" glp_get_obj_dir
  :: Ptr Problem
  -- ^ The problem instance
  -> IO GlpkDirection
  -- ^ The direction of the objective

foreign import ccall "glp_get_num_rows" glp_get_num_rows
  :: Ptr Problem
  -- ^ The problem instance
  -> IO CInt
  -- ^ The number of constraints

foreign import ccall "glp_get_num_cols" glp_get_num_cols
  :: Ptr Problem
  -- ^ The problem instance
  -> IO CInt
  -- ^ The number of variables

foreign import ccall "glp_get_row_name" glp_get_row_name
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The index of the constraint
  -> IO CString
  -- ^ The constraint name

foreign import ccall "glp_get_col_name" glp_get_col_name
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The index of the variable
  -> IO CString
  -- ^ The variable name

foreign import ccall "glp_get_row_type" glp_get_row_type
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The index of the constraint
  -> IO GlpkConstraintType
  -- ^ The constraint type

foreign import ccall "glp_get_row_lb" glp_get_row_lb
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The index of the constraint
  -> IO CDouble
  -- ^ The constraint lower bound

foreign import ccall "glp_get_row_ub" glp_get_row_ub
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The index of the constraint
  -> IO CDouble
  -- ^ The constraint upper bound

foreign import ccall "glp_get_col_type" glp_get_col_type
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The index of the variable
  -> IO GlpkVariableType
  -- ^ The constraint type

foreign import ccall "glp_get_col_lb" glp_get_col_lb
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The index of the variable
  -> IO CDouble
  -- ^ The variable lower bound

foreign import ccall "glp_get_col_ub" glp_get_col_ub
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The index of the variable
  -> IO CDouble
  -- ^ The variable upper bound

foreign import ccall "glp_get_obj_coef" glp_get_obj_coef
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The index of the variable
  -> IO CDouble
  -- ^ The objective coefficient

foreign import ccall "glp_get_num_nz" glp_get_num_nz
  :: Ptr Problem
  -- ^ The problem instance
  -> IO CInt
  -- ^ The number of nonzero constraint coefficients

foreign import ccall "glp_get_mat_row" glp_get_mat_row
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The constraint to retrieve
  -> GlpkArray Column
  -- ^ The variable indices in the constraint
  -> GlpkArray CDouble
  -- ^ The variable coefficients in the constraint
  -> IO CInt
  -- ^ The length of the arrays

foreign import ccall "glp_get_mat_col" glp_get_mat_col
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The constraint to retrieve
  -> GlpkArray Row
  -- ^ The constraint indices the variable is in
  -> GlpkArray CDouble
  -- ^ The constraint coefficients for the variable
  -> IO CInt
  -- ^ The length of the arrays

foreign import ccall "glp_create_index" glp_create_index
  :: Ptr Problem
  -- ^ The problem instance
  -> IO ()

foreign import ccall "glp_delete_index" glp_delete_index
  :: Ptr Problem
  -- ^ The problem instance
  -> IO ()

foreign import ccall "glp_find_row" glp_find_row
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The name of the constraint
  -> IO Row
  -- ^ The index of the constraint

foreign import ccall "glp_find_col" glp_find_col
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The name of the variable
  -> IO Column
  -- ^ The index of the variable

foreign import ccall "glp_set_rii" glp_set_rii
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The constraint to scale
  -> CDouble
  -- ^ The scaling factor
  -> IO ()

foreign import ccall "glp_get_rii" glp_get_rii
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The constraint index
  -> IO CDouble

foreign import ccall "glp_set_sjj" glp_set_sjj
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable to scale
  -> CDouble
  -- ^ The scaling factor
  -> IO ()

foreign import ccall "glp_get_sjj" glp_get_sjj
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable index
  -> IO CDouble

foreign import ccall "glp_scale_prob" glp_scale_prob
  :: Ptr Problem
  -- ^ The problem instance
  -> GlpkScaling
  -- ^ The type of scaling to apply
  -> IO ()

foreign import ccall "glp_unscale_prob" glp_unscale_prob
  :: Ptr Problem
  -- ^ The problem instance
  -> IO ()

foreign import ccall "glp_set_row_stat" glp_set_row_stat
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The constraint to modify
  -> GlpkVariableStatus
  -- ^ The status to apply
  -> IO ()

foreign import ccall "glp_set_col_stat" glp_set_col_stat
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable to modify
  -> GlpkVariableStatus
  -- ^ The status to apply
  -> IO ()

foreign import ccall "glp_std_basis" glp_std_basis
  :: Ptr Problem
  -- ^ The problem instance
  -> IO ()

foreign import ccall "glp_adv_basis" glp_adv_basis
  :: Ptr Problem
  -- ^ The problem instance
  -> Unused CInt
  -- ^ Reserved for future use, must be zero
  -> IO ()

foreign import ccall "glp_cpx_basis" glp_cpx_basis
  :: Ptr Problem
  -- ^ The problem instance
  -> IO ()

foreign import ccall "glp_simplex" glp_simplex
  :: Ptr Problem
  -- ^ The problem instance
  -> Ptr SimplexMethodControlParameters
  -- ^ Simplex control parameters
  -> IO GlpkSimplexStatus
  -- ^ The exit status

foreign import ccall "glp_exact" glp_exact
  :: Ptr Problem
  -- ^ The problem instance
  -> Ptr SimplexMethodControlParameters
  -- ^ Simplex control parameters
  -> IO GlpkSimplexStatus
  -- ^ The exit status

foreign import ccall "glp_init_smcp" glp_init_smcp
  :: Ptr SimplexMethodControlParameters
  -- ^ The Simplex control parameters to initialize
  -> IO ()

foreign import ccall "glp_get_status" glp_get_status
  :: Ptr Problem
  -- ^ The problem instance
  -> IO GlpkSolutionStatus

foreign import ccall "glp_get_prim_stat" glp_get_prim_stat
  :: Ptr Problem
  -- ^ The problem instance
  -> IO GlpkSolutionStatus

foreign import ccall "glp_get_dual_stat" glp_get_dual_stat
  :: Ptr Problem
  -- ^ The problem instance
  -> IO GlpkSolutionStatus

foreign import ccall "glp_get_obj_val" glp_get_obj_val
  :: Ptr Problem
  -- ^ The problem instance
  -> IO CDouble

foreign import ccall "glp_get_row_stat" glp_get_row_stat
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The constraint to query
  -> IO GlpkVariableStatus
  -- ^ The status of the associated with the auxiliary variable

foreign import ccall "glp_get_col_stat" glp_get_col_stat
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable to query
  -> IO GlpkVariableStatus
  -- ^ The status of the variable

foreign import ccall "glp_get_row_prim" glp_get_row_prim
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The constraint to query
  -> IO CDouble
  -- ^ The primal auxiliary variable value

foreign import ccall "glp_get_row_dual" glp_get_row_dual
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The constraint to query
  -> IO CDouble
  -- ^ The dual auxiliary variable value

foreign import ccall "glp_get_col_prim" glp_get_col_prim
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable to query
  -> IO CDouble
  -- ^ The primal variable value

foreign import ccall "glp_get_col_dual" glp_get_col_dual
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable to query
  -> IO CDouble
  -- ^ The dual variable value

foreign import ccall "glp_get_unbnd_ray" glp_get_unbnd_ray
  :: Ptr Problem
  -- ^ The problem instance
  -> IO CInt
  -- ^ The index, k, of the variable producing unboundedness. If 1 <=
  -- k <= m, then k is the kth auxiliary variable. If m + 1 <= k <= m
  -- + n, it is the (k - m)th structural variable.

foreign import ccall "glp_get_bfcp" glp_get_bfcp
  :: Ptr Problem
  -- ^ The problem instance
  -> Ptr BasisFactorizationControlParameters
  -- ^ A pointer that will hold the basis factorization control
  -- parameters
  -> IO ()

foreign import ccall "glp_set_bfcp" glp_set_bfcp
  :: Ptr Problem
  -- ^ The problem instance
  -> Ptr BasisFactorizationControlParameters
  -- ^ The basis factorization control parameters
  -> IO ()

foreign import ccall "glp_interior" glp_interior
  :: Ptr Problem
  -- ^ The problem instance
  -> Ptr InteriorPointControlParameters
  -- ^ The interior point control parameters
  -> IO GlpkInteriorPointStatus
  -- ^ The status of the solve

foreign import ccall "glp_init_iptcp" glp_init_iptcp
  :: Ptr InteriorPointControlParameters
  -- ^ The control parameters to initialize
  -> IO ()

foreign import ccall "glp_ipt_status" glp_ipt_status
  :: Ptr Problem
  -- ^ The problem instance
  -> IO GlpkSolutionStatus
  -- ^ The status of the interior point solve

foreign import ccall "glp_intopt" glp_intopt
  :: Ptr Problem
  -- ^ The problem instance
  -> Ptr (MIPControlParameters a)
  -- ^ The MIP control parameters
  -> IO GlpkMIPStatus
  -- ^ The status of the solve

foreign import ccall "glp_mip_status" glp_mip_status
  :: Ptr Problem
  -- ^ The problem instance
  -> IO GlpkSolutionStatus
  -- The status of the solution

foreign import ccall "glp_mip_obj_val" glp_mip_obj_val
  :: Ptr Problem
  -- ^ The problem instance
  -> IO CDouble
  -- ^ The MIP object

foreign import ccall "glp_mip_row_val" glp_mip_row_val
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The constraint to query
  -> IO CDouble
  -- ^ The value of the auxiliary variable

foreign import ccall "glp_mip_col_val" glp_mip_col_val
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable to query
  -> IO CDouble
  -- ^ The value of the variable

foreign import ccall "glp_check_kkt" glp_check_kkt
  :: Ptr Problem
  -- ^ The problem instance
  -> GlpkSolutionType
  -- ^ The solution type to check
  -> GlpkKKTCheck
  -- ^ The condition to be checked
  -> Ptr CDouble
  -- ^ The largest absolute error
  -> Ptr CInt
  -- ^ The row, column, or variable with the largest absolute error
  -> Ptr CDouble
  -- ^ The largest relative error
  -> Ptr CInt
  -- ^ The row, column, or variable with the largest relative error
  -> IO ()

foreign import ccall "glp_print_sol" glp_print_sol
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The file name to write to
  -> IO CInt
  -- ^ Zero on success

foreign import ccall "glp_read_sol" glp_read_sol
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The file name to read from
  -> IO CInt
  -- ^ Zero on success

foreign import ccall "glp_write_sol" glp_write_sol
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The file name to write to
  -> IO CInt
  -- ^ Zero on success

foreign import ccall "glp_print_ranges" glp_print_ranges
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -- ^ The number of rows and columns
  -> Ptr CInt
  -- ^ The rows and clumns to analyze
  -> Unused CInt
  -- ^ Reserved for future use, must be zero
  -> CString
  -- ^ The file name to write to
  -> IO CInt
  -- ^ Zero on success

foreign import ccall "glp_print_ipt" glp_print_ipt
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The file to write to
  -> IO CInt
  -- Zero on success

foreign import ccall "glp_read_ipt" glp_read_ipt
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The file to read from
  -> IO CInt
  -- Zero on success

foreign import ccall "glp_write_ipt" glp_write_ipt
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The file to write to
  -> IO CInt
  -- Zero on success

foreign import ccall "glp_print_mip" glp_print_mip
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The file to write to
  -> IO CInt
  -- Zero on success

foreign import ccall "glp_read_mip" glp_read_mip
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The file to read from
  -> IO CInt
  -- Zero on success

foreign import ccall "glp_write_mip" glp_write_mip
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The file to write to
  -> IO CInt
  -- Zero on success

foreign import ccall "glp_bf_exists" glp_bf_exists
  :: Ptr Problem
  -- ^ The problem instance
  -> IO CInt
  -- ^ Whether an LP basis factorization exists

foreign import ccall "glp_factorize" glp_factorize
  :: Ptr Problem
  -- ^ Compute an LP basis factorization
  -> IO ()

foreign import ccall "glp_bf_updated" glp_bf_updated
  :: Ptr Problem
  -- ^ The problem instance
  -> IO CInt
  -- ^ Whether the LP basis factorization is updated

foreign import ccall "glp_get_bhead" glp_get_bhead
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -> IO CInt

foreign import ccall "glp_get_row_bind" glp_get_row_bind
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -> IO CInt

foreign import ccall "glp_get_col_bind" glp_get_col_bind
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -> IO CInt

foreign import ccall "glp_ftran" glp_ftran
  :: Ptr Problem
  -- ^ The problem instance
  -> Ptr CDouble
  -> IO ()

foreign import ccall "glp_btran" glp_btran
  :: Ptr Problem
  -- ^ The problem instance
  -> Ptr CDouble
  -> IO ()

foreign import ccall "glp_warm_up" glp_warm_up
  :: Ptr Problem
  -- ^ The problem instance
  -> IO GlpkFactorizationResult

foreign import ccall "glp_eval_tab_row" glp_eval_tab_row
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -> Ptr CInt
  -> Ptr CDouble
  -> IO CInt

foreign import ccall "glp_eval_tab_col" glp_eval_tab_col
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -> Ptr CInt
  -> Ptr CDouble
  -> IO CInt

foreign import ccall "glp_transform_row" glp_transform_row
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -> Ptr CInt
  -> Ptr CDouble
  -> IO CInt

foreign import ccall "glp_transform_col" glp_transform_col
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -> Ptr CInt
  -> Ptr CDouble
  -> IO CInt

foreign import ccall "glp_prim_rtest" glp_prim_rtest
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -> Ptr CInt
  -> Ptr CDouble
  -> CInt
  -> CDouble
  -> IO CInt

foreign import ccall "glp_dual_rtest" glp_dual_rtest
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -> Ptr CInt
  -> Ptr CDouble
  -> CInt
  -> CDouble
  -> IO CInt

foreign import ccall "glp_analyze_bound" glp_analyze_bound
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -> Ptr CDouble
  -> Ptr Column
  -> Ptr CDouble
  -> Ptr Column
  -> IO ()

foreign import ccall "glp_analyze_coef" glp_analyze_coef
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -> Ptr CDouble
  -> Ptr Column
  -> Ptr CDouble
  -> Ptr CDouble
  -> Ptr Column
  -> Ptr CDouble
  -> IO ()

foreign import ccall "glp_init_iocp" glp_init_iocp
  :: Ptr (MIPControlParameters a)
  -- ^ The MIP control parameters to initialize
  -> IO ()

foreign import ccall "glp_ipt_obj_val" glp_ipt_obj_val
  :: Ptr Problem
  -- ^ The problem instance
  -> IO CDouble
  -- ^ The objective value

foreign import ccall "glp_ipt_row_prim" glp_ipt_row_prim
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The constraint to query
  -> IO Double
  -- ^ The primal auxiliary variable value

foreign import ccall "glp_ipt_row_dual" glp_ipt_row_dual
  :: Ptr Problem
  -- ^ The problem instance
  -> Row
  -- ^ The constraint to query
  -> IO Double
  -- ^ The dual auxiliary variable value

foreign import ccall "glp_ipt_col_prim" glp_ipt_col_prim
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable to query
  -> IO CDouble
  -- ^ The primal variable value

foreign import ccall "glp_ipt_col_dual" glp_ipt_col_dual
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable to query
  -> IO Double
  -- ^ The dual variable value

foreign import ccall "glp_ios_reason" glp_ios_reason
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> IO GlpkCallbackReason
  -- ^ The reason the callback is being called

foreign import ccall "glp_ios_get_prob" glp_ios_get_prob
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> IO (Ptr Problem)
  -- ^ The active problem

foreign import ccall "glp_ios_tree_size" glp_ios_tree_size
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> Ptr CInt
  -- ^ The number of active nodes
  -> Ptr CInt
  -- ^ The total number of active and inactive nodes
  -> Ptr CInt
  -- ^ The total number of nodes that have been added to the tree
  -> IO ()

foreign import ccall "glp_ios_curr_node" glp_ios_curr_node
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> IO (GlpkInt GlpkNodeIndex)
  -- ^ The current node in the search tree

foreign import ccall "glp_ios_next_node" glp_ios_next_node
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> GlpkInt GlpkNodeIndex
  -- ^ The target node in the search tree
  -> IO (GlpkInt GlpkNodeIndex)
  -- ^ The next node in the search tree after the target node

foreign import ccall "glp_ios_prev_node" glp_ios_prev_node
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> GlpkInt GlpkNodeIndex
  -- ^ The target node in the search tree
  -> IO (GlpkInt GlpkNodeIndex)
  -- ^ The parent node in the search tree after the target node

foreign import ccall "glp_ios_up_node" glp_ios_up_node
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> GlpkInt GlpkNodeIndex
  -- ^ The target node in the search tree
  -> IO (GlpkInt GlpkNodeIndex)
  -- ^ The parent of the target node

foreign import ccall "glp_ios_node_level" glp_ios_node_level
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> GlpkInt GlpkNodeIndex
  -- ^ The target node in the search tree
  -> IO CInt
  -- ^ The level of the target in the search tree; the root problem
  -- has level 0.

foreign import ccall "glp_ios_node_bound" glp_ios_node_bound
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> GlpkInt GlpkNodeIndex
  -- ^ The target node in the search tree
  -> IO CDouble
  -- ^ The objective bound on the target

foreign import ccall "glp_ios_best_node" glp_ios_best_node
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> IO (GlpkInt GlpkNodeIndex)
  -- ^ The node in the search tree with the best objective bound

foreign import ccall "glp_ios_mip_gap" glp_ios_mip_gap
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> IO CDouble
  -- ^ The current MIP gap

foreign import ccall "glp_ios_node_data" glp_ios_node_data
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> GlpkInt GlpkNodeIndex
  -- ^ The target node in the search tree
  -> IO (Ptr a)
  -- ^ The data associated with the target

foreign import ccall "glp_ios_row_attr" glp_ios_row_attr
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> CInt
  -- ^ The index of the target cut
  -> Ptr GlpkCutAttribute
  -- ^ The information about the target cut
  -> IO ()

foreign import ccall "glp_ios_pool_size" glp_ios_pool_size
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> IO CInt
  -- ^ The number of cutting planes added to the problem

foreign import ccall "glp_ios_add_row" glp_ios_add_row
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> CString
  -- ^ The name of the cutting plane to add
  -> GlpkUserCutType
  -- ^ The type of cut being added
  -> Unused CInt
  -- ^ Unused; must be zero
  -> CInt
  -- ^ The number of variable indices specified
  -> GlpkArray CInt
  -- ^ The variable indices
  -> GlpkArray CDouble
  -- ^ The variable coefficients
  -> GlpkConstraintType
  -- ^ The type of the constraint
  -> CDouble
  -- ^ The right-hand side of the constraint
  -> IO ()

foreign import ccall "glp_ios_del_row" glp_ios_del_row
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> CInt
  -- ^ The index of the cut to delete
  -> IO ()

foreign import ccall "glp_ios_clear_pool" glp_ios_clear_pool
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> IO ()

foreign import ccall "glp_ios_can_branch" glp_ios_can_branch
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> Column

foreign import ccall "glp_ios_branch_upon" glp_ios_branch_upon
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> Column
  -- ^ The index of the variable to branch on
  -> GlpkBranchOption
  -- ^ The branching decision
  -> IO ()

foreign import ccall "glp_ios_select_node" glp_ios_select_node
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> GlpkInt GlpkNodeIndex
  -- ^ The subproblem to explore
  -> IO ()

foreign import ccall "glp_ios_heur_sol" glp_ios_heur_sol
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> GlpkArray CDouble
  -- ^ The variable values of an integer heuristic
  -> IO ()

foreign import ccall "glp_ios_terminate" glp_ios_terminate
  :: Ptr (GlpkTree a)
  -- ^ The search tree
  -> IO ()

foreign import ccall "glp_set_col_kind" glp_set_col_kind
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable index
  -> GlpkVariableType
  -- ^ The type of the variable
  -> IO ()

foreign import ccall "glp_get_col_kind" glp_get_col_kind
  :: Ptr Problem
  -- ^ The problem instance
  -> Column
  -- ^ The variable index
  -> IO GlpkVariableType
  -- ^ The type of the variable

foreign import ccall "glp_get_num_int" glp_get_num_int
  :: Ptr Problem
  -- ^ The problem instance
  -> IO CInt
  -- ^ The number of integer variables

foreign import ccall "glp_get_num_bin" glp_get_num_bin
  :: Ptr Problem
  -- ^ The problem instance
  -> IO CInt
  -- ^ The number of binary variables

foreign import ccall "glp_init_mpscp" glp_init_mpscp
  :: Ptr MPSControlParameters
  -- ^ The MPS control parameters to initialize
  -> IO ()

foreign import ccall "glp_read_mps" glp_read_mps
  :: Ptr Problem
  -- ^ The problem instance
  -> GlpkMPSFormat
  -- ^ The MPS format to read
  -> Ptr MPSControlParameters
  -- ^ The MPS control parameters
  -> CString
  -- ^ The name of the file to read
  -> IO ()

foreign import ccall "glp_write_mps" glp_write_mps
  :: Ptr Problem
  -- ^ The problem instance
  -> GlpkMPSFormat
  -- ^ The MPS format to read
  -> Ptr MPSControlParameters
  -- ^ The MPS control parameters
  -> CString
  -- ^ The name of the file to write to
  -> IO ()

foreign import ccall "glp_init_cpxcp" glp_init_cpxcp
  :: Ptr CplexLPFormatControlParameters
  -- ^ The CPLEX LP control parameters to initialize
  -> IO ()

foreign import ccall "glp_read_lp" glp_read_lp
  :: Ptr Problem
  -- ^ The problem instance
  -> Ptr CplexLPFormatControlParameters
  -- ^ The CPLEX LP control parameters
  -> CString
  -- ^ The name of the file to read
  -> IO CInt
  -- ^ Zero on success

foreign import ccall "glp_write_lp" glp_write_lp
  :: Ptr Problem
  -- ^ The problem instance
  -> Ptr CplexLPFormatControlParameters
  -- ^ The CPLEX LP control parameters
  -> CString
  -- ^ The name of the file to write to
  -> IO CInt
  -- ^ Zero on success

foreign import ccall "glp_read_prob" glp_read_prob
  :: Ptr Problem
  -- ^ The problem instance
  -> Unused CInt
  -- ^ Reserved for future use, must be zero
  -> CString
  -- ^ The file to read from
  -> IO CInt
  -- ^ Zero on success

foreign import ccall "glp_write_prob" glp_write_prob
  :: Ptr Problem
  -- ^ The problem instance
  -> Unused CInt
  -- ^ Reserved for future use, must be zero
  -> CString
  -- ^ The file to write to
  -> IO CInt
  -- ^ Zero on success

foreign import ccall "glp_mpl_alloc_wksp" glp_mpl_alloc_wksp
  :: IO (Ptr MathProgWorkspace)
  -- ^ The allocated MathProg workspace

foreign import ccall "glp_mpl_free_wksp" glp_mpl_free_wksp
  :: Ptr MathProgWorkspace
  -- ^ The MathProg workspace to deallocate
  -> IO ()

foreign import ccall "glp_mpl_init_rand" glp_mpl_init_rand
  :: Ptr MathProgWorkspace
  -- ^ The MathProg workspace
  -> CInt
  -- ^ The random number generator seed
  -> IO MathProgResult

foreign import ccall "glp_mpl_read_model" glp_mpl_read_model
  :: Ptr MathProgWorkspace
  -- ^ The MathProg workspace
  -> CString
  -- ^ The name of the file to read
  -> CInt
  -- ^ If nonzero, skip the data section
  -> IO MathProgResult

foreign import ccall "glp_mpl_read_data" glp_mpl_read_data
  :: Ptr MathProgWorkspace
  -- ^ The MathProg workspace
  -> CString
  -- ^ The name of the file to read
  -> IO MathProgResult

foreign import ccall "glp_mpl_generate" glp_mpl_generate
  :: Ptr MathProgWorkspace
  -- ^ The MathProg workspace
  -> CString
  -- ^ The output file. If NULL, output is written to standard output
  -> IO MathProgResult

foreign import ccall "glp_mpl_build_prob" glp_mpl_build_prob
  :: Ptr MathProgWorkspace
  -- ^ The MathProg workspace
  -> Ptr Problem
  -- ^ The problem instance to write to
  -> IO MathProgResult

foreign import ccall "glp_mpl_postsolve" glp_mpl_postsolve
  :: Ptr MathProgWorkspace
  -- ^ The MathProg workspace
  -> Ptr Problem
  -- ^ The solved problem instance
  -> GlpkSolutionType
  -- ^ The type of solution to be copied
  -> IO MathProgResult

foreign import ccall "glp_read_cnfsat" glp_read_cnfstat
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The file to read from
  -> CInt
  -- ^ Zero on success

foreign import ccall "glp_write_cnfsat" glp_write_cnfstat
  :: Ptr Problem
  -- ^ The problem instance
  -> CString
  -- ^ The file to write to
  -> CInt
  -- ^ Zero on success

foreign import ccall "glp_minisat1" glp_minisat1
  :: Ptr Problem
  -- ^ The problem instance
  -> IO CInt

foreign import ccall "glp_intfeas1" glp_intfeas1
  :: Ptr Problem
  -- ^ The problem instance
  -> CInt
  -> CInt
  -> IO CInt

foreign import ccall "glp_init_env" glp_init_env
  :: IO CInt

foreign import ccall "glp_free_env" glp_free_env
  :: IO CInt

foreign import ccall "glp_version" glp_version
  :: IO CString

foreign import ccall "glp_config" glp_config
  :: CString
  -> IO CString

foreign import ccall "glp_term_out" glp_term_out
  :: GlpkControl
  -> IO GlpkControl

foreign import ccall "glp_term_hook" glp_term_hook
  :: FunPtr (Ptr a -> CString -> IO CInt)
  -> Ptr a
  -> IO ()

foreign import ccall "glp_error_hook" glp_error_hook
  :: FunPtr (Ptr a -> IO CInt)
  -> Ptr a
  -> IO ()

foreign import ccall "wrapper"
  mkHaskellErrorHook :: (Ptr a -> IO CInt) -> IO (FunPtr (Ptr a -> IO CInt))

foreign import ccall "wrapper"
  mkHaskellTermHook :: (Ptr a -> IO CInt) -> IO (FunPtr (Ptr a -> IO CInt))

foreign import ccall "wrapper"
  mkHaskellMIPCallback :: (Ptr (GlpkTree a) -> Ptr a -> IO ()) -> IO (FunPtr (Ptr (GlpkTree a) -> Ptr a -> IO ()))