Ipopt.Raw

Description: lowest-level parts of the binding

specifying problem

createIpoptProblemAD

Arguments

:: Vec

xL Vector of lower bounds for decision variables with length n

-> Vec

xU Vector of upper bounds for decision variables

-> Vec

gL Vector of lower bounds for constraint functions g(x) with length m

-> Vec

gU Vector of upper bounds for constraint functions g(x)

-> (forall a. AnyRFCxt a => V.Vector a -> a)

objective function f : R^n -> R

-> (forall a. AnyRFCxt a => V.Vector a -> V.Vector a)

constraint functions g : R^n -> R^m

-> IO IpProblem

Set-up an IpProblem to be solved later. Only objective function (f) and constraint functions (g) need to be specified. Derivatives needed by ipopt are computed by Numeric.AD.

To solve the optimization problem:

             min f(x)
  such that
          xL <=  x     <= xU
          gL <=  g(x)  <= gU

First create an opaque IpProblem object (nlp):

nlp <- createIpOptProblemAD xL xU gL gU f g

Then pass it off to ipoptSolve.

ipoptSolve nlp x0

Refer to examples/HS71ad.hs for details of setting up the vectors supplied.

createIpoptProblemADSparse

Arguments

:: Vec

xL Vector of lower bounds for decision variables with length n

-> Vec

xU Vector of upper bounds for decision variables

-> Vec

gL Vector of lower bounds for constraint functions g(x) with length m

-> Vec

gU Vector of upper bounds for constraint functions g(x)

-> (V.Vector (Sparse.Sparse C2HSImp.CDouble) -> Sparse.Sparse C2HSImp.CDouble)

objective function f : R^n -> R

-> (V.Vector (Sparse.Sparse C2HSImp.CDouble) -> V.Vector (Sparse.Sparse C2HSImp.CDouble))

constraint functions g : R^n -> R^m

-> IO IpProblem

this is 50% slower than createIpoptProblemAD in one instance http://code.haskell.org/~aavogt/ipopt-hs/examples/bench.html#williams-otto-process). But the benefit is that no RankN types are used (so it is possible to implement more functions without having to modify AnyRFCxt)

solve

ipoptSolve

Arguments

:: VG.Vector v Double

=> IpProblem

-> Vec

starting point x. Note that the value is overwritten with the final x.

-> IO (IpOptSolved v)

data IpOptSolved v

lenses are in Ipopt.PP

Constructors

IpOptSolved

Fields

_ipOptSolved_status :: ApplicationReturnStatus

_ipOptSolved_objective :: Double

_ipOptSolved_x, _ipOptSolved_g, _ipOptSolved_mult_g, _ipOptSolved_mult_x_L, _ipOptSolved_mult_x_U :: v Double

solver options

addIpoptNumOption :: IpProblem -> String -> Double -> IO Bool

addIpoptStrOption :: IpProblem -> String -> String -> IO Bool

addIpoptIntOption :: IpProblem -> String -> Int -> IO Bool

openIpoptOutputFile :: IpProblem -> String -> Int -> IO Bool

types

type Vec = VM.IOVector Double

Vector of numbers

type IpNumber = C2HSImp.CDouble

type IpIndex = C2HSImp.CInt

type IpInt = C2HSImp.CInt

type IpBool = C2HSImp.CInt

type IpF = C2HSImp.FunPtr (C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CDouble -> C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CDouble -> C2HSImp.Ptr () -> IO C2HSImp.CInt)

type IpGradF = C2HSImp.FunPtr (C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CDouble -> C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CDouble -> C2HSImp.Ptr () -> IO C2HSImp.CInt)

type IpG = C2HSImp.FunPtr (C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CDouble -> C2HSImp.CInt -> C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CDouble -> C2HSImp.Ptr () -> IO C2HSImp.CInt)

type IpJacG = C2HSImp.FunPtr (C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CDouble -> C2HSImp.CInt -> C2HSImp.CInt -> C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CDouble -> C2HSImp.Ptr () -> IO C2HSImp.CInt)

type IpH = C2HSImp.FunPtr (C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CDouble -> C2HSImp.CInt -> C2HSImp.CDouble -> C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CDouble -> C2HSImp.CInt -> C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CInt -> C2HSImp.Ptr C2HSImp.CDouble -> C2HSImp.Ptr () -> IO C2HSImp.CInt)

newtype IpProblem

Constructors

IpProblem (C2HSImp.ForeignPtr IpProblem)

type IntermediateCB

Arguments

 = C2HSImp.CInt

alg_mod (0 regular, 1 is resto)

-> C2HSImp.CInt

iter count

-> Double

obj value

-> Double

inf_pr

-> Double

inf_du

-> Double

mu

-> Double

d_norm

-> Double

regularization_size

-> Double

alpha_du

-> Double

alpha_pr

-> C2HSImp.CInt

ls_trials

-> C2HSImp.Ptr ()

user_data (usually null)

-> IO IpBool

data ApplicationReturnStatus

Constructors

InternalError

InsufficientMemory

NonipoptExceptionThrown

UnrecoverableException

InvalidNumberDetected

InvalidOption

InvalidProblemDefinition

NotEnoughDegreesOfFreedom

MaximumCputimeExceeded

ErrorInStepComputation

RestorationFailed

MaximumIterationsExceeded

SolveSucceeded

SolvedToAcceptableLevel

InfeasibleProblemDetected

SearchDirectionBecomesTooSmall

DivergingIterates

UserRequestedStop

FeasiblePointFound

Instances

Enum ApplicationReturnStatus

Show ApplicationReturnStatus

lower-level parts of the binding

createIpoptProblem :: Vec -> Vec -> Vec -> Vec -> Int -> Int -> IpF -> IpG -> IpGradF -> IpJacG -> IpH -> IO IpProblem

freeIpoptProblem :: C2HSImp.FunPtr (C2HSImp.Ptr () -> IO ())

setIpoptProblemScaling :: IpProblem -> Double -> Vec -> Vec -> IO Bool

setIntermediateCallback :: IpProblem -> IntermediateCB -> IO Bool

marshalling functions

wrapIpF :: (VM.MVector s C2HSImp.CDouble -> IO C2HSImp.CDouble) -> IO IpF

wrapIpGradF :: (VM.MVector s C2HSImp.CDouble -> IO (VM.MVector RealWorld C2HSImp.CDouble)) -> IO IpGradF

wrapIpG :: (VM.MVector s C2HSImp.CDouble -> IO (VM.MVector RealWorld C2HSImp.CDouble)) -> IO IpG

wrapIpJacG :: (VM.MVector s C2HSImp.CInt -> VM.MVector s1 C2HSImp.CInt -> IO b) -> (VM.MVector s2 C2HSImp.CDouble -> VM.MVector s3 C2HSImp.CDouble -> IO b1) -> IO IpJacG

wrapIpH :: (VM.MVector s3 C2HSImp.CInt -> VM.MVector s4 C2HSImp.CInt -> IO b1) -> (C2HSImp.CDouble -> VM.MVector s C2HSImp.CDouble -> VM.MVector s1 C2HSImp.CDouble -> VM.MVector s2 C2HSImp.CDouble -> IO b) -> IO IpH

wrapIpF1 :: UnFunPtr IpF -> IO IpF

wrapIpGradF1 :: UnFunPtr IpGradF -> IO IpGradF

wrapIpG1 :: UnFunPtr IpG -> IO IpG

wrapIpJacG1 :: UnFunPtr IpJacG -> IO IpJacG

wrapIpH1 :: UnFunPtr IpH -> IO IpH

wrapIpF2 :: (Integral a2, Storable a, Storable a1) => (VM.MVector s a1 -> IO a) -> a2 -> C2HSImp.Ptr a1 -> t -> C2HSImp.Ptr a -> t1 -> IO IpBool

wrapIpGradF2 :: (Integral a2, Storable a, Storable a1) => (VM.MVector s a1 -> IO (VM.MVector RealWorld a)) -> a2 -> C2HSImp.Ptr a1 -> t -> C2HSImp.Ptr a -> t1 -> IO IpBool

wrapIpG2 :: (Integral a1, Integral a3, Storable a, Storable a2) => (VM.MVector s a2 -> IO (VM.MVector RealWorld a)) -> a3 -> C2HSImp.Ptr a2 -> t -> a1 -> C2HSImp.Ptr a -> t1 -> IO IpBool

wrapIpJacG2 :: (Integral a3, Integral a5, Storable a, Storable a1, Storable a2, Storable a4) => (VM.MVector s a -> VM.MVector s1 a1 -> IO b) -> (VM.MVector s2 a2 -> VM.MVector s3 a4 -> IO b1) -> a3 -> C2HSImp.Ptr a2 -> t -> t1 -> a5 -> C2HSImp.Ptr a -> C2HSImp.Ptr a1 -> C2HSImp.Ptr a4 -> t2 -> IO IpBool

wrapIpH2 :: (Integral a1, Integral a3, Integral a7, Storable a, Storable a2, Storable a4, Storable a5, Storable a6) => (VM.MVector s3 a5 -> VM.MVector s4 a6 -> IO b1) -> (t3 -> VM.MVector s a -> VM.MVector s1 a2 -> VM.MVector s2 a4 -> IO b) -> a3 -> C2HSImp.Ptr a2 -> t -> t3 -> a1 -> C2HSImp.Ptr a -> t1 -> a7 -> C2HSImp.Ptr a5 -> C2HSImp.Ptr a6 -> C2HSImp.Ptr a4 -> t2 -> IO IpBool