-1732.947060918

-0.5

--

```python

#

# Author: Michael D. Johnson

# Date: 13 March 2015

# Email: michael.d.johnson@ucsf.edu

#

import numpy as np

# define the value of the target function

def f(x):

return x**2 + x - 2

# set the initial guess for the variables

def x0():

return [1,2,3,4]

# apply a method of steepest descent to find the minimum value of the function

# returns an array with the best values found and also returns the number of iterations

# required to find the minima.

def steepest_descent(f=f, x0=x0(), epsilon=1e-24, maxiters=100):

"""

Applies a method of steepest descent to find the minimum value of the function.

f: The target function to minimize (default is f(x) = x^2 + x - 2).

x0: Initial guess for the variables (default is [1,2,3,4]).

epsilon: Tolerance to be used in determining whether an acceptable minimum value has been found.

maxiters: Maximum number of iterations allowed (default is 100).

Returns: A list containing the best values found and also returns the number of iterations required to find the minima.

"""

# set up the variables needed for the algorithm

x = x0()

H = np.zeros((len(x), len(x)))

d = None

i = 0

while True:

i += 1

# evaluate the function at the current point

fval = f(x)

if fval < epsilon:

break

# calculate the gradient of the function at the current point

g = np.zeros((len(x),))

for j in range(len(x)):

g[j] = (f(np.append(x, -1)) - f(np.delete(x, j)))/(2*(-1)**j)

# update the Hessian matrix if it has been calculated previously

if d is not None:

H += np.outer(g,g).reshape((len(x),len(x)))/i

# update the direction vector

if d is None:

d = -g

else:

H_inv = np.linalg.pinv(H)

g = f(x) - np.outer(d, x).reshape((1, len(x)))

d = np.dot(H_inv, g)

# update the variables

x -= d

return x, i

# calculate the inverse Hessian matrix using a limited memory algorithm

def invHessian(H):

"""

Calculates the inverse Hessian matrix using a limited memory algorithm.

Returns: The inverse Hessian matrix.

"""

# get the dimensions of the Hessian matrix

n = len(H)

# initialize the variables needed for the limited memory algorithm

L = np.eye(n)

r = np.zeros((n,1))

for k in range(5): # limited number of iterations

L_inv = np.linalg.pinv(L)

r = np.dot(L_inv, np.outer(H, r)) + np.outer(L, np.eye(n))

L = np.dot(L, L_inv)

return L

# calculate the inverse Hessian matrix and then use it to find a minimum value of the function

def min_func_with_Hessian(f=f, x0=x0(), epsilon=1e-24, maxiters=100):

"""

Calculates the inverse Hessian matrix and then uses it to find a minimum value of the function.

f: The target function to minimize (default is f(x) = x^2 + x - 2).

x0: Initial guess for the variables (default is [1,2,3,4]).

epsilon: Tolerance to be used in determining whether an acceptable minimum value has been found.

maxiters: Maximum number of iterations allowed (default is 100).

Returns: A list containing the best values found and also returns the number of iterations required to find the minima.

"""

# evaluate the function at the initial point

fval = f(x0())

# calculate the Hessian matrix

H = np.zeros((len(x0()), len(x0())))

for j in range(len(x0())):

for i in range(j+1, len(x0())):

x = x0()

x[i] = -1

H[j][i] = (f(np.append(x, -1)) - f(np.delete(x, i)))/(2*(-1)**j)

H = np.dot(H.T, H)/len(x0())

# calculate the inverse Hessian matrix

L = invHessian(H)

# apply a method of steepest descent to find the minimum value of the function

x, i = steepest_descent(f=f, x0=x0(), epsilon=epsilon, maxiters=maxiters)

return x, i

# calculate the inverse Hessian matrix and then use it to find a global minimum value of the function

def min_func_with_Hessian_global(f=f, x0=x0(), epsilon=1e-24, maxiters=100):

"""

Calculates the inverse Hessian matrix and then uses it to find a global minimum value of the function.

f: The target function to minimize (default is f(x) = x^2 + x - 2).

x0: Initial guess for the variables (default is [1,2,3,4]).

epsilon: Tolerance to be used in determining whether an acceptable minimum value has been found.

maxiters: Maximum number of iterations allowed (default is 100).

Returns: A list containing the best values found and also returns the number of iterations required to find the minima.

"""

# evaluate the function at the initial point

fval = f(x0())

# calculate the Hessian matrix

H = np.zeros((len(x0()), len(x0())))

for j in range(len(x0())):

for i in range(j+1, len(x0())):

x = x0()

x[i] = -1

H[j][i] = (f(np.append(x, -1)) - f(np.delete(x, i)))/(2*(-1)**j)

H = np.dot(H.T, H)/len(x0())

# calculate the inverse Hessian matrix

L = invHessian(H)

# apply a method of steepest descent to find the minimum value of the function

x, i = steepest_descent(f=f, x0=x0(), epsilon=epsilon, maxiters=maxiters)

# check if this is the global minimum

while True:

i += 1

x, fval = min_func_with_Hessian(f=f, x0=x, epsilon=epsilon/i, maxiters=maxiters)

if fval > i*epsilon/i:

break

return x, i

```