module Numeric.HiGHS.LP.Example
  {-# WARNING "Only for documentation. Do not import." #-}
  where

import qualified Numeric.HiGHS.LP as LP
import Numeric.HiGHS.LP ((.*), (==.))

import qualified Data.Array.Comfort.Storable as Array
import qualified Data.Array.Comfort.Shape as Shape
import Data.Array.Comfort.Storable (Array)
import Data.Tuple.HT (mapSnd)

import Text.Printf (printf)


type X = Shape.Element
type PairShape = Shape.NestedTuple Shape.TupleIndex (X,X)

main :: IO ()
main :: IO ()
main =
  case PairShape -> DataTuple (X, X) (ElementIndex (X, X))
forall tuple.
ElementTuple tuple =>
NestedTuple TupleIndex tuple
-> DataTuple tuple (ElementIndex tuple)
Shape.indexTupleFromShape (PairShape
forall sh. Static sh => sh
Shape.static :: PairShape) of
    (ElementIndex (X, X)
posIx,ElementIndex (X, X)
negIx) ->
      case ((Double, Array PairShape Double) -> (Double, (Double, Double)))
-> Maybe (Double, Array PairShape Double)
-> Maybe (Double, (Double, Double))
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Array PairShape Double -> (Double, Double))
-> (Double, Array PairShape Double) -> (Double, (Double, Double))
forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd Array PairShape Double -> (Double, Double)
Array PairShape Double -> DataTuple (X, X) Double
forall tuple a ixtype.
(NestedTuple tuple, Storable a) =>
Array (NestedTuple ixtype tuple) a -> DataTuple tuple a
Array.toTuple) (Maybe (Double, Array PairShape Double)
 -> Maybe (Double, (Double, Double)))
-> Maybe (Double, Array PairShape Double)
-> Maybe (Double, (Double, Double))
forall a b. (a -> b) -> a -> b
$ (ModelStatus, Maybe (Double, Array PairShape Double))
-> Maybe (Double, Array PairShape Double)
forall a b. (a, b) -> b
snd ((ModelStatus, Maybe (Double, Array PairShape Double))
 -> Maybe (Double, Array PairShape Double))
-> (ModelStatus, Maybe (Double, Array PairShape Double))
-> Maybe (Double, Array PairShape Double)
forall a b. (a -> b) -> a -> b
$
           Method
-> Bounds (ElementIndex (X, X))
-> Constraints Double (ElementIndex (X, X))
-> (Direction, Array PairShape Double)
-> (ModelStatus, Maybe (Double, Array PairShape Double))
forall sh ix.
(Indexed sh, Index sh ~ ix) =>
Method
-> Bounds ix
-> Constraints Double ix
-> (Direction, Objective sh)
-> Result sh
LP.solve Method
LP.choose [] [[Double
1Double -> ElementIndex (X, X) -> Term Double (ElementIndex (X, X))
forall a ix. a -> ix -> Term a ix
.*ElementIndex (X, X)
posIx, (-Double
1)Double -> ElementIndex (X, X) -> Term Double (ElementIndex (X, X))
forall a ix. a -> ix -> Term a ix
.*ElementIndex (X, X)
negIx] [Term Double (ElementIndex (X, X))]
-> Double -> Inequality [Term Double (ElementIndex (X, X))]
forall x. x -> Double -> Inequality x
==. Double
314]
             (Direction
LP.Minimize,
              DataTuple (X, X) Double -> Array PairShape Double
forall tuple a ixtype.
(NestedTuple tuple, Storable a) =>
DataTuple tuple a -> Array (NestedTuple ixtype tuple) a
Array.fromTuple (Double
23,Double
42) :: Array PairShape Double)
        of
          Just (Double
absol, (Double
pos, Double
neg)) ->
            String -> Double -> Double -> Double -> IO ()
forall r. PrintfType r => String -> r
printf String
"absol %f,  pos %f, neg %f\n" Double
absol Double
pos Double
neg
          Maybe (Double, (Double, Double))
_ -> String -> IO ()
forall a. String -> IO a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"HiGHS solver failed"