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.

procedure steepestDescent ( long real array x ( * ); long real value alphap, tolerance ) ;

begin

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}}==

(%o7) done

The optimization subroutine GD sets the reverse communication variable IFLAG. This allows the evaluation of the gradient to be done separately.

IMPLICIT NONE

INTEGER N

STOP 'program complete'

END

{{out}}

<pre>After 31 steps, found minimum at x= 0.107626843548372 y= -1.223259663839920 of f= -0.750063420551493

 

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}}

Results on 32/64 bit Phix agree to 13dp, which I therefore choose to show in full here (but otherwise would not really trust).

<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}}

 

sub steepestDescent(@x, $alpha is copy, $h) {

say "Testing steepest descent method:";

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

{{out}}

<pre>Testing steepest descent method:

=={{header|REXX}}==

The &nbsp; ''tolerance'' &nbsp; can be much smaller; &nbsp; a tolerance of &nbsp; '''1e-200''' &nbsp; was tested. &nbsp; It works, but causes the program to execute a bit slower, but still sub-second execution time.

numeric digits (length( e() ) - length(.) ) % 2 /*use half of number decimal digs in E.*/

tolerance= 1e-30 /*use a much smaller tolerance for REXX*/

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>

=={{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>