Example description
/* nag_opt_handle_solve_ipopt (e04stc) Example Program.
 *
 * Copyright 2020 Numerical Algorithms Group.
 *
 * Mark 27.1, 2020.
 */

/*
 * NLP example: Linear objective + Linear constraint + Non-Linear constraint
 * For illustrative purposes, the linear objective will the trated as a
 * nonlinear function to show the usage of objfun and objgrd user
 * callbacks.
 */

#include <math.h>
#include <nag.h>
#include <stdio.h>

#ifdef __cplusplus
extern "C" {
#endif
static void NAG_CALL objfun(Integer nvar, const double x[], double *fx,
                            Integer *flag, Nag_Comm *comm);
static void NAG_CALL objgrd(Integer nvar, const double x[], Integer nnzfd,
                            double fdx[], Integer *flag, Nag_Comm *comm);
static void NAG_CALL confun(Integer nvar, const double x[], Integer ncnln,
                            double gx[], Integer *flag, Nag_Comm *comm);
static void NAG_CALL congrd(Integer nvar, const double x[], Integer nnzgd,
                            double gdx[], Integer *flag, Nag_Comm *comm);
static void NAG_CALL hess(Integer nvar, const double x[], Integer ncnln,
                          Integer idf, double sigma, const double lambda[],
                          Integer nnzh, double hx[], Integer *flag,
                          Nag_Comm *comm);
static void NAG_CALL monit(Integer nvar, const double x[], Integer nnzu,
                           const double u[], Integer *flag,
                           const double rinfo[], const double stats[],
                           Nag_Comm *comm);
#ifdef __cplusplus
}
#endif

int main(void) {
#define BIGBND 1.0E20
  /* Scalars */
  Integer exit_status = 0;
  Integer i, idlc, idx, j, nnzu, nvar, nclin, ncnln, nnzfd, nnzgd, flag;
  double lmtest;

  /* Arrays */
  Integer iuser[2];
  Integer idxfd[4] = {1, 2, 3, 4};
  double ruser[4] = {24.55, 26.75, 39.00, 40.50};
  double rinfo[32], stats[32], *x = 0, *u = 0;
  double *lambda = 0, *fdx = 0, *gdx = 0;
  double bl[4] = {0, 0, 0, 0};
  double bu[4] = {BIGBND, BIGBND, BIGBND, BIGBND};
  double linbl[2] = {5.0, 1.0};
  double linbu[2] = {BIGBND, 1.0};
  double nlnbl[1] = {21.0};
  double nlnbu[1] = {BIGBND};
  Integer irowb[8] = {1, 1, 1, 1, 2, 2, 2, 2};
  Integer icolb[8] = {1, 2, 3, 4, 1, 2, 3, 4};
  Integer irowgd[4] = {1, 1, 1, 1};
  Integer icolgd[4] = {1, 2, 3, 4};
  Integer irowh[10], icolh[10];
  double b[8] = {2.3, 5.6, 11.1, 1.3, 1.0, 1.0, 1.0, 1.0};
  char opt[80];
  void *handle = 0;

  /* Nag Types */
  NagError fail;
  Nag_FileID nout, mon_file, log_file;
  Nag_Comm comm;

  /* nag_file_open (x04acc).
   *  Open unit number for reading, writing or appending, and
   *  associate unit with named file
   */
  nag_file_open("", 1, &nout, NAGERR_DEFAULT);

  /* nag_file_line_write (x04bac).
   * Write formatted record to external file
   */
  nag_file_line_write(nout, "nag_opt_handle_solve_ipopt (e04stc) "
                            "Example Program Results");

  nag_file_open("e04st_c.mon", 1, &mon_file, NAGERR_DEFAULT);
  nag_file_open("e04st_c.log", 1, &log_file, NAGERR_DEFAULT);

  /* Problem size */
  nvar = 4;
  /* Counter for Lagrange multipliers */
  nnzu = 0;
  /* Objective gradient nonzero elements quantity */
  nnzfd = 4;
  /* Constraint jacobian nonzero elements quantity */
  nnzgd = 4;

  /* nag_opt_handle_init (e04rac).
   * Initialize an empty problem handle with NVAR variables.
   */
  nag_opt_handle_init(&handle, nvar, NAGERR_DEFAULT);

  /* nag_opt_handle_set_simplebounds (e04rhc).
   * Define bounds on the variables
   */
  nag_opt_handle_set_simplebounds(handle, nvar, bl, bu, NAGERR_DEFAULT);
  /* Specify the amount of Lagrange mult. required */
  nnzu += 2 * nvar;

  /* nag_opt_handle_set_nlnobj (e04rgc).
   * Define nonlinear objective
   */
  nag_opt_handle_set_nlnobj(handle, nnzfd, idxfd, NAGERR_DEFAULT);

  /* Add two linear constraints */
  nclin = 2;
  idlc = 0;
  /* nag_opt_handle_set_linconstr (e04rjc).
   * Define a block of linear constraints
   */
  nag_opt_handle_set_linconstr(handle, nclin, linbl, linbu, nclin * nvar, irowb,
                               icolb, b, &idlc, NAGERR_DEFAULT);
  /* Update the Lagrange mult. count */
  nnzu += 2 * nclin;

  /* Add one nonlinear constraint */
  ncnln = 1;

  /* nag_opt_handle_set_nlnconstr (e04rkc).
   * Define a block of nonlinear constraints
   */
  nag_opt_handle_set_nlnconstr(handle, ncnln, nlnbl, nlnbu, nnzgd, irowgd,
                               icolgd, NAGERR_DEFAULT);
  /* Update the Lagrange mult. count */
  nnzu += 2 * ncnln;

  /* Define structure of the Hessian, dense upper triangle */
  for (idx = 0, i = 1; i <= nvar; i++)
    for (j = i; j <= nvar; j++, idx++) {
      icolh[idx] = j;
      irowh[idx] = i;
    }
  /* nag_opt_handle_set_nlnhess (e04rlc).
   * Define structure of Hessian of objective, constraints or the Lagrangian
   */
  nag_opt_handle_set_nlnhess(handle, 1, idx, irowh, icolh, NAGERR_DEFAULT);
  nag_opt_handle_set_nlnhess(handle, 0, idx, irowh, icolh, NAGERR_DEFAULT);

  if (!(x = NAG_ALLOC(nvar, double)) || !(u = NAG_ALLOC(nnzu, double))) {
    printf("Allocation failure\n");
    exit_status = -1;
    goto END;
  }

  for (i = 0; i < nvar; i++)
    x[i] = 1.0;
  iuser[1] = log_file;
  iuser[0] = 0;

  sprintf(opt, "Monitoring File = %" NAG_IFMT, mon_file);
  nag_opt_handle_opt_set(handle, opt, NAGERR_DEFAULT);
  nag_opt_handle_opt_set(handle, "Monitoring Level = 2", NAGERR_DEFAULT);
  nag_opt_handle_opt_set(handle, "Outer Iteration Limit = 26", NAGERR_DEFAULT);
  nag_opt_handle_opt_set(handle, "Print Level = 0", NAGERR_DEFAULT);
  nag_opt_handle_opt_set(handle, "Stop Tolerance 1 = 2.5e-8", NAGERR_DEFAULT);
  nag_opt_handle_opt_set(handle, "Time Limit = 10", NAGERR_DEFAULT);

  comm.iuser = iuser;
  comm.user = ruser;

  INIT_FAIL(fail);
  /* nag_opt_handle_solve_ipopt (e04stc).
   * Call the solver
   */
  nag_opt_handle_solve_ipopt(handle, objfun, objgrd, confun, congrd, hess,
                             monit, nvar, x, nnzu, u, rinfo, stats, &comm,
                             &fail);
  if (fail.code == NE_NOERROR) {
    char msg[80];
    nag_file_line_write(nout, "\nVariables");
    for (i = 0; i < nvar; i++) {
      sprintf(msg, "     x(%10" NAG_IFMT ")%17s=%16.2E", i + 1, "", x[i]);
      nag_file_line_write(nout, msg);
    }
    nag_file_line_write(nout, "Variable bound Lagrange multipliers");
    for (i = 0; i < nvar; i++) {
      sprintf(msg, "    zL(%10" NAG_IFMT ")%17s=%16.2E", i + 1, "", u[2 * i]);
      nag_file_line_write(nout, msg);
      sprintf(msg, "    zU(%10" NAG_IFMT ")%17s=%16.2E", i + 1, "",
              u[2 * i + 1]);
      nag_file_line_write(nout, msg);
    }
    nag_file_line_write(nout, "Linear constraints Lagrange multipliers");
    for (i = 0; i < nclin; i++) {
      sprintf(msg, "    zL(%10" NAG_IFMT ")%17s=%16.2E", i + 1, "",
              u[2 * nvar + 2 * i]);
      nag_file_line_write(nout, msg);
      sprintf(msg, "    zU(%10" NAG_IFMT ")%17s=%16.2E", i + 1, "",
              u[2 * nvar + 2 * i + 1]);
      nag_file_line_write(nout, msg);
    }
    nag_file_line_write(nout, "Nonlinear constraints Lagrange multipliers");
    for (i = 0; i < ncnln; i++) {
      sprintf(msg, "    zL(%10" NAG_IFMT ")%17s=%16.2E", i + 1, "",
              u[2 * (nvar + nclin) + 2 * i]);
      nag_file_line_write(nout, msg);
      sprintf(msg, "    zU(%10" NAG_IFMT ")%17s=%16.2E", i + 1, "",
              u[2 * (nvar + nclin) + 2 * i + 1]);
      nag_file_line_write(nout, msg);
    }

    if (!(lambda = NAG_ALLOC(7, double)) || !(fdx = NAG_ALLOC(nnzfd, double)) ||
        !(gdx = NAG_ALLOC(nnzgd, double))) {
      printf("Allocation failure\n");
      exit_status = -1;
      goto END;
    }

    /* Check of Lagrange multipliers (complementariety)
     * Gradient of the objective (also available in data%coeffs(1:nnzfd))
     */
    objgrd(nvar, x, nnzfd, fdx, &flag, &comm);
    if (flag != 0) {
      exit_status = -1;
      goto END;
    }

    /* Gradient of the nonlinear constraint */
    congrd(nvar, x, nnzgd, gdx, &flag, &comm);
    if (flag != 0) {
      exit_status = -1;
      goto END;
    }

    /* Obtain the multipliers with correct sign
     * 4 bound constraints, 2 linear constraints, and 1 nonlinear constraint
     */
    for (i = 0; i < 7; i++) {
      lambda[i] = u[2 * i + 1] - u[2 * i];
    }
    /* lambda (0..3) mult. related to bounds
     * lambda (4..5) mult. related to linear constraints
     * lambda (6) mult. related to the nonlinear constraint
     */

    nag_file_line_write(nout, "Stationarity test for Lagrange multipliers");
    for (i = 0; i < nvar; i++) {
      lmtest = fdx[i] + lambda[i] + lambda[4] * b[i] + lambda[5] * b[4 + i] +
               lambda[6] * gdx[i];
      if (lmtest < 2.5e-8)
        sprintf(msg, "    lx(%10" NAG_IFMT ")%17s=%16.2E%5s%6s", i + 1, "",
                lmtest, "", "Ok    ");

      else
        sprintf(msg, "    lx(%10" NAG_IFMT ")%17s=%16.2E%5s%6s", i + 1, "",
                lmtest, "", "Failed");
      nag_file_line_write(nout, msg);
    }

    NAG_FREE(lambda);
    NAG_FREE(fdx);
    NAG_FREE(gdx);

    sprintf(msg, "\nAt solution, Objective minimum     =%16.4E", rinfo[0]);
    nag_file_line_write(nout, msg);
    sprintf(msg, "             Constraint violation  =%6s%10.2E", "", rinfo[1]);
    nag_file_line_write(nout, msg);
    sprintf(msg, "             Dual infeasibility    =%6s%10.2E", "", rinfo[2]);
    nag_file_line_write(nout, msg);
    sprintf(msg, "             Complementarity       =%6s%10.2E", "", rinfo[3]);
    nag_file_line_write(nout, msg);
    sprintf(msg, "             KKT error             =%6s%10.2E", "", rinfo[4]);
    nag_file_line_write(nout, msg);
    sprintf(msg, "    after iterations                        :%11.0f",
            stats[0]);
    nag_file_line_write(nout, msg);
    sprintf(msg, "    after objective evaluations             :%11.0f",
            stats[18]);
    nag_file_line_write(nout, msg);
    sprintf(msg, "    after objective gradient evaluations    :%11.0f",
            stats[4]);
    nag_file_line_write(nout, msg);
    sprintf(msg, "    after constraint evaluations            :%11.0f",
            stats[19]);
    nag_file_line_write(nout, msg);
    sprintf(msg, "    after constraint gradient evaluations   :%11.0f",
            stats[20]);
    nag_file_line_write(nout, msg);
    sprintf(msg, "    after hessian evaluations               :%11.0f",
            stats[3]);
    nag_file_line_write(nout, msg);
    nag_file_line_write(
        nout, "\nSee e04st_c.mon file for monitoring information, and");
    nag_file_line_write(nout,
                        "    e04st_c.log file for a detailed iteration log.\n");
  } else {
    printf("Error from nag_opt_handle_solve_ipopt (e04stc).\n%s\n",
           fail.message);
    exit_status = 1;
  }
  if (handle)
    /* nag_opt_handle_free (e04rzc).
     * Destroy the problem handle and deallocate all the memory used
     */
    nag_opt_handle_free(&handle, NAGERR_DEFAULT);

  NAG_FREE(x);
  NAG_FREE(u);

END:
  return exit_status;
}

/* Subroutine */
#include <assert.h>
static void NAG_CALL objfun(Integer nvar, const double x[], double *fx,
                            Integer *flag, Nag_Comm *comm) {
  *flag = 0;
  /* nag_blast_ddot (f16eac).
   * Dot product of two vectors, allows scaling and accumulation
   */
  nag_blast_ddot(Nag_NoConj, 4, 1.0, x, 1, 0.0, comm->user, 1, fx,
                 NAGERR_DEFAULT);
  assert(comm->iuser[0] != 1);
}
static void NAG_CALL objgrd(Integer nvar, const double x[], Integer nnzfd,
                            double fdx[], Integer *flag, Nag_Comm *comm) {
  *flag = 0;
  /* nag_blast_dge_copy (f16qfc).
   * Matrix copy, real rectangular matrix
   */
  nag_blast_dge_copy(Nag_ColMajor, Nag_NoTrans, nnzfd, 1, comm->user, nnzfd,
                     fdx, nnzfd, NAGERR_DEFAULT);
  assert(comm->iuser[0] != 1);
}
static void NAG_CALL confun(Integer nvar, const double x[], Integer ncnln,
                            double gx[], Integer *flag, Nag_Comm *comm) {
  *flag = 0;
  gx[0] = 12.0 * x[0] + 11.9 * x[1] + 41.8 * x[2] + 52.1 * x[3] -
          1.645 * sqrt(.28 * x[0] * x[0] + .19 * x[1] * x[1] +
                       20.5 * x[2] * x[2] + .62 * x[3] * x[3]);
}
static void NAG_CALL congrd(Integer nvar, const double x[], Integer nnzgd,
                            double gdx[], Integer *flag, Nag_Comm *comm) {
  double tmp;
  *flag = 0;
  tmp = sqrt(0.62 * x[3] * x[3] + 20.5 * x[2] * x[2] + 0.19 * x[1] * x[1] +
             0.28 * x[0] * x[0]);
  gdx[0] = (12.0 * tmp - 0.4606 * x[0]) / tmp;
  gdx[1] = (11.9 * tmp - 0.31255 * x[1]) / tmp;
  gdx[2] = (41.8 * tmp - 33.7225 * x[2]) / tmp;
  gdx[3] = (52.1 * tmp - 1.0199 * x[3]) / tmp;
}
static void NAG_CALL hess(Integer nvar, const double x[], Integer ncnln,
                          Integer idf, double sigma, const double lambda[],
                          Integer nnzh, double hx[], Integer *flag,
                          Nag_Comm *comm) {
  double tmp;
  *flag = 0;
  /* nag_blast_dload (f16fbc).
   * Broadcast scalar into real vector
   */
  nag_blast_dload(nnzh, 0.0, hx, 1, NAGERR_DEFAULT);

  if (idf == 0)
    return; /* objective is linear */
  tmp = sqrt(0.62 * x[3] * x[3] + 20.5 * x[2] * x[2] + 0.19 * x[1] * x[1] +
             0.28 * x[0] * x[0]);
  tmp = tmp * (x[3] * x[3] + 33.064516129032258064 * x[2] * x[2] +
               0.30645161290322580645 * x[1] * x[1] +
               0.45161290322580645161 * x[0] * x[0]);
  /* Col 1 */
  hx[0] = (-0.4606 * x[3] * x[3] - 15.229516129032258064 * x[2] * x[2] -
           0.14115161290322580645 * x[1] * x[1]) /
          tmp;
  hx[1] = (0.14115161290322580645 * x[0] * x[1]) / tmp;
  hx[2] = (15.229516129032258064 * x[0] * x[2]) / tmp;
  hx[3] = (0.4606 * x[0] * x[3]) / tmp;
  /* Col 2 */
  hx[4] = (-0.31255 * x[3] * x[3] - 10.334314516129032258 * x[2] * x[2] -
           0.14115161290322580645 * x[0] * x[0]) /
          tmp;
  hx[5] = (10.334314516129032258 * x[1] * x[2]) / tmp;
  hx[6] = (0.31255 * x[1] * x[3]) / tmp;
  /* Col 3 */
  hx[7] = (-33.7225 * x[3] * x[3] - 10.334314516129032258 * x[1] * x[1] -
           15.229516129032258065 * x[0] * x[0]) /
          tmp;
  hx[8] = (33.7225 * x[2] * x[3]) / tmp;
  /* Col 4 */
  hx[9] =
      (-33.7225 * x[2] * x[2] - 0.31255 * x[1] * x[1] - 0.4606 * x[0] * x[0]) /
      tmp;
  /* nag_blast_daxpby (f16ecc).
   * Real weighted vector addition
   */
  if (idf == -1)
    nag_blast_daxpby(nnzh, 0.0, hx, 1, lambda[0], hx, 1, NAGERR_DEFAULT);
  else
    assert(idf == 1);
}
static void NAG_CALL monit(Integer nvar, const double x[], Integer nnzu,
                           const double u[], Integer *flag,
                           const double rinfo[], const double stats[],
                           Nag_Comm *comm) {
  Integer i;
  char msg[80];
  char fmt[80] = "%2" NAG_IFMT "%14.6e %2" NAG_IFMT "%14.6e ";

  *flag = 0;
  nag_file_line_write(comm->iuser[1], "Monitoring...");
  nag_file_line_write(comm->iuser[1], "   x[]");
  for (i = 0; i < nvar; i += 2) {
    sprintf(msg, fmt, i, x[i], i + 1, x[i + 1]);
    nag_file_line_write(comm->iuser[1], msg);
  }
  nag_file_line_write(comm->iuser[1], "   u[]");
  for (i = 0; i < nnzu; i += 2) {
    sprintf(msg, fmt, i, u[i], i + 1, u[i + 1]);
    nag_file_line_write(comm->iuser[1], msg);
  }
  nag_file_line_write(comm->iuser[1], "   rinfo[31]");
  for (i = 0; i < 32; i += 2) {
    sprintf(msg, fmt, i, rinfo[i], i + 1, rinfo[i + 1]);
    nag_file_line_write(comm->iuser[1], msg);
  }
  nag_file_line_write(comm->iuser[1], "   stats[31]");
  for (i = 0; i < 32; i += 2) {
    sprintf(msg, fmt, i, stats[i], i + 1, stats[i + 1]);
    nag_file_line_write(comm->iuser[1], msg);
  }
}