Báo Cáo Môn Học Lập Trình Symbolic CHƯƠNG TRÌNH HỖ TRỢ GIẢI TOÁN NGUYÊN HÀM SỬ DỤNG CƠ SỞ TRI THỨC VÀ MAPLE

ĐẠI HỌC QUỐC GIA THÀNH PHỐ HỒ CHÍ MINH
TRƯỜNG ĐẠI HỌC CƠNG NGHỆ THƠNG TIN
Phịng Sau Đại Học


Báo Cáo Mơn Học Lập Trình Symbolic

CHƯƠNG TRÌNH HỖ TRỢ GIẢI TỐN NGUN HÀM
SỬ DỤNG CƠ SỞ TRI THỨC VÀ MAPLE

Giảng viên hướng dẫn: PGS.TS. Đỗ Văn Nhơn
Học viên thực hiện: Đỗ Duy Phúc
Mã số học viên: CH1101122
Lớp: Cao Học K6

TP.HCM, tháng 1 năm 2013


Mục Lục
Mục Lục.................................................................................................................................................2
Lời Nói Đầu............................................................................................................................................3
Phần 1. Giới Thiệu..................................................................................................................................4
Phần 2. Phần Nhân Tính Tốn Bằng Maple............................................................................................4
2.1. Module các ngun hàm cơ bản.................................................................................................4
2.2. Module biến đổi biểu thức.........................................................................................................4
2.3. Module tích phân tính sẵn..........................................................................................................5
2.4. Module đổi biến vô tỉ và lượng giác............................................................................................5
Phần 3. Giao Diện Chương Trình............................................................................................................9
Tài Liệu Tham Khảo..............................................................................................................................12

2

Lời Nói Đầu
Trong chương trình tốn học phổ thơng, bài tốn tìm ngun hàm (hay tính tích phân)
của một hàm cho trước là một trong những dạng bài tốn khó. Để giải được ta cần
phải xác định dạng của hàm cần tìm ngun hàm. Sau đó áp dụng các biện pháp biến
đổi khác nhau để đưa hàm về các dạng có thể giải được. Cuối cùng mới áp dụng các
phương pháp giải phù hợp để tìm kết quả. Đây là một q trình nhiều bước, áp dụng
nhiều kiến thức tốn, cho nên nhiều học sinh phổ thông khi giải dạng bài tốn này có
cảm giác rất khó khăn.
Để hỗ trợ các học sinh cho việc học giải các bài toán tìm nguyên hàm một cách thú vị
hơn, mục tiêu của báo cáo này là xây dựng một chương trình hỗ trợ giải các bài tốn
tìm ngun hàm cho các hàm ở nhiều dạng khác nhau. Chương trình có ứng dụng bộ
máy tính tốn của chương trình Maple để hỗ trợ tính tốn và trình bày kết quả thơng
qua giao diện được xây dựng bằng thư viện .NET (bằng ngôn ngữ C#).
Với sự thân thiện quen thuộc của giao diện window của .NET và sự mạnh mẽ của bộ
máy tính tốn của Maple, chương trình giúp cho việc giải các bài tốn tìm ngun
hàm trở nên dễ dàng, trực quan hơn rất nhiều.

3


Phần 1. Giới Thiệu
Chương trình được chia làm hai phần chính: phần lõi tính tốn và phần giao diện trình
bày. Phần lõi của chương trình được viết bằng Maple là phần quan trọng nhất, là bộ
não của chương trình. Trong khi phần giao diện window bằng .NET lại mang đến cho
người dùng sự thân thiện, trực quan dễ dàng thao tác.

Phần 2. Phần Nhân Tính Tốn Bằng Maple
Phần nhân tính toán này được kết hợp từ nhiều module. Mỗi module được dùng để

tính tích phân cho hàm số đầu vào ở một dạng cụ thể. Phần này gồm có bảy module.
Các tập tin chứa source code Maple của các module này có thể tìm thấy trong thư mục
“Source_Code\ Module Core (Maple)\”. Chi tiết các module được miêu tả sau đây.
2.1. Module các nguyên hàm cơ bản
Đây là module dùng để tìm nguyên hàm của các hàm số cơ bản được liệt kê trong bản
cơng thức tính tích phân, như: hàm đa thức, hàm lượng giác, hàm logarit, … Module
này được lưu trong tập tin “Module NguyenHamCoBan.mw”.
2.2. Module biến đổi biểu thức
Module này dùng để đưa biểu thức dưới dấu tích phân về dạng đơn giản hơn để có thể
lấy nguyên hàm. Nói một cách khác module đưa biểu thức về dạng tích phân các hàm
cơ bản. Bên cạnh đó nó còn cho phép đổi biến nếu cần thiết.
Module gồm hai thành phần: tập tin cơ sở tri thức Equations.txt và thủ tục
ApplyEquation trong tập tin “Module BienDoiBieuThuc.mw”.
Cấu trúc của tập tin Equations.txt bao gồm nhiều đẳng thức, mỗi đẵng thức bắt đầu
bằng dòng ‘Equation N’ với N là số thứ tự của đẳng thức đó. Các đẵng thức này dùng
để so khớp dạng của hàm được input và biến đổi thành dạng đơn giản hơn để có thể
tính được. Mỗi đẵng thức có cấu trúc gồm:
-

lhs: left hand side – biểu thức đầu vào cần so khớp.
rhs: right hand side – biểu thức đầu ra, hay biểu thức được trả về
newVar: biến mới nếu có đổi biến. Ở đây biểu diễn đẵng thức đổi biến.
cond: điều kiện để đạt được đẳng thức nếu có.
4


Ví dụ:
Equation 5 // đẳng thức thứ 5
lhs : N*(x^2+p*x+q)^m //biểu thức đầu vào so sánh
rhs : N*(u^2+a^2)^m // biểu thức đầu ra

newVar: u = x+p/2 ; a^2= q-p^2/4 // các đẳng thức đổi biến
cond : q-p^2/4>0 // điều kiện.
Kỹ thuật so khớp chủ yếu sử dụng là hàm match của Maple.
2.3. Module tích phân tính sẵn
Module này dùng để đưa ra lời giải cho các bài tốn tính ngun hàm khơng thể tính
bằng các luật đã đưa ra. Module gồm một thủ tục TichPhanTinhSan trong tập tin
“Module TichPhanTinhSan.mw”. Nó so khớp biểu thức đưa vào nếu có biểu thức
tương ứng thì sẽ trả về lời giải cho bài tốn.
2.4. Module đổi biến vô tỉ và lượng giác
Module này dùng để đổi biến cho các bài tốn có chứa các hàm lượng giác và hàm vơ
tỉ. Trong đó:
- Các hàm lượng giác được đổi biến như ví dụ sau: t = tan(x/2)

sin(x) = 2*t/(1+t^2)

cos(x) = (1-t^2)/(1+t^2)

tan(x) = 2*t/(1-t^2)

cotan(x) (hay cot(x)) = (1-c^2)/(2*c)
Các hàm vơ tỉ:
Nếu biểu thức dưới dấu tích phân có chứa ((a*x+b)/(c*x+d))^m với m là số hữu tỉ.
Đặt t = ((a*x+b)/(c*x+d))^m.
Module gồm một thủ tục DBVoTiVaLGiac trong tập tin “DB VoTiVaLGiac.mw”
2.5. Module tích phân từng phần

5


Giả sử ta muốn tính hàm

trong trường hợp f là hàm số phức tạp, khơng tính

trực tiếp được các ngun hàm, thì tách f(x)dx thành 2 thành phần u và dv (f(x)dx =
u*dv) bằng cách áp dụng công thức:

Đây là các dạng chính của hàm f(x) được tổng hợp từ các bài tốn tích phân từng
phần, khi chương trình so khớp biểu thức đúng với một trong các dạng này, áp dụng
trực tiếp để tính u, v.
a)
Đặt u =
b)

, dv = dx
trong đó f là một hàm đa thức

Đặt u = lnng(x), dv = f(x)*d(x)
c) Arctan(g(x)) hoặc f(x)*arctan(g(x))
d) G(x)*sin(n*x) hoặc g(x)*cos(n*x)
e) en*x*sin(x)
f) g(x)*ex
g) sin(ln(x)) hoặc cos(ln(x))
Với những dạng cơ bản này thì kết quả trả về (danh sách chứa các lời giải của bài
tốn) chỉ có 1 phần tử
2.6. Module các hàm định hướng heuristic
Các dạng cơ bản nói trên khơng phải là tất cả các dạng bài tập vì thực tế còn những
dạng khác( thường là mở rộng của những dạng trên) có thể áp dụng tích phân từng
phần nên về nguyên tắc cho việc áp dụng tích phân từng phần là tích phân mới sinh ra
phải đảm bảo đơn giản hơn về tích tốn so với tích phân ban đầu . Song việc đưa ra
một tiêu chuẩn để xác định độ phức tạp về tính tốn của việc tính tích phân của một

hàm số khi chưa tính tốn cụ thể các bước giải là khá khó khăn, vì vậy ở đây ta tiếp
cận vấn đề theo một hướng khác, sát với lối tư duy và giải toán của con người hơn:
Sử dụng những định hướng tìm lời giải có tính kế thừa, những định hướng này được
áp dụng khi hàm số khơng thuộc các dạng cơ bản nói trên. Chương trình nhận dạng
một số đặc điểm đặc trưng của hàm số từ đó có cách đặt biến thích hợp. Vì sử dụng
6


những đặc trưng nên cũng có thể cho ra nhiều hướng giải khác nhau, có thể 1 trong số
đó đúng, cũng có thể khơng hướng nào đúng, và kết quả trả về có thể ko có phần tử
nào, bằng một hoặc nhiều hơn một phần tử.
2.7. Module tổng hợp
Đây là thủ tục chính của chương trình. Thủ tục này chứa các luật biến đổi biểu thức
tổng quát và kết hợp với tất cả module cịn lại. Thủ tục này có cấu trúc chính là vịng
lặp chứa các luật với thứ tự như sau:
1) TQ1 (Luật tổng quát 1): Nếu tới một bước giải nào đó, ta tra ngược lại các
bước giải trước nếu bước giải mới tìm được kết hợp với bước giải trước có
dạng Int(f(x)) = g(Int(f(x)) thì ta giải phương trình tìm Int(f(x)) (với Int là kí
hiệu bằng text của dấu tích phân). Luật này thường dùng phối hợp với tích
phân từng phần để tìm kết quả. Cho nên trước khi áp dụng tích phân từng phần,
ta lưu vết biểu thức trước khi áp dụng. Các biểu thức này sẽ được so sánh với
2)
3)
4)
5)
6)

các bước giải con sau này.
Tìm nguyên hàm cho các hàm số dạng cơ bản. Nếu khơng tìm được trả về 0.
TQ2: Nếu bài tốn có dạng Int(A*f(x)) chuyển thành A*Int(f(x)).

Ứng dụng tích phân tính sẳn. Nếu khơng tìm được trả về 0.
Ứng dụng biển đổi biểu thức. Nếu khơng có đẳng tương ứng trả về 0.
Ứng dụng tích phân từng phần cho các dạng biết trước. Nếu khơng tìm được

dạng thích hợp trả về list rỗng [].
7) Ứng dụng đổi biến vô tỉ và lượng giác. Nếu khơng có sự thay đổi trả về 0.
8) TQ3: nếu biểu thức dưới dấu tích phân là tích các đa thức thì phân phối các đa
thức với nhau.
9) TQ4: nếu biểu thức dưới dấu tích phân có dạng tổng thì phân phối dấu tích
phân vào từng hạng tử.
10)TQ5: nếu biểu thức dưới dấu tích phân là phân thức thì biến đổi thành tổng các
phân thức cơ bản. (dùng hàm convert/parfrac của maple)
11)TQ6: nếu bài tốn có dạng A*Int(B*f(x)) với A, B là hằng số, biến đổi biểu
thức thành A*B*Int(f(x))
12)TQ7: nếu bài tốn có dạng A*Int(f(x)), ta tìm nguyên hàm cho f(x) (ở đây dùng
kĩ thuật đệ quy). Khi đó ta được F(x) là ngun hàm tìm được, tiếp theo ta có
A*F(x).
13)TQ8: nếu bài tốn có dạng tổng thì ta lần lượt tìm nguyên hàm cho các hạng tử
cịn dấu tích phân. Do đó, tại đây ta có nhiều bài toán con, mỗi bài toán con sử
7


dụng đệ quy thủ tục tổng hợp để tìm nguyên hàm. Khi đã tìm được tất cả kết
quả, ta lấy tổng tất cả kết quả lại.
Vòng lặp trong thủ tục sẽ lặp lại cho đến khi nào biểu thức đưa vào có sự thay đổi và
cịn dấu tích phân (Int) trong biểu thức.
Module tổng hợp gồm hai thủ tục INT (thủ tục chính) và Prim (Primitive - thủ tục này
dùng để trình bày lại lời giải đơn giản cho người dùng) nằm trong tập tin “Module
TongHop.mw”.

8


Phần 3. Giao Diện Chương Trình

Giao diện của chương trình được xây dựng bằng thư viện .NET, giồm có hai phần
chính:
- Một là cửa sổ dùng để nhập hàm số cần tính tích phân
- Cửa sổ cịn lại dùng để trình bày lời giải
Một số ví dụ dùng để làm input cho chương trình như sau:
3*x^2+5*x+1
# Hàm đa thức
x/(4*x^2+3)^2
# Đổi biến đơn giản
1/(1+x^3)
# Phân thức phức tạp, đổi biến 2 lần
ln(x)*x
# tptp đơn giản
exp(x)*sin(x)
# Sử dụng công thức f = a+b*f => f = a/(1-b)
3*x/cos(x)^2
# tptp dùng kết quả bài trên
tan(x)/(3*cos(x)+4*sin(x)+5)
# Đổi biến lượng giác đơn giản.

9


10

Kết Luận
Chương trình xây dựng được có thể giải được phần lớn các bài tốn tìm ngun hàm
của các hàm số đơn giản. Chương trình kết nối đã và sử dụng được sức mạnh tính tốn
của Maple kết hợp với giao diện trực quan thân thiện của .NET. Tốc độ giải của các
bài tốn là tương đối nhanh (trong vịng 5-10 giây).
Hạn chế của chương trình là vẫn cịn chưa thể giải hết tất cả các dạng bài toán phức
tạp còn lại. Cấu trúc tri thức sử dụng vẫn còn chưa rõ ràng dễ hiểu cho người dùng có
thể thay đổi được.
Hướng phát triển tiếp theo có thể nghiên cứu bổ sung thêm các module để giải các
dạng hàm số phức tạp hơn mà hiện chưa giải được. Xây dựng cơ sở tri thức rõ ràng
hơn và bổ sung module tra cứu tri thức cho chương trình.

11


Tài Liệu Tham Khảo
[1] Đỗ Văn Nhơn, Tài liệu môn học Lập Trình Symbolic, 2013
[2] Đỗ Văn Nhơn, Maple Guide
[3] Maple Help

12