Ipopt.NLP

see usage in examples/Test3.hs (and other examples)

IPOPT does support naming variables if you use c++ (by overriding a virtual void finalize_metadata), but it's not clear that we can set that from c/haskell

state

data NLPFun

Constructors

NLPFun

Fields

_funF, _funG :: AnyRF Seq.Seq

_boundX, _boundG :: Seq.Seq (Double, Double)

Instances

Show NLPFun

Monoid NLPFun

data NLPState

Constructors

NLPState

Fields

_nMax :: Ix

current maximum index

_currentEnv :: [String]

what namespace are we currently in (see inEnv)

_variables :: Map String Ix

fully qualified (see inEnv) name

_variablesInv :: IxMap String

invert _variables

_constraintLabels, _objLabels :: IntMap String

human-readable descriptions for the constraint, objective and variables

_varLabels :: IxMap String

_varEnv :: IxMap (S.Set [String])

in what environments is a given var used?

_constraintEnv, _objEnv :: IntMap [String]

_nlpfun :: NLPFun

_defaultBounds :: (Double, Double)

the default (xL,xU) for xL < x < xU

_defaultConstraintTol :: (Double, Double)

for nlopt (lower/upper)

_constraintTol :: Seq.Seq (Double, Double)

_initX :: V.Vector Double

inital state variable for the solver

Instances

Show NLPState

newtype IxMap a

Constructors

IxMap (IntMap a)

Instances

Functor IxMap

Show a => Show (IxMap a)

Monoid (IxMap a)

newtype Ix

the solver deals with arrays. This type is for indexes into the array for the current variables that the solver is trying to find.

Constructors

Ix

Fields

_varIx :: Int

Instances

Show Ix

nlpstate0 :: NLPState

the initial state to use when you actually have to get to IO with the solution

type NLPT = StateT NLPState

type NLP = NLPT IO

low level lenses to NLPState

funG :: Lens' NLPFun (AnyRF Seq.Seq)

funF :: Lens' NLPFun (AnyRF Seq.Seq)

boundX :: Lens' NLPFun (Seq.Seq (Double, Double))

boundG :: Lens' NLPFun (Seq.Seq (Double, Double))

varIx :: Iso' Ix Int

variablesInv :: Lens' NLPState (IxMap String)

variables :: Lens' NLPState (Map String Ix)

varLabels :: Lens' NLPState (IxMap String)

varEnv :: Lens' NLPState (IxMap (S.Set [String]))

objLabels :: Lens' NLPState (IntMap String)

objEnv :: Lens' NLPState (IntMap [String])

nlpfun :: Lens' NLPState NLPFun

nMax :: Lens' NLPState Ix

initX :: Lens' NLPState (V.Vector Double)

defaultConstraintTol :: Lens' NLPState (Double, Double)

defaultBounds :: Lens' NLPState (Double, Double)

currentEnv :: Lens' NLPState [String]

constraintTol :: Lens' NLPState (Seq.Seq (Double, Double))

constraintLabels :: Lens' NLPState (IntMap String)

constraintEnv :: Lens' NLPState (IntMap [String])

ixMap :: (Functor f, Profunctor p) => p (IxMap a) (f (IxMap t)) -> p (IntMap a) (f (IntMap t))

ix_ :: Applicative f => Ix -> (a -> f a) -> IxMap a -> f (IxMap a)

should be a way to write an instance of At that'll make the normal atix work with the IxMap Ix (as opposed to IntMap/Int)

at_ :: Functor f => Ix -> (Maybe a -> f (Maybe a)) -> IxMap a -> f (IxMap a)

copyEnv :: MonadState NLPState m => ALens NLPState NLPState (IntMap [String]) (IntMap [String]) -> Key -> m ()

to is one of varEnv, constraintEnv, objEnv

addDesc :: MonadState s m => Setting (->) s s (IntMap a) (IntMap a) -> Maybe a -> Key -> m ()

to should be constraintLabels, objLabels, varLabels

high-level functions

solveNLP'

Arguments

:: (VG.Vector v Double, MonadIO m)

=> (IpProblem -> IO ())

set ipopt options (using functions from Ipopt.Raw) or the ipopts quasiquoter

-> NLPT m (IpOptSolved v)

calls createIpoptProblemAD and ipoptSolve. To be used at the end of a do-block.

solveNLP'sparse

Arguments

:: (VG.Vector v Double, MonadIO m)

=> (IpProblem -> IO ())

set ipopt options (using functions from Ipopt.Raw) or the ipopts quasiquoter

-> NLPT m (IpOptSolved v)

a slower version of solveNLP' that uses createIpoptProblemADSparse

addG

Arguments

:: Monad m

=> Maybe String

optional description

-> (Double, Double)

bounds (gl,gu) for the single inequality gl_i <= g_i(x) <= gu_i

-> AnyRF Identity

g_i(x)

-> NLPT m ()

add a constraint

addF

Arguments

:: Monad m

=> Maybe String

description

-> AnyRF Identity

`f_i(x)`

-> NLPT m ()

add a piece of the objective function, which is added in the form `f_1 + f_2 + ...`, to make it easier to understand (at some point) which components are responsible for the majority of the cost, and which are irrelevant.

var'

Arguments

:: (Monad m, Functor m)

=> Maybe (Double, Double)

bounds (xl,xu) to request that xl <= x <= xu. if Nothing, you get whatever is in defaultBounds

-> Maybe String

optional longer description

-> String

variable name (namespace from the pushEnv / popEnv can make an "x" you request here different from one you previously requested

-> NLPT m Ix

the index (into the rawvector of variables that the solver sees)

add a variable, or get a reference to the the same variable if it has already been used

var :: Monad m => Maybe (Double, Double) -> String -> StateT NLPState m (AnyRF Identity)

a combination of var' and ixToVar

varFresh' :: (Monad m, Functor m) => Maybe (Double, Double) -> String -> NLPT m Ix

var, except this causes the solver to get a new variable, so that you can use:

[a,b,c,d,e] <- replicateM 5 (varFresh (Just (0, 10)) "x")

and the different letters can take different values (between 0 and 10) in the optimal solution (depending on what you do with a and similar in the objective function and other constraints).

varFresh :: Monad m => Maybe (Double, Double) -> String -> StateT NLPState m (AnyRF Identity)

see varFresh'

namespace

When you build up an optimization problem, it may be composed of pieces. Functions in this section help to ease the pain of making unique variables. To illustrate:

m <- inEnv "A" (var b "x")
n <- var b "A.x" 

m and n above should refer to the same variable. In some sense this is "better" that using varFresh all the time, since perhaps you would like to add dependencies between components (say the size of a header pipe, refridgeration unit, foundation etc. has to satisfy sizes of individual components).

inEnv :: Monad m => String -> NLPT m a -> NLPT m a

combination of pushEnv and popEnv

pushEnv :: Monad m => String -> NLPT m ()

popEnv :: Monad m => NLPT m String

piecewise linear

see for example chapter 20 of http://www.ampl.com/BOOK/download.html and use of the splines package in examples/Test4 and examples/Test5

splitVar

Arguments

:: (Monad m, Functor m)

=> Double

b

-> Ix

index for x

-> NLPT m (AnyRF Identity, AnyRF Identity)

(b-x)_+, (x-b)_+

splits a variable x into two positive variables such that x = x^+ - x^- the new variables represent the positive and negative parts of x - b

(xMinus, xPlus) <- splitVar b x

Using max (x-b) 0 instead of xPlus (ie. not telling the solver that b is a special point) seems to work just as well: additional special treatment is needed. For example see chapter 11 of

Nonlinear Programming: Concepts, Algorithms, and Applications to Chemical Processes
Lorenz T. Biegler 
SIAM 2010

which discusses several ways to reformulate the problem so that an ordinary NLP solver will not have trouble with the fact that one of the pair of constraints (x+ = 0 | x- = 0) is tight at an optimum.

ixToVar :: Ix -> AnyRF Identity

bounds

setBounds :: Monad m => Ix -> (Double, Double) -> NLPT m ()

override bounds. Should be unnecessary given var takes bounds.

narrowBounds :: Monad m => Ix -> (Double, Double) -> NLPT m ()

shrink the interval in which that variable is allowed.

internal

seqToVecs :: MonadIO m => Seq.Seq (Double, Double) -> m (Vec, Vec)