Fortran: Gradient method for minimum of a 2D-function - optimization

Question

I made this simple program to compute the minimum of a goal function using the gradient method. I test it for a simple 1D function (http://en.wikipedia.org/wiki/Gradient_descent) and it's work very well giving to me the exact position of the minimum.
I generalize it to a 2D function: x^4+2y^4 which as only one zero in (0,0) as follow:
real*8 function cubic(xvect_old,n)
real(8), dimension(n) :: xvect_old
cubic = 4.d0*(xvect_old(1)**3.d0)+8.d0*(xvect_old(2)**3.d0)
!cubic = 4.d0*(xvect_old(1)**3.d0)-9.d0*(xvect_old(1)**2.d0)
end function cubic
program findmin
implicit none
integer, parameter :: n=2
integer :: i,j,m
real(8) :: cubic
real(8), dimension(n) :: xvect,xvect_old
real(8) :: eps,max_prec
m=30
eps = 0.01d0 ! step size
xvect_old =0.d0
xvect(1) = 2.2d0 ! first guess
xvect(2) = 3.1d0
max_prec = 1e-16
do while ( abs(xvect(1) - xvect_old(1)) > max_prec .and. &
& abs(xvect(2) - xvect_old(2)) > max_prec)
xvect_old(1:2) = xvect(1:2)
xvect(1:2) = xvect_old(1:2) - eps*cubic(xvect_old,n)
end do
print*, "Local minimum occurs at : ", xvect(1:2)
end program findmin
But it give to me, also if I am very near to the correct position (let's say, thanking as first guess (1.2,1.1) ) some large non correct solutions:
(-0.5017 ; 0.3982)
Is the method implemented wrong or there is some lack in my understanding how accurate the method is? I know there are more advanced methods like genetic algorithm which are, maybe, faster but are they also easy to implement?
Thanks a lot.

Answer 1

cubic is supposed to return the gradient and thus must be a vector.
Try the following:
module functions
implicit none
contains
function cubic(x,n) result(g)
integer, intent(in) :: n
real*8, dimension(n), intent(in) :: x
real*8, dimension(n) :: g
g =(/ 4.d0*(x(1)**3.d0), 8.d0*(x(2)**3.d0) /)
end function cubic
end module
program SOGradient
use functions
implicit none
integer, parameter :: n=2
integer :: i,j,m
real(8), dimension(n) :: xvect,xvect_old
real(8) :: eps,max_prec
m=30
eps = 0.01d0 ! step size
xvect_old =(/ 0.d0, 0d0 /)
! first guess
xvect = (/ 2.2d0, 3.1d0 /)
max_prec = 1e-12
do while ( MAXVAL(ABS(xvect-xvect_old))>max_prec )
xvect_old = xvect
xvect = xvect_old - eps*cubic(xvect_old,n)
end do
print*, "Local minimum occurs at : ", xvect
end program SOGradient
Of course the closer you get to the minimum, the smaller the step so the convergence is really slow. I would suggest using a newton raphson type method to find where the gradient is zero.
So to find the minimum of f(x,y) find the gradient g(x,y)=[gx,gy]=[df/dx,df/dy] and the gradient of the gradient h(x,y) = [[ dgx/dx, dgx/dy],[dgy/dx, dgy/dy]]
Now you iterate with
[x,y] -> [x,y] - h(x,y)^(-1)*g(x,y)
In you case f(x,y) = x^4+2*y^2, g=[4*x^3, 8*y^3] and h=[[12*x^2,0],[0,24*y^2]]
[x,y] -> [x,y] - [x/3,y/3]
which obviously has a solution in (0,0), but converges there much faster.