Tải bản đầy đủ (.pdf) (21 trang)
  1. Trang chủ
    2. >>
  2. Giáo Dục - Đào Tạo
    3. >>
  3. Cao đẳng - Đại học

Phần mềm hỗ trợ ôn thi Toán -10 ppt

Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (512.75 KB, 21 trang )










- 181 -
Đạo hàm:
Nhập các biểu thức bằng các ky tự toán học đặc trưng.
Lưu ý:
Khi muốn thực hiện phép nhân 2 biểu thức, ví dụ u.v thì ta phải nhập như sau (u)(v).
Khi muốn lũy thừa 1 biểu thức, ví dụ u
v
thì ta phải nhập như sau (u)
v
.
D. Phụ lục các thuật giải trong chương trình:
Không gian toạ độ:
− Tính vector tạo bởi 2 điểm:
vector.x = Bx – A.x
vector.y = By – A.y
vector.z = Bz – A.z

− Tính khoảng cách từ 1 điểm đến 1 mặt phẳng:
kc =
mp.n.z*mp.n.zmp.n.y*mp.n.ymp.n.x*mp.n.x
mp.Dz*mp.n.zy*mp.n.yx*mp.n.x
++


+
+
+


− Tính khoảng cách giữa 2 đường thẳng:
A
∈
đt1, 1vt là vector chỉ phương
B ∈ đt2, 2vt là vector chỉ phương
kc = ( AB . 1vt ). 2vt / 1vt . 2vt

− Viết phương trình đoạn vuông góc chung giữa 2 đường thẳng chéo nhau:
temp = 1vt . 2vt

mp1.vt1 = temp;
mp1.vt2 = vt1;
mp1.TinhPhapVector();









- 182 -
mp1.a = a1;
mp1.TinhD();


mp2.vt1 = temp;
mp2.vt2 = vt2;
mp2.TinhPhapVector();
mp2.a = a2;
mp2.TinhD();

dt_kq.mp1 = mp1;
dt_kq.mp2 = mp2;

− Tính diện tích mặt cầu:
S = 4*PI*R
2

− Tính thể tích mặt cầu:
V =
3
4
*PI*R
3

− Kiểm tra mặt phẳng song song với 1 mặt phẳng khác:
Nếu (mp1.n.x*mp2.n.y != mp1.n.y*mp2.n.x)
không song song;
Nếu (mp1.n.x*mp2.n.z != mp1.n.z*mp2.n.x)
không song song;
Nếu (mp1.n.y*mp2.n.z != mp1.n.z*mp2.n.y)
không song song;
Nếu (mp1.n.x*mp2.D == mp1.D*mp2.n.x)
không song song;

Còn lại : song song










- 183 -
− Kiểm tra mặt phẳng trùng với 1 mặt phẳng khác:
Nếu (n.x*mp.n.y != n.y*mp.n.x)
không trùng
Nếu (n.x*mp.n.z != n.z*mp.n.x)
không trùng
Nếu (n.y*mp.n.z != n.z*mp.n.y)
không trùng
Nếu (n.x*mp.D != D*mp.n.x)
không trùng
Trùng

− Kiểm tra mặt phẳng vuông góc với 1 mặt phẳng khác:
Nếu (n.x*mp.n.x + n.y*mp.n.y + n.z*mp.n.z == 0)
Vuông góc
Không vuông góc

− Tính diện tích của tứ diện:
AB = A.TinhVector(B);

AC = A.TinhVector(C);
S = ((AB.TichHuuHuong(AC)).TinhGiaTri())/2 ;

− Tính thể tích của tứ diện:
AB = A.TinhVector(B);
AC = A.TinhVector(C);
AD = A.TinhVector(D);
V = (((AB.TichHuuHuong(AC)).TichHuuHuong(AD)).TinhGiaTri())/2 ;

− Tính tích hữu hướng của 2 vector:
vtkq.x = y*vt.z - z*vt.y;









- 184 -
vtkq.y = z*vt.x - x*vt.z;
vtkq.z = x*vt.y - y*vt.x;

Mặt phẳng toạ độ:
− Khoảng cách từ 1 điểm đến 1 đường thẳng:
kc =
dt.vtpt.y*dt.vtpt.ydt.vtpt.x*dt.vtpt.x
dt.C y *dt.vtpt.y x *dt.vtpt.x
+

+
+


− Tìm giao điểm giữa 2 đường thẳng:
Nếu ( vtpt.x==0 )
{
diem.y =
vtpt.y
C-

diem.x =
dt.vtpt.x
dt.vtpt.y*diem.y-dt.C-

}
Nếu ( vtpt.y==0 )
{
diem.x =
vtpt.x
C-

diem.y =
dt.vtpt.y
dt.vtpt.x*diem.x-dt.C-

}
Nếu ( dt.vtpt.x==0 )
{
diem.y =

dt.vtpt.y
dt.C-

diem.x =
vtpt.x
vtpt.y*diem.y-C-

}
Nếu ( dt.vtpt.y==0 )









- 185 -
{
diem.x =
dt.vtpt.z
dt.C-

diem.y =
vtpt.y
vtpt.x*diem.x-C-

}


diem.y =
vtpt.x*dt.vtpt.y-dt.vtpt.x*vtpt.y
dt.vtpt.x*C-vtpt.x*dt.C

diem.x =
vtpt.y*dt.vtpt.x-dt.vtpt.y*vtpt.x
dt.vtpt.y*C-vtpt.y*dt.C


− Phương trình tiếp tuyến qua 1 điểm thuộc đường tròn:
tt.a = diem;
tt.vtpt.x = diem.x - Tam.x;
tt.vtpt.y = diem.y - Tam.y;
tt.TinhVectorChiPhuong();
tt.TinhC();

− Phương trình tiếp tuyến qua 1 điểm không thuộc đường tròn:
t
1
= Tam.x-diem.x;
t
2
= Tam.y-diem.y;
candelta = )-
2
(*)-
1
(-
21
R

t
R
t
)
t
*
t
(
2
2
2
2
2

k1 =
R
t
tt
2
2
21
-
1
candelta - *

k2 =
R
t
tt
2

2
21
-
1
candelta * +











- 186 -
tt1.a = diem;
tt1.vtpt.x = k1;
tt1.vtpt.y = -1;
tt1.TinhVectorChiPhuong();
tt1.TinhC();
taphop.Thêm(temp);

tt2.a = diem;
tt2.vtpt.x = k2;
tt2.vtpt.y = -1;
tt2.TinhVectorChiPhuong();
tt2.TinhC();
taphop.Thêm(temp);


− Vị trí tương đối giữa 2 đường tròn:
Nếu ( Tam.KhoangCachDenDiem(dt.Tam)==0 && R==dt.R)
2 đường tròn trùng nhau.

Nếu ( Tam.KhoangCachDenDiem(dt.Tam)==0 && R!=dt.R)
2 đường tròn trùng tâm.

Nếu ( Tam.KhoangCachDenDiem(dt.Tam) > R+dt.R)
2 đường tròn nằm ngoài nhau."

Nếu ( Tam.KhoangCachDenDiem(dt.Tam) == R+dt.R)
đường tròn tiếp xúc ngoài nhau.

Nếu ( Tam.KhoangCachDenDiem(dt.Tam) < Math.Abs(R-dt.R) )
2 đường tròn chứa nhau

Nếu ( Tam.KhoangCachDenDiem(dt.Tam) == Math.Abs(R-dt.R) )









- 187 -
2 đường tròn tiếp xúc trong nhau.


còn lại 2 đường tròn cắt nhau tại 2 điểm phân biệt.

− Kiểm tra 1 đường thẳng tiếp xúc với Ellipse:
Nếu ( dthang.vtpt.x*dthang.vtpt.x*a*a +
dthang.vtpt.y*dthang.vtpt.y*b*b == dthang.C*dthang.C)
Có tiếp xúc
Ngược lại : không tiếp xúc

− Kiểm tra 1 đường thẳng tiếp xúc với Hyperbol:
Nếu ( dthang.vtpt.x*dthang.vtpt.x*a*a -
dthang.vtpt.y*dthang.vtpt.y*b*b == dthang.C*dthang.C)
Có tiếp xúc
Nếu ( dthang.vtpt.x*dthang.vtpt.x*a*a -
dthang.vtpt.y*dthang.vtpt.y*b*b == -dthang.C*dthang.C)
Có tiếp xúc
Ngược lại : không tiếp xúc

Khảo sát và vẽ đồ thị hàm số:
− Khảo sát và vẽ đồ thị hàm số đa thức:
+ Tìm miền xác định.
+ Tính đạo hàm cấp 1.
+ Tính đạo hàm cấp 2.
+ Tính giới hạn vô cực.
+ Tìm giao điểm với OY.
+ Xuất kết quả khảo sát.
+ Vẽ bảng biến thiên.
+ Vẽ đồ thị.










- 188 -

− Khảo sát và vẽ đồ thị hàm số hữu tỉ:
+ Tìm miền xác định.
+ Tính đạo hàm cấp 1.
+ Tìm giới hạn tiệm cận đứng.
+ Tìm giới hạn tiệm cận ngang.
+ Tìm giới hạn tiệm cận xiên.
+ Xuất kết quả khảo sát.
+ Vẽ bảng biến thiên.
+ Vẽ đồ thị.

Đạo hàm:
− Nhận diện đề:
+ Lớp cha sẽ nhận diện ra dạng đề thuộc lớp con nào.
+ Lớp cha cấp địa chỉ của lớp con và gọi hàm nhận diện đề của lớp con.
+ Lớp con phân tích đề để lấy các thông tin cần thiết.

Các dạng MathML đặc trưng cho các dạng biểu thức là:
Đơn thức:
Ax
<math>
<mn>3</mn>
<mi>X</mi>

</math>

x
<math>
<mi>X</mi>
</math>









- 189 -

ax
b
<math>
<mn>3</mn>
<msup>
<mrow>
<mi>X</mi>
</mrow>
<mrow>
<mn>5</mn>
</mrow>
</msup>
</math>


x
b

<math>
<msup>
<mrow>
<mi>X</mi>
</mrow>
<mrow>
<mn>5</mn>
</mrow>
</msup>
</math>

A X
<math>
<mn>3</mn>
<mroot>
<mrow>
<mi>X</mi>










- 190 -
</mrow>
<mrow />
</mroot>
</math>

X
<math>
<mroot>
<mrow>
<mi>X</mi>
</mrow>
<mrow />
</mroot>
</math>

A
C
X
<math>
<mn>3</mn>
<mroot>
<mrow>
<mi>X</mi>
</mrow>
<mrow>
<mn>4</mn>
</mrow>
</mroot>
</math>


C
X
<math>
<mroot>









- 191 -
<mrow>
<mi>X</mi>
</mrow>
<mrow>
<mn>4</mn>
</mrow>
</mroot>
</math>

A
X
B

<math>
<mn>3</mn>

<mroot>
<mrow>
<msup>
<mrow>
<mi>X</mi>
</mrow>
<mrow>
<mn>5</mn>
</mrow>
</msup>
</mrow>
<mrow />
</mroot>
</math>

X
B

<math>
<mroot>
<mrow>










- 192 -
<msup>
<mrow>
<mi>X</mi>
</mrow>
<mrow>
<mn>5</mn>
</mrow>
</msup>
</mrow>
<mrow />
</mroot>
</math>

A
C
B
X

<math>
<mn>3</mn>
<mroot>
<mrow>
<msup>
<mrow>
<mi>X</mi>
</mrow>
<mrow>
<mn>5</mn>
</mrow>

</msup>
</mrow>
<mrow>
<mn>4</mn>
</mrow>
</mroot>









- 193 -
</math>

<math>
<mrow>
<mo>&lpar;</mo>
<mo>&minus;</mo>
<mn>3</mn>
<mo>&rpar;</mo>
</mrow>
<mroot>
<mrow>
<msup>
<mrow>
<mi>X</mi>

</mrow>
<mrow>
<mn>5</mn>
</mrow>
</msup>
</mrow>
<mrow>
<mn>4</mn>
</mrow>
</mroot>
</math>

C
B
X

<math>
<mroot>
<mrow>
<msup>









- 194 -

<mrow><mi>X</mi></mrow>
<mrow><mn>5</mn></mrow>
</msup>
</mrow>
<mrow>
<mn>4</mn>
</mrow>
</mroot>
</math>

A
X
C
B

<math>
<mn>3</mn>
<msup>
<mrow>
<mi>X</mi>
</mrow>
<mrow>
<mfrac>
<mrow>
<mn>5</mn>
</mrow>
<mrow>
<mn>4</mn>
</mrow>
</mfrac>

</mrow>
</msup>
</math>

X
C
B










- 195 -
<math>
<msup>
<mrow>
<mi>X</mi>
</mrow>
<mrow>
<mfrac>
<mrow>
<mn>5</mn>
</mrow>
<mrow>
<mn>4</mn>

</mrow>
</mfrac>
</mrow>
</msup>
</math>

Biểu thức phức:
CONG,TRU
<math xmlns="
<mi>U</mi>
<mo>&plus;</mo>
<mi>V</mi>
</math>

(U)
V

<math>
<msup>
<mrow>
<mrow>
<mo>&lpar;</mo>










- 196 -
<mi>U</mi>
<mo>&rpar;</mo>
</mrow>
</mrow>
<mrow>
<mi>V</mi>
</mrow>
</msup>
</math>

U/V
<math xmlns="
<mfrac>
<mrow>
<mi>U</mi>
</mrow>
<mrow>
<mi>V</mi>
</mrow>
</mfrac>
</math>

(U)(V)
<math>
<mrow>
<mo>&lpar;</mo>
<mi>U</mi>
<mo>&rpar;</mo>

</mrow>
<mrow>
<mo>&lpar;</mo>
<mi>V</mi>









- 197 -
<mo>&rpar;</mo>
</mrow>
</math>

COS(U) SIN TG COTG LN
<math xmlns="
<mi>COS</mi>
<mrow>
<mo>&lpar;</mo>
<mi>U</mi>
<mo>&rpar;</mo>
</mrow>
</math>

HANGSO
<math xmlns="

<mn>hs</mn>
</math>

CANSO
<math>
<mroot>
<mrow>
<mi>X</mi>
</mrow>
<mrow />
</mroot>
</math>
<math>
<mroot>
<mrow>
<mi>X</mi>









- 198 -
</mrow>
<mrow>
<mn>4</mn>
</mrow>

</mroot>
</math>

"<math>
<mrow>
<mo>#lpar;</mo>
<mo>#minus;</mo>
<mn>3</mn>
<mo>#rpar;</mo>
</mrow>
<mi>x</mi>
</math>"

<math>
<mrow>
<mo>&lpar;</mo>
<mo>&minus;</mo>
<mn>3</mn>
<mo>&rpar;</mo>
</mrow>
<mi>X</mi>
</math>

− Tính đạo hàm:
+ Đạo hàm của 1 biểu thức là một biểu thức.
+ Một biểu thức phức tạp được cấu thành từ nhều biểu thức nhỏ hơn.










- 199 -
+ Tính đạo hàm của một biểu thức phức tạp bằng cách tính đạo hàm của
từng thành phần nhỏ và kết hợp thành biểu thức cần tính.


Phụ lục quy tắc tính đạo hàm:
Biểu thức căn:
public override BIEU_THUC TinhDaoHam()
{
HANG_SO hs1 = new HANG_SO();
hs1.hangso = 1 - CanSo;

BIEU_THUC_U_MU_V umuv1 = new BIEU_THUC_U_MU_V();
umuv1.u = u;
umuv1.v = hs1;

BIEU_THUC_CAN can1 = new BIEU_THUC_CAN();
can1.CanSo = CanSo;
can1.u = umuv1;

BIEU_THUC_NHAN nhan1 = new BIEU_THUC_NHAN();
nhan1.u = u.TinhDaoHam();
nhan1.v = can1;

return nhan1;

}
Biểu thức chia:
public override BIEU_THUC TinhDaoHam()
{
BIEU_THUC_CHIA chia = new BIEU_THUC_CHIA();
BIEU_THUC_NHAN nhan1 = new BIEU_THUC_NHAN();
BIEU_THUC_NHAN nhan2 = new BIEU_THUC_NHAN();
BIEU_THUC_NHAN nhan3 = new BIEU_THUC_NHAN();
BIEU_THUC_TRU tru = new BIEU_THUC_TRU();

nhan1.u = u.TinhDaoHam();
nhan1.v = v;

nhan2.u = u;
nhan2.v = v.TinhDaoHam();

nhan3.u = v;









- 200 -
nhan3.v = v;

tru.u = nhan1;

tru.v = nhan2;

chia.u = tru;
chia.v = nhan3;

return chia;
}
Biểu thức cộng:
public override BIEU_THUC TinhDaoHam()
{
BIEU_THUC_CONG cong = new BIEU_THUC_CONG();
cong.u = u.TinhDaoHam();
cong.v = v.TinhDaoHam();

return cong;
}
Biểu thức COS:
public override BIEU_THUC TinhDaoHam()
{
HANG_SO hs = new HANG_SO();
hs.hangso = -1;

BIEU_THUC_NHAN nhan1 = new BIEU_THUC_NHAN();
nhan1.u = hs;
nhan1.v = u.TinhDaoHam();

BIEU_THUC_SIN sin = new BIEU_THUC_SIN();
sin.u = u;

BIEU_THUC_NHAN nhan2 = new BIEU_THUC_NHAN();

nhan2.u = nhan1;
nhan2.v = sin;

return nhan2;
}
Biểu thức COTG:
public override BIEU_THUC TinhDaoHam()
{
HANG_SO hs = new HANG_SO();
hs.hangso = -1;









- 201 -
BIEU_THUC_NHAN nhan1 = new BIEU_THUC_NHAN();
nhan1.u = hs;
nhan1.v = u.TinhDaoHam();
BIEU_THUC_SIN sin = new BIEU_THUC_SIN();
sin.u = u;
BIEU_THUC_NHAN nhan2 = new BIEU_THUC_NHAN();
nhan2.u = sin;
nhan2.v = sin;
BIEU_THUC_CHIA chia = new BIEU_THUC_CHIA();
chia.u = nhan1;

chia.v = nhan2;
return chia;
}
Biểu thức LN:
public override BIEU_THUC TinhDaoHam(){
BIEU_THUC_CHIA chia = new BIEU_THUC_CHIA();
chia.u = u.TinhDaoHam();
chia.v = u;
return chia;
}
Biểu thức nhân:
public override BIEU_THUC TinhDaoHam()
{
BIEU_THUC_NHAN nhan1 = new BIEU_THUC_NHAN();
nhan1.u = u.TinhDaoHam();
nhan1.v = v;
BIEU_THUC_NHAN nhan2 = new BIEU_THUC_NHAN();
nhan2.u = u;
nhan2.v = v.TinhDaoHam();
BIEU_THUC_CONG cong = new BIEU_THUC_CONG();
cong.u = nhan1;
cong.v = nhan2;
return cong;
}
Biểu thức SIN:
public override BIEU_THUC TinhDaoHam(){
BIEU_THUC_COS cos = new BIEU_THUC_COS();
cos.u = u;
BIEU_THUC_NHAN nhan = new BIEU_THUC_NHAN();
nhan.u = u.TinhDaoHam();

nhan.v = cos;
return nhan;
}

Tài liệu liên quan

Tài liệu bạn tìm kiếm đã sẵn sàng tải về

Tải bản đầy đủ ngay
×