コード例 #1
0
ファイル: Prn2lb.cs プロジェクト: chemscobra/dwsim4-1
        public void Run(int N, double[] X, int offset_x, double F, double[] G, int offset_g, int IPRINT, int ITFILE
                        , int ITER, int NFGV, int NACT, double SBGNRM, int NINT, ref BFGSWord WORD
                        , int IWORD, int IBACK, double STP, double XSTEP)
        {
            #region Variables

            int I = 0; int IMOD = 0;

            #endregion


            #region Array Index Correction

            int o_x = -1 + offset_x;  int o_g = -1 + offset_g;

            #endregion


            #region Prolog



            // c     ************
            // c
            // c     Subroutine prn2lb
            // c
            // c     This subroutine prints out new information after a successful
            // c       line search.
            // c
            // c
            // c                           *  *  *
            // c
            // c     NEOS, November 1994. (Latest revision June 1996.)
            // c     Optimization Technology Center.
            // c     Argonne National Laboratory and Northwestern University.
            // c     Written by
            // c                        Ciyou Zhu
            // c     in collaboration with R.H. Byrd, P. Lu-Chen and J. Nocedal.
            // c
            // c
            // c     ************


            // c           'word' records the status of subspace solutions.

            #endregion


            #region Body

            if (IWORD == 0)
            {
                // c                            the subspace minimization converged.
                WORD = BFGSWord.con;
            }
            else
            {
                if (IWORD == 1)
                {
                    // c                          the subspace minimization stopped at a bound.
                    WORD = BFGSWord.bnd;
                }
                else
                {
                    if (IWORD == 5)
                    {
                        // c                             the truncated Newton step has been used.
                        WORD = BFGSWord.tnt;
                    }
                    else
                    {
                        WORD = BFGSWord.aaa;
                    }
                }
            }
            if (IPRINT >= 99)
            {
                //ERROR-ERROR         WRITE (6,*) 'LINE SEARCH',IBACK,' times; norm of step = ',XSTEP;
                //ERROR-ERROR         WRITE (6,2001) ITER,F,SBGNRM;
                if (IPRINT > 100)
                {
                    //ERROR-ERROR            WRITE (6,1004) 'X =',(X(I), I = 1, N);
                    //ERROR-ERROR            WRITE (6,1004) 'G =',(G(I), I = 1, N);
                }
            }
            else
            {
                if (IPRINT > 0)
                {
                    IMOD = FortranLib.Mod(ITER, IPRINT);
                    if (IMOD == 0)
                    {
                        ;           //ERROR-ERRORWRITE(6,2001)ITER,F,SBGNRM
                    }
                }
            }
            if (IPRINT >= 1)
            {
                ;             //ERROR-ERRORWRITE(ITFILE,3001)ITER,NFGV,NINT,NACT,WORD,IBACK,STP,XSTEP,SBGNRM,F
            }
            return;


            #endregion
        }
コード例 #2
0
        public void Run(int N, double[] X, int offset_x, double F, BFGSTask TASK, int IPRINT, int INFO
                        , int ITFILE, int ITER, int NFGV, int NINTOL, int NSKIP, int NACT
                        , double SBGNRM, double TIME, int NINT, BFGSWord WORD, int IBACK, double STP
                        , double XSTEP, int K, double CACHYT, double SBTIME, double LNSCHT)
        {
            #region Variables

            int I = 0;

            #endregion


            #region Array Index Correction

            int o_x = -1 + offset_x;

            #endregion


            #region Prolog



            // c     ************
            // c
            // c     Subroutine prn3lb
            // c
            // c     This subroutine prints out information when either a built-in
            // c       convergence test is satisfied or when an error message is
            // c       generated.
            // c
            // c
            // c                           *  *  *
            // c
            // c     NEOS, November 1994. (Latest revision June 1996.)
            // c     Optimization Technology Center.
            // c     Argonne National Laboratory and Northwestern University.
            // c     Written by
            // c                        Ciyou Zhu
            // c     in collaboration with R.H. Byrd, P. Lu-Chen and J. Nocedal.
            // c
            // c
            // c     ************



            #endregion


            #region Body

            if (TASK == BFGSTask.ERROR)
            {
                goto LABEL999;
            }

            if (IPRINT >= 0)
            {
                //ERROR-ERROR         WRITE (6,3003);
                //ERROR-ERROR         WRITE (6,3004);
                //ERROR-ERROR         WRITE(6,3005) N,ITER,NFGV,NINTOL,NSKIP,NACT,SBGNRM,F;
                if (IPRINT >= 100)
                {
                    //ERROR-ERROR            WRITE (6,1004) 'X =',(X(I),I = 1,N);
                }
                if (IPRINT >= 1)
                {
                    ;             //ERROR-ERRORWRITE(6,*)' F =',F
                }
            }
            LABEL999 :;
            if (IPRINT >= 0)
            {
                //ERROR-ERROR         WRITE (6,3009) TASK;
                if (INFO != 0)
                {
                    if (INFO == -1)
                    {
                        ;              //ERROR-ERRORWRITE(6,9011)
                    }
                    if (INFO == -2)
                    {
                        ;              //ERROR-ERRORWRITE(6,9012)
                    }
                    if (INFO == -3)
                    {
                        ;              //ERROR-ERRORWRITE(6,9013)
                    }
                    if (INFO == -4)
                    {
                        ;              //ERROR-ERRORWRITE(6,9014)
                    }
                    if (INFO == -5)
                    {
                        ;              //ERROR-ERRORWRITE(6,9015)
                    }
                    if (INFO == -6)
                    {
                        ;              //ERROR-ERRORWRITE(6,*)' Input nbd(',K,') is invalid.'
                    }
                    if (INFO == -7)
                    {
                        ;              //ERROR-ERRORWRITE(6,*)' l(',K,') > u(',K,').  No feasible solution.'
                    }
                    if (INFO == -8)
                    {
                        ;              //ERROR-ERRORWRITE(6,9018)
                    }
                    if (INFO == -9)
                    {
                        ;              //ERROR-ERRORWRITE(6,9019)
                    }
                }
                if (IPRINT >= 1)
                {
                    ;             //ERROR-ERRORWRITE(6,3007)CACHYT,SBTIME,LNSCHT
                }
                //ERROR-ERROR         WRITE (6,3008) TIME;
                if (IPRINT >= 1)
                {
                    if (INFO == -4 || INFO == -9)
                    {
                        //ERROR-ERROR               WRITE (ITFILE,3002)ITER,NFGV,NINT,NACT,WORD,IBACK,STP,XSTEP;
                    }
                    //ERROR-ERROR            WRITE (ITFILE,3009) TASK;
                    if (INFO != 0)
                    {
                        if (INFO == -1)
                        {
                            ;              //ERROR-ERRORWRITE(ITFILE,9011)
                        }
                        if (INFO == -2)
                        {
                            ;              //ERROR-ERRORWRITE(ITFILE,9012)
                        }
                        if (INFO == -3)
                        {
                            ;              //ERROR-ERRORWRITE(ITFILE,9013)
                        }
                        if (INFO == -4)
                        {
                            ;              //ERROR-ERRORWRITE(ITFILE,9014)
                        }
                        if (INFO == -5)
                        {
                            ;              //ERROR-ERRORWRITE(ITFILE,9015)
                        }
                        if (INFO == -8)
                        {
                            ;              //ERROR-ERRORWRITE(ITFILE,9018)
                        }
                        if (INFO == -9)
                        {
                            ;              //ERROR-ERRORWRITE(ITFILE,9019)
                        }
                    }
                    //ERROR-ERROR            WRITE (ITFILE,3008) TIME;
                }
            }


            return;


            #endregion
        }
コード例 #3
0
ファイル: Prn2lb.cs プロジェクト: davidsiaw/neuron
        public void Run(int N, double[] X, int offset_x, double F, double[] G, int offset_g, int IPRINT, int ITFILE
            , int ITER, int NFGV, int NACT, double SBGNRM, int NINT, ref BFGSWord WORD
            , int IWORD, int IBACK, double STP, double XSTEP)
        {
            #region Variables

            int I = 0; int IMOD = 0;

            #endregion

            #region Array Index Correction

             int o_x = -1 + offset_x;  int o_g = -1 + offset_g;

            #endregion

            #region Prolog

            // c     ************
            // c
            // c     Subroutine prn2lb
            // c
            // c     This subroutine prints out new information after a successful
            // c       line search.
            // c
            // c
            // c                           *  *  *
            // c
            // c     NEOS, November 1994. (Latest revision June 1996.)
            // c     Optimization Technology Center.
            // c     Argonne National Laboratory and Northwestern University.
            // c     Written by
            // c                        Ciyou Zhu
            // c     in collaboration with R.H. Byrd, P. Lu-Chen and J. Nocedal.
            // c
            // c
            // c     ************

            // c           'word' records the status of subspace solutions.

            #endregion

            #region Body

             if (IWORD == 0)
             {
                 // c                            the subspace minimization converged.
                 WORD = BFGSWord.con;
             }
             else
             {
                 if (IWORD == 1)
                 {
                     // c                          the subspace minimization stopped at a bound.
                     WORD = BFGSWord.bnd;
                 }
                 else
                 {
                     if (IWORD == 5)
                     {
                         // c                             the truncated Newton step has been used.
                         WORD = BFGSWord.tnt;
                     }
                     else
                     {
                         WORD = BFGSWord.aaa;
                     }
                 }
             }
            if (IPRINT >= 99)
            {
                //ERROR-ERROR         WRITE (6,*) 'LINE SEARCH',IBACK,' times; norm of step = ',XSTEP;
                //ERROR-ERROR         WRITE (6,2001) ITER,F,SBGNRM;
                if (IPRINT > 100)
                {
                    //ERROR-ERROR            WRITE (6,1004) 'X =',(X(I), I = 1, N);
                    //ERROR-ERROR            WRITE (6,1004) 'G =',(G(I), I = 1, N);
                }
            }
            else
            {
                if (IPRINT > 0)
                {
                    IMOD = FortranLib.Mod(ITER,IPRINT);
                    if (IMOD == 0) ;//ERROR-ERRORWRITE(6,2001)ITER,F,SBGNRM
                }
            }
            if (IPRINT >= 1) ;//ERROR-ERRORWRITE(ITFILE,3001)ITER,NFGV,NINT,NACT,WORD,IBACK,STP,XSTEP,SBGNRM,F

            return;

            #endregion
        }
コード例 #4
0
        /// <param name="N">
        /// is an integer variable.
        /// On entry n is the number of variables.
        /// On exit n is unchanged.
        ///</param>
        /// <param name="M">
        /// is an integer variable.
        /// On entry m is the maximum number of variable metric
        /// corrections allowed in the limited memory matrix.
        /// On exit m is unchanged.
        ///</param>
        /// <param name="X">
        /// is a double precision array of dimension n.
        /// On entry x is an approximation to the solution.
        /// On exit x is the current approximation.
        ///</param>
        /// <param name="L">
        /// is a double precision array of dimension n.
        /// On entry l is the lower bound of x.
        /// On exit l is unchanged.
        ///</param>
        /// <param name="U">
        /// is a double precision array of dimension n.
        /// On entry u is the upper bound of x.
        /// On exit u is unchanged.
        ///</param>
        /// <param name="NBD">
        /// is an integer array of dimension n.
        /// On entry nbd represents the type of bounds imposed on the
        /// variables, and must be specified as follows:
        /// nbd(i)=0 if x(i) is unbounded,
        /// 1 if x(i) has only a lower bound,
        /// 2 if x(i) has both lower and upper bounds,
        /// 3 if x(i) has only an upper bound.
        /// On exit nbd is unchanged.
        ///</param>
        /// <param name="F">
        /// is a double precision variable.
        /// On first entry f is unspecified.
        /// On final exit f is the value of the function at x.
        ///</param>
        /// <param name="G">
        /// is a double precision array of dimension n.
        /// On first entry g is unspecified.
        /// On final exit g is the value of the gradient at x.
        ///</param>
        /// <param name="FACTR">
        /// is a double precision variable.
        /// On entry factr .GE. 0 is specified by the user.  The iteration
        /// will stop when
        ///
        /// (f^k - f^{k+1})/max{|f^k|,|f^{k+1}|,1} .LE. factr*epsmch
        ///
        /// where epsmch is the machine precision, which is automatically
        /// generated by the code.
        /// On exit factr is unchanged.
        ///</param>
        /// <param name="PGTOL">
        /// is a double precision variable.
        /// On entry pgtol .GE. 0 is specified by the user.  The iteration
        /// will stop when
        ///
        /// max{|proj g_i | i = 1, ..., n} .LE. pgtol
        ///
        /// where pg_i is the ith component of the projected gradient.
        /// On exit pgtol is unchanged.
        ///</param>
        /// <param name="WN">
        /// is a double precision working array of dimension 2m x 2m
        /// used to store the LEL^T factorization of the indefinite matrix
        /// K = [-D -Y'ZZ'Y/theta     L_a'-R_z'  ]
        /// [L_a -R_z           theta*S'AA'S ]
        ///
        /// where     E = [-I  0]
        /// [ 0  I]
        ///</param>
        /// <param name="SND">
        /// is a double precision working array of dimension 2m x 2m
        /// used to store the lower triangular part of
        /// N = [Y' ZZ'Y   L_a'+R_z']
        /// [L_a +R_z  S'AA'S   ]
        ///</param>
        /// <param name="Z">
        /// is used at different times to store the Cauchy point and
        ///</param>
        /// <param name="INDEX">
        /// is an integer working array of dimension n.
        /// In subroutine freev, index is used to store the free and fixed
        /// variables at the Generalized Cauchy Point (GCP).
        ///</param>
        /// <param name="IWHERE">
        /// is an integer working array of dimension n used to record
        /// the status of the vector x for GCP computation.
        /// iwhere(i)=0 or -3 if x(i) is free and has bounds,
        /// 1       if x(i) is fixed at l(i), and l(i) .ne. u(i)
        /// 2       if x(i) is fixed at u(i), and u(i) .ne. l(i)
        /// 3       if x(i) is always fixed, i.e.,  u(i)=x(i)=l(i)
        /// -1       if x(i) is always free, i.e., no bounds on it.
        ///</param>
        /// <param name="INDX2">
        /// is an integer working array of dimension n.
        /// Within subroutine cauchy, indx2 corresponds to the array iorder.
        /// In subroutine freev, a list of variables entering and leaving
        /// the free set is stored in indx2, and it is passed on to
        /// subroutine formk with this information.
        ///</param>
        /// <param name="TASK">
        /// is a working string of characters of length 60 indicating
        /// the current job when entering and leaving this subroutine.
        ///</param>
        /// <param name="IPRINT">
        /// is an INTEGER variable that must be set by the user.
        /// It controls the frequency and type of output generated:
        /// iprint.LT.0    no output is generated;
        /// iprint=0    print only one line at the last iteration;
        /// 0.LT.iprint.LT.99 print also f and |proj g| every iprint iterations;
        /// iprint=99   print details of every iteration except n-vectors;
        /// iprint=100  print also the changes of active set and final x;
        /// iprint.GT.100  print details of every iteration including x and g;
        /// When iprint .GT. 0, the file iterate.dat will be created to
        /// summarize the iteration.
        ///</param>
        /// <param name="CSAVE">
        /// is a working string of characters of length 60.
        ///</param>
        /// <param name="LSAVE">
        /// is a logical working array of dimension 4.
        ///</param>
        /// <param name="ISAVE">
        /// is an integer working array of dimension 23.
        ///</param>
        /// <param name="DSAVE">
        /// is a double precision working array of dimension 29.
        ///
        ///</param>
        public void Run(int N, int M, ref double[] X, int offset_x, double[] L, int offset_l, double[] U, int offset_u, int[] NBD, int offset_nbd
                        , ref double F, ref double[] G, int offset_g, double FACTR, double PGTOL, ref double[] WS, int offset_ws, ref double[] WY, int offset_wy
                        , ref double[] SY, int offset_sy, ref double[] SS, int offset_ss, double[] YY, int offset_yy, ref double[] WT, int offset_wt, ref double[] WN, int offset_wn, ref double[] SND, int offset_snd
                        , ref double[] Z, int offset_z, ref double[] R, int offset_r, ref double[] D, int offset_d, ref double[] T, int offset_t, ref double[] WA, int offset_wa, double[] SG, int offset_sg
                        , double[] SGO, int offset_sgo, double[] YG, int offset_yg, double[] YGO, int offset_ygo, ref int[] INDEX, int offset_index, ref int[] IWHERE, int offset_iwhere, ref int[] INDX2, int offset_indx2
                        , ref BFGSTask TASK, int IPRINT, ref BFGSTask CSAVE, ref bool[] LSAVE, int offset_lsave, ref int[] ISAVE, int offset_isave, ref double[] DSAVE, int offset_dsave)
        {
            #region Variables

            BFGSWord WORD = BFGSWord.aaa;

            bool   PRJCTD = false; bool CNSTND = false; bool BOXED = false; bool UPDATD = false; bool WRK = false;
            int    I = 0; int K = 0; int NINTOL = 0; int ITFILE = 0; int IBACK = 0; int NSKIP = 0;
            int    HEAD = 0; int COL = 0; int ITER = 0; int ITAIL = 0; int IUPDAT = 0; int NINT = 0; int NFGV = 0; int INFO = 0;
            int    IFUN = 0; int IWORD = 0; int NFREE = 0; int NACT = 0; int ILEAVE = 0; int NENTER = 0; double THETA = 0;
            double FOLD = 0; double DDOT = 0; double DR = 0; double RR = 0; double TOL = 0; double DPMEPS = 0; double XSTEP = 0;
            double SBGNRM = 0; double DDUM = 0; double DNORM = 0; double DTD = 0; double EPSMCH = 0; double CPU1 = 0;
            double CPU2 = 0; double CACHYT = 0; double SBTIME = 0; double LNSCHT = 0; double TIME1 = 0; double TIME2 = 0;
            double GD = 0; double GDOLD = 0; double STP = 0; double STPMX = 0; double TIME = 0;

            #endregion


            #region Array Index Correction

            int o_x = -1 + offset_x;  int o_l = -1 + offset_l;  int o_u = -1 + offset_u;  int o_nbd = -1 + offset_nbd;
            int o_g = -1 + offset_g; int o_ws = -1 - N + offset_ws;  int o_wy = -1 - N + offset_wy;
            int o_sy = -1 - M + offset_sy; int o_ss = -1 - M + offset_ss;  int o_yy = -1 - M + offset_yy;
            int o_wt = -1 - M + offset_wt; int o_wn = -1 - (2 * M) + offset_wn;  int o_snd = -1 - (2 * M) + offset_snd;
            int o_z = -1 + offset_z; int o_r = -1 + offset_r;  int o_d = -1 + offset_d;  int o_t = -1 + offset_t;
            int o_wa = -1 + offset_wa; int o_sg = -1 + offset_sg;  int o_sgo = -1 + offset_sgo;  int o_yg = -1 + offset_yg;
            int o_ygo = -1 + offset_ygo; int o_index = -1 + offset_index;  int o_iwhere = -1 + offset_iwhere;
            int o_indx2 = -1 + offset_indx2; int o_lsave = -1 + offset_lsave;  int o_isave = -1 + offset_isave;
            int o_dsave = -1 + offset_dsave;

            #endregion


            #region Prolog



            // c     ************
            // c
            // c     Subroutine mainlb
            // c
            // c     This subroutine solves bound constrained optimization problems by
            // c       using the compact formula of the limited memory BFGS updates.
            // c
            // c     n is an integer variable.
            // c       On entry n is the number of variables.
            // c       On exit n is unchanged.
            // c
            // c     m is an integer variable.
            // c       On entry m is the maximum number of variable metric
            // c          corrections allowed in the limited memory matrix.
            // c       On exit m is unchanged.
            // c
            // c     x is a double precision array of dimension n.
            // c       On entry x is an approximation to the solution.
            // c       On exit x is the current approximation.
            // c
            // c     l is a double precision array of dimension n.
            // c       On entry l is the lower bound of x.
            // c       On exit l is unchanged.
            // c
            // c     u is a double precision array of dimension n.
            // c       On entry u is the upper bound of x.
            // c       On exit u is unchanged.
            // c
            // c     nbd is an integer array of dimension n.
            // c       On entry nbd represents the type of bounds imposed on the
            // c         variables, and must be specified as follows:
            // c         nbd(i)=0 if x(i) is unbounded,
            // c                1 if x(i) has only a lower bound,
            // c                2 if x(i) has both lower and upper bounds,
            // c                3 if x(i) has only an upper bound.
            // c       On exit nbd is unchanged.
            // c
            // c     f is a double precision variable.
            // c       On first entry f is unspecified.
            // c       On final exit f is the value of the function at x.
            // c
            // c     g is a double precision array of dimension n.
            // c       On first entry g is unspecified.
            // c       On final exit g is the value of the gradient at x.
            // c
            // c     factr is a double precision variable.
            // c       On entry factr >= 0 is specified by the user.  The iteration
            // c         will stop when
            // c
            // c         (f^k - f^{k+1})/max{|f^k|,|f^{k+1}|,1} <= factr*epsmch
            // c
            // c         where epsmch is the machine precision, which is automatically
            // c         generated by the code.
            // c       On exit factr is unchanged.
            // c
            // c     pgtol is a double precision variable.
            // c       On entry pgtol >= 0 is specified by the user.  The iteration
            // c         will stop when
            // c
            // c                 max{|proj g_i | i = 1, ..., n} <= pgtol
            // c
            // c         where pg_i is the ith component of the projected gradient.
            // c       On exit pgtol is unchanged.
            // c
            // c     ws, wy, sy, and wt are double precision working arrays used to
            // c       store the following information defining the limited memory
            // c          BFGS matrix:
            // c          ws, of dimension n x m, stores S, the matrix of s-vectors;
            // c          wy, of dimension n x m, stores Y, the matrix of y-vectors;
            // c          sy, of dimension m x m, stores S'Y;
            // c          ss, of dimension m x m, stores S'S;
            // c	   yy, of dimension m x m, stores Y'Y;
            // c          wt, of dimension m x m, stores the Cholesky factorization
            // c                                  of (theta*S'S+LD^(-1)L'); see eq.
            // c                                  (2.26) in [3].
            // c
            // c     wn is a double precision working array of dimension 2m x 2m
            // c       used to store the LEL^T factorization of the indefinite matrix
            // c                 K = [-D -Y'ZZ'Y/theta     L_a'-R_z'  ]
            // c                     [L_a -R_z           theta*S'AA'S ]
            // c
            // c       where     E = [-I  0]
            // c                     [ 0  I]
            // c
            // c     snd is a double precision working array of dimension 2m x 2m
            // c       used to store the lower triangular part of
            // c                 N = [Y' ZZ'Y   L_a'+R_z']
            // c                     [L_a +R_z  S'AA'S   ]
            // c
            // c     z(n),r(n),d(n),t(n),wa(8*m) are double precision working arrays.
            // c       z is used at different times to store the Cauchy point and
            // c       the Newton point.
            // c
            // c     sg(m),sgo(m),yg(m),ygo(m) are double precision working arrays.
            // c
            // c     index is an integer working array of dimension n.
            // c       In subroutine freev, index is used to store the free and fixed
            // c          variables at the Generalized Cauchy Point (GCP).
            // c
            // c     iwhere is an integer working array of dimension n used to record
            // c       the status of the vector x for GCP computation.
            // c       iwhere(i)=0 or -3 if x(i) is free and has bounds,
            // c                 1       if x(i) is fixed at l(i), and l(i) .ne. u(i)
            // c                 2       if x(i) is fixed at u(i), and u(i) .ne. l(i)
            // c                 3       if x(i) is always fixed, i.e.,  u(i)=x(i)=l(i)
            // c                -1       if x(i) is always free, i.e., no bounds on it.
            // c
            // c     indx2 is an integer working array of dimension n.
            // c       Within subroutine cauchy, indx2 corresponds to the array iorder.
            // c       In subroutine freev, a list of variables entering and leaving
            // c       the free set is stored in indx2, and it is passed on to
            // c       subroutine formk with this information.
            // c
            // c     task is a working string of characters of length 60 indicating
            // c       the current job when entering and leaving this subroutine.
            // c
            // c     iprint is an INTEGER variable that must be set by the user.
            // c       It controls the frequency and type of output generated:
            // c        iprint<0    no output is generated;
            // c        iprint=0    print only one line at the last iteration;
            // c        0<iprint<99 print also f and |proj g| every iprint iterations;
            // c        iprint=99   print details of every iteration except n-vectors;
            // c        iprint=100  print also the changes of active set and final x;
            // c        iprint>100  print details of every iteration including x and g;
            // c       When iprint > 0, the file iterate.dat will be created to
            // c                        summarize the iteration.
            // c
            // c     csave is a working string of characters of length 60.
            // c
            // c     lsave is a logical working array of dimension 4.
            // c
            // c     isave is an integer working array of dimension 23.
            // c
            // c     dsave is a double precision working array of dimension 29.
            // c
            // c
            // c     Subprograms called
            // c
            // c       L-BFGS-B Library ... cauchy, subsm, lnsrlb, formk,
            // c
            // c        errclb, prn1lb, prn2lb, prn3lb, active, projgr,
            // c
            // c        freev, cmprlb, matupd, formt.
            // c
            // c       Minpack2 Library ... timer, dpmeps.
            // c
            // c       Linpack Library ... dcopy, ddot.
            // c
            // c
            // c     References:
            // c
            // c       [1] R. H. Byrd, P. Lu, J. Nocedal and C. Zhu, ``A limited
            // c       memory algorithm for bound constrained optimization'',
            // c       SIAM J. Scientific Computing 16 (1995), no. 5, pp. 1190--1208.
            // c
            // c       [2] C. Zhu, R.H. Byrd, P. Lu, J. Nocedal, ``L-BFGS-B: FORTRAN
            // c       Subroutines for Large Scale Bound Constrained Optimization''
            // c       Tech. Report, NAM-11, EECS Department, Northwestern University,
            // c       1994.
            // c
            // c       [3] R. Byrd, J. Nocedal and R. Schnabel "Representations of
            // c       Quasi-Newton Matrices and their use in Limited Memory Methods'',
            // c       Mathematical Programming 63 (1994), no. 4, pp. 129-156.
            // c
            // c       (Postscript files of these papers are available via anonymous
            // c        ftp to eecs.nwu.edu in the directory pub/lbfgs/lbfgs_bcm.)
            // c
            // c                           *  *  *
            // c
            // c     NEOS, November 1994. (Latest revision June 1996.)
            // c     Optimization Technology Center.
            // c     Argonne National Laboratory and Northwestern University.
            // c     Written by
            // c                        Ciyou Zhu
            // c     in collaboration with R.H. Byrd, P. Lu-Chen and J. Nocedal.
            // c
            // c
            // c     ************



            #endregion


            #region Body

            if (TASK == BFGSTask.START)
            {
                this._timer.Run(ref TIME1);

                // c        Generate the current machine precision.

                EPSMCH = this._dpmeps.Run();

                // c        Initialize counters and scalars when task='START'.

                // c           for the limited memory BFGS matrices:
                COL    = 0;
                HEAD   = 1;
                THETA  = ONE;
                IUPDAT = 0;
                UPDATD = false;

                // c           for operation counts:
                ITER   = 0;
                NFGV   = 0;
                NINT   = 0;
                NINTOL = 0;
                NSKIP  = 0;
                NFREE  = N;

                // c           for stopping tolerance:
                TOL = FACTR * EPSMCH;

                // c           for measuring running time:
                CACHYT = 0;
                SBTIME = 0;
                LNSCHT = 0;

                // c           'word' records the status of subspace solutions.
                WORD = BFGSWord.aaa;

                // c           'info' records the termination information.
                INFO = 0;

                if (IPRINT >= 1)
                {
                    // c                                open a summary file 'iterate.dat'
                    //ERROR-ERROR            OPEN (8, FILE = 'iterate.dat', STATUS = 'unknown');
                    ITFILE = 8;
                }

                // c        Check the input arguments for errors.

                this._errclb.Run(N, M, FACTR, L, offset_l, U, offset_u, NBD, offset_nbd
                                 , ref TASK, ref INFO, ref K);
                if (TASK == BFGSTask.ERROR)
                {
                    this._prn3lb.Run(N, X, offset_x, F, TASK, IPRINT, INFO
                                     , ITFILE, ITER, NFGV, NINTOL, NSKIP, NACT
                                     , SBGNRM, ZERO, NINT, WORD, IBACK, STP
                                     , XSTEP, K, CACHYT, SBTIME, LNSCHT);
                    return;
                }

                this._prn1lb.Run(N, M, L, offset_l, U, offset_u, X, offset_x, IPRINT
                                 , ITFILE, EPSMCH);

                // c        Initialize iwhere & project x onto the feasible set.

                this._active.Run(N, L, offset_l, U, offset_u, NBD, offset_nbd, ref X, offset_x, ref IWHERE, offset_iwhere
                                 , IPRINT, ref PRJCTD, ref CNSTND, ref BOXED);

                // c        The end of the initialization.
            }
            else
            {
                // c          restore local variables.

                PRJCTD = LSAVE[1 + o_lsave];
                CNSTND = LSAVE[2 + o_lsave];
                BOXED  = LSAVE[3 + o_lsave];
                UPDATD = LSAVE[4 + o_lsave];

                NINTOL = ISAVE[1 + o_isave];
                ITFILE = ISAVE[3 + o_isave];
                IBACK  = ISAVE[4 + o_isave];
                NSKIP  = ISAVE[5 + o_isave];
                HEAD   = ISAVE[6 + o_isave];
                COL    = ISAVE[7 + o_isave];
                ITAIL  = ISAVE[8 + o_isave];
                ITER   = ISAVE[9 + o_isave];
                IUPDAT = ISAVE[10 + o_isave];
                NINT   = ISAVE[12 + o_isave];
                NFGV   = ISAVE[13 + o_isave];
                INFO   = ISAVE[14 + o_isave];
                IFUN   = ISAVE[15 + o_isave];
                IWORD  = ISAVE[16 + o_isave];
                NFREE  = ISAVE[17 + o_isave];
                NACT   = ISAVE[18 + o_isave];
                ILEAVE = ISAVE[19 + o_isave];
                NENTER = ISAVE[20 + o_isave];

                THETA  = DSAVE[1 + o_dsave];
                FOLD   = DSAVE[2 + o_dsave];
                TOL    = DSAVE[3 + o_dsave];
                DNORM  = DSAVE[4 + o_dsave];
                EPSMCH = DSAVE[5 + o_dsave];
                CPU1   = DSAVE[6 + o_dsave];
                CACHYT = DSAVE[7 + o_dsave];
                SBTIME = DSAVE[8 + o_dsave];
                LNSCHT = DSAVE[9 + o_dsave];
                TIME1  = DSAVE[10 + o_dsave];
                GD     = DSAVE[11 + o_dsave];
                STPMX  = DSAVE[12 + o_dsave];
                SBGNRM = DSAVE[13 + o_dsave];
                STP    = DSAVE[14 + o_dsave];
                GDOLD  = DSAVE[15 + o_dsave];
                DTD    = DSAVE[16 + o_dsave];

                // c        After returning from the driver go to the point where execution
                // c        is to resume.

                if (TASK == BFGSTask.FG_LNSRCH)
                {
                    goto LABEL666;
                }
                if (TASK == BFGSTask.NEW_X)
                {
                    goto LABEL777;
                }
                if (TASK == BFGSTask.FG_ST || TASK == BFGSTask.FG_START)
                {
                    goto LABEL111;
                }
                if (TASK == BFGSTask.STOP)
                {
                    if (TASK == BFGSTask.CPU)
                    {
                        // c                                          restore the previous iterate.
                        this._dcopy.Run(N, T, offset_t, 1, ref X, offset_x, 1);
                        this._dcopy.Run(N, R, offset_r, 1, ref G, offset_g, 1);
                        F = FOLD;
                    }
                    goto LABEL999;
                }
            }

            // c     Compute f0 and g0.

            TASK = BFGSTask.FG_START;
            // c          return to the driver to calculate f and g; reenter at 111.
            goto LABEL1000;
            LABEL111 :;
            NFGV = 1;

            // c     Compute the infinity norm of the (-) projected gradient.

            this._projgr.Run(N, L, offset_l, U, offset_u, NBD, offset_nbd, X, offset_x, G, offset_g
                             , ref SBGNRM);

            if (IPRINT >= 1)
            {
                //ERROR-ERROR         WRITE (6,1002) ITER,F,SBGNRM;
                //ERROR-ERROR         WRITE (ITFILE,1003) ITER,NFGV,SBGNRM,F;
            }
            if (SBGNRM <= PGTOL)
            {
                // c                                terminate the algorithm.
                TASK = BFGSTask.CONV;
                goto LABEL999;
            }

            // c ----------------- the beginning of the loop --------------------------

            LABEL222 :;
            if (IPRINT >= 99)
            {
                ;              //ERROR-ERRORWRITE(6,1001)ITER+1
            }
            IWORD = -1;
            // c
            if (!CNSTND && COL > 0)
            {
                // c                                            skip the search for GCP.
                this._dcopy.Run(N, X, offset_x, 1, ref Z, offset_z, 1);
                WRK  = UPDATD;
                NINT = 0;
                goto LABEL333;
            }

            // cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
            // c
            // c     Compute the Generalized Cauchy Point (GCP).
            // c
            // cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc

            this._timer.Run(ref CPU1);
            this._cauchy.Run(N, X, offset_x, L, offset_l, U, offset_u, NBD, offset_nbd, G, offset_g
                             , ref INDX2, offset_indx2, ref IWHERE, offset_iwhere, ref T, offset_t, ref D, offset_d, ref Z, offset_z, M
                             , WY, offset_wy, WS, offset_ws, SY, offset_sy, WT, offset_wt, THETA, COL
                             , HEAD, ref WA, 1 + o_wa, ref WA, 2 * M + 1 + o_wa, ref WA, 4 * M + 1 + o_wa, ref WA, 6 * M + 1 + o_wa, ref NINT
                             , SG, offset_sg, YG, offset_yg, IPRINT, SBGNRM, ref INFO, EPSMCH);
            if (INFO != 0)
            {
                // c         singular triangular system detected; refresh the lbfgs memory.
                if (IPRINT >= 1)
                {
                    ;             //ERROR-ERRORWRITE(6,1005)
                }
                INFO   = 0;
                COL    = 0;
                HEAD   = 1;
                THETA  = ONE;
                IUPDAT = 0;
                UPDATD = false;
                this._timer.Run(ref CPU2);
                CACHYT += CPU2 - CPU1;
                goto LABEL222;
            }
            this._timer.Run(ref CPU2);
            CACHYT += CPU2 - CPU1;
            NINTOL += NINT;

            // c     Count the entering and leaving variables for iter > 0;
            // c     find the index set of free and active variables at the GCP.

            this._freev.Run(N, ref NFREE, ref INDEX, offset_index, ref NENTER, ref ILEAVE, ref INDX2, offset_indx2
                            , IWHERE, offset_iwhere, ref WRK, UPDATD, CNSTND, IPRINT, ITER);

            NACT = N - NFREE;

            LABEL333 :;

            // c     If there are no free variables or B=theta*I, then
            // c                                        skip the subspace minimization.

            if (NFREE == 0 || COL == 0)
            {
                goto LABEL555;
            }

            // cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
            // c
            // c     Subspace minimization.
            // c
            // cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc

            this._timer.Run(ref CPU1);

            // c     Form  the LEL^T factorization of the indefinite
            // c       matrix    K = [-D -Y'ZZ'Y/theta     L_a'-R_z'  ]
            // c                     [L_a -R_z           theta*S'AA'S ]
            // c       where     E = [-I  0]
            // c                     [ 0  I]

            if (WRK)
            {
                this._formk.Run(N, NFREE, INDEX, offset_index, NENTER, ILEAVE, INDX2, offset_indx2
                                , IUPDAT, UPDATD, ref WN, offset_wn, ref SND, offset_snd, M, WS, offset_ws
                                , WY, offset_wy, SY, offset_sy, THETA, COL, HEAD, ref INFO);
            }
            if (INFO != 0)
            {
                // c          nonpositive definiteness in Cholesky factorization;
                // c          refresh the lbfgs memory and restart the iteration.
                if (IPRINT >= 1)
                {
                    ;             //ERROR-ERRORWRITE(6,1006)
                }
                INFO   = 0;
                COL    = 0;
                HEAD   = 1;
                THETA  = ONE;
                IUPDAT = 0;
                UPDATD = false;
                this._timer.Run(ref CPU2);
                SBTIME += CPU2 - CPU1;
                goto LABEL222;
            }

            // c        compute r=-Z'B(xcp-xk)-Z'g (using wa(2m+1)=W'(xcp-x)
            // c                                                   from 'cauchy').
            this._cmprlb.Run(N, M, X, offset_x, G, offset_g, WS, offset_ws, WY, offset_wy
                             , SY, offset_sy, WT, offset_wt, Z, offset_z, ref R, offset_r, ref WA, offset_wa, INDEX, offset_index
                             , THETA, COL, HEAD, NFREE, CNSTND, ref INFO);
            if (INFO != 0)
            {
                goto LABEL444;
            }
            // c       call the direct method.
            this._subsm.Run(N, M, NFREE, INDEX, offset_index, L, offset_l, U, offset_u
                            , NBD, offset_nbd, ref Z, offset_z, ref R, offset_r, WS, offset_ws, WY, offset_wy, THETA
                            , COL, HEAD, ref IWORD, ref WA, offset_wa, WN, offset_wn, IPRINT
                            , ref INFO);
            LABEL444 :;
            if (INFO != 0)
            {
                // c          singular triangular system detected;
                // c          refresh the lbfgs memory and restart the iteration.
                if (IPRINT >= 1)
                {
                    ;             //ERROR-ERRORWRITE(6,1005)
                }
                INFO   = 0;
                COL    = 0;
                HEAD   = 1;
                THETA  = ONE;
                IUPDAT = 0;
                UPDATD = false;
                this._timer.Run(ref CPU2);
                SBTIME += CPU2 - CPU1;
                goto LABEL222;
            }

            this._timer.Run(ref CPU2);
            SBTIME += CPU2 - CPU1;
            LABEL555 :;

            // cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
            // c
            // c     Line search and optimality tests.
            // c
            // cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc

            // c     Generate the search direction d:=z-x.

            for (I = 1; I <= N; I++)
            {
                D[I + o_d] = Z[I + o_z] - X[I + o_x];
            }
            this._timer.Run(ref CPU1);
            LABEL666 :;
            this._lnsrlb.Run(N, L, offset_l, U, offset_u, NBD, offset_nbd, ref X, offset_x, F
                             , ref FOLD, ref GD, ref GDOLD, G, offset_g, D, offset_d, ref R, offset_r
                             , ref T, offset_t, Z, offset_z, ref STP, ref DNORM, ref DTD, ref XSTEP
                             , ref STPMX, ITER, ref IFUN, ref IBACK, ref NFGV, ref INFO
                             , ref TASK, BOXED, CNSTND, ref CSAVE, ref ISAVE, 22 + o_isave, ref DSAVE, 17 + o_dsave);
            if (INFO != 0 || IBACK >= 20)
            {
                // c          restore the previous iterate.
                this._dcopy.Run(N, T, offset_t, 1, ref X, offset_x, 1);
                this._dcopy.Run(N, R, offset_r, 1, ref G, offset_g, 1);
                F = FOLD;
                if (COL == 0)
                {
                    // c             abnormal termination.
                    if (INFO == 0)
                    {
                        INFO = -9;
                        // c                restore the actual number of f and g evaluations etc.
                        NFGV  -= 1;
                        IFUN  -= 1;
                        IBACK -= 1;
                    }
                    TASK  = BFGSTask.ABNO;
                    ITER += 1;
                    goto LABEL999;
                }
                else
                {
                    // c             refresh the lbfgs memory and restart the iteration.
                    if (IPRINT >= 1)
                    {
                        ;             //ERROR-ERRORWRITE(6,1008)
                    }
                    if (INFO == 0)
                    {
                        NFGV -= 1;
                    }
                    INFO   = 0;
                    COL    = 0;
                    HEAD   = 1;
                    THETA  = ONE;
                    IUPDAT = 0;
                    UPDATD = false;
                    TASK   = BFGSTask.RESTART;
                    this._timer.Run(ref CPU2);
                    LNSCHT += CPU2 - CPU1;
                    goto LABEL222;
                }
            }
            else
            {
                if (TASK == BFGSTask.FG_LNSRCH)
                {
                    // c          return to the driver for calculating f and g; reenter at 666.
                    goto LABEL1000;
                }
                else
                {
                    // c          calculate and print out the quantities related to the new X.
                    this._timer.Run(ref CPU2);
                    LNSCHT += CPU2 - CPU1;
                    ITER   += 1;

                    // c        Compute the infinity norm of the projected (-)gradient.

                    this._projgr.Run(N, L, offset_l, U, offset_u, NBD, offset_nbd, X, offset_x, G, offset_g
                                     , ref SBGNRM);

                    // c        Print iteration information.

                    this._prn2lb.Run(N, X, offset_x, F, G, offset_g, IPRINT, ITFILE
                                     , ITER, NFGV, NACT, SBGNRM, NINT, ref WORD
                                     , IWORD, IBACK, STP, XSTEP);
                    goto LABEL1000;
                }
            }
            LABEL777 :;

            // c     Test for termination.

            if (SBGNRM <= PGTOL)
            {
                // c                                terminate the algorithm.
                TASK = BFGSTask.CONV;
                goto LABEL999;
            }

            DDUM = Math.Max(Math.Abs(FOLD), Math.Max(Math.Abs(F), ONE));
            if ((FOLD - F) <= TOL * DDUM)
            {
                // c                                        terminate the algorithm.
                TASK = BFGSTask.CONV;
                if (IBACK >= 10)
                {
                    INFO = -5;
                }
                // c           i.e., to issue a warning if iback>10 in the line search.
                goto LABEL999;
            }

            // c     Compute d=newx-oldx, r=newg-oldg, rr=y'y and dr=y's.

            for (I = 1; I <= N; I++)
            {
                R[I + o_r] = G[I + o_g] - R[I + o_r];
            }
            RR = this._ddot.Run(N, R, offset_r, 1, R, offset_r, 1);
            if (STP == ONE)
            {
                DR   = GD - GDOLD;
                DDUM = -GDOLD;
            }
            else
            {
                DR = (GD - GDOLD) * STP;
                this._dscal.Run(N, STP, ref D, offset_d, 1);
                DDUM = -GDOLD * STP;
            }

            if (DR <= EPSMCH * DDUM)
            {
                // c                            skip the L-BFGS update.
                NSKIP += 1;
                UPDATD = false;
                if (IPRINT >= 1)
                {
                    ;             //ERROR-ERRORWRITE(6,1004)DR,DDUM
                }
                goto LABEL888;
            }

            // cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
            // c
            // c     Update the L-BFGS matrix.
            // c
            // cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc

            UPDATD  = true;
            IUPDAT += 1;

            // c     Update matrices WS and WY and form the middle matrix in B.

            this._matupd.Run(N, M, ref WS, offset_ws, ref WY, offset_wy, ref SY, offset_sy, ref SS, offset_ss
                             , D, offset_d, R, offset_r, ref ITAIL, IUPDAT, ref COL, ref HEAD
                             , ref THETA, RR, DR, STP, DTD);

            // c     Form the upper half of the pds T = theta*SS + L*D^(-1)*L';
            // c        Store T in the upper triangular of the array wt;
            // c        Cholesky factorize T to J*J' with
            // c           J' stored in the upper triangular of wt.

            this._formt.Run(M, ref WT, offset_wt, SY, offset_sy, SS, offset_ss, COL, THETA
                            , ref INFO);

            if (INFO != 0)
            {
                // c          nonpositive definiteness in Cholesky factorization;
                // c          refresh the lbfgs memory and restart the iteration.
                if (IPRINT >= 1)
                {
                    ;             //ERROR-ERRORWRITE(6,1007)
                }
                INFO   = 0;
                COL    = 0;
                HEAD   = 1;
                THETA  = ONE;
                IUPDAT = 0;
                UPDATD = false;
                goto LABEL222;
            }

            // c     Now the inverse of the middle matrix in B is

            // c       [  D^(1/2)      O ] [ -D^(1/2)  D^(-1/2)*L' ]
            // c       [ -L*D^(-1/2)   J ] [  0        J'          ]

            LABEL888 :;

            // c -------------------- the end of the loop -----------------------------

            goto LABEL222;
            LABEL999 :;
            this._timer.Run(ref TIME2);
            TIME = TIME2 - TIME1;
            this._prn3lb.Run(N, X, offset_x, F, TASK, IPRINT, INFO
                             , ITFILE, ITER, NFGV, NINTOL, NSKIP, NACT
                             , SBGNRM, TIME, NINT, WORD, IBACK, STP
                             , XSTEP, K, CACHYT, SBTIME, LNSCHT);
            LABEL1000 :;

            // c     Save local variables.

            LSAVE[1 + o_lsave] = PRJCTD;
            LSAVE[2 + o_lsave] = CNSTND;
            LSAVE[3 + o_lsave] = BOXED;
            LSAVE[4 + o_lsave] = UPDATD;

            ISAVE[1 + o_isave]  = NINTOL;
            ISAVE[3 + o_isave]  = ITFILE;
            ISAVE[4 + o_isave]  = IBACK;
            ISAVE[5 + o_isave]  = NSKIP;
            ISAVE[6 + o_isave]  = HEAD;
            ISAVE[7 + o_isave]  = COL;
            ISAVE[8 + o_isave]  = ITAIL;
            ISAVE[9 + o_isave]  = ITER;
            ISAVE[10 + o_isave] = IUPDAT;
            ISAVE[12 + o_isave] = NINT;
            ISAVE[13 + o_isave] = NFGV;
            ISAVE[14 + o_isave] = INFO;
            ISAVE[15 + o_isave] = IFUN;
            ISAVE[16 + o_isave] = IWORD;
            ISAVE[17 + o_isave] = NFREE;
            ISAVE[18 + o_isave] = NACT;
            ISAVE[19 + o_isave] = ILEAVE;
            ISAVE[20 + o_isave] = NENTER;

            DSAVE[1 + o_dsave]  = THETA;
            DSAVE[2 + o_dsave]  = FOLD;
            DSAVE[3 + o_dsave]  = TOL;
            DSAVE[4 + o_dsave]  = DNORM;
            DSAVE[5 + o_dsave]  = EPSMCH;
            DSAVE[6 + o_dsave]  = CPU1;
            DSAVE[7 + o_dsave]  = CACHYT;
            DSAVE[8 + o_dsave]  = SBTIME;
            DSAVE[9 + o_dsave]  = LNSCHT;
            DSAVE[10 + o_dsave] = TIME1;
            DSAVE[11 + o_dsave] = GD;
            DSAVE[12 + o_dsave] = STPMX;
            DSAVE[13 + o_dsave] = SBGNRM;
            DSAVE[14 + o_dsave] = STP;
            DSAVE[15 + o_dsave] = GDOLD;
            DSAVE[16 + o_dsave] = DTD;


            return;


            #endregion
        }
コード例 #5
0
ファイル: Prn3lb.cs プロジェクト: davidsiaw/neuron
        public void Run(int N, double[] X, int offset_x, double F, BFGSTask TASK, int IPRINT, int INFO
            , int ITFILE, int ITER, int NFGV, int NINTOL, int NSKIP, int NACT
            , double SBGNRM, double TIME, int NINT, BFGSWord WORD, int IBACK, double STP
            , double XSTEP, int K, double CACHYT, double SBTIME, double LNSCHT)
        {
            #region Variables

            int I = 0;

            #endregion

            #region Array Index Correction

             int o_x = -1 + offset_x;

            #endregion

            #region Prolog

            // c     ************
            // c
            // c     Subroutine prn3lb
            // c
            // c     This subroutine prints out information when either a built-in
            // c       convergence test is satisfied or when an error message is
            // c       generated.
            // c
            // c
            // c                           *  *  *
            // c
            // c     NEOS, November 1994. (Latest revision June 1996.)
            // c     Optimization Technology Center.
            // c     Argonne National Laboratory and Northwestern University.
            // c     Written by
            // c                        Ciyou Zhu
            // c     in collaboration with R.H. Byrd, P. Lu-Chen and J. Nocedal.
            // c
            // c
            // c     ************

            #endregion

            #region Body

            if (TASK == BFGSTask.ERROR) goto LABEL999;

            if (IPRINT >= 0)
            {
                //ERROR-ERROR         WRITE (6,3003);
                //ERROR-ERROR         WRITE (6,3004);
                //ERROR-ERROR         WRITE(6,3005) N,ITER,NFGV,NINTOL,NSKIP,NACT,SBGNRM,F;
                if (IPRINT >= 100)
                {
                    //ERROR-ERROR            WRITE (6,1004) 'X =',(X(I),I = 1,N);
                }
                if (IPRINT >= 1) ;//ERROR-ERRORWRITE(6,*)' F =',F
            }
            LABEL999:;
            if (IPRINT >= 0)
            {
                //ERROR-ERROR         WRITE (6,3009) TASK;
                if (INFO != 0)
                {
                    if (INFO ==  - 1) ;//ERROR-ERRORWRITE(6,9011)
                    if (INFO ==  - 2) ;//ERROR-ERRORWRITE(6,9012)
                    if (INFO ==  - 3) ;//ERROR-ERRORWRITE(6,9013)
                    if (INFO ==  - 4) ;//ERROR-ERRORWRITE(6,9014)
                    if (INFO ==  - 5) ;//ERROR-ERRORWRITE(6,9015)
                    if (INFO ==  - 6) ;//ERROR-ERRORWRITE(6,*)' Input nbd(',K,') is invalid.'
                    if (INFO ==  - 7) ;//ERROR-ERRORWRITE(6,*)' l(',K,') > u(',K,').  No feasible solution.'
                    if (INFO ==  - 8) ;//ERROR-ERRORWRITE(6,9018)
                    if (INFO ==  - 9) ;//ERROR-ERRORWRITE(6,9019)
                }
                if (IPRINT >= 1) ;//ERROR-ERRORWRITE(6,3007)CACHYT,SBTIME,LNSCHT
                //ERROR-ERROR         WRITE (6,3008) TIME;
                if (IPRINT >= 1)
                {
                    if (INFO ==  - 4 || INFO ==  - 9)
                    {
                        //ERROR-ERROR               WRITE (ITFILE,3002)ITER,NFGV,NINT,NACT,WORD,IBACK,STP,XSTEP;
                    }
                    //ERROR-ERROR            WRITE (ITFILE,3009) TASK;
                    if (INFO != 0)
                    {
                        if (INFO ==  - 1) ;//ERROR-ERRORWRITE(ITFILE,9011)
                        if (INFO ==  - 2) ;//ERROR-ERRORWRITE(ITFILE,9012)
                        if (INFO ==  - 3) ;//ERROR-ERRORWRITE(ITFILE,9013)
                        if (INFO ==  - 4) ;//ERROR-ERRORWRITE(ITFILE,9014)
                        if (INFO ==  - 5) ;//ERROR-ERRORWRITE(ITFILE,9015)
                        if (INFO ==  - 8) ;//ERROR-ERRORWRITE(ITFILE,9018)
                        if (INFO ==  - 9) ;//ERROR-ERRORWRITE(ITFILE,9019)
                    }
                    //ERROR-ERROR            WRITE (ITFILE,3008) TIME;
                }
            }

            return;

            #endregion
        }