| //Translated by Jose Antonio De Santiago-Castillo. | |
| //E-mail:JAntonioDeSantiago@gmail.com | |
| //Website: www.DotNumerics.com | |
| // | |
| //Fortran to C# Translation. | |
| //Translated by: | |
| //F2CSharp Version 0.72 (Dicember 7, 2009) | |
| //Code Optimizations: , assignment operator, for-loop: array indexes | |
| // | |
| using System; | |
| using DotNumerics.FortranLibrary; | |
| namespace DotNumerics.Optimization.LBFGSB | |
| { | |
| public class DCSTEP | |
| { | |
| const double ZERO = 0.0E0; const double P66 = 0.66E0; const double TWO = 2.0E0; const double THREE = 3.0E0; | |
| public DCSTEP() | |
| { | |
| } | |
| /// <param name="STX"> | |
| /// is a double precision variable. | |
| /// On entry stx is the best step obtained so far and is an | |
| /// endpoint of the interval that contains the minimizer. | |
| /// On exit stx is the updated best step. | |
| ///</param> | |
| /// <param name="FX"> | |
| /// is a double precision variable. | |
| /// On entry fx is the function at stx. | |
| /// On exit fx is the function at stx. | |
| ///</param> | |
| /// <param name="DX"> | |
| /// is a double precision variable. | |
| /// On entry dx is the derivative of the function at | |
| /// stx. The derivative must be negative in the direction of | |
| /// the step, that is, dx and stp - stx must have opposite | |
| /// signs. | |
| /// On exit dx is the derivative of the function at stx. | |
| ///</param> | |
| /// <param name="STY"> | |
| /// is a double precision variable. | |
| /// On entry sty is the second endpoint of the interval that | |
| /// contains the minimizer. | |
| /// On exit sty is the updated endpoint of the interval that | |
| /// contains the minimizer. | |
| ///</param> | |
| /// <param name="FY"> | |
| /// is a double precision variable. | |
| /// On entry fy is the function at sty. | |
| /// On exit fy is the function at sty. | |
| ///</param> | |
| /// <param name="DY"> | |
| /// is a double precision variable. | |
| /// On entry dy is the derivative of the function at sty. | |
| /// On exit dy is the derivative of the function at the exit sty. | |
| ///</param> | |
| /// <param name="STP"> | |
| /// is a double precision variable. | |
| /// On entry stp is the current step. If brackt is set to .true. | |
| /// then on input stp must be between stx and sty. | |
| /// On exit stp is a new trial step. | |
| ///</param> | |
| /// <param name="FP"> | |
| /// is a double precision variable. | |
| /// On entry fp is the function at stp | |
| /// On exit fp is unchanged. | |
| ///</param> | |
| /// <param name="DP"> | |
| /// is a double precision variable. | |
| /// On entry dp is the the derivative of the function at stp. | |
| /// On exit dp is unchanged. | |
| ///</param> | |
| /// <param name="BRACKT"> | |
| /// is an logical variable. | |
| /// On entry brackt specifies if a minimizer has been bracketed. | |
| /// Initially brackt must be set to .false. | |
| /// On exit brackt specifies if a minimizer has been bracketed. | |
| /// When a minimizer is bracketed brackt is set to .true. | |
| ///</param> | |
| /// <param name="STPMIN"> | |
| /// is a double precision variable. | |
| /// On entry stpmin is a lower bound for the step. | |
| /// On exit stpmin is unchanged. | |
| ///</param> | |
| /// <param name="STPMAX"> | |
| /// is a double precision variable. | |
| /// On entry stpmax is an upper bound for the step. | |
| /// On exit stpmax is unchanged. | |
| ///</param> | |
| public void Run(ref double STX, ref double FX, ref double DX, ref double STY, ref double FY, ref double DY | |
| , ref double STP, double FP, double DP, ref bool BRACKT, double STPMIN, double STPMAX) | |
| { | |
| double GAMMA = 0; double P = 0; double Q = 0; double R = 0; double S = 0; double SGND = 0; double STPC = 0; | |
| double STPF = 0;double STPQ = 0; double THETA = 0; | |
| // c ********** | |
| // c | |
| // c Subroutine dcstep | |
| // c | |
| // c This subroutine computes a safeguarded step for a search | |
| // c procedure and updates an interval that contains a step that | |
| // c satisfies a sufficient decrease and a curvature condition. | |
| // c | |
| // c The parameter stx contains the step with the least function | |
| // c value. If brackt is set to .true. then a minimizer has | |
| // c been bracketed in an interval with endpoints stx and sty. | |
| // c The parameter stp contains the current step. | |
| // c The subroutine assumes that if brackt is set to .true. then | |
| // c | |
| // c min(stx,sty) < stp < max(stx,sty), | |
| // c | |
| // c and that the derivative at stx is negative in the direction | |
| // c of the step. | |
| // c | |
| // c The subroutine statement is | |
| // c | |
| // c subroutine dcstep(stx,fx,dx,sty,fy,dy,stp,fp,dp,brackt, | |
| // c stpmin,stpmax) | |
| // c | |
| // c where | |
| // c | |
| // c stx is a double precision variable. | |
| // c On entry stx is the best step obtained so far and is an | |
| // c endpoint of the interval that contains the minimizer. | |
| // c On exit stx is the updated best step. | |
| // c | |
| // c fx is a double precision variable. | |
| // c On entry fx is the function at stx. | |
| // c On exit fx is the function at stx. | |
| // c | |
| // c dx is a double precision variable. | |
| // c On entry dx is the derivative of the function at | |
| // c stx. The derivative must be negative in the direction of | |
| // c the step, that is, dx and stp - stx must have opposite | |
| // c signs. | |
| // c On exit dx is the derivative of the function at stx. | |
| // c | |
| // c sty is a double precision variable. | |
| // c On entry sty is the second endpoint of the interval that | |
| // c contains the minimizer. | |
| // c On exit sty is the updated endpoint of the interval that | |
| // c contains the minimizer. | |
| // c | |
| // c fy is a double precision variable. | |
| // c On entry fy is the function at sty. | |
| // c On exit fy is the function at sty. | |
| // c | |
| // c dy is a double precision variable. | |
| // c On entry dy is the derivative of the function at sty. | |
| // c On exit dy is the derivative of the function at the exit sty. | |
| // c | |
| // c stp is a double precision variable. | |
| // c On entry stp is the current step. If brackt is set to .true. | |
| // c then on input stp must be between stx and sty. | |
| // c On exit stp is a new trial step. | |
| // c | |
| // c fp is a double precision variable. | |
| // c On entry fp is the function at stp | |
| // c On exit fp is unchanged. | |
| // c | |
| // c dp is a double precision variable. | |
| // c On entry dp is the the derivative of the function at stp. | |
| // c On exit dp is unchanged. | |
| // c | |
| // c brackt is an logical variable. | |
| // c On entry brackt specifies if a minimizer has been bracketed. | |
| // c Initially brackt must be set to .false. | |
| // c On exit brackt specifies if a minimizer has been bracketed. | |
| // c When a minimizer is bracketed brackt is set to .true. | |
| // c | |
| // c stpmin is a double precision variable. | |
| // c On entry stpmin is a lower bound for the step. | |
| // c On exit stpmin is unchanged. | |
| // c | |
| // c stpmax is a double precision variable. | |
| // c On entry stpmax is an upper bound for the step. | |
| // c On exit stpmax is unchanged. | |
| // c | |
| // c MINPACK-1 Project. June 1983 | |
| // c Argonne National Laboratory. | |
| // c Jorge J. More' and David J. Thuente. | |
| // c | |
| // c MINPACK-2 Project. October 1993. | |
| // c Argonne National Laboratory and University of Minnesota. | |
| // c Brett M. Averick and Jorge J. More'. | |
| // c | |
| // c ********** | |
| SGND = DP * (DX / Math.Abs(DX)); | |
| // c First case: A higher function value. The minimum is bracketed. | |
| // c If the cubic step is closer to stx than the quadratic step, the | |
| // c cubic step is taken, otherwise the average of the cubic and | |
| // c quadratic steps is taken. | |
| if (FP > FX) | |
| { | |
| THETA = THREE * (FX - FP) / (STP - STX) + DX + DP; | |
| S = Math.Max(Math.Abs(THETA), Math.Max(Math.Abs(DX), Math.Abs(DP))); | |
| GAMMA = S * Math.Sqrt(Math.Pow(THETA / S,2) - (DX / S) * (DP / S)); | |
| if (STP < STX) GAMMA = - GAMMA; | |
| P = (GAMMA - DX) + THETA; | |
| Q = ((GAMMA - DX) + GAMMA) + DP; | |
| R = P / Q; | |
| STPC = STX + R * (STP - STX); | |
| STPQ = STX + ((DX / ((FX - FP) / (STP - STX) + DX)) / TWO) * (STP - STX); | |
| if (Math.Abs(STPC - STX) < Math.Abs(STPQ - STX)) | |
| { | |
| STPF = STPC; | |
| } | |
| else | |
| { | |
| STPF = STPC + (STPQ - STPC) / TWO; | |
| } | |
| BRACKT = true; | |
| // c Second case: A lower function value and derivatives of opposite | |
| // c sign. The minimum is bracketed. If the cubic step is farther from | |
| // c stp than the secant step, the cubic step is taken, otherwise the | |
| // c secant step is taken. | |
| } | |
| else | |
| { | |
| if (SGND < ZERO) | |
| { | |
| THETA = THREE * (FX - FP) / (STP - STX) + DX + DP; | |
| S = Math.Max(Math.Abs(THETA), Math.Max(Math.Abs(DX), Math.Abs(DP))); | |
| GAMMA = S * Math.Sqrt(Math.Pow(THETA / S,2) - (DX / S) * (DP / S)); | |
| if (STP > STX) GAMMA = - GAMMA; | |
| P = (GAMMA - DP) + THETA; | |
| Q = ((GAMMA - DP) + GAMMA) + DX; | |
| R = P / Q; | |
| STPC = STP + R * (STX - STP); | |
| STPQ = STP + (DP / (DP - DX)) * (STX - STP); | |
| if (Math.Abs(STPC - STP) > Math.Abs(STPQ - STP)) | |
| { | |
| STPF = STPC; | |
| } | |
| else | |
| { | |
| STPF = STPQ; | |
| } | |
| BRACKT = true; | |
| // c Third case: A lower function value, derivatives of the same sign, | |
| // c and the magnitude of the derivative decreases. | |
| } | |
| else | |
| { | |
| if (Math.Abs(DP) < Math.Abs(DX)) | |
| { | |
| // c The cubic step is computed only if the cubic tends to infinity | |
| // c in the direction of the step or if the minimum of the cubic | |
| // c is beyond stp. Otherwise the cubic step is defined to be the | |
| // c secant step. | |
| THETA = THREE * (FX - FP) / (STP - STX) + DX + DP; | |
| S = Math.Max(Math.Abs(THETA), Math.Max(Math.Abs(DX), Math.Abs(DP))); | |
| // c The case gamma = 0 only arises if the cubic does not tend | |
| // c to infinity in the direction of the step. | |
| GAMMA = S * Math.Sqrt(Math.Max(ZERO, Math.Pow(THETA / S,2) - (DX / S) * (DP / S))); | |
| if (STP > STX) GAMMA = - GAMMA; | |
| P = (GAMMA - DP) + THETA; | |
| Q = (GAMMA + (DX - DP)) + GAMMA; | |
| R = P / Q; | |
| if (R < ZERO && GAMMA != ZERO) | |
| { | |
| STPC = STP + R * (STX - STP); | |
| } | |
| else | |
| { | |
| if (STP > STX) | |
| { | |
| STPC = STPMAX; | |
| } | |
| else | |
| { | |
| STPC = STPMIN; | |
| } | |
| } | |
| STPQ = STP + (DP / (DP - DX)) * (STX - STP); | |
| if (BRACKT) | |
| { | |
| // c A minimizer has been bracketed. If the cubic step is | |
| // c closer to stp than the secant step, the cubic step is | |
| // c taken, otherwise the secant step is taken. | |
| if (Math.Abs(STPC - STP) < Math.Abs(STPQ - STP)) | |
| { | |
| STPF = STPC; | |
| } | |
| else | |
| { | |
| STPF = STPQ; | |
| } | |
| if (STP > STX) | |
| { | |
| STPF = Math.Min(STP + P66 * (STY - STP), STPF); | |
| } | |
| else | |
| { | |
| STPF = Math.Max(STP + P66 * (STY - STP), STPF); | |
| } | |
| } | |
| else | |
| { | |
| // c A minimizer has not been bracketed. If the cubic step is | |
| // c farther from stp than the secant step, the cubic step is | |
| // c taken, otherwise the secant step is taken. | |
| if (Math.Abs(STPC - STP) > Math.Abs(STPQ - STP)) | |
| { | |
| STPF = STPC; | |
| } | |
| else | |
| { | |
| STPF = STPQ; | |
| } | |
| STPF = Math.Min(STPMAX, STPF); | |
| STPF = Math.Max(STPMIN, STPF); | |
| } | |
| // c Fourth case: A lower function value, derivatives of the same sign, | |
| // c and the magnitude of the derivative does not decrease. If the | |
| // c minimum is not bracketed, the step is either stpmin or stpmax, | |
| // c otherwise the cubic step is taken. | |
| } | |
| else | |
| { | |
| if (BRACKT) | |
| { | |
| THETA = THREE * (FP - FY) / (STY - STP) + DY + DP; | |
| S = Math.Max(Math.Abs(THETA), Math.Max(Math.Abs(DY), Math.Abs(DP))); | |
| GAMMA = S * Math.Sqrt(Math.Pow(THETA / S,2) - (DY / S) * (DP / S)); | |
| if (STP > STY) GAMMA = - GAMMA; | |
| P = (GAMMA - DP) + THETA; | |
| Q = ((GAMMA - DP) + GAMMA) + DY; | |
| R = P / Q; | |
| STPC = STP + R * (STY - STP); | |
| STPF = STPC; | |
| } | |
| else | |
| { | |
| if (STP > STX) | |
| { | |
| STPF = STPMAX; | |
| } | |
| else | |
| { | |
| STPF = STPMIN; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| // c Update the interval which contains a minimizer. | |
| if (FP > FX) | |
| { | |
| STY = STP; | |
| FY = FP; | |
| DY = DP; | |
| } | |
| else | |
| { | |
| if (SGND < ZERO) | |
| { | |
| STY = STX; | |
| FY = FX; | |
| DY = DX; | |
| } | |
| STX = STP; | |
| FX = FP; | |
| DX = DP; | |
| } | |
| // c Compute the new step. | |
| STP = STPF; | |
| } | |
| } | |
| // c====================== The end of dcstep ============================== | |
| } | |