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 => Vector a -> a)

objective function f : R^n -> R

-> (forall a. AnyRFCxt a => Vector a -> 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 the example Test2.hs for details of setting up the vectors supplied.

solve

ipoptSolve

Arguments

:: 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 :: v Double

_ipOptSolved_g :: v Double

_ipOptSolved_mult_g :: v Double

_ipOptSolved_mult_x_L :: v Double

_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 = IOVector Double

Vector of numbers

type IpNumber = CDouble

type IpIndex = CInt

type IpInt = CInt

type IpBool = CInt

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

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

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

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

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

newtype IpProblem

Constructors

IpProblem (ForeignPtr IpProblem)

type IntermediateCB

Arguments

 = CInt

alg_mod (0 regular, 1 is resto)

-> 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

-> CInt

ls_trials

-> Ptr ()

user_data (usually null)

-> IO IpBool

data ApplicationReturnStatus

Constructors

SolveSucceeded

SolvedToAcceptableLevel

InfeasibleProblemDetected

SearchDirectionBecomesTooSmall

DivergingIterates

UserRequestedStop

FeasiblePointFound

MaximumIterationsExceeded

RestorationFailed

ErrorInStepComputation

MaximumCputimeExceeded

NotEnoughDegreesOfFreedom

InvalidProblemDefinition

InvalidOption

InvalidNumberDetected

UnrecoverableException

NonipoptExceptionThrown

InsufficientMemory

InternalError

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 :: FunPtr (Ptr () -> IO ())

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

setIntermediateCallback :: IpProblem -> IntermediateCB -> IO Bool

marshalling functions

wrapIpF :: (MVector s CDouble -> IO CDouble) -> IO IpF

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

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

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

wrapIpH :: (MVector s3 CInt -> MVector s4 CInt -> IO b1) -> (CDouble -> MVector s CDouble -> MVector s1 CDouble -> MVector s2 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) => (MVector s a1 -> IO a) -> a2 -> Ptr a1 -> t -> Ptr a -> t1 -> IO IpBool

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

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

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

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