Gradient descent: Difference between revisions

{{Trans|Fortran}}

THe results agree with the Fortran sample and the Julia sample to 6 places.

BEGIN

LONG REAL alpha := alphap;

print( ( "Testing steepest descent method:", newline ) );

print( ( "The minimum is at x[0] = ", fixed( x[ 0 ], -10, 6 ), ", x[1] = ", fixed( x[ 1 ], -10, 6 ), newline ) )

{{out}}

<pre>

{{Trans|ALGOL 68}} which is a {{Trans|Go}} with the gradient function from {{Trans|Fortran}}

The results agree (to 6 places) with the Fortran and Julia samples.

begin

alpha := alphap;

g0 := g( x ); % Initial estimate of result. %

delG := 0.0;

for i := 0 until 1 do delG := delG + ( fi( i ) * fi( i ) );

b := alpha / delG;

% Iterate until value is <= tolerance. %

delG := 0;

for i := 0 until 1 do delG := delg + ( fi( i ) * fi( i ) );

if delG > 0 then begin

b := alpha / delG;

end steepestDescent ;

% Provides a rough calculation of gradient g(x). %

begin

x := p( 0 );

y := p( 1 );

end gradG ;

% Function for which minimum is to be found. %

;

begin

x( 0 ) := 0.1; % Initial guess of location of minimum. %

x( 1 ) := -1;

write( "The minimum is at x(0) = ", x( 0 ), ", x(1) = ", x( 1 ) )

end

{{out}}

<pre>

The minimum is at x(0) = 0.1076268, x(1) = -1.2232596

</pre>

 

=={{header|Fortran}}==

(-2*(x-1)**2*y*exp(-y**2))+exp(-2*x**2)*(y+2)+exp(-2*x**2)*y

(%o7) done

IMPLICIT NONE

INTEGER N

RETURN

END

*___Name______Type________In/Out___Description_________________________

* N Integer In Number of Variables.

*-----------------------------------------------------------------------

SUBROUTINE GD (N, X, G, TOL, IFLAG)

IMPLICIT NONE

INTEGER N, IFLAG

INTEGER I

 

DO I = 1, N

GNORM = GNORM + G(I)**2

RETURN ! success

END IF

END ! of gd

 

PARAMETER (N = 2)

INTEGER ITER, J, IFLAG

 

IFLAG = 0

DO J = 1, 1 000 000

STOP 'too many iterations!'

 

$ 'After ', ITER, ' steps, found minimum at x=',

$ X(1), ' y=', X(2), ' of f=', F

STOP 'program complete'

END

{{out}}

STOP program complete

</pre>

 

However, since it was originally written, I've substituted Fortran's gradient function for the original one (see Talk page) which now gives results which agree (to 6 decimal places) with those of the Fortran, Julia, Algol 68 and Algol W solutions. As a number of other solutions are based on this one, I suggest their authors update them accordingly.

 

import (

fmt.Println("Testing steepest descent method:")

fmt.Printf("The minimum is at x = %f, y = %f for which f(x, y) = %f.\n", x[0], x[1], g(x))

 

{{out}}

Testing steepest descent method:

The minimum is at x = 0.107627, y = -1.223260 for which f(x, y) = -0.750063.

</pre>

 

=={{header|Julia}}==

 

f(x) = (x[1] - 1) * (x[1] - 1) * e^(-x[2]^2) + x[2] * (x[2] + 2) * e^(-2 * x[1]^2)

 

println(optimize(f, [0.1, -1.0], GradientDescent()))

<pre>

Results of Optimization Algorithm

* Gradient Calls: 35

</pre>

 

=={{header|Perl}}==

Calculate with <code>bignum</code> for numerical stability.

{{trans|Raku}}

use warnings;

use bignum;

my @x = <0.1 -1>; # Initial guess of location of minimum.

 

{{out}}

<pre>The minimum is at x[0] = 0.107653, x[1] = -1.223370</pre>

=={{header|Phix}}==

{{trans|Go}}

{{out}}

<pre>

Testing steepest descent method:

</pre>

 

I could have used ∇ and Δ in the variable names, but it looked too confusing, so I've gone with <var>grad-</var> and <var>del-</var>

 

 

(define (apply-vector f v)

(module+ main

(Gradient-descent))

 

{{out}}

(formerly Perl 6)

{{trans|Go}}

 

 

 

 

 

while ( $delG > $h ) { # Iterate until value is <= tolerance.

 

 

 

$g1 > $g0 ?? ( $alpha /= 2 ) !! ( $g0 = $g1 ) # Adjust parameter.

}

 

}

 

# Function for which minimum is to be found.

 

my $tolerance = 0.0000006 ; my $alpha = 0.1;

say "Testing steepest descent method:";

say "The minimum is at x[0] = ", @x[0], ", x[1] = ", @x[1];

{{out}}

<pre>Testing steepest descent method:

</pre>

 

=={{header|REXX}}==

alpha= 0.1

say center(' testing for the steepest descent method ', 79, "═")

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

b= alpha / delG

do while delG>tolerance

call gradG

b= alpha / delG

end /*while*/

return

/*──────────────────────────────────────────────────────────────────────────────────────*/

exp: procedure; parse arg x; ix= x%1; if abs(x-ix)>.5 then ix= ix + sign(x); x= x - ix

numeric form; m.=9; parse value format(x,2,1,,0) 'E0' with g "E" _ .; g=g *.5'e'_ %2

do j=0 while h>9; m.j=h; h= h % 2 + 1; end /*j*/

{{out|output|text=&nbsp; when using the internal default inputs:}}

<pre>

═══════════════════ testing for the steepest descent method ═══════════════════

</pre>

 

=={{header|Scala}}==

{{trans|Go}}

 

/** Steepest descent method modifying input values*/

}

}

{{out}}

<pre>

<br><br>

 

// Using the steepest-descent method to search

// for minimum values of a multi-variable function

gradientDescentMain();

 

{{out}}

<pre>

* &nbsp; [Linear Regression using Gradient Descent by Adarsh Menon]

<br><br>

let data: number[][] =

[[32.5023452694530, 31.70700584656990],

 

gradientDescentMain();

 

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-fmt}}

 

// Function for which minimum is to be found.

var g = Fn.new { |x|

return (x[0]-1)*(x[0]-1)*

}

 

var x = p[0]

var y = p[1]

}

 

steepestDescent.call(x, alpha, tolerance)

System.print("Testing steepest descent method:")

 

{{out}}

=={{header|zkl}}==

{{trans|Go}} with tweaked gradG

g0:=f(x,y); # Initial estimate of result.

fix,fiy := gradG(f,x,y,h); # Calculate initial gradient

g0:=f(x,y);

return((f(x + h, y) - g0)/h, (f(x, y + h) - g0)/h)

(x - 1).pow(2)*(-y.pow(2)).exp() +

y*(y + 2)*(-2.0*x.pow(2)).exp()

println("Testing steepest descent method:");

{{out}}

<pre>