eq2b.f90

Go to the documentation of this file.

!> @file eq2b.f90
!! @ingroup FORT1THREAD_EXAMPLES
!!
!! 
!! Tests EQ2 constraints that are made post-triangular by transfer of bounds.
!! 
!! \f{eqnarray*}{
!! \min 7&x1&+8&x2&+100&x3&\\
!! &x1&  &&       +&x3& = 2.0 \\
!! &x1&+  &x2&     &&   < 1.0 \\
!! &x1&, &x2&, &x3& \geq 0
!! \f}
!! 
!!
!! For more information about the individual callbacks, please have a look at the source code.
 
!> Main program. A simple setup and call of CONOPT
!!
Program eq2b
!
!  Declare the user callback routines as Integer, External:
!
   Use proginfo
   Use coidef
   implicit None
 
   Integer, External :: eq2b_readmatrix ! Mandatory Matrix definition routine defined below
   Integer, External :: std_status      ! Standard callback for displaying solution status
   Integer, External :: std_solution    ! Standard callback for displaying solution values
   Integer, External :: std_message     ! Standard callback for managing messages
   Integer, External :: std_errmsg      ! Standard callback for managing error messages
#if defined(itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: eq2b_ReadMatrix
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: Std_Status
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: Std_Solution
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: Std_Message
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: Std_ErrMsg
#endif
!
!  Control vector
!
   INTEGER :: numcallback
   INTEGER, Dimension(:), Pointer :: cntvect
   INTEGER :: coi_error
 
   real*8, dimension(3) :: xsol1 = (/ 1.0d0, 0.0d0, 1.0d0 /)
   real*8, dimension(3) :: xdua1 = (/ 0.0d0, 101.0d0, 0.0d0 /)
   real*8, dimension(3) :: udua1 = (/ 100.d0, -93.d0, 0.d0 /)
   Integer :: i
   Logical :: error
 
   Call startup
!
!  Create and initialize a Control Vector
!
   numcallback = coidef_size()
   Allocate( cntvect(numcallback) )
   coi_error = coidef_inifort( cntvect )
!
!  Tell CONOPT about the size of the model by populating the Control Vector:
!
!  Number of variables
!
   coi_error = max( coi_error, coidef_numvar( cntvect, 3 ) )
!
!  Number of equations
!
   coi_error = max( coi_error, coidef_numcon( cntvect, 3 ) )
!
!  Number of nonzeros in the Jacobian.
!
   coi_error = max( coi_error, coidef_numnz( cntvect, 7 ) )
!
!  Number of nonlinear nonzeros.
!
   coi_error = max( coi_error, coidef_numnlnz( cntvect, 0 ) )
!
!  Optimization direction is Minimize = -1
!
   coi_error = max( coi_error, coidef_optdir( cntvect, -1 ) )
!
!  Objective is constraint 3
!
   coi_error = max( coi_error, coidef_objcon( cntvect, 3 ) )
!
!  Define the options file as 'eq2b.opt'
!
   coi_error = max( coi_error, coidef_optfile( cntvect, 'eq2b.opt'  ) )
!
!  Tell CONOPT about the callback routines:
!
   coi_error = max( coi_error, coidef_readmatrix( cntvect, eq2b_readmatrix ) )
   coi_error = max( coi_error, coidef_status( cntvect, std_status     ) )
   coi_error = max( coi_error, coidef_solution( cntvect, std_solution   ) )
   coi_error = max( coi_error, coidef_message( cntvect, std_message    ) )
   coi_error = max( coi_error, coidef_errmsg( cntvect, std_errmsg     ) )
 
#if defined(LICENSE_INT_1) && defined(LICENSE_INT_2) && defined(LICENSE_INT_3) && defined(LICENSE_TEXT)
   coi_error = max( coi_error, coidef_license( cntvect, license_int_1, license_int_2, license_int_3, license_text) )
#endif
 
   If ( coi_error .ne. 0 ) THEN
      write(*,*)
      write(*,*) '**** Fatal Error while loading CONOPT Callback routines.'
      write(*,*)
      call flog( "Skipping Solve due to setup errors", 1 )
   ENDIF
   do_allocate = .true.
!
!  Start CONOPT:
!
   coi_error = coi_solve( cntvect )
 
   write(*,*)
   write(*,*) 'End of example eq2b'
 
   If ( coi_error /= 0 ) then
      call flog( "Errors encountered during solution", 1 )
   elseif ( stacalls == 0 .or. solcalls == 0 ) then
      call flog( "Status or Solution routine was not called", 1 )
   elseif ( sstat /= 1 .or. mstat /= 1 ) then  ! This is an LP model
      call flog( "Solver and Model Status was not as expected (1,1)", 1 )
   elseif ( abs( obj-107.0d0 ) > 0.000001d0 ) then
      call flog( "Incorrect objective returned", 1 )
   Else
!
!  Check the primal and dual solution itself
!
      error = .false.
      do i = 1, 3
         if ( abs(xprim(i)-xsol1(i)) > 1.d-7 ) error = .true.
         if ( abs(xdual(i)-xdua1(i)) > 1.d-7 ) error = .true.
         if ( abs(udual(i)-udua1(i)) > 1.d-7 ) error = .true.
      enddo
      if ( error ) call flog( "Eq2b: Numerical solution was not as expected.", 1 )
      Call checkdual( 'Eq2b', minimize )
   endif
 
   if ( coi_free(cntvect) /= 0 ) call flog( "Error while freeing control vector",1)
 
   call flog( "Successful Solve", 0 )
 
End Program eq2b
!
! ============================================================================
!  Define information about the model:
!
 
!>  Define information about the model
!!
!! @include{doc} readMatrix_params.dox
Integer Function eq2b_readmatrix( lower, curr, upper, vsta, type, rhs, esta,      &
                            colsta, rowno, value, nlflag, n, m, nz, usrmem )
#if defined(itl)
!DEC$ ATTRIBUTES STDCALL, REFERENCE, NOMIXED_STR_LEN_ARG :: eq2b_ReadMatrix
#endif
   implicit none
   integer, intent (in)                      :: n      ! number of variables
   integer, intent (in)                      :: m      ! number of constraints
   integer, intent (in)                      :: nz     ! number of nonzeros
   real*8,  intent (in out), dimension(n)    :: lower  ! vector of lower bounds
   real*8,  intent (in out), dimension(n)    :: curr   ! vector of initial values
   real*8,  intent (in out), dimension(n)    :: upper  ! vector of upper bounds
   integer, intent (in out), dimension(n)    :: vsta   ! vector of initial variable status
                                                       ! (not defined here)
   integer, intent (out),    dimension(m)    :: type   ! vector of equation types
   integer, intent (in out), dimension(m)    :: esta   ! vector of initial equation status
                                                       ! (not defined here)
   real*8,  intent (in out), dimension(m)    :: rhs    ! vector of right hand sides
   integer, intent (in out), dimension(n+1)  :: colsta ! vector with start of column indices
   integer, intent (out),    dimension(nz)   :: rowno  ! vector of row numbers
   integer, intent (in out), dimension(nz)   :: nlflag ! vector of nonlinearity flags
   real*8,  intent (in out), dimension(nz)   :: value  ! vector of matrix values
   real*8   usrmem(*)                                  ! optional user memory
!
!  Define information about the Variables:
!
!  Curr is not defined. We will use the default starting values of
!  zero.
!
!  By default, we do not define the status argument Vsta.
!
!  The variables are Positive, i.e. have a lower bound of zero.
!
   lower(1) = 0.d0
   lower(2) = 0.d0
   lower(3) = 0.d0
!
!  Define information about the Constraints:
!
   rhs(1)  = 2.0d0
   type(1) = 0      ! =E=
   rhs(2)  = 1.0d0
   type(2) = 2      ! =L=
   type(3) = 3      ! =N=
!
!  The Jacobian has to be sorted column-wise so we will just define
!  the elements column by column according to the table above:
!
   colsta(1) = 1
   rowno(1)  = 1
   value(1)  = 1.d0
   rowno(2)  = 2
   value(2)  = 1.d0
   rowno(3)  = 3
   value(3)  = 7.d0
!
   colsta(2) = 4
   rowno(4)  = 2
   value(4)  = 1.0d0
   rowno(5)  = 3
   value(5)  = 8.0d0
!
   colsta(3) = 6
   rowno(6)  = 1
   value(6)  = 1.d0
   rowno(7)  = 3
   value(7)  = 100.0d0
!
!
!  End of columns, the next free position is = number of elements+1:
!
   colsta(4) = 8
 
   eq2b_readmatrix = 0
 
end Function eq2b_readmatrix