conopt.f90

Go to the documentation of this file.

!  CONOPT Fortran API
!
!  Copyright (C) 1995-2025 GAMS Software GmbH
!  Copyright (C) 1995-2025 GAMS Development Corporation
 
!> @file conopt.f90
!! @ingroup PUBLICAPI_FILES
!! @brief public Fortran API source file
 
#if defined(_WIN32) && !defined(_WIN64)
#define dec_directives_win32
#endif
 
module conopt
!
!  Definition of the interface for the CONOPT4 Library
!
!> @cond KEEP_F90_INTERFACE
   interface
!> @endcond
!
!  Routines used for initialization purposes
!
      !> @cond UNDOCUMENTED_F90API
      ! returns the size the Control Vector must have, measured in standard Integer units.
      function coidef_size( ) bind(c, name = "COIDEF_Size")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_Size
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int) :: COIDEF_Size
      end function coidef_size
      !> @endcond
 
      !> initializes the Control Vector by placing default values in the various positions.
      !! @attention Either this method or conopt::coi_create() must be called.
      !!
      !! There is currently no error checking and this method will always return 0.
      !!
      !! If you have multiple models with multiple Control Vectors then you must call either this method
      !! or conopt::coi_create() to create a control vector for each. If you solve a sequence of different
      !! models then you can use the same Control Vector provided you don't need to
      !! reinitialize it. If the control vector must be reinitialized, then it is
      !! necessary to call conopt::coi_free() followed by conopt::coi_create() between the
      !! solves.
      !!
      !! @param cntvect    the control vector
      !!
      !! @ingroup THE_CONTROL_VECTOR_F90
      function coidef_ini( CntVect ) bind(c, name = "COIDEF_Ini")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_Ini
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int) :: coidef_ini
      end function coidef_ini
 
      !> @cond UNDOCUMENTED_F90API
      !> initialisation method for Fortran applications.
      !!
      !! This method will initialise the control vector and set the parameters associated with the base and array indices.
      !!
      !! @param cntvect    the control vector
      !!
      !! @ingroup THE_CONTROL_VECTOR_F90
      !!
      function coidef_inifort( CntVect ) bind(c, name = "COIDEF_IniFort")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_IniFort
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int) :: coidef_inifort
      end function coidef_inifort
      !> @endcond
!
!  Routines used to register sizes
!
      !> defines the number of variables in the model.
      !! @attention Mandatory routine. The number must be positive.
      !!
      !! defines the number of variables in the model. The number does not include
      !! any slack or artificial variables.
      !!
      !! @param cntvect    the control vector
      !! @param numvar     the number of variables
      !!
      !! @ingroup REGISTRATION_OF_SIZES_F90
      !!
      function coidef_numvar( CntVect, NumVar ) bind(c, name = "COIDEF_NumVar")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_NumVar
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: numvar
         integer(c_int) :: coidef_numvar
      end function coidef_numvar
 
      !> defines the number of constraints in the model.
      !!
      !! @attention Mandatory routine. The number must be positive.
      !!
      !! defines the number of constraints in the model. The number includes the
      !! objective function if the objective is defined as an expression (see
      !! coidef_objcon() and coidef_objvar()).
      !!
      !! @param cntvect    the control vector
      !! @param numcon     the number of constraints
      !!
      !! @ingroup REGISTRATION_OF_SIZES_F90
      !!
      function coidef_numcon( CntVect, NumCon ) bind(c, name = "COIDEF_NumCon")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_NumCon
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: numcon
         integer(c_int) :: coidef_numcon
      end function coidef_numcon
 
      !> defines the number of nonzero elements in the Jacobian.
      !!
      !! @attention Mandatory routine. The number must be positive.
      !!
      !! defines the number of nonzero elements in the Jacobian of the model (the
      !! matrix of first derivatives of all constraints with respect to all variables).
      !!
      !! @param cntvect    the control vector
      !! @param numnz      the number of nonzero elements
      !!
      !! @ingroup REGISTRATION_OF_SIZES_F90
      !!
      function coidef_numnz( CntVect, NumNz ) bind(c, name = "COIDEF_NumNz")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_NumNz
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: numnz
         integer(c_int) :: coidef_numnz
      end function coidef_numnz
 
      !> defines the Number of Nonlinear Nonzeros.
      !!
      !! @attention Mandatory routine.
      !!
      !! defines the number of nonlinear nonzeros in the Jacobian. The number is zero
      !! if the model is linear and positive if the model is nonlinear.
      !!
      !! @param cntvect    the control vector
      !! @param numnlnz    the number of nonlinear nonzeros
      !!
      !! @ingroup REGISTRATION_OF_SIZES_F90
      !!
      function coidef_numnlnz( CntVect, NumNlNz ) bind(c, name = "COIDEF_NumNlNz")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_NumNlNz
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: numnlnz
         integer(c_int) :: coidef_numnlnz
      end function coidef_numnlnz
 
      !> defines the Number of Hessian Nonzeros.
      !!
      !! defines the number of nonzeros in the Hessian. The number is zero
      !! if the model is linear and positive if the model is nonlinear.
      !!
      !! @param cntvect    the control vector
      !! @param numhess    the number of nonzeros in Hessian
      !!
      !! @ingroup REGISTRATION_OF_SIZES_F90
      !!
      function coidef_numhess( CntVect, NumHess ) bind(c, name = "COIDEF_NumHess")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_NumHess
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: numhess
         integer(c_int) :: coidef_numhess
      end function coidef_numhess
!
!  Routines used to register the objective
!
      !> defines the Optimization Direction.
      !!
      !! defines the optimization direction. `OptDir = +1` defines maximization and
      !! `OptDir = -1` defines minimization. Setting an optimization direction is optional. If
      !! no optimization direction is set, the CONOPT will search for a feasible solution and
      !! then stop.
      !!
      !! @param cntvect    the control vector
      !! @param optdir     the optimization direction
      !!
      !! @ingroup REGISTRATION_OF_SIZES_F90
      !!
      function coidef_optdir( CntVect, OptDir ) bind(c, name = "COIDEF_OptDir")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_OptDir
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: optdir
         integer(c_int) :: coidef_optdir
      end function coidef_optdir
 
      !> defines the Objective Constraint.
      !!
      !! \note The constraint must be a Free Row, see argument `TYPE` in
      !! `ReadMatrix` in section \ref API_READMATRIX_F90 "ReadMatrix".
      !!
      !! If both an objective variable and constraint are set, the last one set will
      !! be used in the optimization. You can turn a previously defined objective off by defining variable
      !! or constraint 0 as the objective (Fortran notation) or variable or
      !! constraint -1 (C notation).
      !!
      !! @param cntvect    the control vector
      !! @param objcon     the index of the objective constraint
      !!
      !! @ingroup REGISTRATION_OF_SIZES_F90
      !!
      function coidef_objcon( CntVect, ObjCon ) bind(c, name = "COIDEF_ObjCon")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_ObjCon
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: objcon
         integer(c_int) :: coidef_objcon
      end function coidef_objcon
 
      !> defines the Objective Variable.
      !!
      !! @param cntvect    the control vector
      !! @param objvar     the index of the objective variable
      !!
      !! @ingroup REGISTRATION_OF_SIZES_F90
      !!
      function coidef_objvar( CntVect, ObjVar ) bind(c, name = "COIDEF_ObjVar")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_ObjVar
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: objvar
         integer(c_int) :: coidef_objvar
      end function coidef_objvar
!
!  Routines used to register the license information
!
      !> @defgroup DEF_COI_LICENSE ""
      !! define the License Information.
      !!
      !! The license consists of three integer codes and a string that defines the user.
      !! If the license is not defined or if it is incorrect then CONOPT will run in
      !! small-scale demo mode and it will only be able to solve small models.
      !!
      !! \if HIDDEN_DOC
      !! where the last argument must hold the length of `LicString`, e.g. <i>in the form
      !! of `strlen(LicString)`.</i> The length is added to conform to Fortran calling
      !! conventions.
      !! \endif
      !!
      !! @param licint1    the first license integer code
      !! @param licint2    the second license integer code
      !! @param licint3    the third license integer code
      !! @param licstring     the license string
 
      !> @copydoc DEF_COI_LICENSE
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_license( CntVect, LicInt1, LicInt2, LicInt3, Licstring )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_License
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_LICENSE'::COIDEF_License
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         character(len=*,kind=c_char), intent(in) :: licstring
         integer(c_int), intent(in) :: licint1, licint2, licint3
         integer(c_int) :: coidef_license
      end function coidef_license
!
!  Routines used to register various options
!
      !> @defgroup DEF_COI_ITLIM ""
      !! define the Iteration Limit.
      !!
      !! By default CONOPT uses an iteration limit of <b>1 million iterations</b>.
      !! This method can be used to set a new iteration limit.
      !!
      !! The call is optional.
      !!
      !! @param itlim      the iteration limit
 
      !> @copydoc DEF_COI_ITLIM
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_itlim( CntVect, ItLim ) bind(c, name = "COIDEF_ItLim")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_ItLim
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: itlim
         integer(c_int) :: coidef_itlim
      end function coidef_itlim
 
      !> @defgroup DEF_COI_ERRLIM ""
      !! define the Error Limit.
      !!
      !! The nonlinear functions may not be defined in all points, and the user written
      !! callback routine `FDEval` has an argument for
      !! telling CONOPT if a point is “bad”. CONOPT may try other points to avoid “bad”
      !! points up to a defined error limit (as specified by a call to this method). The default error limit is
      !! <b>zero</b>, i.e. CONOPT will by default stop if a “bad” point is encountered.
      !!
      !! The call is optional.
      !!
      !! @param errlim     the error limit
 
      !> @copydoc DEF_COI_ERRLIM
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_errlim( CntVect, ErrLim ) bind(c, name = "COIDEF_ErrLim")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_ErrLim
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: errlim
         integer(c_int) :: coidef_errlim
      end function coidef_errlim
 
      !> @defgroup DEF_COI_DEBUGFV ""
      !! turn Debugging of FDEval on and off.
      !!
      !! CONOPT has a Function and Derivative Debugger that can check if the function
      !! values and derivatives computed by `FDEval` seem to be consistent and the
      !! derivatives are consistent with the sparsity pattern of the Jacobian.
      !!
      !! The interpretation of `DebugFV` is:
      !!
      !! - <b>0:</b>    No debugging (the default value)
      !! - <b>-1:</b>   Perform debugging in the initial point only.
      !! - <b>+n:</b>   Perform debugging every n’th iteration.
      !!
      !! The value can also be defined in an options file or options routine be setting
      !! `LKDEBG`. Error messages and error return codes are described in
      !! \ref API_ERROR_RETURN_CODES.
      !!
      !! @param debugfv    the flag to enable debugging of function evaluations
 
      !> @copydoc DEF_COI_DEBUGFV
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_debugfv( CntVect, DebugFV ) bind(c, name = "COIDEF_DebugFV")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_DebugFV
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: debugfv
         integer(c_int) :: coidef_debugfv
      end function coidef_debugfv
 
      !> @defgroup DEF_COI_MAXSUP ""
      !! limit on superbasics.
      !!
      !! CONOPT uses a reduced gradient algorithm and performs its optimization in a
      !! space of “Superbasic” variables. It needs a square matrix of size the number of
      !! superbasic variables for estimated second order information. Since this matrix
      !! can be fairly large, CONOPT places a limit that by default is at least <b>500
      !! rows and columns</b>. For larger models CONOPT reserves around <b>25% of the
      !! memory</b> needed for other purposes to this matrix. If you have a model with
      !! many superbasic variables it may be advantageous to increase this limit.
      !!
      !! \note If you provide second order information, through one of the `2DLagr`,
      !! `2DDir`, or `2DDirLag` routines, then it is usually not worth while to increase
      !! `MaxSup`.
      !!
      !! The limit can also be defined in an options file or options routine by setting
      !! `LFNSUP`.
      !!
      !! @param maxsup     the limit on superbasics
 
      !> @copydoc DEF_COI_MAXSUP
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_maxsup( CntVect, MaxSup ) bind(c, name = "COIDEF_MaxSup")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_MaxSup
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: maxsup
         integer(c_int) :: coidef_maxsup
      end function coidef_maxsup
 
      !> @defgroup DEF_COI_SQUARE ""
      !! square models.
      !!
      !! CONOPT has a special routine for solve square sets of equations without an
      !! objective function.
      !!
      !! @param square     `Square = 1` informs CONOPT that the model is Square. `Square = 0` is the default used for an ordinary optimization model.
 
      !> @copydoc DEF_COI_SQUARE
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_square( CntVect, Square ) bind(c, name = "COIDEF_Square")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_Square
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: square
         integer(c_int) :: coidef_square
      end function coidef_square
 
      !> @defgroup DEF_COI_EMPTYROW ""
      !! allow empty rows.
      !!
      !! CONOPT performs many tests on the input data and by default it does not allow
      !! empty rows, i.e. constraints that do not depend on any variables. In some
      !! modeling systems environments it can be useful to allow empty rows.
      !!
      !! @param emptyrow   1 allows empty rows, 0 is the default behavior.
 
      !> @copydoc DEF_COI_EMPTYROW
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_emptyrow( CntVect, EmptyRow ) bind(c, name = "COIDEF_EmptyRow")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_EmptyRow
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: emptyrow
         integer(c_int) :: coidef_emptyrow
      end function coidef_emptyrow
 
      !> @defgroup DEF_COI_EMPTYCOL ""
      !! allow empty columns.
      !!
      !! CONOPT performs many tests on the input data and by default it does not allow
      !! empty columns, i.e. variables that do not appear in any constraints. In some
      !! modeling systems environments it can be useful to allow empty columns. To
      !! bypass the usual tests you must inform CONOPT that empty columns should be
      !! allowed.
      !!
      !! @param emptycol   1 allows empty columns, 0 is the default behaviour.
 
      !> @copydoc DEF_COI_EMPTYCOL
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_emptycol( CntVect, EmptyCol ) bind(c, name = "COIDEF_EmptyCol")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_EmptyCol
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: emptycol
         integer(c_int) :: coidef_emptycol
      end function coidef_emptycol
 
      !> @defgroup DEF_COI_DEBUG2D ""
      !! turn debugging of 2nd derivatives on and off.
      !!
      !! CONOPT has a rudimentary routine for checking if the 2<sup>nd</sup> derivatives
      !! computed by `2DLagr`, `2DDir`, or `2DDirLag` seem to be consistent with the
      !! derivatives computed by `FDEval`.
      !!
      !! The interpretation of `Debug2D` is:
      !!
      !! - <b>0:</b>     No debugging (the default value)
      !! - <b>-1:</b>   Perform debugging in the initial point only.
      !! - <b>+n:</b>   Perform debugging every n’th iteration.
      !!
      !! The value can also be defined in an options file or options routine be setting
      !! `LKDEB2`. Error return codes and examples of messages can be found in
      !! \ref API_ERROR_RETURN_CODES.
      !!
      !! @param debug2d    the flag to enable the debugging of the second derivative evaulations
 
      !> @copydoc DEF_COI_DEBUG2D
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_debug2d( CntVect, Debug2D ) bind(c, name = "COIDEF_Debug2D")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_Debug2D
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: debug2d
         integer(c_int) :: coidef_debug2d
      end function coidef_debug2d
 
      !> define Optfile / Option order.
      !!
      !! By default CONOPT will first process the options defined in a file, see
      !! coidef_optfile(), and the process the options defined via
      !! a call-back routine. This method is called to change this  order.
      !!
      !! The interpretation of `OptOrder` is:
      !! - <b>0:</b>    Process option defined via the option file
      !! before options defined via the options callback. <i>(default
      !! value)</i>
      !! - <b>1:</b>    Process option defined via the options callback
      !! before options defined via options file.
      !!
      !! @param cntvect    the control vector
      !! @param optorder   Option processing order
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_optorder( CntVect, OptOrder ) bind(c, name = "COIDEF_OptOrder")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_OptOrder
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: optorder
         integer(c_int) :: coidef_optorder
      end function coidef_optorder
 
      !> @defgroup DEF_COI_DISCONT ""
      !! allow discontinuous functions and derivatives.
      !!
      !! CONOPT assumes that all functions are smooth with smooth derivatives and that
      !! these functions and derivatives can be computed with a noise level close to the
      !! machine precision. CONOPT can also be used on models with non-smooth
      !! derivatives, e.g. models with `ABS` or `MIN` or `MAX` functions, but the
      !! algorithm will still work as if all functions and derivatives are smooth. A few
      !! internal tests may fail for a model with discontinuous derivatives. The call will only
      !! turn the tests off or on; it will not alter the optimization behavior.
      !!
      !! @param discont    1 allows discontinuous functions and derivatives, 0 is the default behaviour.
 
      !> @copydoc DEF_COI_DISCONT
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_discont( CntVect, DisCont ) bind(c, name = "COIDEF_DisCont")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_DisCont
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: discont
         integer(c_int) :: coidef_discont
      end function coidef_discont
 
      !> @defgroup DEF_COI_THREADS ""
      !! number of threads allowed internally in CONOPT.
      !!
      !! As discussed in \ref API_MULTI_THREADING CONOPT can use
      !! multiple threads using the `OpenMP` standard. The multi-threading capability is
      !! divided into three areas: <b>(1)</b> Internally in CONOPT, <b>(2)</b> during
      !! function and derivative calls using the `FDEval` callback routine,
      !! and <b>(3)</b> during directional 2<sup>nd</sup> derivative
      !! calls using the 2DDir callback routine.
      !!
      !! This method is used to define how many threads can be used internally
      !! in CONOPT. The argument `ThreadS` is interpreted as follows:
      !!
      !! - <b>ThreadS = 0:</b> use `MaxThread` threads, as many as the `OpenMP` system will allocate,
      !! - <b>ThreadS = 1:</b> use one thread <i>(this is the default)</i>,
      !! - <b>ThreadS > 1:</b> use `min(ThreadS,MaxThread)` threads.
      !!
      !! @param threads    the number of threads allowed internally
 
      !> @copydoc DEF_COI_THREADS
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_threads( CntVect, ThreadS ) bind(c, name = "COIDEF_ThreadS")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_ThreadS
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: threads
         integer(c_int) :: coidef_threads
      end function coidef_threads
 
      !> @defgroup DEF_COI_THREADF ""
      !! number of threads allowed for simultaneous `FDEval` calls.
      !!
      !! This method can be used to define how many threads can be used for
      !! simultaneous `FDEval` calls. The argument `ThreadF` is interpreted as follows:
      !!
      !! - <b>ThreadF = 0:</b> use the same number of threads as internally in CONOPT
      !! <i>(this is the default)</i>,
      !!
      !! - <b>ThreadF = 1:</b> use one thread,
      !!
      !! - <b>ThreadF > 1:</b> use `min(ThreadS,ThreadF)` threads.
      !!
      !! @param threadf    the number of threads for simultaneous `FDEval` calls
 
      !> @copydoc DEF_COI_THREADF
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_threadf( CntVect, ThreadF ) bind(c, name = "COIDEF_ThreadF")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_ThreadF
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: threadf
         integer(c_int) :: coidef_threadf
      end function coidef_threadf
 
      !> @defgroup DEF_COI_THREAD2D ""
      !! number of threads allowed for simultaneous `2DDir` calls.
      !!
      !! This method can be used to define how many threads can be used
      !! for simultaneous `2DDir` calls. The argument `Thread2D` is interpreted as
      !! follows:
      !!
      !! - <b>Thread2D = 0:</b> use the same number of threads as internally in CONOPT
      !! <i>(this is the default)</i>,
      !!
      !! - <b>Thread2D = 1:</b> use one thread,
      !!
      !! - <b>Thread2D > 1:</b> use `min(Thread2D,ThreadF)` threads.
      !!
      !! @param thread2d   the number of threads for simultaneous `2DDir` calls
 
      !> @copydoc DEF_COI_THREAD2D
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_thread2d( CntVect, Thread2D ) bind(c, name = "COIDEF_Thread2D")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_Thread2D
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: thread2d
         integer(c_int) :: coidef_thread2d
      end function coidef_thread2d
 
      !> @defgroup DEF_COI_THREADC ""
      !! check for thread compatibility.
      !!
      !! When using multiple threads, the result of the execution is in most cases
      !! independent of the number of threads. However, a few operations mostly related
      !! to summations can create slightly different results depending on the number of
      !! threads, and therefore the results may depend on the number of threads.
      !! `ThreadC` can be used to force reproducible results. The execution is done as
      !! if there were `ThreadC` threads independent of the actual number of `ThreadS`
      !! <i>(`ThreadS` > `ThreadC`)</i>.
      !!
      !! This method can be used to define how many threads CONOPT should simulate.
      !! The argument `ThreadC` is interpreted as follows:
      !!
      !! - <b>ThreadC = 0:</b> let the execution be controlled by `ThreadS` defined above,
      !! - <b>ThreadC > 1:</b> simulate the use of `ThreadC > ThreadS` threads.
      !!
      !! <b>The upper bound on `ThreadC` is currently 8.</b>
      !!
      !! @param threadc    the number of threads CONOPT should simulate
 
      !> @copydoc DEF_COI_THREADC
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_threadc( CntVect, ThreadC ) bind(c, name = "COIDEF_ThreadC")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_ThreadC
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: threadc
         integer(c_int) :: coidef_threadc
      end function coidef_threadc
 
      !> allow output to StdOut.
      !!
      !! CONOPT will by default not write to Standard Output or Fortran Write(*,*) to
      !! avoid problems in certain Windowing environments. All communication goes via
      !! callback routines. If there are errors during the initial setup of communication
      !! it can sometimes be difficult to locate these errors. If you allow output to
      !! Standard Output then CONOPT may provide some extra debugging information.
      !!
      !! @param cntvect    the control vector
      !! @param tostdout   1 to output to Standard Output, 0 to silence the output.
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_stdout( CntVect, ToStdOut ) bind(c, name = "COIDEF_StdOut")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_StdOut
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: tostdout
         integer(c_int) :: coidef_stdout
      end function coidef_stdout
 
      !> @defgroup DEF_COI_CLEARM ""
      !! ClearM
      !!
      !! @param clearm
 
      !> @copydoc DEF_COI_CLEARM
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_clearm( CntVect, ClearM ) bind(c, name = "COIDEF_ClearM")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_ClearM
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: clearm
         integer(c_int) :: coidef_clearm
      end function coidef_clearm
 
      !> define zero noise level.
      !!
      !! CONOPT has a Function and Derivative Debugger that also tests whether variables that
      !! should not appear in an equation actually have an influence on the function
      !! value: the variables that should not appear are all perturbed by random amounts
      !! and the function is called again. If the function changes by the slightest
      !! amount, this must have been caused by one of the variables that should not
      !! influence the equation, and an error has been identified.
      !!
      !! However, some implementations may give very small function changes as shown by
      !! the following example: Equation \f$i\f$ depends on \f$\sum_{j \neq i}X(j)\f$.
      !! Initially, compute \f$XS = \sum_{i}X(i)\f$ and the compute \f$XS-X(i)\f$ for
      !! use in `Equation` \f$i\f$. Because of the round-off errors involved in
      !! computing \f$XS-X(i)\f$, \f$X(i)\f$ may seem to appear in `Equation` \f$i\f$.
      !! For these rare cases you may need to define a small <i>"zero noise level"</i>
      !! and all derivatives less that this value will not be considered errors.
      !! The default value is zero.
      !!
      !! @param cntvect    the control vector
      !! @param zeronoise  the threshold for zero noise level in function derivatives
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_zeronoise( CntVect, ZeroNoise ) bind(c, name = "COIDEF_ZeroNoise")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_ZeroNoise
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: zeronoise
         integer(c_int) :: coidef_zeronoise
      end function coidef_zeronoise
 
      !> @defgroup DEF_COI_RESLIM ""
      !! define resource limit.
      !!
      !! CONOPT will by default allow the optimization to run for <b>1 million
      !! seconds</b>. A new limit can be set by a call to this method.
      !!
      !! \note `ResLim` is a double precision number.
      !!
      !! @param reslim     the solve time limit in seconds
 
      !> @copydoc DEF_COI_RESLIM
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_reslim( CntVect, ResLim ) bind(c, name = "COIDEF_ResLim")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_ResLim
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         real(c_double), value :: reslim
         integer(c_int) :: coidef_reslim
      end function coidef_reslim
 
      !> factor for Hessian density relative to Jacobian density HessFac.
      !!
      !! CONOPT will not use the Hessian of the Lagrangian if it is too dense. The limit
      !! on the number of nonzero Hessian elements (on an below the diagonal) is set to
      !! `HessFac` times the number of nonlinear Jacobian elements,:vertical resize 120
      !! and the default value of `HessFac` is 10. The assumption is
      !! that computations involving a dense Hessian will be too expensive.
      !!
      !! The Hessian factor can also be defined by defining the option `RVHESS`.
      !!
      !! @param cntvect    the control vector
      !! @param hessfac    the threshold factor for Hessian density relative to Jacobian density
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_hessfac( CntVect, HessFac ) bind(c, name = "COIDEF_HessFac")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_HessFac
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         real(c_double), value :: hessfac
         integer(c_int) :: coidef_hessfac
      end function coidef_hessfac
 
      !> @defgroup DEF_COI_MAXHEAP ""
      !! define Limit on Heap Memory.
      !!
      !! By default CONOPT will allocate the memory it needs from the computers heap
      !! memory using `Allocate` or `malloc` calls. For very large models CONOPT may try
      !! to allocate more than the available physical memory and the responsiveness of
      !! the computer may suffer. This may not be acceptable in certain server
      !! environments. This method is used to define a limit on the amount of heap
      !! memory that CONOPT will allocate.
      !! If CONOPT reaches a point where it needs more memory than allowed it will try
      !! to continue without extra memory (if this is possible) or it will stop with an
      !! out of memory message and the sovle will return the value <b>113</b> or
      !! <b>114</b>.
      !!
      !! `MaxHeap` is measured in <b>MegaBytes</b>. A positive `MaxHeap` value indicates
      !! a limit while `Maxheap = 0.0` indicates that the limit is set by the physical
      !! memory or the virtual memory system on the machine. After you have solved a
      !! model you can query the amount of memory actually used with the
      !! coiget_maxheapused() or COIGET_MaxHeapUsed().
      !!
      !! The call is optional.
      !!
      !! @param maxheap    the limit on heap memory
 
      !> @copydoc DEF_COI_MAXHEAP ""
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_maxheap( CntVect, MaxHeap ) bind(c, name = "COIDEF_MaxHeap")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_MaxHeap
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         real(c_double), value :: maxheap
         integer(c_int) :: coidef_maxheap
      end function coidef_maxheap
 
      !> define callback routine for defining an options file.
      !!
      !! It is possible to define an options file with user defined values for certain
      !! options. To define an options file you must write a callback routine that gives
      !! CONOPT the file name (see \ref API_OPTFILE_F90 "OptFile") and register this optional
      !! routine with a call to coidef_optfile() before CONOPT is started. The name of
      !! your version of `OptFile` must be declared as external and given to
      !! coidef_optfile() as its second argument.
      !!
      !! \note By default the options defined via an option file are processed before the
      !! options defined via the callback routine (see coidef_option()). The order can be changed with a call to coidef_optorder().
      !!
      !! For the definition of the `Optfile` callback function, see \ref API_OPTFILE_F90 "Optfile"
      !!
      !! @param cntvect    the control vector
      !! @param optfile    the pointer to the `OptFile` routine for providing the options file name
      !!
      !! @ingroup REGISTRATION_OF_OPTIONAL_CALLBACK_ROUTINES_F90
      !!
      function coidef_optfile( CntVect, Optfile )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Optfile
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_OPTFILE'::COIDEF_Optfile
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         character(len=*,kind=c_char) :: optfile
         integer(c_int) :: coidef_optfile
      end function coidef_optfile
!
! Routines used to reguster alternative interpretations of the interface
!
      !> @cond UNDOCUMENTED_F90API
      !> define the Base index for vectors.
      !!
      !! Some of the vectors that are passed between CONOPT and the callback routines
      !! point to other vectors. Examples are Row Indices and Start of Column pointers.
      !! You must define to CONOPT if you use Fortran conventions with 1 as the first
      !! element or C conventions with 0. The base will also determine how the index
      !! of the objective is interpreted.
      !!
      !! @param cntvect    the control vector
      !! @param base       the base index for vectors
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_base( CntVect, Base ) bind(c, name = "COIDEF_Base")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_Base
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: base
         integer(c_int) :: coidef_base
      end function coidef_base
 
      !> define Fortran Conventions for Argument Passing.
      !!
      !! This is equivalent to calling coidef_base(1) in Fortran
      !! or COIDEF_Base(1) in C.
      !!
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_fortran( CntVect ) bind(c, name = "COIDEF_Fortran")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_Fortran
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int) :: coidef_fortran
      end function coidef_fortran
 
      !> define C Conventions for Argument Passing.
      !!
      !! This is equivalent to calling coidef_base(0) in Fortran
      !! or COIDEF_Base(0) in C.
      !!
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_c( CntVect ) bind(c, name = "COIDEF_C")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_C
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int) :: coidef_c
      end function coidef_c
      !> @endcond
 
      !> handling of the initial status values.
      !!
      !! CONOPT can take advantage of initial ‘Status’ information about the variables
      !! and constraints. This is information of the type: Variable number \f$i\f$ is
      !! basic, variable \f$j\f$ is superbasic, variable \f$k\f$ is at lower bound
      !! etc.
      !!
      !! \note If you are going to provide Status information when building the model then
      !! CONOPT must be informed a call to this method with the second argument
      !! equal to 1 or 2 (depending on the definition you choose). You can turn it off
      !! again with another call with the value 0 (the default initial value).
      !!
      !! @param cntvect    the control vector
      !! @param inistat    the initial status
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_inistat( CntVect, IniStat ) bind(c, name = "COIDEF_IniStat")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_IniStat
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: inistat
         integer(c_int) :: coidef_inistat
      end function coidef_inistat
 
      !> @defgroup DEF_COI_FVINCLIN ""
      !! include the linear terms in function evaluations.
      !!
      !! CONOPT assumes that the function values returned by the user defined callback
      !! routine `FDEval` only include nonlinear terms, i.e. terms that correspond to
      !! variables that appear nonlinearly in the particular constraint.
      !!
      !! If you prefer your `FDEval` routine to return function values as the
      !! sum of both linear and nonlinear terms then you must inform CONOPT by calling
      !! this method with `FVincLin = 1`. `FVincLin = 0` will return CONOPT to
      !! the default behavior.
      !!
      !! @param fvinclin   the linear terms in functions
 
      !> @copydoc DEF_COI_FVINCLIN
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_fvinclin( CntVect, FVIncLin ) bind(c, name = "COIDEF_FVincLin")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_FVincLin
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: fvinclin
         integer(c_int) :: coidef_fvinclin
      end function coidef_fvinclin
 
      !> @defgroup DEF_COI_FVFORALL ""
      !! call the FDEval for all constraints, including linear constraints.
      !!
      !! CONOPT will usually only call the user provided `FDEval` routine for
      !! nonlinear constraints. However, some models may have constant terms included
      !! in `FDEval` instead of in the right hand side, also for linear constraints.
      !!
      !! \note If your `FDEval` routine is programmed this way you must tell CONOPT to
      !! call `FDEval` for all constraints, linear as well as nonlinear, by calling
      !! this method with `FVforAll = 1`. Calling again with `FVforAll = 0` will
      !! return CONOPT to its default behavior.
      !!
      !! @param fvforall   the linear constraints in functions
 
      !> @copydoc DEF_COI_FVFORALL
      !! @param cntvect    the control vector
      !!
      !! @ingroup REGISTRATION_OF_OPTIONS_F90
      !!
      function coidef_fvforall( CntVect, FVforAll ) bind(c, name = "COIDEF_FVforAll")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIDEF_FVforAll
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), value :: fvforall
         integer(c_int) :: coidef_fvforall
      end function coidef_fvforall
!
!  Routines used to register the callback so CONOPT can find them:
!
      !> define callback routine for providing the matrix data to CONOPT.
      !!
      !! CONOPT gets information about the structure of the model from a user written
      !! callback routine referred to as `ReadMatrix`. You must register this routine with a call to
      !! this method before CONOPT is started. The name
      !! of your version of `ReadMatrix` must be declared as external.
      !!
      !! \note There is no type checking for the argument list on External functions in
      !! Fortran, so you must be very careful.
      !!
      !! @param cntvect           the control vector
      !! @param coi_readmatrix        the pointer to the user-defined `ReadMatrix` callback routine
      !!
      !! @ingroup REGISTRATION_OF_MANDATORY_CALLBACK_ROUTINES_F90
      !!
      function coidef_readmatrix( CntVect, coi_ReadMatrix )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_ReadMatrix
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_READMATRIX'::COIDEF_ReadMatrix
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_readmatrix
         integer(c_int) :: coidef_readmatrix
      end function coidef_readmatrix
 
      !> define callback routine for performing function and derivative evaluations.
      !!
      !! CONOPT get information about the nonlinearities from a user written callback
      !! routine referred to as `FDEval`. You
      !! must register this routine with a call to this method before CONOPT is
      !! started. The name of your version of `FDEval` must be declared as external.
      !!
      !! @param cntvect    the control vector
      !! @param coi_fdeval pointer to the user-defined `FDEval` callback routine
      !!
      !! @ingroup REGISTRATION_OF_MANDATORY_CALLBACK_ROUTINES_F90
      !!
      function coidef_fdeval( CntVect, coi_FDEval )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_FDEval
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_FDEVAL'::COIDEF_FDEval
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_fdeval
         integer(c_int) :: coidef_fdeval
      end function coidef_fdeval
 
      !> define callback routine to perform initialization tasks for the function and derivative evaluation.
      !!
      !! The nonlinear `FDEval` routine is usually called for several constraints in one
      !! point before being called for constraints in another point. An optional user
      !! provided `FDEvalIni` routine can be used to perform common tasks that are
      !! needed in preparation for a new point. You must register this
      !! routine with a call to this method before CONOPT is started. The name of
      !! your version of `FDEvalIni` must be declared as external.
      !!
      !! @param cntvect          the control vector
      !! @param coi_fdevalini    the pointer to the `FDEvalIni` routine for initializing data before nonlinear evaluations
      !!
      !! @ingroup REGISTRATION_OF_OPTIONAL_CALLBACK_ROUTINES_F90
      !!
      function coidef_fdevalini( CntVect, coi_FDEvalIni )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_FDEvalIni
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_FDEVALINI'::COIDEF_FDEvalIni
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_fdevalini
         integer(c_int) :: coidef_fdevalini
      end function coidef_fdevalini
 
      !> define callback routine for the termination of the function and derivative evaluation.
      !!
      !! After the nonlinear `FDEval` routine has been called for several constraints in
      !! one point an optional user provided `FDEvalEnd` routine can be used to perform
      !! common cleanup tasks. If you want to use this possibility you must
      !! register this routine with a call to this method before CONOPT is
      !! started. The name of your version of `FDEvalEnd` must be declared as external.
      !!
      !! @param cntvect          the control vector
      !! @param coi_fdevalend    the pointer to the `FDEvalEnd` routine for cleanup after nonlinear evaluations
      !!
      !! @ingroup REGISTRATION_OF_OPTIONAL_CALLBACK_ROUTINES_F90
      !!
      function coidef_fdevalend( CntVect, coi_FDEvalEnd )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_FDEvalEnd
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_FDEVALEND'::COIDEF_FDEvalEnd
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_fdevalend
         integer(c_int) :: coidef_fdevalend
      end function coidef_fdevalend
 
      !> define callback routine for returning the completion status.
      !!
      !! When CONOPT has finished optimizing it informs the modeler about the status of
      !! the solution: Optimal, Infeasible, Normal completion, Interrupted by function
      !! evaluation errors etc. This is done by a call to a user written callback routine
      !! referred to as `Status`. You must
      !! register this routine with a call to this method before CONOPT is started.
      !! The name of your version of `Status` must be declared as external.
      !!
      !! @param cntvect    the control vector
      !! @param coi_status pointer to the user-defined `Status` callback routine
      !!
      !! @ingroup REGISTRATION_OF_MANDATORY_CALLBACK_ROUTINES_F90
      !!
      function coidef_status( CntVect, coi_Status )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Status
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_STATUS'::COIDEF_Status
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_status
         integer(c_int) :: coidef_status
      end function coidef_status
 
      !> define callback routine for returning the final solution values.
      !!
      !! After the user written callback Status has been called CONOPT will usually
      !! (unless the Status indicates some serious error condition) call another user
      !! written callback routine called `Solution` to inform the modeler about the
      !! actual primal and dual solution values. You must register this routine with a call to
      !! this method before CONOPT is started. The name of your version of
      !! `Solution` must be declared as external.
      !!
      !! @param cntvect         the control vector
      !! @param coi_solution    the pointer to the user-defined `Solution` callback routine
      !!
      !! @ingroup REGISTRATION_OF_MANDATORY_CALLBACK_ROUTINES_F90
      !!
      function coidef_solution( CntVect, coi_Solution )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Solution
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_SOLUTION'::COIDEF_Solution
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_solution
         integer(c_int) :: coidef_solution
      end function coidef_solution
 
      !> define callback routine for handling messages returned during the solution process.
      !!
      !! Apart from the solution itself, CONOPT provides a number of messages about
      !! progress and problems during the optimization. Most messages are provided in the
      !! form of character strings that are passed as arguments to a user written
      !! callback routine called `Message`. It is the modelers responsibility to handle
      !! these messages. You must register this routine with a call
      !! to this method before CONOPT is started. The name of your version of
      !! `Message` must be declared as external.
      !!
      !! @param cntvect        the control vector
      !! @param coi_message    the pointer to the user-defined `Message` callback routine
      !!
      !! @ingroup REGISTRATION_OF_MANDATORY_CALLBACK_ROUTINES_F90
      !!
      function coidef_message( CntVect, coi_Message )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Message
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_MESSAGE'::COIDEF_Message
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_message
         integer(c_int) :: coidef_message
      end function coidef_message
 
      !> define callback routine for returning error messages for row, column or Jacobian elements.
      !!
      !! Certain messages, including error messages, refer to a particular variable
      !! and/or constraint. The mandatory `ErrMsg` callback routine is used to format and
      !! display these messages. If
      !! you want to supply it you must register it with a call to this method before
      !! CONOPT is started. The name of your version of `ErrMsg` must be declared as
      !! external.
      !!
      !! @param cntvect    the control vector
      !! @param coi_errmsg pointer to the user-defined `ErrMsg` callback routine
      !!
      !! @ingroup REGISTRATION_OF_MANDATORY_CALLBACK_ROUTINES_F90
      !!
      function coidef_errmsg( CntVect, coi_ErrMsg )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_ErrMsg
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_ERRMSG'::COIDEF_ErrMsg
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_errmsg
         integer(c_int) :: coidef_errmsg
      end function coidef_errmsg
 
      !> define callback routine for monitoring the algorithmic progress.
      !!
      !! If you would like to write your own iteration log then CONOPT can provide the
      !! necessary information to a user written callback routine called `Progress`.
      !! `Progress` can also be used to communicate a Stop messages back to CONOPT. If you
      !! would like CONOPT to call your `Progress` routine you must register it with a
      !! call to this method before CONOPT is started. The name of your version of
      !! `Progress` must be declared as external.
      !!
      !! @param cntvect         the control vector
      !! @param coi_progress    the pointer to the `Progress` routine for logging iteration progress or sending stop messages
      !!
      !! @ingroup REGISTRATION_OF_OPTIONAL_CALLBACK_ROUTINES_F90
      !!
      function coidef_progress( CntVect, coi_Progress )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Progress
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_PROGRESS'::COIDEF_Progress
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_progress
         integer(c_int) :: coidef_progress
      end function coidef_progress
 
      !> define callback routine for defining runtime options.
      !!
      !! An alternative or supplement to an options file is an option callback routine
      !! that CONOPT calls repeatedly to get non-default option values. To use this
      !! method you must write a callback routine that gives CONOPT the names and values
      !! of the non default options and you must
      !! register this optional routine with a call to this method before CONOPT is
      !! started. The name of your version of Option must be declared as external.
      !!
      !! \note By default the options defined via an option file are processed before the options defined via the
      !! callback routine.
      !!
      !! @param cntvect       the control vector
      !! @param coi_option    the pointer to the `Option` routine for setting non-default option values
      !!
      !! @ingroup REGISTRATION_OF_OPTIONAL_CALLBACK_ROUTINES_F90
      !!
      function coidef_option( CntVect, coi_Option )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Option
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_OPTION'::COIDEF_Option
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_option
         integer(c_int) :: coidef_option
      end function coidef_option
 
      !> define callback routine for providing the triangular order information.
      !!
      !! During preprocessing of a model CONOPT can provide information about the
      !! solution sequence of triangular parts of a model. This can be useful for
      !! analyzing certain types of infeasibilities. If you want to use this feature you
      !! must register a `TriOrd` callback routine with a call to this method before CONOPT is started. The
      !! name of your version of `TriOrd` must be declared as external.
      !!
      !! @param cntvect       the control vector
      !! @param coi_triord    the pointer to the `TriOrd` routine for analyzing the solution sequence of triangular parts.
      !!
      !! @ingroup REGISTRATION_OF_OPTIONAL_CALLBACK_ROUTINES_F90
      !!
      function coidef_triord( CntVect, coi_TriOrd )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_TriOrd
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_TRIORD'::COIDEF_TriOrd
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_triord
         integer(c_int) :: coidef_triord
      end function coidef_triord
 
      !> define callback routine for performing function and derivative evaluations on intervals.
      !!
      !! During preprocessing CONOPT can take advantage of interval information for
      !! function values and derivatives if this is available. If you can provide
      !! interval information you can register an optional `FDInterval` function and
      !! derivative evaluation callback routine with a call to this method before CONOPT is
      !! started. The name of your version of `FDInterval` must be declared as external.
      !!
      !! @param cntvect           the control vector
      !! @param coi_fdinterval    the pointer to the `FDInterval` routine for providing interval data for functions and derivatives
      !!
      !! @ingroup REGISTRATION_OF_OPTIONAL_CALLBACK_ROUTINES_F90
      !!
      function coidef_fdinterval( CntVect, coi_FDInterval )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_FDInterval
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_FDINTERVAL'::COIDEF_FDInterval
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_fdinterval
         integer(c_int) :: coidef_fdinterval
      end function coidef_fdinterval
 
      !> define callback routine for computing the second derivative for a constraint in a direction.
      !!
      !! CONOPT can take advantage of 2<sup>nd</sup> derivatives in various forms, as
      !! discussed in the \ref API_DEFINING_SECOND_ORDER_INFO_F90 section. If you can provide
      !! directional 2<sup>nd</sup> derivatives of the individual constraints then you
      !! can register an optional `2DDir` callback routine with a call to this method before CONOPT is
      !! started. The name of your version of `2DDir` must be declared as external.
      !!
      !! @param cntvect    the control vector
      !! @param coi_2ddir  the pointer to the `2DDir` callback routine for supplying directional second derivatives of constraints
      !!
      !! @ingroup REGISTRATION_OF_OPTIONAL_CALLBACK_ROUTINES_F90
      !!
      function coidef_2ddir( CntVect, coi_2dDir )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_2DDir
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_2DDIR'::COIDEF_2DDir
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_2ddir
         integer(c_int) :: coidef_2ddir
      end function coidef_2ddir
 
      !> define callback routine for initializing the computation of second derivatives for a constraint in a direction.
      !!
      !! The `2DDir` routine defined above will be called in batches. First it will be
      !! called in one point and with a given direction for all nonlinear constraints
      !! except pre-triangular constraints and constraints with dual variables equal to
      !! zero, then for the same constraints in the same point but with a different
      !! direction, and later again in a new point with a new direction and possibly for
      !! a different set of constraints (due to changes in the dual variables). If the
      !! modeler would like to perform certain common tasks each time the point or the
      !! direction changes then this can be done in a callback routine defined with
      !! this method.
      !! If you would like to provide this initialization routine then you can register an optional
      !! `2DDirIni` callback routine with a call to this method before CONOPT is started.  The name
      !! of your version of `2DDirIni` must be declared as external.
      !!
      !! @param cntvect         the control vector
      !! @param coi_2ddirini    the pointer to the `2DDirIni` callback routine for initializing tasks when the point or direction changes
      !!
      !! @ingroup REGISTRATION_OF_OPTIONAL_CALLBACK_ROUTINES_F90
      !!
      function coidef_2ddirini( CntVect, coi_2dDirIni )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_2DDirIni
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_2DDIRINI'::COIDEF_2DDirIni
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_2ddirini
         integer(c_int) :: coidef_2ddirini
      end function coidef_2ddirini
 
      !> define callback routine for termination the computation of second derivatives for a constraint in a direction.
      !!
      !! After the `2DDir` routine defined above has been called for a number of
      !! constraints in a particular point and in a particular direction the optional
      !! `2DDirEnd` routine will be called if it has been defined by the modeler. in
      !! batches. If the modeler would like to perform certain common cleanup tasks each
      !! time the `2DDir` calls for a point or a direction have been finished then this
      !! can be done in a callback routine defined with this method as discussed in
      !! \ref API_2DDIREND_F90 "2DDirEnd section". If you would like to provide this
      !! termination routine then you can register an optional `2DDirEnd` callback
      !! routine with a call to
      !! this method before CONOPT is started. The name of your version of
      !! `2DDirEnd` must be declared as external.
      !!
      !! @param cntvect         the control vector
      !! @param coi_2ddirend    the pointer to the `2DDirEnd` callback routine for cleanup after processing a point or direction
      !!
      !! @ingroup REGISTRATION_OF_OPTIONAL_CALLBACK_ROUTINES_F90
      !!
      function coidef_2ddirend( CntVect, coi_2dDirEnd )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_2DDirEnd
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_2DDIREND'::COIDEF_2DDirEnd
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_2ddirend
         integer(c_int) :: coidef_2ddirend
      end function coidef_2ddirend
 
      !> define callback routine for computing the second derivative of the Lagrangian in a direction.
      !!
      !! CONOPT can take advantage of 2<sup>nd</sup> derivatives in various forms as
      !! discussed in \ref API_DEFINING_SECOND_ORDER_INFO_F90. If you can provide directional
      !! 2<sup>nd</sup> derivatives of the Lagrangian then you can register an optional
      !! `2DDirLagr` callback routine with a call to this method before CONOPT is started. The name
      !! of your version of `2DDirLagr` must be declared as external.
      !!
      !! @param cntvect          the control vector
      !! @param coi_2ddirlagr    the pointer to the `2DDirLagr` callback routine for supplying directional second derivatives of the Lagrangian
      !!
      !! @ingroup REGISTRATION_OF_OPTIONAL_CALLBACK_ROUTINES_F90
      !!
      function coidef_2ddirlagr( CntVect, coi_2dDirLagr )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_2DDirLagr
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_2DDIRLAGR'::COIDEF_2DDirLagr
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_2ddirlagr
         integer(c_int) :: coidef_2ddirlagr
      end function coidef_2ddirlagr
 
      function coidef_2dlagrsize( CntVect, coi_2dLagrSize )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_2DLagrSize
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_2DLAGRSIZE'::COIDEF_2DLagrSize
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_2dlagrsize
         integer(c_int) :: coidef_2dlagrsize
      end function coidef_2dlagrsize
 
      !> define callback routine for providing the structure of the second derivatives of the Lagrangian.
      !!
      !! CONOPT can take advantage of 2<sup>nd</sup> derivatives in various forms,
      !! including the Hessian of the Lagrangian and directional 2<sup>nd</sup>
      !! derivatives. If you can provide the Hessian of the Lagrangian as a sparse
      !! matrix, you can register the optional 2DLagrStr callback routine with a call to this method
      !! before CONOPT is started. The name of your version of 2DLagrStr must be declared
      !! as external.
      !!
      !! @param cntvect          the control vector.
      !! @param coi_2dlagrstr    the pointer to the 2DLagrStr callback routine, which defines the structure of the Hessian of the Lagrangian.
      !!
      !! @ingroup REGISTRATION_OF_OPTIONAL_CALLBACK_ROUTINES_F90
      !!
      function coidef_2dlagrstr( CntVect, coi_2dLagrStr )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_2DLagrStr
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_2DLAGRSTR'::COIDEF_2DLagrStr
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_2dlagrstr
         integer(c_int) :: coidef_2dlagrstr
      end function coidef_2dlagrstr
 
      !> define callback routine for computing the values of the second derivatives of the Lagrangian.
      !!
      !! CONOPT can take advantage of 2<sup>nd</sup> derivatives in various forms,
      !! including the Hessian of the Lagrangian and directional 2<sup>nd</sup>
      !! derivatives. If you can provide the Hessian of the Lagrangian as a sparse
      !! matrix, you can register the optional 2DLagrVal callback routine with a call to this method
      !! before CONOPT is started. The name of your version of 2DLagrVal must be declared
      !! as external.
      !!
      !! @param cntvect          the control vector.
      !! @param coi_2dlagrval    the pointer to the 2DLagrVal callback routine, which provides the values of the Hessian of the Lagrangian.
      !!
      !! @ingroup REGISTRATION_OF_OPTIONAL_CALLBACK_ROUTINES_F90
      !!
      function coidef_2dlagrval( CntVect, coi_2dLagrVal )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_2DLagrVal
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_2DLAGRVAL'::COIDEF_2DLagrVal
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int), external :: coi_2dlagrval
         integer(c_int) :: coidef_2dlagrval
      end function coidef_2dlagrval
 
      !> provides a pointer to user memory that is available in all callback functions. NOTE: this is not a callback function, but a
      !! pointer to a data structure.
      !!
      !! Communication between the modeler’s main program and the callback routines can
      !! take place via common blocks or global variables. For use in a thread safe
      !! application CONOPT offers an alternative communication mechanism called `User
      !! Memory`. The modeler can register a memory location (usually the address of the
      !! start of a vector) as `User Memory` and CONOPT will provide this address to all
      !! callback routines. You register `User Memory` by calling this method with
      !! the `User Memory` as the second argument.
      !!
      !! @param cntvect    the control vector
      !! @param usrmem     the user memory location for communication between the main program and callback routines
      !!
      !! @ingroup REGISTRATION_OF_OPTIONAL_CALLBACK_ROUTINES_F90
      !!
      function coidef_usrmem( CntVect, UsrMem )
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_UsrMem
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_USRMEM'::COIDEF_UsrMem
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         type(*) :: usrmem
         integer(c_int) :: coidef_usrmem
      end function coidef_usrmem
 
!
!  The actual SOLVE call
!
 
      !> @defgroup DEF_COI_SOLVE ""
      !! method for starting the solving process of CONOPT.
 
      !> @copydoc DEF_COI_SOLVE
      !!
      !! @param cntvect    the control vector
      !!
      !! @ingroup UTILITY_ROUTINES_F90
      function coi_solve( CntVect ) bind(c, name = "COI_Solve")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COI_Solve
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int) :: coi_solve
      end function coi_solve
!
!  Various Utility routines
!
      !> returns the version number. It can be used to ensure that the modeler is linked to the correct version of the
      !! CONOPT DLL.
      !!
      !! @param major    major version number
      !! @param minor    minor version number
      !! @param patch    patch version number
      !!
      !! @ingroup UTILITY_ROUTINES_F90
      Subroutine coiget_version( major, minor, patch ) bind(c, name = "COIGET_Version")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIGET_Version
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), intent(inout) :: major, minor, patch
      end Subroutine coiget_version
 
      !> After a model has been solved this method will return the amount of heap memory used.
      !!
      !! @param cntvect    the control vector
      !!
      !! @ingroup UTILITY_ROUTINES_F90
      function coiget_maxheapused( CntVect ) bind(c, name = "COIGET_MaxHeapUsed")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIGET_MaxHeapUsed
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         real(c_double) :: coiget_maxheapused
      end function coiget_maxheapused
 
      !> returns the maximum number of threads that can be used by CONOPT.
      !!
      !! If you are using multiple threads it may be necessary to know in advance how many threads CONOPT can use. If
      !! called inside a parallel loop, this method will return one---indicating that CONOPT cannot use multiple
      !! threads when CONOPT itself is called in parallel. Therefore, this method should be called in some sequential
      !! initialization code and not inside a function evaluation routine, that could be called in parallel.
      !!
      !! @param cntvect    the control vector
      !!
      !! @ingroup UTILITY_ROUTINES_F90
      function coiget_maxthreads( CntVect ) bind(c, name = "COIGET_MaxThreads")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIGET_MaxThreads
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int) :: coiget_maxthreads
      end function coiget_maxthreads
 
      !> returns the range errors that were encountered.
      !!
      !! @param cntvect    the control vector
      !!
      !! @ingroup UTILITY_ROUTINES_F90
      function coiget_rangeerrors( CntVect ) bind(c, name = "COIGET_RangeErrors")
#if defined (dec_directives_win32)
!DEC$ ATTRIBUTES STDCALL :: COIGET_RangeErrors
#endif
         use, intrinsic :: iso_c_binding
         implicit none
         integer(c_int), dimension(*), intent(inout) :: cntvect
         integer(c_int) :: coiget_rangeerrors
      end function coiget_rangeerrors
 
!> @cond KEEP_F90_INTERFACE
   end interface
!> @endcond
 
   contains
 
   !> initializes CONOPT and creates the control vector.
   !!
   !! This method calls an initialization step for the Control Vector that places default values in the various positions.
   !! In addition, the initialization will set the parameters associated with the
   !! base and array indices, i.e. starting at 1 for Fortran and 0 for C.
   !!
   !! If you have multiple models with multiple Control Vectors then you must call
   !! this method for each control vector. If you solve a sequence of different
   !! models then you can use the same Control Vector provided you don't need to
   !! reinitialize it. If the control vector must be reinitialized, then it is
   !! necessary to call conopt::coi_free() followed by conopt::coi_create() between the
   !! solves.
   !!
   !! @param cntvect     the control vector
   !!
   !! @ingroup THE_CONTROL_VECTOR_F90
   function coi_create( CntVect )
      use, intrinsic :: iso_c_binding
      implicit none
      integer(c_int), dimension(:), pointer :: cntvect
      integer(c_int) :: coi_create
 
      integer(c_int) :: numcallback, alloc_stat
 
      numcallback = coidef_size()
      allocate( cntvect(numcallback), stat = alloc_stat )
      if ( alloc_stat /= 0 ) then
         coi_create = 4 ! MemoryProblem
      else
         coi_create = coidef_inifort( cntvect )
      endif
 
   end function coi_create
 
   !> frees the control vector.
   !!
   !! @param cntvect     the control vector
   !!
   !! @ingroup THE_CONTROL_VECTOR_F90
   function coi_free( CntVect )
      use, intrinsic :: iso_c_binding
      implicit none
      integer(c_int), dimension(:), pointer :: cntvect
      integer(c_int) :: coi_free
 
      integer(c_int) :: alloc_stat
 
      if ( associated( cntvect ) ) then
         deallocate( cntvect, stat = alloc_stat )
         if ( alloc_stat /= 0 ) then
            coi_free = 4 ! MemoryProblem
         else
            nullify( cntvect )
            coi_free = 0
         endif
      else
         coi_free = 4 ! MemoryProblem
      endif
 
   end function coi_free
 
end module conopt