Numeric.Optimization

This module aims to provide unified interface to various numerical optimization, like scipy.optimize in Python.

In this module, you need to explicitly provide the function to calculate the gradient, but you can use numeric-optimization-ad or numeric-optimization-backprop to define it using automatic differentiation.

Main function

minimize

Arguments

:: forall prob. (IsProblem prob, Optionally (HasGrad prob), Optionally (HasHessian prob))

=> Method

Numerical optimization algorithm to use

-> Params (Vector Double)

Parameters for optimization algorithms. Use def as a default.

-> prob

Optimization problem to solve

-> Vector Double

Initial value

-> IO (Result (Vector Double))

Minimization of scalar function of one or more variables.

This function is intended to provide functionality similar to Python's scipy.optimize.minimize.

Example:

{-# LANGUAGE OverloadedLists #-}

import Data.Vector.Storable (Vector)
import Numeric.Optimization

main :: IO ()
main = do
  (x, result, stat) <- minimize LBFGS def (WithGrad rosenbrock rosenbrock') [-3,-4]
  print (resultSuccess result)  -- True
  print (resultSolution result)  -- [0.999999999009131,0.9999999981094296]
  print (resultValue result)  -- 1.8129771632403013e-18

-- https://en.wikipedia.org/wiki/Rosenbrock_function
rosenbrock :: Vector Double -> Double
rosenbrock [x,y] = sq (1 - x) + 100 * sq (y - sq x)

rosenbrock' :: Vector Double -> Vector Double
rosenbrock' [x,y] =
  [ 2 * (1 - x) * (-1) + 100 * 2 * (y - sq x) * (-2) * x
  , 100 * 2 * (y - sq x)
  ]

sq :: Floating a => a -> a
sq x = x ** 2

Problem specification

Problems are specified by types of IsProblem type class.

In the simplest case, Vector Double -> Double is a instance of IsProblem class. It is enough if your problem does not have constraints and the selected algorithm does not require further information (e.g. gradients and hessians),

You can equip a problem with other information using wrapper types:

• WithBounds
• WithConstraints
• WithGrad
• WithHessian

If you need further flexibility or efficient implementation, you can define instance of IsProblem by yourself.

class IsProblem prob where

Optimization problems

Minimal complete definition

func

Methods

func :: prob -> Vector Double -> Double

Objective function

It is called fun in scipy.optimize.minimize.

bounds :: prob -> Maybe (Vector (Double, Double))

Bounds

constraints :: prob -> [Constraint]

Constraints

Instances

IsProblem prob => IsProblem (WithBounds prob)

Defined in Numeric.Optimization

Methods

func :: WithBounds prob -> Vector Double -> Double

bounds :: WithBounds prob -> Maybe (Vector (Double, Double))

constraints :: WithBounds prob -> [Constraint]

IsProblem prob => IsProblem (WithConstraints prob)

Defined in Numeric.Optimization

Methods

func :: WithConstraints prob -> Vector Double -> Double

bounds :: WithConstraints prob -> Maybe (Vector (Double, Double))

constraints :: WithConstraints prob -> [Constraint]

IsProblem prob => IsProblem (WithGrad prob)

Defined in Numeric.Optimization

Methods

func :: WithGrad prob -> Vector Double -> Double

bounds :: WithGrad prob -> Maybe (Vector (Double, Double))

constraints :: WithGrad prob -> [Constraint]

IsProblem prob => IsProblem (WithHessian prob)

Defined in Numeric.Optimization

Methods

func :: WithHessian prob -> Vector Double -> Double

bounds :: WithHessian prob -> Maybe (Vector (Double, Double))

constraints :: WithHessian prob -> [Constraint]

IsProblem (Vector Double -> Double)

Defined in Numeric.Optimization

Methods

func :: (Vector Double -> Double) -> Vector Double -> Double

bounds :: (Vector Double -> Double) -> Maybe (Vector0 (Double, Double))

constraints :: (Vector Double -> Double) -> [Constraint]

class IsProblem prob => HasGrad prob where

Optimization problem equipped with gradient information

Minimal complete definition

grad | grad' | grad'M

Methods

grad :: prob -> Vector Double -> Vector Double

Gradient of a function computed by func

It is called jac in scipy.optimize.minimize.

grad' :: prob -> Vector Double -> (Double, Vector Double)

Pair of func and grad

grad'M :: PrimMonad m => prob -> Vector Double -> MVector (PrimState m) Double -> m Double

Similar to grad' but destination passing style is used for gradient vector

Instances

HasGrad prob => HasGrad (WithBounds prob)

Defined in Numeric.Optimization

Methods

grad :: WithBounds prob -> Vector Double -> Vector Double

grad' :: WithBounds prob -> Vector Double -> (Double, Vector Double)

grad'M :: PrimMonad m => WithBounds prob -> Vector Double -> MVector (PrimState m) Double -> m Double

HasGrad prob => HasGrad (WithConstraints prob)

Defined in Numeric.Optimization

Methods

grad :: WithConstraints prob -> Vector Double -> Vector Double

grad' :: WithConstraints prob -> Vector Double -> (Double, Vector Double)

grad'M :: PrimMonad m => WithConstraints prob -> Vector Double -> MVector (PrimState m) Double -> m Double

IsProblem prob => HasGrad (WithGrad prob)

Defined in Numeric.Optimization

Methods

grad :: WithGrad prob -> Vector Double -> Vector Double

grad' :: WithGrad prob -> Vector Double -> (Double, Vector Double)

grad'M :: PrimMonad m => WithGrad prob -> Vector Double -> MVector (PrimState m) Double -> m Double

HasGrad prob => HasGrad (WithHessian prob)

Defined in Numeric.Optimization

Methods

grad :: WithHessian prob -> Vector Double -> Vector Double

grad' :: WithHessian prob -> Vector Double -> (Double, Vector Double)

grad'M :: PrimMonad m => WithHessian prob -> Vector Double -> MVector (PrimState m) Double -> m Double

Optionally (HasGrad prob) => Optionally (HasGrad (WithBounds prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasGrad (WithBounds prob)))

Optionally (HasGrad prob) => Optionally (HasGrad (WithConstraints prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasGrad (WithConstraints prob)))

IsProblem prob => Optionally (HasGrad (WithGrad prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasGrad (WithGrad prob)))

Optionally (HasGrad prob) => Optionally (HasGrad (WithHessian prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasGrad (WithHessian prob)))

Optionally (HasGrad (Vector Double -> Double))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasGrad (Vector Double -> Double)))

class IsProblem prob => HasHessian prob where

Optimization problem equipped with hessian information

Minimal complete definition

hessian

Methods

hessian :: prob -> Vector Double -> Matrix Double

Hessian of a function computed by func

It is called hess in scipy.optimize.minimize.

hessianProduct :: prob -> Vector Double -> Vector Double -> Vector Double

The product of the hessian H of a function f at x with a vector x.

It is called hessp in scipy.optimize.minimize.

See also https://hackage.haskell.org/package/ad-4.5.4/docs/Numeric-AD.html#v:hessianProduct.

Instances

HasHessian prob => HasHessian (WithBounds prob)

Defined in Numeric.Optimization

Methods

hessian :: WithBounds prob -> Vector Double -> Matrix Double

hessianProduct :: WithBounds prob -> Vector Double -> Vector Double -> Vector Double

HasHessian prob => HasHessian (WithConstraints prob)

Defined in Numeric.Optimization

Methods

hessian :: WithConstraints prob -> Vector Double -> Matrix Double

hessianProduct :: WithConstraints prob -> Vector Double -> Vector Double -> Vector Double

HasHessian prob => HasHessian (WithGrad prob)

Defined in Numeric.Optimization

Methods

hessian :: WithGrad prob -> Vector Double -> Matrix Double

hessianProduct :: WithGrad prob -> Vector Double -> Vector Double -> Vector Double

IsProblem prob => HasHessian (WithHessian prob)

Defined in Numeric.Optimization

Methods

hessian :: WithHessian prob -> Vector Double -> Matrix Double

hessianProduct :: WithHessian prob -> Vector Double -> Vector Double -> Vector Double

Optionally (HasHessian prob) => Optionally (HasHessian (WithBounds prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasHessian (WithBounds prob)))

Optionally (HasHessian prob) => Optionally (HasHessian (WithConstraints prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasHessian (WithConstraints prob)))

Optionally (HasHessian prob) => Optionally (HasHessian (WithGrad prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasHessian (WithGrad prob)))

IsProblem prob => Optionally (HasHessian (WithHessian prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasHessian (WithHessian prob)))

Optionally (HasHessian (Vector Double -> Double))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasHessian (Vector Double -> Double)))

data Constraint

Type of constraint

Currently, no constraints are supported.

boundsUnconstrained :: Int -> Vector (Double, Double)

Bounds for unconstrained problems, i.e. (-∞,+∞).

isUnconstainedBounds :: Vector (Double, Double) -> Bool

Whether all lower bounds are -∞ and all upper bounds are +∞.

Wrapper types

data WithGrad prob

Wrapper type for adding gradient function to a problem

Constructors

WithGrad prob (Vector Double -> Vector Double)

Instances

IsProblem prob => HasGrad (WithGrad prob)

Defined in Numeric.Optimization

Methods

grad :: WithGrad prob -> Vector Double -> Vector Double

grad' :: WithGrad prob -> Vector Double -> (Double, Vector Double)

grad'M :: PrimMonad m => WithGrad prob -> Vector Double -> MVector (PrimState m) Double -> m Double

HasHessian prob => HasHessian (WithGrad prob)

Defined in Numeric.Optimization

Methods

hessian :: WithGrad prob -> Vector Double -> Matrix Double

hessianProduct :: WithGrad prob -> Vector Double -> Vector Double -> Vector Double

IsProblem prob => IsProblem (WithGrad prob)

Defined in Numeric.Optimization

Methods

func :: WithGrad prob -> Vector Double -> Double

bounds :: WithGrad prob -> Maybe (Vector (Double, Double))

constraints :: WithGrad prob -> [Constraint]

IsProblem prob => Optionally (HasGrad (WithGrad prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasGrad (WithGrad prob)))

Optionally (HasHessian prob) => Optionally (HasHessian (WithGrad prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasHessian (WithGrad prob)))

data WithHessian prob

Wrapper type for adding hessian to a problem

Constructors

WithHessian prob (Vector Double -> Matrix Double)

Instances

HasGrad prob => HasGrad (WithHessian prob)

Defined in Numeric.Optimization

Methods

grad :: WithHessian prob -> Vector Double -> Vector Double

grad' :: WithHessian prob -> Vector Double -> (Double, Vector Double)

grad'M :: PrimMonad m => WithHessian prob -> Vector Double -> MVector (PrimState m) Double -> m Double

IsProblem prob => HasHessian (WithHessian prob)

Defined in Numeric.Optimization

Methods

hessian :: WithHessian prob -> Vector Double -> Matrix Double

hessianProduct :: WithHessian prob -> Vector Double -> Vector Double -> Vector Double

IsProblem prob => IsProblem (WithHessian prob)

Defined in Numeric.Optimization

Methods

func :: WithHessian prob -> Vector Double -> Double

bounds :: WithHessian prob -> Maybe (Vector (Double, Double))

constraints :: WithHessian prob -> [Constraint]

Optionally (HasGrad prob) => Optionally (HasGrad (WithHessian prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasGrad (WithHessian prob)))

IsProblem prob => Optionally (HasHessian (WithHessian prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasHessian (WithHessian prob)))

data WithBounds prob

Wrapper type for adding bounds to a problem

Constructors

WithBounds prob (Vector (Double, Double))

Instances

HasGrad prob => HasGrad (WithBounds prob)

Defined in Numeric.Optimization

Methods

grad :: WithBounds prob -> Vector Double -> Vector Double

grad' :: WithBounds prob -> Vector Double -> (Double, Vector Double)

grad'M :: PrimMonad m => WithBounds prob -> Vector Double -> MVector (PrimState m) Double -> m Double

HasHessian prob => HasHessian (WithBounds prob)

Defined in Numeric.Optimization

Methods

hessian :: WithBounds prob -> Vector Double -> Matrix Double

hessianProduct :: WithBounds prob -> Vector Double -> Vector Double -> Vector Double

IsProblem prob => IsProblem (WithBounds prob)

Defined in Numeric.Optimization

Methods

func :: WithBounds prob -> Vector Double -> Double

bounds :: WithBounds prob -> Maybe (Vector (Double, Double))

constraints :: WithBounds prob -> [Constraint]

Optionally (HasGrad prob) => Optionally (HasGrad (WithBounds prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasGrad (WithBounds prob)))

Optionally (HasHessian prob) => Optionally (HasHessian (WithBounds prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasHessian (WithBounds prob)))

data WithConstraints prob

Wrapper type for adding constraints to a problem

Constructors

WithConstraints prob [Constraint]

Instances

HasGrad prob => HasGrad (WithConstraints prob)

Defined in Numeric.Optimization

Methods

grad :: WithConstraints prob -> Vector Double -> Vector Double

grad' :: WithConstraints prob -> Vector Double -> (Double, Vector Double)

grad'M :: PrimMonad m => WithConstraints prob -> Vector Double -> MVector (PrimState m) Double -> m Double

HasHessian prob => HasHessian (WithConstraints prob)

Defined in Numeric.Optimization

Methods

hessian :: WithConstraints prob -> Vector Double -> Matrix Double

hessianProduct :: WithConstraints prob -> Vector Double -> Vector Double -> Vector Double

IsProblem prob => IsProblem (WithConstraints prob)

Defined in Numeric.Optimization

Methods

func :: WithConstraints prob -> Vector Double -> Double

bounds :: WithConstraints prob -> Maybe (Vector (Double, Double))

constraints :: WithConstraints prob -> [Constraint]

Optionally (HasGrad prob) => Optionally (HasGrad (WithConstraints prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasGrad (WithConstraints prob)))

Optionally (HasHessian prob) => Optionally (HasHessian (WithConstraints prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasHessian (WithConstraints prob)))

Algorithm selection

data Method

Selection of numerical optimization algorithms

Constructors

CGDescent

Conjugate gradient method based on Hager and Zhang [1].

The implementation is provided by nonlinear-optimization package [3] which is a binding library of [2].

This method requires gradient but does not require hessian.

• [1] Hager, W. W. and Zhang, H. A new conjugate gradient method with guaranteed descent and an efficient line search. Society of Industrial and Applied Mathematics Journal on Optimization, 16 (2005), 170-192.
• [2] https://www.math.lsu.edu/~hozhang/SoftArchive/CG_DESCENT-C-3.0.tar.gz
• [3] https://hackage.haskell.org/package/nonlinear-optimization

LBFGS

Limited memory BFGS (L-BFGS) algorithm [1]

The implementtion is provided by lbfgs package [2] which is a binding of liblbfgs [3].

This method requires gradient but does not require hessian.

• [1] https://en.wikipedia.org/wiki/Limited-memory_BFGS
• [2] https://hackage.haskell.org/package/lbfgs
• [3] https://github.com/chokkan/liblbfgs

LBFGSB

Limited memory BFGS algorithm with bound constraints (L-BFGS-B) [1][2][3]

The implementation is provided by l-bfgs-b package [4] which is a bindign to L-BFGS-B fortran code [5].

• [1] R. H. Byrd, P. Lu and J. Nocedal. A Limited Memory Algorithm for Bound Constrained Optimization, (1995), SIAM Journal on Scientific and Statistical Computing , 16, 5, pp. 1190-1208.
• [2] C. Zhu, R. H. Byrd and J. Nocedal. L-BFGS-B: Algorithm 778: L-BFGS-B, FORTRAN routines for large scale bound constrained optimization (1997), ACM Transactions on Mathematical Software, Vol 23, Num. 4, pp. 550-560.
• [3] J. L. Morales and J. Nocedal. L-BFGS-B: Remark on Algorithm 778: L-BFGS-B, FORTRAN routines for large scale bound constrained optimization (2011), ACM Transactions on Mathematical Software, Vol 38, Num. 7, pp. 1–4
• [4] https://hackage.haskell.org/package/l-bfgs-b
• [5] http://users.iems.northwestern.edu/~nocedal/lbfgsb.html

Since: 0.1.1.0

Newton

Naïve implementation of Newton method in Haskell

This method requires both gradient and hessian.

Instances

Bounded Method

Defined in Numeric.Optimization

Methods

minBound :: Method

maxBound :: Method

Enum Method

Defined in Numeric.Optimization

Methods

succ :: Method -> Method

pred :: Method -> Method

toEnum :: Int -> Method

fromEnum :: Method -> Int

enumFrom :: Method -> [Method]

enumFromThen :: Method -> Method -> [Method]

enumFromTo :: Method -> Method -> [Method]

enumFromThenTo :: Method -> Method -> Method -> [Method]

Show Method

Defined in Numeric.Optimization

Methods

showsPrec :: Int -> Method -> ShowS

show :: Method -> String

showList :: [Method] -> ShowS

Eq Method

Defined in Numeric.Optimization

Methods

(==) :: Method -> Method -> Bool

(/=) :: Method -> Method -> Bool

Ord Method

Defined in Numeric.Optimization

Methods

compare :: Method -> Method -> Ordering

(<) :: Method -> Method -> Bool

(<=) :: Method -> Method -> Bool

(>) :: Method -> Method -> Bool

(>=) :: Method -> Method -> Bool

max :: Method -> Method -> Method

min :: Method -> Method -> Method

isSupportedMethod :: Method -> Bool

Whether a Method is supported under the current environment.

data Params a

Parameters for optimization algorithms

TODO:

• Better way to pass algorithm specific parameters?
• Separate paramsCallback from other more concrete serializeable parameters?

Constructors

Params

Fields

• paramsCallback :: Maybe (a -> IO Bool)

  If callback function returns True, the algorithm execution is terminated.

• paramsTol :: Maybe Double

  Tolerance for termination. When tol is specified, the selected algorithm sets some relevant solver-specific tolerance(s) equal to tol.

  If specified, this value is used as defaults for paramsFTol and paramsGTol.

• paramsFTol :: Maybe Double

  LBFGS stops iteration when delta-based convergence test (see paramsPast) is enabled and the following condition is met:

  \[ \left|\frac{f' - f}{f}\right| < \mathrm{ftol}, \]

  where f' is the objective value of past (paramsPast) iterations ago, and f is the objective value of the current iteration. The default value is 1e-5.

  LBFGSB stops iteration when the following condition is met:

  \[ \frac{f^k - f^{k+1}}{\mathrm{max}\{|f^k|,|f^{k+1}|,1\}} \le \mathrm{ftol}. \]

  The default value is 1e7 * (epsilon :: Double) = 2.220446049250313e-9.

  Since: 0.1.1.0

• paramsGTol :: Maybe Double

  LBFGSB stops iteration when \(\mathrm{max}\{|\mathrm{pg}_i| \mid i = 1, \ldots, n\} \le \mathrm{gtol}\) where \(\mathrm{pg}_i\) is the i-th component of the projected gradient.

  Since: 0.1.1.0

• paramsMaxIters :: Maybe Int

  Maximum number of iterations.

  Currently only LBFGSB, CGDescent, and Newton uses this.

  Since: 0.1.1.0

• paramsPast :: Maybe Int

  Distance for delta-based convergence test in LBFGS

  This parameter determines the distance, in iterations, to compute the rate of decrease of the objective function. If the value of this parameter is Nothing, the library does not perform the delta-based convergence test. The default value is Nothing.

  Since: 0.1.1.0

• paramsMaxCorrections :: Maybe Int

  The maximum number of variable metric corrections used in LBFGSB to define the limited memory matrix.

  Since: 0.1.1.0

Instances

Contravariant Params

Defined in Numeric.Optimization

Methods

contramap :: (a' -> a) -> Params a -> Params a'

(>$) :: b -> Params b -> Params a

Default (Params a)

Defined in Numeric.Optimization

Methods

def :: Params a

Result

data Result a

Optimization result

Constructors

Result

Fields

• resultSuccess :: Bool

  Whether or not the optimizer exited successfully.

• resultMessage :: String

  Description of the cause of the termination.

• resultSolution :: a

  Solution

• resultValue :: Double

  Value of the function at the solution.

• resultGrad :: Maybe a

  Gradient at the solution

• resultHessian :: Maybe (Matrix Double)

  Hessian at the solution; may be an approximation.

• resultHessianInv :: Maybe (Matrix Double)

  Inverse of Hessian at the solution; may be an approximation.

• resultStatistics :: Statistics

  Statistics of optimizaion process

Instances

Functor Result

Defined in Numeric.Optimization

Methods

fmap :: (a -> b) -> Result a -> Result b

(<$) :: a -> Result b -> Result a

Show a => Show (Result a)

Defined in Numeric.Optimization

Methods

showsPrec :: Int -> Result a -> ShowS

show :: Result a -> String

showList :: [Result a] -> ShowS

data Statistics

Statistics of optimizaion process

Constructors

Statistics

Fields

• totalIters :: Int

  Total number of iterations.

• funcEvals :: Int

  Total number of function evaluations.

• gradEvals :: Int

  Total number of gradient evaluations.

• hessianEvals :: Int

  Total number of hessian evaluations.

• hessEvals :: Int

  Deprecated: Use hessianEvals instead

  Total number of hessian evaluations.

Instances

Show Statistics

Defined in Numeric.Optimization

Methods

showsPrec :: Int -> Statistics -> ShowS

show :: Statistics -> String

showList :: [Statistics] -> ShowS

data OptimizationException

The bad things that can happen when you use the library.

Constructors

UnsupportedProblem String

UnsupportedMethod Method

GradUnavailable

HessianUnavailable

Instances

Exception OptimizationException

Defined in Numeric.Optimization

Methods

toException :: OptimizationException -> SomeException

fromException :: SomeException -> Maybe OptimizationException

displayException :: OptimizationException -> String

Show OptimizationException

Defined in Numeric.Optimization

Methods

showsPrec :: Int -> OptimizationException -> ShowS

show :: OptimizationException -> String

showList :: [OptimizationException] -> ShowS

Eq OptimizationException

Defined in Numeric.Optimization

Methods

(==) :: OptimizationException -> OptimizationException -> Bool

(/=) :: OptimizationException -> OptimizationException -> Bool

Utilities and Re-export

class Default a where

A class for types with a default value.

Minimal complete definition

Nothing

Methods

def :: a

The default value for this type.

Instances

Default All

Defined in Data.Default.Class

Methods

def :: All

Default Any

Defined in Data.Default.Class

Methods

def :: Any

Default CClock

Defined in Data.Default.Class

Methods

def :: CClock

Default CDouble

Defined in Data.Default.Class

Methods

def :: CDouble

Default CFloat

Defined in Data.Default.Class

Methods

def :: CFloat

Default CInt

Defined in Data.Default.Class

Methods

def :: CInt

Default CIntMax

Defined in Data.Default.Class

Methods

def :: CIntMax

Default CIntPtr

Defined in Data.Default.Class

Methods

def :: CIntPtr

Default CLLong

Defined in Data.Default.Class

Methods

def :: CLLong

Default CLong

Defined in Data.Default.Class

Methods

def :: CLong

Default CPtrdiff

Defined in Data.Default.Class

Methods

def :: CPtrdiff

Default CSUSeconds

Defined in Data.Default.Class

Methods

def :: CSUSeconds

Default CShort

Defined in Data.Default.Class

Methods

def :: CShort

Default CSigAtomic

Defined in Data.Default.Class

Methods

def :: CSigAtomic

Default CSize

Defined in Data.Default.Class

Methods

def :: CSize

Default CTime

Defined in Data.Default.Class

Methods

def :: CTime

Default CUInt

Defined in Data.Default.Class

Methods

def :: CUInt

Default CUIntMax

Defined in Data.Default.Class

Methods

def :: CUIntMax

Default CUIntPtr

Defined in Data.Default.Class

Methods

def :: CUIntPtr

Default CULLong

Defined in Data.Default.Class

Methods

def :: CULLong

Default CULong

Defined in Data.Default.Class

Methods

def :: CULong

Default CUSeconds

Defined in Data.Default.Class

Methods

def :: CUSeconds

Default CUShort

Defined in Data.Default.Class

Methods

def :: CUShort

Default Int16

Defined in Data.Default.Class

Methods

def :: Int16

Default Int32

Defined in Data.Default.Class

Methods

def :: Int32

Default Int64

Defined in Data.Default.Class

Methods

def :: Int64

Default Int8

Defined in Data.Default.Class

Methods

def :: Int8

Default Word16

Defined in Data.Default.Class

Methods

def :: Word16

Default Word32

Defined in Data.Default.Class

Methods

def :: Word32

Default Word64

Defined in Data.Default.Class

Methods

def :: Word64

Default Word8

Defined in Data.Default.Class

Methods

def :: Word8

Default Ordering

Defined in Data.Default.Class

Methods

def :: Ordering

Default Integer

Defined in Data.Default.Class

Methods

def :: Integer

Default ()

Defined in Data.Default.Class

Methods

def :: ()

Default Double

Defined in Data.Default.Class

Methods

def :: Double

Default Float

Defined in Data.Default.Class

Methods

def :: Float

Default Int

Defined in Data.Default.Class

Methods

def :: Int

Default Word

Defined in Data.Default.Class

Methods

def :: Word

(Default a, RealFloat a) => Default (Complex a)

Defined in Data.Default.Class

Methods

def :: Complex a

Default (First a)

Defined in Data.Default.Class

Methods

def :: First a

Default (Last a)

Defined in Data.Default.Class

Methods

def :: Last a

Default a => Default (Dual a)

Defined in Data.Default.Class

Methods

def :: Dual a

Default (Endo a)

Defined in Data.Default.Class

Methods

def :: Endo a

Num a => Default (Product a)

Defined in Data.Default.Class

Methods

def :: Product a

Num a => Default (Sum a)

Defined in Data.Default.Class

Methods

def :: Sum a

Integral a => Default (Ratio a)

Defined in Data.Default.Class

Methods

def :: Ratio a

Default a => Default (IO a)

Defined in Data.Default.Class

Methods

def :: IO a

Default (Params a)

Defined in Numeric.Optimization

Methods

def :: Params a

Default (Maybe a)

Defined in Data.Default.Class

Methods

def :: Maybe a

Default [a]

Defined in Data.Default.Class

Methods

def :: [a]

Default r => Default (e -> r)

Defined in Data.Default.Class

Methods

def :: e -> r

(Default a, Default b) => Default (a, b)

Defined in Data.Default.Class

Methods

def :: (a, b)

(Default a, Default b, Default c) => Default (a, b, c)

Defined in Data.Default.Class

Methods

def :: (a, b, c)

(Default a, Default b, Default c, Default d) => Default (a, b, c, d)

Defined in Data.Default.Class

Methods

def :: (a, b, c, d)

(Default a, Default b, Default c, Default d, Default e) => Default (a, b, c, d, e)

Defined in Data.Default.Class

Methods

def :: (a, b, c, d, e)

(Default a, Default b, Default c, Default d, Default e, Default f) => Default (a, b, c, d, e, f)

Defined in Data.Default.Class

Methods

def :: (a, b, c, d, e, f)

(Default a, Default b, Default c, Default d, Default e, Default f, Default g) => Default (a, b, c, d, e, f, g)

Defined in Data.Default.Class

Methods

def :: (a, b, c, d, e, f, g)

class Optionally c where

Optional constraint

Methods

optionalDict :: Maybe (Dict c)

Instances

Optionally (HasGrad prob) => Optionally (HasGrad (WithBounds prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasGrad (WithBounds prob)))

Optionally (HasGrad prob) => Optionally (HasGrad (WithConstraints prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasGrad (WithConstraints prob)))

IsProblem prob => Optionally (HasGrad (WithGrad prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasGrad (WithGrad prob)))

Optionally (HasGrad prob) => Optionally (HasGrad (WithHessian prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasGrad (WithHessian prob)))

Optionally (HasGrad (Vector Double -> Double))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasGrad (Vector Double -> Double)))

Optionally (HasHessian prob) => Optionally (HasHessian (WithBounds prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasHessian (WithBounds prob)))

Optionally (HasHessian prob) => Optionally (HasHessian (WithConstraints prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasHessian (WithConstraints prob)))

Optionally (HasHessian prob) => Optionally (HasHessian (WithGrad prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasHessian (WithGrad prob)))

IsProblem prob => Optionally (HasHessian (WithHessian prob))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasHessian (WithHessian prob)))

Optionally (HasHessian (Vector Double -> Double))

Defined in Numeric.Optimization

Methods

optionalDict :: Maybe (Dict (HasHessian (Vector Double -> Double)))

hasOptionalDict :: c => Maybe (Dict c)

Utility function to define Optionally instances