coistart.f90

Go to the documentation of this file.

!> @file coistart.f90
!! @ingroup PUBLICAPI_FILES
!! @brief public Fortran API source file
 
!> @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
Integer Function coi_solve( CntVect )
 
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COI_Solve
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COI_Solve
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COI_SOLVE'::COI_Solve
#endif
#endif
!
!  LOGICAL OPERATION
!      Basic entry point for CONOPT DLL
!
   Use conopt_utilities
   IMPLICIT NONE
 
   INTEGER, Dimension(NumCallBack), Intent(In Out) :: cntvect
 
 
   Logical                               :: nolicense
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coi_solve = corruptcntr
      Return
   Endif
 
   If ( cntvect(indx_range) /= 0 ) then
      coi_solve = rangeproblem
      Return
   Endif
 
   nolicense = .false.
   If ( nolicense ) Then
      coi_solve = licenseproblem
      Return
   Endif
 
   CALL coeai( cntvect )
#if defined (write20)
   close(20)
#endif
   coi_solve = cntvect(indx_error)  ! Needs changing
 
END Function coi_solve
 
!> 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 )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIGET_VERSION
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIGET_Version
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIGET_VERSION' :: COIGET_Version
#endif
#endif
   Use conopt_utilities
   IMPLICIT NONE
   INTEGER, Intent(Out) :: major, minor, patch
 
   major = 4
   minor = 37
   patch = 0
 
END Subroutine coiget_version
 
!> 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
Integer Function coiget_maxthreads( CntVect )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIGET_MaxThreads
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIGET_MaxThreads
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIGET_MAXTHREADS'::COIGET_MaxThreads
#endif
#endif
   Use conopt_utilities
!$ Use OMP_Lib
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: maxthreads
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      maxthreads = -1
   Else
      maxthreads = 1
!$    If ( .not. OMP_IN_PARALLEL() ) Then
!$       Maxthreads  = OMP_GET_MAX_THREADS()
!$    Endif
   Endif
   coiget_maxthreads = maxthreads
 
End function coiget_maxthreads
 
!> 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
Real*8 Function coiget_maxheapused( CntVect )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIGET_MaxHeapUsed
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIGET_MaxHeapUsed
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIGET_MAXHEAPUSED'::COIGET_MaxHeapUsed
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Real(co_r) :: maxheapused
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coiget_maxheapused = corruptcntr
   Else
      Call unpackreal( cntvect, indx_maxheapused, maxheapused )
      coiget_maxheapused = maxheapused
   Endif
 
End function coiget_maxheapused
 
!> returns the range errors that were encountered.
!!
!! @param cntvect    the control vector
!!
!! @ingroup UTILITY_ROUTINES_F90
Integer Function coiget_rangeerrors( CntVect )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIGET_RangeErrors
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIGET_RangeErrors
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIGET_RANGEERRORS'::COIGET_RangeErrors
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coiget_rangeerrors = corruptcntr
   Else
      coiget_rangeerrors = cntvect(indx_range)
   Endif
 
End function coiget_rangeerrors
 
!> returns the size the Control Vector must have, measured in standard Integer units.
!!
!! @ingroup THE_CONTROL_VECTOR_F90
Integer Function coidef_size( )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_Size
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Size
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_SIZE'::COIDEF_Size
#endif
#endif
   USE conopt_utilities
   coidef_size = numcallback
End Function coidef_size
 
!> initializes the Control Vector by placing default values in the various positions.
!! @attention It must always 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
!! this method for each control vector. If you solve a sequence of different
!! models then you can use the same Control Vector provided you initialize it with
!! a call to this method between the solves.
!!
!! @param cntvect    the control vector
!!
!! @ingroup THE_CONTROL_VECTOR_F90
Integer Function coidef_ini( CntVect )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_Ini
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Ini
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_INI'::COIDEF_Ini
#endif
#endif
   USE conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer(CO_P) :: address
   Character(Len=CO_Filelen) :: filename
   Integer, External :: coidef_optfile
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Optfile
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_OPTFILE'::COIDEF_Optfile
#endif
!
!  Initialize the control vector to default values.
!  First the real values where we use a packing routine
!
   Call storereal( cntvect, indx_reslim    , 1.0e6_co_r )  ! Give a lot of time
   Call storereal( cntvect, indx_hessfac   , 0.0_co_r )   ! Rvhess is by default 0
   Call storereal( cntvect, indx_zeronoise , 0.0_co_r )   ! ZeroNoise = 0
   Call storereal( cntvect, indx_maxheap   , 0.0_co_r )   ! MaxHeap = 0 means no limit
!
!  Integer sizes and options are initialized here:
!
   cntvect(indx_numvar)   = -1      ! Undefined number of variables
   cntvect(indx_numcon)   = -1      ! Undefined number of constraints
   cntvect(indx_numnz)    = -1      ! Undefined number of nonzeros
   cntvect(indx_numnlnz)  = -1      ! Undefined number of nonlinear nonzeros
   cntvect(indx_numhess)  = -1      ! Undefined number of Hessian nonzeros
   cntvect(indx_optdir)   = 0       ! Undefined optimization direction: -1 = Minimize. +1 = Maximize
   cntvect(indx_objtyp)   = 0       ! Undefined objective type: +1 = variable, -1 = constraint
   cntvect(indx_objindx)  = -1      ! Undefined objective index
   cntvect(indx_base)     = -1      ! Undefined base index
   cntvect(indx_fortran)  = -1      ! Undefined Fortran/C interface
   cntvect(indx_itlim)    = 1000000 ! Many Interations
   cntvect(indx_errlim)   = 0       ! Function Evaluation Errors are not accepted
   cntvect(indx_inistat)  = 0       ! Status information is not provided
   cntvect(indx_fvinclin) = 0       ! FDEval does not includes linear terms
   cntvect(indx_fvforall) = 0       ! FDEval is not defined for all constraints
   cntvect(indx_debugfv)  = 0       ! No debugging of FDEval
   cntvect(indx_maxsup)   = -1      ! Default Limit on superbasics in reduced Hessian
   cntvect(indx_range)    = 0       ! There were no range problems in the COIDEF_XXX calls
   cntvect(indx_square)   = 0       ! Default not a square system
   cntvect(indx_emptyrow) = 0       ! Default empty rows are not allowed
   cntvect(indx_emptycol) = 0       ! Default empty columns are not allowed
   cntvect(indx_debug2d)  = 0       ! No debugging of the Hessian of Lagrangian
   cntvect(indx_optorder) = 0       ! The option order is _Optfile first then _Option (1 is opposite order)
   cntvect(indx_discont)  = 0       ! The model is smooth and continuously differentiable
   cntvect(indx_stdout)   = 0       ! Default: We cannot write to standard out = write(*,*)
   cntvect(indx_error)    = 0       ! Default: There are no errors.
   cntvect(indx_clearm)   = 0       ! Default: do not clear memory after allocation
   cntvect(indx_maxheapused) = 0    ! Maximum Memory used is not defined yet
   cntvect(indx_threads)  = 4       ! Default 4 threads
   cntvect(indx_threadf)  = 0       ! Default threads for FDEval is in Threads
   cntvect(indx_thread2d) = 0       ! Default threads for 2DDir is in Threads
   cntvect(indx_threadc)  = 0       ! Default compatibility-threads is off.
   cntvect(indx_licint1)  = 987     ! Default no licence code
   cntvect(indx_licint2)  = 654     ! Default no licence code
   cntvect(indx_licint3)  = 321     ! Default no licence code
   cntvect(indx_liccod1)  = 123     ! Default no licence code
   cntvect(indx_liccod2)  = 456     ! Default no licence code
   cntvect(indx_liccod3)  = 789     ! Default no licence code
   address = 0_co_p
!
!  Initialize all callback addresses to 0
!
   Call storeaddr( cntvect, indx_readmatrix, address )
   Call storeaddr( cntvect, indx_fdevalini , address )
   Call storeaddr( cntvect, indx_fdeval    , address )
   Call storeaddr( cntvect, indx_fdevalend , address )
   Call storeaddr( cntvect, indx_status    , address )
   Call storeaddr( cntvect, indx_solution  , address )
   Call storeaddr( cntvect, indx_message   , address )
   Call storeaddr( cntvect, indx_progress  , address )
   Call storeaddr( cntvect, indx_option    , address )
   Call storeaddr( cntvect, indx_errmsg    , address )
   Call storeaddr( cntvect, indx_triord    , address )
   Call storeaddr( cntvect, indx_fdinterval, address )
   Call storeaddr( cntvect, indx_2ddirini  , address )
   Call storeaddr( cntvect, indx_2ddir     , address )
   Call storeaddr( cntvect, indx_2ddirend  , address )
   Call storeaddr( cntvect, indx_2ddirlagr , address )
   Call storeaddr( cntvect, indx_2dlagrsize, address )
   Call storeaddr( cntvect, indx_2dlagrstr , address )
   Call storeaddr( cntvect, indx_2dlagrval , address )
   Call storeaddr( cntvect, indx_usrmem    , address )
!
!  Add a few 'magic numbers' so we can check for an overwritten control
!  vector.
!
   cntvect(1)           = numcallback
   cntvect(numcallback) = numcallback
!
!  Initialize the options file to blank. Needs the magic numbers first.
!
   filename = ' '
   coidef_ini = coidef_optfile( cntvect, filename )
 
End Function coidef_ini
 
!> 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
!!
Integer Function coidef_inifort( CntVect )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_IniFort
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_IniFort
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_INIFORT'::COIDEF_IniFort
#endif
#endif
   USE conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
 
   Integer, External :: coidef_ini
   Integer, External :: coidef_fortran
   Integer, External :: coidef_base
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Ini
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_INI'::COIDEF_Ini
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Fortran
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_FORTRAN'::COIDEF_Fortran
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Base
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_BASE'::COIDEF_Base
#endif
   Integer :: i
 
   coidef_inifort = coidef_ini( cntvect )
   If ( coidef_inifort == 0 ) Then
      i = coidef_base( cntvect, 1 )
      i = coidef_fortran( cntvect )
   Endif
 
End Function coidef_inifort
 
!> 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
!!
Integer Function coidef_numvar( CntVect, NumVar )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_NumVar
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_NumVar
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_NUMVAR'::COIDEF_NumVar
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: numvar
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_numvar = corruptcntr
   Elseif ( numvar < 0 ) Then
      coidef_numvar = rangeproblem; cntvect(indx_range) = 1;
#if defined (write20)
      write(20,*) 'COIDEF_NumVar: Illegal argument. NumVar=',numvar
#endif
   Else
      coidef_numvar = 0
      cntvect(indx_numvar) = numvar
   Endif
 
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
!!
Integer Function coidef_numcon( CntVect, NumCon )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_NumCon
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_NumCon
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_NUMCON'::COIDEF_NumCon
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: numcon
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_numcon = corruptcntr
   Elseif ( numcon < 0 ) Then
      coidef_numcon = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_NumCon: Illegal argument. NumCon=',numcon
#endif
   Else
      coidef_numcon = 0
      cntvect(indx_numcon) = numcon
   Endif
 
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
!!
Integer Function coidef_numnz( CntVect, NumNz )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_NumNz
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_NumNz
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_NUMNZ'::COIDEF_NumNz
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: numnz
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_numnz = corruptcntr
   Elseif ( numnz < 0 ) Then
      coidef_numnz = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_NumNz: Illegal argument. NumNz=',numnz
#endif
   Else
      coidef_numnz = 0
      cntvect(indx_numnz) = numnz
   Endif
 
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
!!
Integer Function coidef_numnlnz( CntVect, NumNlNz )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_NumNlNz
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_NumNlNz
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_NUMNLNZ'::COIDEF_NumNlNz
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: numnlnz
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_numnlnz = corruptcntr
   Elseif ( numnlnz < 0 ) Then
      coidef_numnlnz = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_NumNlNz: Illegal argument. NumNlNz=',numnlnz
#endif
   Else
      coidef_numnlnz = 0
      cntvect(indx_numnlnz) = numnlnz
   Endif
 
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
!!
Integer Function coidef_numhess( CntVect, NumHess )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_NumHess
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_NumHess
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_NUMHESS'::COIDEF_NumHess
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: numhess
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_numhess = corruptcntr
   Elseif ( numhess < 0 ) Then
      coidef_numhess = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_NumHess: Illegal argument. NumHess=',numhess
#endif
   Else
      coidef_numhess = 0
      cntvect(indx_numhess) = numhess
   Endif
 
End function coidef_numhess
 
!> 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
!!
Integer Function coidef_optdir( CntVect, OptDir )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_OptDir
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_OptDir
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_OPTDIR'::COIDEF_OptDir
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: optdir
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_optdir = corruptcntr
   Elseif ( optdir > 1 .or. optdir < -1 ) Then
      coidef_optdir = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_OptDir: Illegal argument. OptDir=',optdir
#endif
   Else
      coidef_optdir = 0
      cntvect(indx_optdir) = optdir
   Endif
 
End function coidef_optdir
 
!> defines the Objective Variable.
!!
!! @param cntvect    the control vector
!! @param objvar     the index of the objective variable
!!
!! @ingroup REGISTRATION_OF_SIZES_F90
!!
Integer Function coidef_objvar( CntVect, ObjVar )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_ObjVar
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_ObjVar
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_OBJVAR'::COIDEF_ObjVar
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: objvar
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_objvar = corruptcntr
   Elseif ( objvar < 0 ) Then
      coidef_objvar = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_ObjVar: Illegal argument. ObjVar=',objvar
#endif
   Else
      coidef_objvar = 0
      cntvect(indx_objindx) = objvar
      cntvect(indx_objtyp ) = 1
   Endif
 
End function coidef_objvar
 
!> 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
!!
Integer Function coidef_objcon( CntVect, ObjCon )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_ObjCon
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_ObjCon
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_OBJCON'::COIDEF_ObjCon
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: objcon
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_objcon = corruptcntr
   Elseif ( objcon < 0 ) Then
      coidef_objcon = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_ObjCon: Illegal argument. ObjCon=',objcon
#endif
   Else
      coidef_objcon = 0
      cntvect(indx_objindx) = objcon
      cntvect(indx_objtyp ) = -1
   Endif
 
End function coidef_objcon
 
!> @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
!!
Integer Function coidef_license( CntVect, LicInt1, LicInt2, LicInt3, LicString )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_License
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_License
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_LICENSE'::COIDEF_License
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Character(len=*) :: licstring
   Character(len=CO_LicLen) :: lictext
   Integer :: licint1, licint2, licint3
   Integer :: liccod1, liccod2, liccod3
   Integer :: i, j
   Character(len=8) date
   Integer year, month, day
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_license = corruptcntr
   Else
      coidef_license = 0
      cntvect(indx_licint1) = licint1
      cntvect(indx_licint2) = licint2
      cntvect(indx_licint3) = licint3
 
      call date_and_time( date )  ! Todays Date
      read(date,"(I4,i2,i2)") year, month, day
      liccod1 = 0
      liccod2 = day + 30 * month + 360 * ( year-2000 )
      liccod3 = 0
      do i = 1, len(licstring)
         liccod1 = liccod1 + ichar(licstring(i:i))*i
         liccod3 = liccod3 + mod(ichar(licstring(i:i))*987,1048576)
      enddo
      lictext = licstring
      i = indx_lictext
      do j = 1, co_liclen, 4
         Call packchar( lictext(j:j+3), cntvect(i) )
         i = i + 1
      enddo
 
      cntvect(indx_liccod1) = liccod1
      cntvect(indx_liccod2) = liccod2
      cntvect(indx_liccod3) = liccod3
   Endif
 
End function coidef_license
 
!> 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
!!
Integer Function coidef_base( CntVect, Base )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_BASE
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Base
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_BASE'::COIDEF_Base
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: base
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_base = corruptcntr
   Elseif ( base < 0 .or. base > 1) Then
      coidef_base = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_Base: Illegal argument. NumBase=',base
#endif
   Else
      coidef_base = 0
      cntvect(indx_base) = base
   Endif
 
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
!!
Integer Function coidef_fortran( CntVect )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_Fortran
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Fortran
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_FORTRAN'::COIDEF_Fortran
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_fortran = corruptcntr
   Else
      coidef_fortran = 0
      cntvect(indx_fortran) = 1
   Endif
 
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
!!
Integer Function coidef_c( CntVect )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_C
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_C
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_C'::COIDEF_C
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_c = corruptcntr
   Else
      coidef_c = 0
      cntvect(indx_fortran) = 0
   Endif
 
End function coidef_c
 
!> @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
!!
Integer Function coidef_itlim( CntVect, ItLim )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_ItLim
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_ItLim
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_ITLIM'::COIDEF_ItLim
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: itlim
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_itlim = corruptcntr
   Elseif ( itlim < 0 ) Then
      coidef_itlim = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_ItLim: Illegal argument. ItLim=',itlim
#endif
   Else
      coidef_itlim = 0
      cntvect(indx_itlim) = itlim
   Endif
 
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
!!
Integer Function coidef_errlim( CntVect, ErrLim )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_ErrLim
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_ErrLim
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_ERRLIM'::COIDEF_ErrLim
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: errlim
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_errlim = corruptcntr
   Elseif ( errlim < 0 ) Then
      coidef_errlim = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_ErrLim: Illegal argument. ErrLim=',errlim
#endif
   Else
      coidef_errlim = 0
      cntvect(indx_errlim) = errlim
   Endif
 
End function coidef_errlim
 
!> @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
!!
Integer Function coidef_reslim( CntVect, ResLim )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_ResLim
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_ResLim
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_RESLIM'::COIDEF_ResLim
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Real(co_r) :: reslim
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_reslim = corruptcntr
   Elseif ( reslim < 0.0_co_r ) Then
      coidef_reslim = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_ResLim: Illegal argument. ResLim=',reslim
#endif
   Else
      coidef_reslim = 0
      Call storereal( cntvect, indx_reslim, reslim )
   Endif
 
End function coidef_reslim
 
!> @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
!!
Integer Function coidef_maxheap( CntVect, MaxHeap )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_MaxHeap
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_MaxHeap
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_MAXHEAP'::COIDEF_MaxHeap
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Real(co_r) :: maxheap
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_maxheap = corruptcntr
   Elseif ( maxheap < 0.0_co_r ) Then
      coidef_maxheap = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_Maxheap: Illegal argument. Maxheap=',maxheap
#endif
   Else
      coidef_maxheap = 0
      Call storereal( cntvect, indx_maxheap, maxheap )
   Endif
 
End function coidef_maxheap
 
!> 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
!!
Integer Function coidef_inistat( CntVect, IniStat )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_IniStat
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_IniStat
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_INISTAT'::COIDEF_IniStat
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: inistat
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_inistat = corruptcntr
   Elseif ( inistat < 0 .or. inistat > 2 ) Then
      coidef_inistat = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_IniStat: Illegal argument. IniStat=',inistat
#endif
   Else
      coidef_inistat = 0
      cntvect(indx_inistat) = inistat
   Endif
 
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
!!
Integer Function coidef_fvinclin( CntVect, FVincLin )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_FVincLin
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_FVincLin
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_FVINCLIN'::COIDEF_FVincLin
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: fvinclin
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_fvinclin = corruptcntr
   Elseif ( fvinclin < 0 .or. fvinclin > 1) Then
      coidef_fvinclin = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_FVincLin: Illegal argument. FVincLin=',fvinclin
#endif
   Else
      coidef_fvinclin = 0
      cntvect(indx_fvinclin) = fvinclin
   Endif
 
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
!!
Integer Function coidef_fvforall( CntVect, FVforAll )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_FVforAll
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_FVforAll
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_FVFORALL'::COIDEF_FVforAll
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: fvforall
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_fvforall = corruptcntr
   Elseif ( fvforall < 0 .or. fvforall > 1 ) Then
      coidef_fvforall = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_FVforAll: Illegal argument. FVforAll=',fvforall
#endif
   Else
      coidef_fvforall = 0
      cntvect(indx_fvforall) = fvforall
   Endif
 
End function coidef_fvforall
 
!> @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
!!
Integer Function coidef_maxsup( CntVect, MaxSup )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_MaxSup
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_MaxSup
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_MAXSUP'::COIDEF_MaxSup
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: maxsup
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_maxsup = corruptcntr
   Elseif ( maxsup < -1 ) Then
      coidef_maxsup = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_MaxSup: Illegal argument. MaxSup=',maxsup
#endif
   Else
      coidef_maxsup = 0
      cntvect(indx_maxsup) = maxsup
   Endif
 
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
!!
Integer Function coidef_square( CntVect, Square )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_Square
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Square
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_SQUARE'::COIDEF_Square
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: square
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_square = corruptcntr
   Elseif ( square < 0 .or. square > 1 ) Then
      coidef_square = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_Square: Illegal argument. Square=',square
#endif
   Else
      coidef_square = 0
      cntvect(indx_square) = square
   Endif
 
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
!!
Integer Function coidef_emptyrow( CntVect, EmptyRow )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_EmptyRow
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_EmptyRow
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_EMPTYROW'::COIDEF_EmptyRow
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: emptyrow
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_emptyrow = corruptcntr
   Elseif ( emptyrow < 0 .or. emptyrow > 1 ) Then
      coidef_emptyrow = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_EmptyRow: Illegal argument. EmptyRow=',emptyrow
#endif
   Else
      coidef_emptyrow = 0
      cntvect(indx_emptyrow) = emptyrow
   Endif
 
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
!!
Integer Function coidef_emptycol( CntVect, EmptyCol )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_EmptyCol
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_EmptyCol
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_EMPTYCOL'::COIDEF_EmptyCol
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: emptycol
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_emptycol = corruptcntr
   Elseif ( emptycol < 0 .or. emptycol > 1 ) Then
      coidef_emptycol = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_EmptyCol: Illegal argument. EmptyCol=',emptycol
#endif
   Else
      coidef_emptycol = 0
      cntvect(indx_emptycol) = emptycol
   Endif
 
End function coidef_emptycol
 
!> @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
!!
Integer Function coidef_discont( CntVect, DisCont )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_DisCont
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_DisCont
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_DISCONT'::COIDEF_DisCont
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: discont
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_discont = corruptcntr
   Elseif ( discont < 0 .or. discont > 1 ) Then
      coidef_discont = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_DisCont: Illegal argument. DisCont=',discont
#endif
   Else
      coidef_discont = 0
      cntvect(indx_discont) = discont
   Endif
 
End function coidef_discont
 
!> 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
!!
Integer Function coidef_hessfac( CntVect, HessFac )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_HessFac
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_HessFac
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_HESSFAC'::COIDEF_HessFac
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Real(co_r) :: hessfac
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_hessfac = corruptcntr
   Elseif ( hessfac < 0.0_co_r ) Then
#if defined (write20)
      write(20,*) 'COIDEF_HessFac: Illegal argument. HessFac=',hessfac
#endif
      coidef_hessfac = rangeproblem; cntvect(indx_range) = 1
   Else
      coidef_hessfac = 0
      Call storereal( cntvect, indx_hessfac, hessfac )
   Endif
 
End function coidef_hessfac
 
!> @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
!!
Integer Function coidef_debugfv( CntVect, DebugFV )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_DebugFV
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_DebugFV
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_DEBUGFV'::COIDEF_DebugFV
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: debugfv
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_debugfv = corruptcntr
   Elseif ( debugfv < -1 ) Then
      coidef_debugfv = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_DebugFV: Illegal argument. DebugFV=',debugfv
#endif
   Else
      coidef_debugfv = 0
      cntvect(indx_debugfv) = debugfv
   Endif
 
End function coidef_debugfv
 
!> @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
!!
Integer Function coidef_debug2d( CntVect, Debug2D )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_Debug2D
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Debug2D
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_DEBUG2D'::COIDEF_Debug2D
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: debug2d
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_debug2d = corruptcntr
   Elseif ( debug2d < -1 ) Then
      coidef_debug2d = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_Debug2D: Illegal argument. Debug2D=',debug2d
#endif
   Else
      coidef_debug2d = 0
      cntvect(indx_debug2d) = debug2d
   Endif
 
End function coidef_debug2d
 
!> 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
!!
Integer Function coidef_zeronoise( CntVect, ZeroNoise )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_ZeroNoise
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_ZeroNoise
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_ZERONOISE'::COIDEF_ZeroNoise
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Real(co_r) :: zeronoise
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_zeronoise = corruptcntr
   Elseif ( zeronoise < 0.0_co_r ) Then
      coidef_zeronoise = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_ZeroNoise: Illegal argument. ZeroNoise=',zeronoise
#endif
   Else
      coidef_zeronoise = 0
      Call storereal( cntvect, indx_zeronoise, zeronoise )
   Endif
 
End function coidef_zeronoise
 
!> @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
!!
Integer Function coidef_threads( CntVect, Threads )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_Threads
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Threads
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_THREADS'::COIDEF_Threads
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: threads
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_threads = corruptcntr
   Elseif ( threads < 0 ) Then
      coidef_threads = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_Threads: Illegal argument. Threads=',threads
#endif
   Else
      coidef_threads = 0
      cntvect(indx_threads) = threads
   Endif
 
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
!!
Integer Function coidef_threadf( CntVect, ThreadF )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_ThreadF
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_ThreadF
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_THREADF'::COIDEF_ThreadF
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: threadf
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_threadf = corruptcntr
   Elseif ( threadf < 0 ) Then
      coidef_threadf = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_ThreadF: Illegal argument. ThreadF=',threadf
#endif
   Else
      coidef_threadf = 0
      cntvect(indx_threadf) = threadf
   Endif
 
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
!!
Integer Function coidef_thread2d( CntVect, Thread2D )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_Thread2D
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Thread2D
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_THREAD2D'::COIDEF_Thread2D
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: thread2d
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_thread2d = corruptcntr
   Elseif ( thread2d < 0 ) Then
      coidef_thread2d = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_Thread2D: Illegal argument. Thread2D=',thread2d
#endif
   Else
      coidef_thread2d = 0
      cntvect(indx_thread2d) = thread2d
   Endif
 
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
!!
Integer Function coidef_threadc( CntVect, ThreadC )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_ThreadC
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_ThreadC
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_THREADC'::COIDEF_ThreadC
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: threadc
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_threadc = corruptcntr
   Elseif ( threadc < 0 ) Then
      coidef_threadc = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_ThreadC: Illegal argument. ThreadC=',threadc
#endif
   Else
      coidef_threadc = 0
      cntvect(indx_threadc) = threadc
   Endif
 
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
!!
Integer Function coidef_stdout( CntVect, toStdOut )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_StdOut
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_StdOut
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_STDOUT'::COIDEF_StdOut
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: tostdout
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_stdout = corruptcntr
   Elseif ( tostdout < 0 .or. tostdout > 1 ) Then
      coidef_stdout = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_StdOut: Illegal argument. StdOut=',tostdout
#endif
   Else
      coidef_stdout = 0
      cntvect(indx_stdout) = tostdout
   Endif
 
End function coidef_stdout
 
!> 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
!!
Integer Function coidef_optorder( CntVect, OptOrder )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_OptOrder
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_OptOrder
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_OPTORDER'::COIDEF_OptOrder
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: optorder
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_optorder = corruptcntr
   Elseif ( optorder < 0 .OR. optorder > 1 ) Then
      coidef_optorder = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_OptOrder: Illegal argument. OptOrder=',optorder
#endif
   Else
      coidef_optorder = 0
      cntvect(indx_optorder) = optorder
   Endif
 
End function coidef_optorder
 
!> @defgroup DEF_COI_CLEARM ""
!! ClearM
!!
!! @param clearm
 
!> @copydoc DEF_COI_CLEARM
!! @param cntvect    the control vector
!!
!! @ingroup REGISTRATION_OF_OPTIONS_F90
!!
Integer Function coidef_clearm( CntVect, ClearM )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_ClearM
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_ClearM
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_CLEARM'::COIDEF_ClearM
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, dimension(NumCallBack) :: cntvect
   Integer :: clearm
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_clearm = corruptcntr
   Elseif ( clearm < 0 .or. clearm > 1 ) Then
      coidef_clearm = rangeproblem; cntvect(indx_range) = 1
#if defined (write20)
      write(20,*) 'COIDEF_ClearM: Illegal argument. ClearM=',clearm
#endif
   Else
      coidef_clearm = 0
      cntvect(indx_clearm) = clearm
   Endif
 
End function coidef_clearm
 
!> 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
!!
Integer Function coidef_optfile( CntVect, Optfile )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_Optfile
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Optfile
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_OPTFILE'::COIDEF_Optfile
#endif
#endif
   Use conopt_utilities
   Implicit None
   Character(Len=*) :: optfile
   Integer, dimension(NumCallBack) :: cntvect
   Character(Len=CO_Filelen) :: filename
   integer :: i,j
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_optfile = corruptcntr
   Else
      filename = optfile
      i = indx_optfile
      do j = 1, co_filelen, 4
         Call packchar( filename(j:j+3), cntvect(i) )
         i = i + 1
      enddo
      coidef_optfile = 0
   Endif
 
End Function coidef_optfile
 
!> 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
!!
Integer Function coidef_readmatrix( CntVect, COI_ReadMatrix )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_ReadMatrix
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_ReadMatrix
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_READMATRIX'::COIDEF_ReadMatrix
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_readmatrix
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_readmatrix = corruptcntr
   Else
      coidef_readmatrix = 0
      address           = coi_addressofext( coi_readmatrix )
      Call storeaddr( cntvect, indx_readmatrix, address )
   Endif
 
End Function coidef_readmatrix
 
!> 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
!!
Integer Function coidef_fdevalini( CntVect, COI_FDEvalIni )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_FDEvalIni
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_FDEvalIni
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_FDEVALINI'::COIDEF_FDEvalIni
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_fdevalini
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_fdevalini = corruptcntr
   Else
      coidef_fdevalini = 0
      address       = coi_addressofext( coi_fdevalini )
      Call storeaddr( cntvect, indx_fdevalini, address )
   Endif
 
End Function coidef_fdevalini
 
!> 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
!!
Integer Function coidef_fdeval( CntVect, COI_FDEval )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_FDEval
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_FDEval
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_FDEVAL'::COIDEF_FDEval
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_fdeval
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_fdeval = corruptcntr
   Else
      coidef_fdeval = 0
      address       = coi_addressofext( coi_fdeval )
      Call storeaddr( cntvect, indx_fdeval, address )
   Endif
 
End Function coidef_fdeval
 
!> 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
!!
Integer Function coidef_fdevalend( CntVect, COI_FdevalEnd )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_FdevalEnd
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_FDEvalEnd
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_FDEVALEND'::COIDEF_FDEvalEnd
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_fdevalend
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_fdevalend = corruptcntr
   Else
      coidef_fdevalend = 0
      address       = coi_addressofext( coi_fdevalend )
      Call storeaddr( cntvect, indx_fdevalend, address )
   Endif
 
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
!!
Integer Function coidef_status( CntVect, COI_Status )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_Status
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Status
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_STATUS'::COIDEF_Status
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_status
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_status = corruptcntr
   Else
      coidef_status = 0
      address       = coi_addressofext( coi_status )
      Call storeaddr( cntvect, indx_status, address )
   Endif
 
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
!!
Integer Function coidef_solution( CntVect, COI_Solution )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_Solution
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Solution
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_SOLUTION'::COIDEF_Solution
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_solution
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_solution = corruptcntr
   Else
      coidef_solution = 0
      address         = coi_addressofext( coi_solution )
      Call storeaddr( cntvect, indx_solution, address )
   Endif
 
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
!!
Integer Function coidef_message( CntVect, COI_Message )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_Message
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Message
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_MESSAGE'::COIDEF_Message
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_message
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_message = corruptcntr
   Else
      coidef_message = 0
      address        = coi_addressofext( coi_message )
      Call storeaddr( cntvect, indx_message, address )
   Endif
 
End Function coidef_message
 
!> 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
!!
Integer Function coidef_progress( CntVect, COI_Progress )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_Progress
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Progress
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_PROGRESS'::COIDEF_Progress
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_progress
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_progress = corruptcntr
   Else
      coidef_progress = 0
      address         = coi_addressofext( coi_progress )
      Call storeaddr( cntvect, indx_progress, address )
   Endif
 
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
!!
Integer Function coidef_option( CntVect, COI_Option )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_Option
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_Option
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_OPTION'::COIDEF_Option
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_option
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_option = corruptcntr
   Else
      coidef_option = 0
      address       = coi_addressofext( coi_option )
      Call storeaddr( cntvect, indx_option, address )
   Endif
 
End Function coidef_option
 
!> 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
!!
Integer Function coidef_errmsg( CntVect, COI_ErrMsg )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_ErrMsg
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_ErrMsg
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_ERRMSG'::COIDEF_ErrMsg
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_errmsg
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_errmsg = corruptcntr
   Else
      coidef_errmsg = 0
      address       = coi_addressofext( coi_errmsg )
      Call storeaddr( cntvect, indx_errmsg, address )
   Endif
 
End Function coidef_errmsg
 
!> 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
!!
Integer Function coidef_triord( CntVect, COI_TriOrd )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_TriOrd
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_TriOrd
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_TRIORD'::COIDEF_TriOrd
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_triord
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_triord = corruptcntr
   Else
      coidef_triord = 0
      address       = coi_addressofext( coi_triord )
      Call storeaddr( cntvect, indx_triord, address )
   Endif
 
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
!!
Integer Function coidef_fdinterval( CntVect, COI_FDInterval )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_FDInterval
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_FDInterval
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_FDINTERVAL'::COIDEF_FDInterval
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_fdinterval
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_fdinterval = corruptcntr
   Else
      coidef_fdinterval = 0
      address           = coi_addressofext( coi_fdinterval )
      Call storeaddr( cntvect, indx_fdinterval, address )
   Endif
 
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
!!
Integer Function coidef_2ddir( CntVect, COI_2DDir )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_2DDir
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_2DDir
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_2DDIR'::COIDEF_2DDir
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_2ddir
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_2ddir = corruptcntr
   Else
      coidef_2ddir = 0
      address      = coi_addressofext( coi_2ddir )
      Call storeaddr( cntvect, indx_2ddir, address )
   Endif
 
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
!!
Integer Function coidef_2ddirini( CntVect, COI_2DDirIni )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_2DDirIni
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_2DDirIni
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_2DDIRINI'::COIDEF_2DDirIni
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_2ddirini
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_2ddirini = corruptcntr
   Else
      coidef_2ddirini = 0
      address      = coi_addressofext( coi_2ddirini )
      Call storeaddr( cntvect, indx_2ddirini, address )
   Endif
 
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
!!
Integer Function coidef_2ddirend( CntVect, COI_2DDirEnd )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_2DDirEnd
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_2DDirEnd
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_2DDIREND'::COIDEF_2DDirEnd
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_2ddirend
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_2ddirend = corruptcntr
   Else
      coidef_2ddirend = 0
      address      = coi_addressofext( coi_2ddirend )
      Call storeaddr( cntvect, indx_2ddirend, address )
   Endif
 
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
!!
Integer Function coidef_2ddirlagr( CntVect, COI_2DDirLagr )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_2DDirLagr
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_2DDirLagr
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_2DDIRLAGR'::COIDEF_2DDirLagr
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_2ddirlagr
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_2ddirlagr = corruptcntr
   Else
      coidef_2ddirlagr = 0
      address         = coi_addressofext( coi_2ddirlagr )
      Call storeaddr( cntvect, indx_2ddirlagr, address )
   Endif
 
End Function coidef_2ddirlagr
 
Integer Function coidef_2dlagrsize( CntVect, COI_2DLagrSize )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_2DLagrSize
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_2DLagrSize
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_2DLAGRSIZE'::COIDEF_2DLagrSize
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_2dlagrsize
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_2dlagrsize = corruptcntr
   Else
      coidef_2dlagrsize = 0
      address       = coi_addressofext( coi_2dlagrsize )
      Call storeaddr( cntvect, indx_2dlagrsize, address )
   Endif
 
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
!!
Integer Function coidef_2dlagrstr( CntVect, COI_2DLagrStr )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_2DLagrStr
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_2DLagrStr
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_2DLAGRSTR'::COIDEF_2DLagrStr
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_2dlagrstr
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_2dlagrstr = corruptcntr
   Else
      coidef_2dlagrstr = 0
      address       = coi_addressofext( coi_2dlagrstr )
      Call storeaddr( cntvect, indx_2dlagrstr, address )
   Endif
 
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
!!
Integer Function coidef_2dlagrval( CntVect, COI_2DLagrVal )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_2DLagrVal
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_2DLagrVal
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_2DLAGRVAL'::COIDEF_2DLagrVal
#endif
#endif
   Use conopt_utilities
   Implicit None
   External coi_2dlagrval
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_2dlagrval = corruptcntr
   Else
      coidef_2dlagrval = 0
      address       = coi_addressofext( coi_2dlagrval )
      Call storeaddr( cntvect, indx_2dlagrval, address )
   Endif
 
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
!!
Integer Function coidef_usrmem( CntVect, UsrMem )
#if defined (dec_directives)
!DEC$ ATTRIBUTES DLLEXPORT :: COIDEF_UsrMem
#if defined (itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: COIDEF_UsrMem
!DEC$ ATTRIBUTES DECORATE, ALIAS: 'COIDEF_USRMEM'::COIDEF_UsrMem
#endif
#endif
   Use conopt_utilities
   Implicit None
   Integer, Dimension(*) :: usrmem ! Should be pointer to void but using a Character may add an extra argument
   Integer(CO_P) :: address
   Integer, dimension(NumCallBack) :: cntvect
 
   If ( cntvect(1) /= numcallback .or. cntvect(numcallback) /= numcallback) Then
      coidef_usrmem = corruptcntr
   Else
      coidef_usrmem = 0
      address       = coi_addressofext( usrmem )
      Call storeaddr( cntvect, indx_usrmem, address )
   Endif
 
End Function coidef_usrmem