FR算法matlab代码

根据提供的引用内容，我们可以了解到FR算法是一种无约束最优化方法，可以用于求解无约束最优化问题。下面是FR算法的Matlab代码实现：

function [x, fval, exitflag, output] = FR(fun, x0, options)
% FR - Fletcher-Reeves conjugate gradient method
%   [x, fval, exitflag, output] = FR(fun, x0) starts at x0 and attempts to
%   find a local minimum of the function fun. fun is a function handle. x0
%   is a column vector. The function fun(x) should return a scalar value.
%
%   [x, fval, exitflag, output] = FR(fun, x0, options) minimizes with the
%   default optimization parameters replaced by values in the structure
%   options, created with the OPTIMOPTIONS function.
%
%   The FR function can be called with a function handle and an initial
%   guess as follows:
%       x = FR(@fun, x0);
%
%   The function returns the minimum value of the function and the
%   corresponding values of the variables.
%
%   The function can also be called with additional options as follows:
%       options = optimoptions('FR', 'TolFun', 1e-6, 'MaxIter', 1000);
%       x = FR(@fun, x0, options);
%
%   The available options are:
%       TolFun - Termination tolerance on the function value (default: 1e-6)
%       MaxIter - Maximum number of iterations allowed (default: 1000)
%
%   The function returns the following:
%       x - Minimum value of the function
%       fval - Value of the function at the minimum
%       exitflag - Reason for stopping
%           1 - Function value below TolFun
%           2 - Maximum number of iterations reached
%       output - Structure containing output information
           iterations - Number of iterations performed
%           message - Termination message
%
%   Example:
%       fun = @(x) x(1)^2 + x(2)^2;
%       x0 = [3; 4];
%       x = FR(fun, x0);
%
%   Reference:
%       Nocedal, J., & Wright, S. J. (2006). Numerical optimization
%       (2nd ed.). Springer.
%
%   See also OPTIMOPTIONS.

% Set default options
defaultOptions.TolFun = 1e-6;
defaultOptions.MaxIter = 1000;

% Check for user-defined options
if nargin < 3
    options = [];
end

% Merge user-defined options with default options
options = mergeOptions(defaultOptions, options);

% Initialize variables
x = x0;
fval = fun(x);
g = grad(fun, x);
d = -g;
k = 0;

% Main loop
while norm(g) > options.TolFun && k < options.MaxIter
    % Compute step size
    alpha = linesearch(fun, x, d);
    
    % Update variables
    x = x + alpha*d;
    fval_old = fval;
    fval = fun(x);
    g_old = g;
    g = grad(fun, x);
    
    % Compute beta
    beta = (g'*g)/(g_old'*g_old);
    
    % Update direction
    d = -g + beta*d;
    
    % Update iteration count
    k = k + 1;
end

% Set exit flag and output message
if norm(g) <= options.TolFun
    exitflag = 1;
    message = 'Function value below TolFun';
else
    exitflag = 2;
    message = 'Maximum number of iterations reached';
end

% Set output structure
output.iterations = k;
output.message = message;
end

function g = grad(fun, x)
% Compute gradient of function at point x
h = 1e-6;
n = length(x);
g = zeros(n, 1);
for i = 1:n
    e = zeros(n, 1);
    e(i) = 1;
    g(i) = (fun(x+h*e) - fun(x-h*e))/(2*h);
end
end

function alpha = linesearch(fun, x, d)
% Compute step size using backtracking line search
alpha = 1;
rho = 0.5;
c = 1e-4;
fval = fun(x);
g = grad(fun, x);
while fun(x+alpha*d) > fval + c*alpha*(g'*d)
    alpha = rho*alpha;
end
end

function options = mergeOptions(defaultOptions, options)
% Merge user-defined options with default options
if isempty(options)
    options = defaultOptions;
else
    fields = fieldnames(defaultOptions);
    for i = 1:length(fields)
        if ~isfield(options, fields{i})
            options.(fields{i}) = defaultOptions.(fields{i});
        end
    end
end
end