package com.imsl.test.example.math;

import com.imsl.math.*;

/**
 * <p>
 * Solves a nonlinear programming problem using a finite
 * difference gradient.</p>
 *
 * A general nonlinear programming problem is solved using a finite difference
 * gradient. The problem
 * <p>
 * $${\rm {min}} \,\, F(x) = (x_1 - 2)^2 + (x_2 - 1)^2$$</p>
 * <p>
 * subject to </p>
 *
 * <p>
 * $$g_1(x) = x_1 - 2x_2 + 1 = 0$$<br/>
 * $$g_2(x) = -x_1^2 / 4 - x_2^2 + 1 \ge 0$$</p>
 * <p>
 * is solved.</p>
 *
 * @see <a href="MinConNLPEx1.java">Code</a>
 * @see <a href="doc-files/MinConNLPEx1.out">Output</a>
 */
public class MinConNLPEx1 implements MinConNLP.Function {

    /**
     * Defines the objective function and constraints.
     *
     * <p>
     * This function is called by <code>MinConNLP</code>.
     * </p>
     *
     *
     * @param x a <code>double</code> array containing the variable values
     * @param iact an <code>int</code> specifying the return value. If
     * <code>iact=0</code> this function returns the objective function
     * evaluated at <code>x</code>. If <code>iact</code>=\(1, 2, 3,...\), this
     * function returns the constraint with that index evaluated at
     * <code>x</code>.
     * @param ierr a <code>boolean</code> array of length 1, where
     * <code>ierr[0]=false</code> when no error or undesirable condition occurs
     * during evaluation, and <code>ierr[0]=true</code> indicates some issue
     * during evaluation
     * @return a <code>double</code> the value specified by <code>iact</code>
     *
     */
    @Override
    public double f(double[] x, int iact, boolean[] ierr) {
        double result;
        ierr[0] = false;
        if (iact == 0) {
            result = (x[0] - 2.e0) * (x[0] - 2.e0)
                    + (x[1] - 1.e0) * (x[1] - 1.e0);
            return result;
        } else {
            switch (iact) {
                case 1:
                    result = (x[0] - 2.e0 * x[1] + 1.e0);
                    return result;
                case 2:
                    result = (-(x[0] * x[0]) / 4.e0 - (x[1] * x[1]) + 1.e0);
                    return result;
                default:
                    ierr[0] = true;
                    return 0.e0;
            }
        }
    }

    public static void main(String args[]) throws Exception {
        int m = 2;
        int me = 1;
        int n = 2;
        double xinit[] = {2., 2.};

        MinConNLP minconnon = new MinConNLP(m, me, n);
        minconnon.setGuess(xinit);
        MinConNLPEx1 fcn = new MinConNLPEx1();
        double[] x = minconnon.solve(fcn);
        System.out.println("x is " + x[0] + " " + x[1]);
    }
}