Below is the current code I have. How do I edit it so I can input multiple variables for my objective function and input a gradient rather than a $1$D vector for the derivative function?

For example, I want my objective function to be f$($x$1,$x$2)=$ x$1^2+$x$2^2+$ x$1*$x$2$

import numpy as np

#Algorithm $4\mathrm{.}3$ Bracketing Phase for Line Search Algorithm

#The bracketing phase finds an interval within which we are certain

#to find a point that satisfies the strong Wolfe conditions.

def line$\_$search$\_$bracketing$($phi$,$ phi$\_$prime, alpha$\_$init, mu$1,$ mu$2,$ sigma$)$:

#Inputs:

#phi $($objective function$)$

#phi$\_$prime $($objective function derivative$)$

#alpha$\_$init $($initial step size$)$

#mu$1($decrease factor $01)$

a$1=0$ #Define Initial Bracket $<--$this is the initial point as well?

phi$0=$ phi$(0)$

phi$0\_$prime $=$ phi$\_$prime$(0)$

a$2=$ alpha$\_$init

phi$1=$ phi$0$

phi$1\_$prime $=$ phi$0\_$prime #Used in Pinpoint

first $=$ True

#Iteration Loop to Find Suitable Step Size $($to satisfy Wolfe conditions$)$

while True:

phi$2=$ phi$($a$2)$ #Calculate value for step point

phi$2\_$prime $=$ phi$\_$prime$($a$2)$ #Calculate derivative for step point

#if step point is greater than sufficient decrease line OR greater than initial point

if $($phi$2>$ phi$0+$ mu$1*$ a$2*$ phi$0\_$prime$)$ or $($not first and phi$2>$ phi$1)$:

a$\_$star $=$ pinpoint$($phi$,$ phi$\_$prime, a$1,$ a$2)$ #run pinpoint function

return a$\_$star

phi$2\_$prime$\_$abs $=$ np$.$abs$($phi$2\_$prime$)$

#if magnitude of slope of step point is close enough to zero then exit line search

if phi$2\_$prime$\_$abs $<=-$mu$2*$ phi$0\_$prime:

return a$2$

#if magnitude of slope of step point is too great, call pinpoint function

elif phi$2\_$prime $>=0$:

a$\_$star $=$ pinpoint$($phi$,$ phi$\_$prime, a$2,$ a$1)$

return a$\_$star

#Shift all values over to search again

a$1=$ a$2$

phi$1=$ phi$2$

phi$1\_$prime $=$ phi$2\_$prime

a$2=$ sigma $*$ a$2$

first $=$ False

#Algorithm $4\mathrm{.}4$ Pinpoint function for the line search algorithm

#The pinpointing phase finds a point that satisfies the strong Wolfe

#conditions within the interval provided by the bracketing phase.

def pinpoint$($phi$,$ phi$\_$prime, a$\_$low, a$\_$high, mu$1=0\mathrm{.}25,$ mu$2=0\mathrm{.}9)$:

k $=0$

while True:

# Cubic interpolation $-$ Call function to locate potential minimum between a$1$ and a$2$

a$\_$p $=$ cubic$\_$interpolation$($phi$,$ phi$\_$prime, a$\_$low, a$\_$high$)$

phi$\_$p $=$ phi$($a$\_$p$)$

phi$\_$p$\_$prime $=$ phi$\_$prime$($a$\_$p$)$

#Check wolfe conditions and update interval accordingly.

#If conditions are met, return step size

if phi$\_$p $>$ phi$(0)+$ mu$1*$ a$\_$p $*$ phi$(0)$:

a$\_$high $=$ a$\_$p

elif phi$\_$p$\_$prime $>=$ mu$2*$ phi$(0)$:

return a$\_$p

elif phi$\_$p$\_$prime $*($a$\_$high $-$ a$\_$low$)>=0$:

a$\_$high $=$ a$\_$low

a$\_$low $=$ a$\_$p

k $+=1$

#Cubic Interpolation $-$ Choses $3$ points within the interval, connects the points using cubic polynomial fit

#and finds the minimum of the three points to return the interpolated step size.

def cubic$\_$interpolation$($phi$,$ phi$\_$prime, a$\_$low, a$\_$high$)$:

# Perform cubic interpolation using polyfit

alpha$\_$values $=$ np$.$array$([$a$\_$low, $0\mathrm{.}5*($a$\_$low $+$ a$\_$high$),$ a$\_$high$])$ #Bisection Method $($array of $3$ points$)$

phi$\_$values $=$ np$.$array$([$phi$($alpha$)$ for alpha in alpha$\_$values$])$ #Find phi values of three points

phi$\_$prime$\_$values $=$ np$.$array$([$phi$\_$prime$($alpha$)$ for alpha in alpha$\_$values$])$ #Find sloped of three points

# Fit a cubic polynomial to the data

coefficients $=$ np$.$polyfit$($alpha$\_$values, phi$\_$values, $3)$

# Find the minimum of the cubic polynomial

a$\_$p $=-$coefficients$[1]/(3*$ coefficients$[0])$

return a$\_$p #return minimum point between original a$1$ and a$2$ as calcuulated by cubic interpolation

#$-----------------------------------------------------------------------------------------------------------$

# Define your phi and phi$\_$prime functions

#Objective Function

def phi$($alpha$)$:

return np$.$sum$($alpha $-2)**2+1$

#Objective Function Derivative

def phi$\_$prime$($alpha$)$:

return $2*($alpha $-2)$

# Set initial parameters

#Initial Step Size

alpha$\_$init $=0\mathrm{.}1$

#Decrease Factor $01$

sigma $=2$

# Perform line search bracketing

optimal$\_$step $=$ line$\_$search$\_$bracketing$($phi$,$ phi$\_$prime, alpha$\_$init, mu$1,$ mu$2,$ sigma$)$

print$("$Optimal Step:", optimal$\_$step$)$