TRƯỜNG ĐẠI HỌC BÁCH KHOA

ĐẠI HỌC ĐÀ NẴNG

KHOA ĐIỆN

...🙤🕮🙦…

BÀI TẬP
TOÁN NÂNG CAO

GVHD : TS. Trần Thị Minh Dung.

Họ và tên: Phan Phúc Tài

MSSV: 105200382.
Nhóm HP: 20Nh36.
Lớp SH: 20TDHCLC1.

Đà Nẵng, 11/2023
Giải bài toán tối ưu bằng phương pháp Bisection.
Bài 1:
clear; clc;
k = 1;
x = 2;
f = (x^2);
f_mang = f;
x_mang = x;
fmin = f ;
xmin = x;
kmin = 1;
while k < 10
a = 2+3/(2^(k+1));
d = (-1)^(k+1);
x = x + a*d;
x_mang = [x_mang, x];
f = (x^2);
f_mang = [f_mang, f];
k = k +1 ;
if f < fmin
fmin = f;
xmin = x;
kmin = k;
end
end
f_mang;
x_mang;
fmin;
xmin;
kmin;
xlabel('x');
ylabel('f(x)');
legend('f(x) = x^2', 'Cac Diem');
title('Ham f(x) ');
grid on;
x_range = -10:0.1:10;
f_x = x_range.^2;
plot(x_range, f_x, '--', 'Color', 'r', 'LineWidth', 4);
hold on;
scatter(x_mang, f_mang, 'filled', 'MarkerFaceColor', 'blue');
Kết quả

Bài 2:
% Tệp equation.m
function f_val = equation(x)
f_val = x/(1+x.^2);
end
% Gọi hàm
f = @(x) x/(1+x.^2);

% Phương pháp chia đôi

a = -0.65; % Điểm bắt đầu của khoảng
b = 0.75; % Điểm kết thúc của khoảng
diemdung = 1e-4; % Sai số cho phép
c = (a + b) / 2; % Điểm chính giữa của khoảng

while abs(b - a) > diemdung

f_a = equation(a);
f_c = equation(c);

if f_a * f_c < 0

b = c; % Khoảng mới là [a, c]
else
a = c; % Khoảng mới là [c, b]
end
 % Nghiệm xấp xỉ
c = (a + b) / 2;

end

% Hiển thị kết quả bằng fprintf

fprintf('Nghiệm xấp xỉ: %g\n', c);
%fprintf('Điểm bắt đầu: %f\n', a);
%fprintf('Điểm kết thúc: %f\n', b);

% Vẽ đồ thị
x = linspace(-2, 2, 100);
y = x/(1+x.^2);

figure;
plot(x, y);
hold on;
plot(c, c/(1+c.^2), 'ro', 'MarkerSize', 10, 'MarkerFaceColor', 'r');
title('Đồ thị của pt và nghiệm xấp xỉ');
xlabel('x');
ylabel('y');
legend('equation', 'Nghiệm xấp xỉ');

Kết quả

BÀI TẬP CHƯƠNG 3(LẦN 2).

Chương trình hàm function cho phương trình chỉ có 1 biến:

function step_size = armijo_rule(f, grad_f, x, alpha, beta, max_iter)
step_size = 1.0;
 iter_count = 0;

while iter_count < max_iter

f_val = f(x);
grad_val = grad_f(x);
new_f_val = f(x - step_size * grad_val);

if new_f_val <= f_val - alpha * step_size * norm(grad_val)^2

% Điều kiện Armijo được thỏa mãn
break;
end

% Giảm kích thước bước

step_size = step_size * beta;
iter_count = iter_count + 1;
end
end

Chương trình hàm function dành cho phương trình có 2 biến:

function step_size = armijo_rule_2d(f, grad_f_x, grad_f_y, x, y, alpha, beta,
max_iter)
step_size = 1.0;
iter_count = 0;

while iter_count < max_iter

f_val = f(x, y);
grad_val_x = grad_f_x(x, y);
grad_val_y = grad_f_y(x, y);
new_f_val = f(x - step_size * grad_val_x, y - step_size * grad_val_y);

if new_f_val <= f_val - alpha * step_size * (norm(grad_val_x)^2 +

norm(grad_val_y)^2)
% Điều kiện Armijo được thỏa mãn
break;
end

% Giảm kích thước bước

step_size = step_size * beta;
iter_count = iter_count + 1;
end
end
Bài 1:
% Hàm mục tiêu
g = @(x, y) 2 * x * y + 2 * x - x.^2 - 2 * y.^2;

% Gradient của hàm mục tiêu theo biến x

grad_g_x = @(x, y) 2 * y + 2 - 2 * x;

% Gradient của hàm mục tiêu theo biến y

grad_g_y = @(x, y) 2 * x - 4 * y;

% Vị trí ban đầu

x = 1.0;
y = 2.0;

% Các đối số cho phương pháp Armijo Rule

alpha = 1;
beta = 1;
max_iter = 100;

% Áp dụng phương pháp Armijo Rule để tìm kích thước bước tối ưu
step_size = armijo_rule_2d(g, grad_g_x, grad_g_y, x, y, alpha, beta, max_iter);

% Cập nhật vị trí mới bằng gradient descent với kích thước bước tối ưu
x_new = x - step_size * grad_g_x(x, y);
y_new = y - step_size * grad_g_y(x, y);

% Hiển thị kết quả

fprintf('Vị trí ban đầu: x = %f, y = %f\n', x, y);
fprintf('Kích thước bước tối ưu: %f\n', step_size);
fprintf('Vị trí mới: x = %f, y = %f\n', x_new, y_new);

Kết quả
Bài 2
% Hàm mục tiêu
g = @(x, y) x * y.^2;

% Gradient của hàm mục tiêu theo biến x

grad_g_x = @(x, y) y.^2;

% Gradient của hàm mục tiêu theo biến y

grad_g_y = @(x, y) 2 * x * y;

% Vị trí ban đầu

x = 1.0;
y = 2.0;

% Các đối số cho phương pháp Armijo Rule

alpha = 1;
beta = 1;
max_iter = 100;

% Áp dụng phương pháp Armijo Rule để tìm kích thước bước tối ưu
step_size = armijo_rule_2d(g, grad_g_x, grad_g_y, x, y, alpha, beta, max_iter);

% Cập nhật vị trí mới bằng gradient descent với kích thước bước tối ưu
x_new = x - step_size * grad_g_x(x, y);
y_new = y - step_size * grad_g_y(x, y);

% Hiển thị kết quả

fprintf('Vị trí ban đầu: x = %f, y = %f\n', x, y);
fprintf('Kích thước bước tối ưu: %f\n', step_size);
fprintf('Vị trí mới: x = %f, y = %f\n', x_new, y_new);

Kết quả
Bài 3:
% Hàm mục tiêu
f = @(x) x.^3 - 6 * x.^2 + 9 * x - 8;

% Gradient của hàm mục tiêu

grad_f = @(x) 3 * x.^2 - 12 * x + 9;

% Vị trí ban đầu

x = 5.0;

% Các đối số cho phương pháp Armijo Rule

alpha = 1;
beta = 1;
max_iter = 100;

% Áp dụng phương pháp Armijo Rule để tìm kích thước bước tối ưu
step_size = armijo_rule(f, grad_f, x, alpha, beta, max_iter);

% Cập nhật vị trí mới bằng gradient descent với kích thước bước tối ưu
x_new = x - step_size * grad_f(x);

% Hiển thị kết quả

disp(['Vị trí ban đầu: ', num2str(x)]);
disp(['Kích thước bước tối ưu: ', num2str(step_size)]);
disp(['Vị trí mới: ', num2str(x_new)]);

Kết quả
Bài 4:
% Hàm mục tiêu
f = @(x) (x-2).^2 + cos(x);

% Gradient của hàm mục tiêu

grad_f = @(x) 2 * (x-2) - sin(x);

% Vị trí ban đầu

x = 5.0;

% Các đối số cho phương pháp Armijo Rule

alpha = 1;
beta = 1;
max_iter = 100;

% Áp dụng phương pháp Armijo Rule để tìm kích thước bước tối ưu
step_size = armijo_rule(f, grad_f, x, alpha, beta, max_iter);

% Cập nhật vị trí mới bằng gradient descent với kích thước bước tối ưu
x_new = x - step_size * grad_f(x);

% Hiển thị kết quả

disp(['Vị trí ban đầu: ', num2str(x)]);
disp(['Kích thước bước tối ưu: ', num2str(step_size)]);
disp(['Vị trí mới: ', num2str(x_new)]);

Kết quả
Bài 5:
% Hàm mục tiêu
f = @(x) exp(x) - 3 * x.^2;

% Gradient của hàm mục tiêu

grad_f = @(x) exp(x) - 6 * x;

% Vị trí ban đầu

x = 5.0;

% Các đối số cho phương pháp Armijo Rule

alpha = 1;
beta = 1;
max_iter = 100;

% Áp dụng phương pháp Armijo Rule để tìm kích thước bước tối ưu
step_size = armijo_rule(f, grad_f, x, alpha, beta, max_iter);

% Cập nhật vị trí mới bằng gradient descent với kích thước bước tối ưu
x_new = x - step_size * grad_f(x);

% Hiển thị kết quả

fprintf('Vị trí ban đầu: %f\n', x);
fprintf('Kích thước bước tối ưu: %f\n', step_size);
fprintf('Vị trí mới: %f\n', x_new);

Kết quả
Bài 6:
% Hàm mục tiêu
g = @(x, y) x - y + 2 * x.^2 + 2*x*y + y.^2;

% Gradient của hàm mục tiêu theo biến x

grad_g_x = @(x, y) 1 + 4 * x + 2 * y;

% Gradient của hàm mục tiêu theo biến y

grad_g_y = @(x, y) -1 + 2 * x+2 * y;

% Vị trí ban đầu

x = 1.0;
y = 2.0;

% Các đối số cho phương pháp Armijo Rule

alpha = 1;
beta = 1;
max_iter = 100;

% Áp dụng phương pháp Armijo Rule để tìm kích thước bước tối ưu
step_size = armijo_rule_2d(g, grad_g_x, grad_g_y, x, y, alpha, beta, max_iter);

% Cập nhật vị trí mới bằng gradient descent với kích thước bước tối ưu
x_new = x - step_size * grad_g_x(x, y);
y_new = y - step_size * grad_g_y(x, y);

% Hiển thị kết quả

fprintf('Vị trí ban đầu: x = %f, y = %f\n', x, y);
fprintf('Kích thước bước tối ưu: %f\n', step_size);
fprintf('Vị trí mới: x = %f, y = %f\n', x_new, y_new);

Kết quả
 BÀI TẬP CHƯƠNG 3(LẦN 3)

Giải bài toán tối ưu bằng phương pháp Steepest Descent method.

Bài 1:
clc;clear;
% Hàm mục tiêu
f = @(x) (x(1)-4)^4 + (x(2)-3)^2 + 4*(x(3)+5)^4;

% Gradient của hàm mục tiêu

gradient = @(x) [4*(x(1)-4)^3, 2*(x(2)-3), 16*(x(3)+5)^3];

% Điểm khởi tạo

x0 = [4, 2, -1];
x = x0;

% Tham số
epsilon = 1e-6;

% Thuật toán Steepest Descent

while true
grad = gradient(x); % Tính gradient
d = -grad; % Hướng đi
alpha = 0.1; % Giá trị ban đầu của stepsize

% Tìm stepsize alpha

while f(x + alpha*d) >= f(x)
alpha = alpha * 0.5; % Giảm stepsize
end

x_new = x + alpha*d; % Cập nhật x

 % Kiểm tra điều kiện dừng
if norm(x_new - x) < epsilon
break;
end

x = x_new;
end

% Kết quả
min_value = f(x);
min_point = x;
disp('Giá trị nhỏ nhất của hàm mục tiêu:');
disp(min_value);
disp('Điểm tới hạn:');
disp(min_point);

Kết quả

Bài 2:
clc;clear;
% Hàm mục tiêu
f = @(x) 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;

% Gradient của hàm mục tiêu

gradient = @(x) [-400*x(1)*(x(2)-x(1)^2)^2 - 2*(1-x(1)), 200*(x(2)-x(1)^2)];

% Số lần lặp tối đa

max_iter = 0.1;

% Điểm khởi tạo

x0 = [2, -2];
x = x0;
iter = 0;

% Tham số
epsilon = 1e-4;

% Thuật toán Steepest Descent

while iter < max_iter
grad = gradient(x); % Tính gradient
d = -grad; % Hướng đi
alpha = 0.1; % Giá trị ban đầu của stepsize

% Tìm stepsize alpha

while f(x + alpha*d) >= f(x)
alpha = alpha * 0.5; % Giảm stepsize
end

x_new = x + alpha*d; % Cập nhật x

% Kiểm tra điều kiện dừng

if norm(x_new - x) < epsilon
break;
end

x = x_new;

iter = iter + 1;
end

% Kết quả
min_value = f(x);
min_point = x;
disp('Giá trị nhỏ nhất của hàm mục tiêu:');
disp(min_value);
disp('Điểm tới hạn:');
disp(min_point);
Kết quả

Giải bài toán bằng phương pháp Newton method.

Bài 3:
clc;
clear;

function x_min = newton_3(f, x0, epsilon)

% Đạo hàm bậc 1
f_cuongcute1 = @(x) 1 + (4/3)*x^(1/3);

% Đạo hàm bậc 2

f_cuongcute2 = @(x) (4/9)*x^(-2/3);

x = x0;
while true
x_new = x - f_cuongcute1(x) / f_cuongcute2(x);

% Kiểm tra điều kiện dừng

if abs(x_new - x) < epsilon
break;
end

x = x_new;
end
 x_min = x;
end

% Hàm mục tiêu

f = @(x) x + x^(4/3);

% Điểm khởi tạo

x0 = 1;

% Ngưỡng dừng
epsilon = 1e-6;

% Tìm giá trị nhỏ nhất bằng phương pháp Newton

x_min = newton_3(f, x0, epsilon);

% Kết quả
min_value = f(x_min);
min_point = x_min;
disp('Giá trị nhỏ nhất của hàm mục tiêu:');
disp(min_value);
disp('Điểm tới hạn:');
disp(min_point);

Kết quả

Bài 4:
function x_min = newton4(f, x0, epsilon)
% Đạo hàm bậc 1
f_cuongcute1 = @(x) 3*x^2 - 24.2*x + 7.45;

% Đạo hàm bậc 2

f_cuongcute2 = @(x) 6*x - 24.4;
 x = x0;
while true
x_new = x - f_cuongcute1(x) / f_cuongcute2(x);

% Kiểm tra điều kiện dừng

if abs(x_new - x) < epsilon
break;
end

x = x_new;
end

x_min = x;
end
clc;
clear;

% Hàm mục tiêu

f = @(x) x^3 - 12.2*x^2 + 7.45*x + 42;

% Điểm khởi tạo

x0 = 1;

% Ngưỡng dừng
epsilon = 1e-6;

% Tìm giá trị nhỏ nhất bằng phương pháp Newton

x_min = newton_4(f, x0, epsilon);

% Kết quả
min_value = f(x_min);
min_point = x_min;
disp('Giá trị nhỏ nhất của hàm mục tiêu:');
disp(min_value);
disp('Điểm tới hạn:');
disp(min_point);
Kết quả

Bài 5:
function x_min = newton_5(f, x0, epsilon)
% Đạo hàm bậc 1
f_cuongcute1 = @(x) exp(x) - 3;

% Đạo hàm bậc 2

f_cuongcute2 = @(x) exp(x);

x = x0;
while true
x_new = x - f_cuongcute1(x) / f_cuongcute2(x);

% Kiểm tra điều kiện dừng

if abs(x_new - x) < epsilon
break;
end

x = x_new;
end

x_min = x;
end
clc;
clear;

% Hàm mục tiêu

f = @(x) exp(x) - 3*x;

% Điểm khởi tạo

x0 = 1;
% Ngưỡng dừng
epsilon = 1e-6;

% Tìm giá trị nhỏ nhất bằng phương pháp Newton

x_min = newton_5(f, x0, epsilon);

% Kết quả
min_value = f(x_min);
min_point = x_min;
disp('Giá trị nhỏ nhất của hàm mục tiêu:');
disp(min_value);
disp('Điểm tới hạn:');
disp(min_point);

Kết quả

Giải bằng phương pháp Quasi - Newton method.

Bài 6:
clc;
clear;
% Hàm mục tiêu
f = @(x) x + x^(4/3);

% Đạo hàm của hàm mục tiêu

grad_f = @(x) 1 + (4/3)*x^(1/3);

% Ma trận xấp xỉ đạo hàm bậc hai ban đầu

H = eye(1);

% Điểm khởi tạo

x0 = 1;
x = x0;
vonglap = 0;

while vonglap < 10

% Tính gradient tại x
g = grad_f(x);

% Kiểm tra điều kiện dừng

if norm(g) < 1e-6
break;
end

% Tính hướng tìm kiếm bằng công thức BFGS

d = -H * g;

% Tìm kiếm tối ưu trên đường thẳng

alpha = 1;
x_new = x + alpha * d;

% Tính gradient tại x_new

g_new = grad_f(x_new);

% Tính a
a = alpha*d;

% Tính b
b = g_new - g;

% Cập nhật ma trận xấp xỉ đạo hàm bậc hai B theo công thức BFGS

H_new = H + (1 + (b'*H*b)/(b'*a))*((a*a')/a'*b) - (H*b*a'+(H*b'*a')')/(b'*a);

% Cập nhật giá trị x

x = x_new;

vonglap = vonglap + 1;
end

% Kết quả
min_value = f(x);
min_point = x;
disp('Giá trị nhỏ nhất của hàm mục tiêu:');
disp(min_value);
disp('Điểm tối ưu:');
disp(min_point);

Kết quả

Bài 7:
clc;
clear;

% Hàm mục tiêu

f = @(x) 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;

% Gradient của hàm mục tiêu

grad_f = @(x) [-400*x(1)*(x(2)-x(1)^2) - 2*(1-x(1)); 200*(x(2)-x(1)^2)];

% Điểm khởi tạo

x0 = [2; -2];

% Ma trận xấp xỉ đạo hàm bậc hai ban đầu

H = eye(2);

% Vòng lặp tối ưu

x = x0;
vonglap = 0;
while vonglap < 1
 % Tính gradient tại x
g = grad_f(x);

% Kiểm tra điều kiện dừng

if norm(g) < 1e-6
break;
end

% Tính hướng tìm kiếm bằng công thức BFGS

d = -H * g;

% Tìm kiếm tối ưu trên đường thẳng

alpha = 1;
x_new = x + alpha * d;

% Tính gradient tại x_new

g_new = grad_f(x_new);

% Tính s
a = alpha*d;

% Tính y
b = g_new - g;

% Cập nhật ma trận xấp xỉ đạo hàm bậc hai B theo công thức BFGS

H_new = H + (1 + (b'.*H.*b)/(b'.*a))*((a.*a')/a'.*b) -
(H.*b.*a'+(H.*b'.*a')')/(b'.*a);

% Cập nhật giá trị x

x = x_new;

vonglap = vonglap + 1;
end

% Kết quả
min_value = f(x);
min_point = x;
disp('Giá trị nhỏ nhất của hàm mục tiêu:');
disp(min_value);
disp('Điểm tối ưu:');
disp(min_point);
Kết quả:

BÀI TẬP CHƯƠNG 4.

Kiểm trả bằng lệnh fminunc hoặc fminsearch.

Bài 1:
clc;clear;
fun = @(x) 3*x(1)^2 + 2*x(1)*x(2) + x(2)^2 - 4*x(1) + 5*x(2);
x0 = [1,1];
[x,fval] = fminunc(fun,x0)

Kết quả

Bài 2:
options = optimoptions("fminunc","Algorithm","trust-
region","SpecifyObjectiveGradient",true);
x0 = [-1,2];
fun = @func;
x = fminunc(fun,x0,options)

Kết quả

Bài 3:
fun = @(x) x(1)*exp(-(x(1)^2 + x(2)^2)) + (x(1)^2 + x(2)^2)/20;
x0 = [1,2];
[x,fval] = fminunc(fun,x0)

File func.m
function [f,g] = func(x)
f = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;

if nargout > 1
g = [-400*x(1)*(x(2)-x(1)^2) - 2*(1-x(1));200*(x(2)-x(1)^2)];

end

Kết quả
Bài 4:
%fun = @(x) 100*(x(2) - x(1)^2)^2 + (1 - x(1))^2;
%x0 = [-1.2,1];
%x = fminsearch(fun,x0);
options = optimset('Display','iter','PlotFcns',@optimplotfval);
fun = @(x) 100*(x(2) - x(1)^2)^2 + (1 - x(1))^2;
x0 = [-1.2,1];
x = fminsearch(fun,x0,options);

Kết quả
 BÀI TẬP CHƯƠNG 4
Bài 1: Dùng lệnh fmincon để giải bài toán.
% Định nghĩa hàm mục tiêu
fun = @(x) 100*(x(2) - x(1)^2)^2 + (1 - x(1))^2;

% Định nghĩa ràng buộc

A = [];
b = [];
Aeq = [];
beq = [];
lb = [0; 0.5];
ub = [0.5; 0.8];

% Giải bài toán tối ưu

x0 = [0.5; 0.5]; % Giá trị khởi tạo
options = optimoptions('fmincon', 'Display', 'iter'); % Tùy chọn
[x_opt, fval] = fmincon(fun, x0, A, b, Aeq, beq, lb, ub, @circlecon, options);

% Hiển thị kết quả

disp('Giá trị tối ưu:');
disp(x_opt);
disp('Giá trị hàm mục tiêu tối ưu:');
disp(fval);

% Hàm ràng buộc phi tuyến

function [c, ceq] = circlecon(x)
c = (x(1) - 1/3)^2 + (x(2) - 1/3)^2 - (1/2)^2;
ceq = [];
end

Kết quả

Bài 2:
% Định nghĩa hàm mục tiêu
fun = @(x) (x(1) - 9)^2 + (x(2) - 6)^2;

% Khởi tạo giá trị ban đầu

x0 = [0; 0];

% Sử dụng hàm fmincon để tìm giá trị nhỏ nhất

options = optimoptions('fmincon', 'Display', 'iter');
[x_opt, fval] = fmincon(fun, x0, [], [], [], [], [], [], @nonlcon, options);

% Hiển thị kết quả

disp('Giá trị tối ưu của x:');
disp(x_opt);
disp('Giá trị tối ưu của hàm mục tiêu:');
disp(fval);

% Vẽ đồ thị
x1 = linspace(-10, 10, 100);
x2 = linspace(-10, 10, 100);
[X1, X2] = meshgrid(x1, x2);
Z = (X1 - 9).^2 + (X2 - 6).^2;
C1 = X1.^2 - X2;
C2 = X2 - 4;

figure;
contour(X1, X2, Z, 50); % Đồ thị hàm mục tiêu
hold on;
contour(X1, X2, C1, [0 0], 'LineColor', 'r', 'LineWidth', 2); % Đồ thị ràng buộc
thứ nhất
contour(X1, X2, C2, [0 0], 'LineColor', 'g', 'LineWidth', 2); % Đồ thị ràng buộc
thứ hai
plot(x_opt(1), x_opt(2), 'ro', 'MarkerSize', 10, 'LineWidth', 2); % Đánh dấu giá
trị tối ưu
xlabel('x1');
ylabel('x2');
title('Hàm mục tiêu và ràng buộc');
legend('Hàm mục tiêu', 'Ràng buộc 1', 'Ràng buộc 2', 'Giá trị tối ưu');
grid on;
hold off;

% Hàm ràng buộc phi tuyến

function [c, ceq] = nonlcon(x)
c = [x(1)^2 - x(2); x(2) - 4];
ceq = [];
end

Kết quả

Đồ thị
PHƯƠNG PHÁP LP SIMPLEX.
Bài 1:
clc;clear;
f = [-50; -120; -40; -80]; % Vector hệ số của hàm mục tiêu (dương vì chúng ta
đang tối thiểu hóa)
A = [2, 1, 1, 0; 0, 3, 1, 1; 4, 0, 1, 0; 1, 1, 0, 1]; % Ma trận ràng buộc bất đẳng
thức
b = [450; 180; 400; 110]; % Vector bên phải của ràng buộc bất đẳng thức
Aeq = []; % Không có ràng buộc đẳng thức
beq = []; % Không có ràng buộc đẳng thức
lb = [0; 0; 0; 0]; % Giới hạn dưới của các biến (x1, x2, x3, x4 >= 0)
ub = []; % Không có giới hạn trên của các biến

x = linprog(f, A, b, Aeq, beq, lb, ub) % Sử dụng linprog để giải bài toán tối ưu

% Kết quả
max_value = -f' * x;
disp(['Giá trị tối ưu của x1: ', num2str(x(1))]);
disp(['Giá trị tối ưu của x2: ', num2str(x(2))]);
disp(['Giá trị tối ưu của x3: ', num2str(x(3))]);
disp(['Giá trị tối ưu của x4: ', num2str(x(4))]);
disp(['Giá trị nhỏ nhất của hàm: ', num2str(max_value)]);

Kết quả

Bài 2
clc;
clear;

f = [-7/6; -13/10]; % Vector hệ số của hàm mục tiêu (dương vì chúng ta đang
tối thiểu hóa)
A = [1/30, 1/40; 1/28, 1/35; 1/30, 1/25]; % Ma trận ràng buộc bất đẳng thức
b = [1; 1; 1]; % Vector bên phải của ràng buộc bất đẳng thức
Aeq = []; % Không có ràng buộc đẳng thức
beq = []; % Không có ràng buộc đẳng thức
lb = [0; 0]; % Giới hạn dưới của các biến (x1, x2 >= 0)
ub = []; % Không có giới hạn trên của các biến

x = linprog(f, A, b, Aeq, beq, lb, ub); % Sử dụng linprog để giải bài toán tối ưu

% Kết quả
max_value = -f' * x;
disp(['Giá trị tối ưu của x1: ', num2str(x(1))]);
disp(['Giá trị tối ưu của x2: ', num2str(x(2))]);
disp(['Giá trị nhỏ nhất của hàm: ', num2str(max_value)]);
Kết quả

Bài 3:
clc;
clear;

f = [-3; -2]; % Vector hệ số của hàm mục tiêu (dương vì chúng ta đang tối thiểu
hóa)
A = [1, 0; 1, 3; 2, 1]; % Ma trận ràng buộc bất đẳng thức
b = [12; 45; 30]; % Vector bên phải của ràng buộc bất đẳng thức
Aeq = []; % Không có ràng buộc đẳng thức
beq = []; % Không có ràng buộc đẳng thức
lb = [0; 0]; % Giới hạn dưới của các biến (x1, x2, x3 >= 0)
ub = []; % Không có giới hạn trên của các biến

x = linprog(f, A, b, Aeq, beq, lb, ub); % Sử dụng linprog để giải bài toán tối ưu

% Kết quả
max_value = -f' * x;
disp(['Giá trị tối ưu của x1: ', num2str(x(1))]);
disp(['Giá trị tối ưu của x2: ', num2str(x(2))]);
disp(['Giá trị nhỏ nhất của hàm: ', num2str(max_value)]);
Kết quả

Bài 4:
clc;
clear;

f = [-5; -12]; % Vector hệ số của hàm mục tiêu (dương vì chúng ta đang tối
thiểu hóa)
A = [20, 10; 10, 20; 10, 30]; % Ma trận ràng buộc bất đẳng thức
b = [200; 120; 150]; % Vector bên phải của ràng buộc bất đẳng thức
Aeq = []; % Không có ràng buộc đẳng thức
beq = []; % Không có ràng buộc đẳng thức
lb = [0; 0]; % Giới hạn dưới của các biến (x1, x2, x3 >= 0)
ub = []; % Không có giới hạn trên của các biến

x = linprog(f, A, b, Aeq, beq, lb, ub); % Sử dụng linprog để giải bài toán tối ưu

% Kết quả
max_value = -f' * x;
disp(['Giá trị tối ưu của x1: ', num2str(x(1))]);
disp(['Giá trị tối ưu của x2: ', num2str(x(2))]);
disp(['Giá trị nhỏ nhất của hàm: ', num2str(max_value)]);

Kết quả
Bài 5:
clc;
clear;

f = [-750; -1000]; % Vector hệ số của hàm mục tiêu (dương vì chúng ta đang
tối thiểu hóa)
A = [1, 1; 1 2; 4, 3]; % Ma trận ràng buộc bất đẳng thức
b = [10; 15; 25]; % Vector bên phải của ràng buộc bất đẳng thức
Aeq = []; % Không có ràng buộc đẳng thức
beq = []; % Không có ràng buộc đẳng thức
lb = [0; 0]; % Giới hạn dưới của các biến (x1, x2, x3 >= 0)
ub = []; % Không có giới hạn trên của các biến

x = linprog(f, A, b, Aeq, beq, lb, ub); % Sử dụng linprog để giải bài toán tối ưu

% Kết quả
max_value = -f' * x;
disp(['Giá trị tối ưu của x1: ', num2str(x(1))]);
disp(['Giá trị tối ưu của x2: ', num2str(x(2))]);
disp(['Giá trị nhỏ nhất của hàm: ', num2str(max_value)]);

Kết quả
BT LP TOÁN NÂNG CAO

Bài 1: Max 50 +120 +40 +

s.t 2 + + 450
3 + + 180
4 + 400
+ + 110
, , , 0.
Code
% Hệ số hàm mục tiêu
f = [-50; -120; -40; -80];

% Hệ số ràng buộc
A=[
2 1 1 0;
0 3 1 -1;
4 0 1 0;
1101
];

% Hằng số ràng buộc

b = [450; 180; 400; 110];

% Giới hạn biến

lb = zeros(4, 1);

% Giải bài toán tối ưu

[x, fval, exitflag, output] = linprog(f, A, b, [], [], lb);

% Hiển thị kết quả

disp('Ket qua toi uu:');
disp(x);
disp(['Gia tri ham muc tieu toi uu: ', num2str(-fval)]);
disp(['Exit Flag: ', num2str(exitflag)]);

Kết quả
 Bài 2: max +

s.t + 1
+ 1
+ 1
, 0.
Code

% Hệ số hàm mục tiêu

f = [-17/6; -13/10];

% Hệ số ràng buộc
A=[
1/30 1/40;
1/30 1/25;
1/28 1/35
];

% Hằng số ràng buộc

b = [1; 1; 1];

% Giới hạn biến

lb = zeros(2, 1);

% Giải bài toán tối ưu

[x, fval, exitflag, output] = linprog(f, A, b, [], [], lb);

% Hiển thị kết quả

disp('Ket qua toi uu:');
disp(x);
disp(['Gia tri ham muc tieu toi uu: ', num2str(-fval)]);
disp(['Exit Flag: ', num2str(exitflag)]);

Kết quả

Bài 3: Min 3
 St ≤12
≤ 45
2 ≤ 30
≥0
Code
% Hệ số hàm mục tiêu
f = [3; 2];

% Hệ số ràng buộc
A=[
1 0;
1 3;
21
];

% Hằng số ràng buộc

b = [12; 45; 30];

% Giới hạn biến

lb = zeros(2, 1);

% Giải bài toán tối ưu

[x, fval, exitflag, output] = linprog(f, A, b, [], [], lb);

% Hiển thị kết quả

disp('Ket qua toi uu:');
disp(x);
disp(['Gia tri ham muc tieu toi uu: ', num2str(-fval)]);
disp(['Exit Flag: ', num2str(exitflag)]);
Kết quả

Bài 4:
Max 5x+12y
s.t 20x+10y 200
10x+20y 120
10x+30y 150
x 0, y 0
Code
% Hệ số hàm mục tiêu
f = [-5; -12];

% Hệ số ràng buộc
A=[
20 10;
10 20;
10 30
];

% Hằng số ràng buộc

b = [200; 120; 150];

% Giới hạn biến

lb = zeros(2, 1);

% Giải bài toán tối ưu

[x, fval, exitflag, output] = linprog(f, A, b, [], [], lb);

% Hiển thị kết quả

disp('Ket qua toi uu:');
disp(x);
disp(['Gia tri ham muc tieu toi uu: ', num2str(-fval)]);
disp(['Exit Flag: ', num2str(exitflag)]);

Kết quả

Bài 5: Max
St ≤ 10
≤ 15
≤ 25
≥0, ≥0

Code
% Hệ số hàm mục tiêu
f = [3; 2];
% Hệ số ràng buộc
A=[
1 0;
1 3;
02
];

% Hằng số ràng buộc

b = [12; 45; 30];

% Giới hạn biến

lb = zeros(2, 1);

% Giải bài toán tối ưu

[x, fval, exitflag, output] = linprog(f, -A, -b, [], [], lb);

% Hiển thị kết quả

disp('Ket qua toi uu:');
disp(x);
disp(['Gia tri ham muc tieu toi uu: ', num2str(-fval)]);

disp(['Exit Flag: ', num2str(exitflag)]);

Kết quả