שימושי מחשב במתמטיקה-תרגול 6 - BIU



שימושי מחשב במתמטיקה-תרגול 6

בשיעור זה נלמד לחשב אינטגרלים מסוימים ולא מסוימים, אינטגרציה בחלקים, אינטגרציה ע"י החלפת נושא האינטגרל, הצגת סכום רימן וחישוב אינטגרל בשיטה נומרית.

MAPLE

האינטגרל הסטנדרטי

• הפקודות int , Int

הפקודות int ו- Int מחשבות אינטגרל מסוים ואינטגרל לא מסוים.

תיאור הפקודה:

דוגמאות:

1) חשב את האינטגרל הלא מסוים של הפונקציה [pic]

פתרון:

> int(sin(x)*cos(x)+x^2*cos(x),x);

[pic]

אם נבצע את הפקודה Int:

> Int(sin(x)*cos(x)+x^2*cos(x),x);

[pic]

ז"א נקבל את ביטוי האינטגרל. איך לפתור אותו? נראה בהמשך...

2) חשב את השטח הכלוא בין הפונקציה [pic] ובין הפונקציה [pic] בקטע [pic].

פתרון:

ראשית נשרטט את הפונקציה ונמצא נקודות חיתוך

> plot([x,x^3*sin(2*x)*cos(3*x)],x=0..Pi);

[pic]

> a1:=fsolve(x=x^3*sin(2*x)*cos(3*x),x=2.5);

[pic]

> a2:=fsolve(x=x^3*sin(2*x)*cos(3*x),x=3.1);

[pic]

> s1:=int(x-x^3*sin(2*x)*cos(3*x),x=0..a1);

[pic]

> s2:=int(x^3*sin(2*x)*cos(3*x)-x,x=a1..a2);

[pic]

> s:=s1+s2;

[pic]

אם נכתוב Int (עם I לא i ) נקבל את ביטוי האינטגרל:

> s1:=Int(x-x^3*sin(2*x)*cos(3*x),x=0..a1);

[pic]

> s2:=Int(x^3*sin(2*x)*cos(3*x)-x,x=a1..a2);

[pic]

> s:=s1+s2;

[pic]

• הפקודה value

הפקודה value מחשבת את ערכו של ביטוי מתמטי כדוגמת סכום, מכפלה, אינטגרל, גבול וכו'..

תיאור הפקודה:

דוגמאות:

1) בסוף הדוגמה האחרונה הצבנו לתוך המשתנה s את ביטוי האינטגרל המבטא את השטח הדרוש. כעת נפתור אותו:

> value(s);

[pic]

קיבלנו את אותו הערך כמו בתחילת הדוגמה האחרונה. נסיק מסקנה:

int(expr,x=a..b); = value(Int(expr,x=a..b));

כמובן שלפקודה Int יש שימושים רחבים ללא קשר לפקודה value.

• הפקודות Sum, sum

הפקודות Sum, sum סוכמות ביטויים אלגבריים.

תיאור הפקודה:

הערה: הפקודה sum(f,k); מקבילה לפקודה sum(f,k=1..k);.

דוגמה:

1) חשב את הסכום [pic]

פתרון:

> sum(k/(k+1),k=1..10);

[pic]

אם נכתוב Sum (במקום sum) נקבל:

> a:=Sum(1-1/(k+1),k=1..10);

[pic]

נחשב את ערכו של הביטוי:

> value(a);

[pic]

גם כאן

sum(f,k=m..n); = value(Sum(f,k=m..n));

אם נחשב את אותו הביטוי עבור k ללא תחום נקבל:

> sum(k/(k+1),k);

[pic]

כאשר

[pic]

2) חשב את הסכום [pic]

פתרון:

> sum(k,k);

[pic]

ניתן גם לכתוב:

> Sum(k,k=1..k)=sum(k,k=1..k);

[pic]

הפקודות הבאות לקוחות מתוך הספרייה student של Maple ולכן לפני שימוש בפקודות

אלו צריך לדאוג שיהיה בזיכרון של Maple את פקודות ספרייה זו.

עושים זאת ע"י הפקודה with(student); ( - כמובן שרק פעם אחת)

אינטגרל כפול ומשולש

• הפקודה Doubleint

הפקודה Doubleint מחשבת אינטגרל כפול מסוים ואינטגרל כפול לא מסוים.

תיאור הפקודה:

דוגמאות:

1) חשב את הנפח הכלוא בין הפונקציה [pic] לבין המשטח x,y

פתרון:

תחילה נשרטט את הפונקציה

> plot3d(x*y+2*x-y,x=0..5,y=-5..5);

[pic]

> with(student):

> s:=Doubleint(x*y+2*x-y,x=0..5,y=-5..5);

[pic]

> value(s);

[pic]

אם עבור אותה הפונקציה נחשב את האינטגרל הלא מסוים:

> s:=Doubleint(x*y+2*x-y,x,y);

[pic]

נקבל:

> value(s);

[pic]

2) חשב את הנפח הכלוא בתוך כדור שמרכזו בראשית הצירים ורדיוסו 1.

פתרון:

ראשית נשרטט את גרף הכדור:

> plot3d([-sqrt(1-x^2-y^2),sqrt(1-x^2-y^2)],

x=-sqrt(1-y^2)..sqrt(1-y^2),y=-1..1);

[pic]

כעת

כעת נחשב את נפח הכדור:

> s:=Doubleint(2*sqrt(1-x^2-y^2),

x=-sqrt(1-y^2)..sqrt(1-y^2),y=-1..1);

[pic]

> value(s);

[pic]

הסבר:

1. משוואת כדור

[pic]

2. נפח כדור:

[pic]

3. חישבנו את הנפח מעל מישור x,y שמשוואתו: [pic] וכפלנו ב-2.

• הפקודה Tripleint

הפקודה Tirpleint מחשבת אינטגרל משולש מסוים ואינטגרל משולש לא מסוים.

תיאור הפקודה:

דוגמה:

חשב את האינטגרל [pic] גם כאינטגרל לא מסוים.

פתרון:

חישוב האינטגרל המסוים:

> s:=Tripleint(x*y+z^2*x/(y+4),x=-1..2,y=-2..3,z=-3..4);

[pic]

> value(s);

[pic]

חישוב האינטגרל הלא מסוים:

> s:=Tripleint(x*y+z^2*x/(y+4),x,y,z);

[pic]

> value(s);

[pic]

שיטות אינטגרציה

• הפקודה changevar

הפקודה changevar מבצעת שינוי משתנה באינטגרל.

תיאור הפקודה:

דוגמאות:

1) בצע שינוי משתנה באינטגרל [pic] (לשיקולך) ופתור.

פתרון:

> a:=changevar(x=sin(t),Int(x^2/sqrt(1-x^2),x),t);

[pic]

> value(a);

[pic]

> f:=t->value(a);

[pic]

> changevar(t=arcsin(x),(f(t),t),x);

[pic]

2) בצע החלפת משתנה באינטגרל [pic] (לשיקולך) ופתור

פתרון:

> a:=changevar(x=exp(t),Int(1/(x*ln(x)^r),x),t);

[pic]

> value(a);

[pic]

> f:=t->value(a);

[pic]

> changevar(t=ln(x),(f(t),t),x);

[pic]

נראה דוגמה לכך שכאשר משנים את משתנה האינטגרל עבור אינטגרל מסוים, גם גבולות

האינטגרל משתנים:

3) בצע החלפת משתנה באינטגרל [pic] ופתור.

פתרון:

> a:=changevar(x^2=25-t^2,

Int(x^7*sqrt(25-x^2),x=0..4),t);

[pic]

> b:=simplify(expand(a));

[pic]

> value(a);

[pic]

• הפקודה intparts

הפקודה intparts מבצעת אינטגרציה בחלקים עפ"י הכלל: [pic]

תיאור הפקודה:

דוגמאות:

1) בצע אינטגרציה בחלקים עבור [pic] עד לפישוט מקסימלי ולקבלת התוצאה.

פתרון:

> a1:=intparts(Int(x*ln(x)^2,x),ln(x)^2);

[pic]

> b1:=op(1,a1); a2:=op(2,op(2,a1));

[pic]

[pic]

> a3:=intparts(a2,ln(x));

[pic]

> b2:=op(1,a3); a4:=op(2,op(2,a3));

[pic]

[pic]

> b3:=value(a4);

[pic]

> s:=b1-(b2-(b3));

[pic]

• אינטגרציה של פונקציות רציונליות

כעת נלמד איך פותרים אינטגרל מסוג [pic] עבור[pic] פולינומים, ב-MAPLE. הפקודה convert

הפקודה convert מקבלת ביטוי אלגברי מסוג מסוים ומחזירה ביטוי מסוג אחר.

לענייננו, אנו רוצים להפוך שבר של פולינומים לסכום של שברים פשוטים:

(הפקודה convert איננה לקוחה מתוך הספרייה student)

דוגמה:

חשב את האינטגרל

פתרון:

> a:=(3*x^2-5*x)/(3*x^3-x^2-10*x+8);

[pic]

> b:=convert(a,parfrac);

[pic]

> int(b,x);

[pic]

שיטות נומריות לחישוב אינטגרל מסוים

• הפקודות leftbox , middlebox , rightbox

הפקודות rightbox, middlebox, leftbox משרטטות גרף המתאר קירוב לאינטגרל המסוים.

תיאור הפקודה:

דוגמאות:

1) שרטט קירוב לאינטגרל המסוים [pic] ע"י 10 מלבנים ימניים בצבע צהוב, הפונקציה תהיה בצבע כחול.

פתרון:

> rightbox(x^2+sin(x)-

cos(x),x=1..4,10,'shading'=yellow,color=blue);

[pic]

2) שרטט קירוב לאינטגרל המסוים [pic] ע"י 8 מלבנים אמצעיים בצבע ורוד, הפונקציה תהיה בצבע אדום.

פתרון:

> middlebox(x^2+sin(x^2),x=3..7,8,

'shading'=pink,color=red);

[pic]

3) שרטט קירוב לאינטגרל המסוים [pic] ע"י 14 מלבנים שמאליים בצבע סגול בהיר, הפונקציה תהיה בצבע סגול כהה.

פתרון:

> leftbox(x^5+x*cos(x),x=2..7,14,

'shading'=plum,color=maroon);

[pic]

• הפקודות leftsum , middlesum , rightsum

הפקודות rightsum, middlesum, leftsum מחשבות קירוב לאינטגרל המסוים ע"י חישוב שטחי מלבנים:

הפקודה rightsum מחשבת את שטחי המלבנים של הפקודה rightbox המתאימה,

הפקודה middlesum מחשבת את שטחי המלבנים של הפקודה middlebox המתאימה,

והפקודה leftsum מחשבת את שטחי המלבנים של הפקודה leftbox המתאימה,

תיאור הפקודה:

דוגמאות: (בדוגמאות אלה נחשב את שטח המלבנים ששרטטנו למעלה)

1) חשב קירוב לאינטגרל המסוים [pic] ע"י 10 מלבנים ימניים.

פתרון:

> a:=rightsum(x^2+sin(x)-cos(x),x=1..4,10);

[pic]

> evalf(a);

[pic]

2) חשב קירוב לאינטגרל המסוים [pic] ע"י 8 מלבנים אמצעיים.

פתרון:

> b:=middlesum(x^2+sin(x^2),x=3..7,8);

[pic]

> evalf(b);

[pic]

3) חשב קירוב לאינטגרל המסוים [pic] ע"י 14 מלבנים שמאליים.

פתרון:

> c:=leftsum(x^5+x*cos(x),x=2..7,14);

[pic]

> evalf(c);

[pic]

• הפקודות simpson, trapezoid

הפקודה simpson, trapezoid מחשבות קירוב לאינטגרל המסוים ע"י הכללים הבאים:

כלל סימפסון:

[pic]

כלל הטרפז:

[pic]

כאשר: n – מספר הקטעים לאחר חלוקת הקטע [a,b] ו- h=(b-a)/n

תיאור הפקודה:

דוגמאות:

1) מצא קירוב לאינטגרל המסוים [pic] ע"י כלל סימפסון עם 6 מלבנים.

פתרון:

> a:=simpson(x*sin(x)+x^2+cos(x),x=2..5);

[pic]

> evalf(a);

[pic]

2) מצא קירוב לאינטגרל המסוים [pic] ע"י כלל הטרפז עם 5 מלבנים.

פתרון:

> b:=trapezoid(cos(2*x)+sin(x^2),x=-1..1,5);

[pic]

> evalf(b);

[pic]

• הפקודה ApproximateInt

הפקודה ApproximateInt מחשבת קירוב לאינטגרל המסוים ע"י כלל הטרפז או כלל סימפסון.

שימו לב: פקודה זו שייכת לספרייה Student[Calculus1] ולכן לפני שימוש בה צריך לכתוב:

with(Student[Calculus1]):

תיאור הפקודה:

דוגמאות:

1) חשב קירוב לאינטגרל המסוים [pic] ע"י כלל הטרפז עם 10 צעדים.

1. הצג את התוצאה ע"י ערך

2. הצע את התוצאה ע"י ביטוי של סכום

3. הצג את התוצאה ע"י גרף

פתרון:

א.

> with(Student[Calculus1]):

> a:=ApproximateInt((sin(x)+cos(x))*x^2, x=0..5, method = trapezoid);

[pic]

> evalf(a);

[pic]

ב.

> a:=ApproximateInt((sin(x)+cos(x))*x^2, x=0..5,

method = trapezoid,output=sum);

[pic]

> evalf(a);

[pic]

ג.

> ApproximateInt((sin(x)+cos(x))*x^2, x=0..5,

method = trapezoid,output=plot);

[pic]

2) חשב קירוב לאינטגרל המסוים [pic] ע"י כלל סימפסון עם 5 צעדים.

1. הצג את התוצאה ע"י ערך

2. הצע את התוצאה ע"י ביטוי של סכום

3. הצג את התוצאה ע"י גרף

פתרון:

א.

> a:=ApproximateInt(exp(x)*x^2, x=3..4,

method = simpson,partition=5);

[pic]

> evalf(a);

[pic]

ב.

> a:=ApproximateInt(exp(x)*x^2, x=3..4, method = simpson,output=sum,partition=5);

[pic]

> evalf(a);

[pic]

ג.

> ApproximateInt(exp(x)*x^2, x=3..4,

method = simpson,output=plot,partition=5);

[pic]

MATLAB

MATLAB כידוע, היא תוכנה לחישובים נומריים ולכן נתמקד בפקודות המחשבות אינטגרל מסוים.

האינטגרל הסטנדרטי

• הפקודה quad

הפקודה quad מחזירה את תוצאת האינטגרל המסוים עפ"י שיטת סימפסון.

תיאור הפקודה:

דוגמאות:

1) חשב את האינטגרל [pic] בדיוק של 6 ספרות. הגדר את הפונקציה כפונקציה אנונימית.

פתרון:

[pic]

[pic]

[pic]

2) חשב את האינטגרל [pic]

1. בדיוק של 6 ספרות.

2. בדיוק של 7 ספרות.

3. בדיוק של 8 ספרות.

הגדר את הפונקציה בקובץ M.

פתרון:

f4.m

[pic]

תחילה נראה את גרף הפונקציה:

[pic]

[pic]

ברור שפונקציה זוגית ולכן סימטרית כלומר תוצאת האינטגרל הדרוש היא 0.

א.

[pic]

ב.

[pic]

ג.

[pic]

• הפקודה quadl

הפקודה quadl מחזירה את תוצאת האינטגרל המסוים עפ"י שיטת תרבועי גאוס.

תיאור הפקודה:

דוגמאות:

1) חשב את האינטגרל [pic] בדיוק של 6 ספרות. הגדר את הפונקציה בקובץ M.

פתרון:

הגדרת הפונקציה בקובץ M:

f4.m

[pic]

תחילה נשרטט את הפונקציה

[pic]

[pic]

[pic]

2) חשב את האינטגרל [pic] בדיוק של 8 ספרות. הגדר את הפונקציה כפונקציה אנונימית.

פתרון:

[pic]

[pic]

[pic]

האינטגרל הכפול והמשולש

• הפקודה dblquad

הפקודה dblquad מחזירה את תוצאת האינטגרל הכפול המסוים ע"י קריאה לפקודה quad.

תיאור הפקודה:

דוגמאות:

1) חשב את האינטגרל [pic] בדיוק של 6 ספרות. הגדר את הפונקציה כפונקציה אנונימית.

פתרון:

[pic]

2) חשב את האינטגרל [pic] בדיוק של 6 ספרות. הגדר את הפונקציה בקובץ M.

פתרון:

f4.m

[pic]

[pic]

• הפקודה triplequad

הפקודה triplequad מחזירה את תוצאת האינטגרל המשולש המסוים.

תיאור הפקודה:

דוגמאות:

1) חשב את האינטגרל [pic] בדיוק של 6 ספרות ובדיוק של 10 ספרות, השווה ביניהם.

פתרון:

[pic]

לכאורה אין הבדל בין התשובות, נבדוק עבור יותר ספרות אחרי הנקודה:

[pic]

אכן יש הבדל!!!

2) חשב את האינטגרל [pic] בדיוק של 6 ספרות. הגדר את הפונקציה בקובץ M.

פתרון:

f4.m

[pic]

[pic]

-----------------------

int(expr,x);

int(expr,x=a..b);

Int(expr,x);

Int(expr,x=a..b);

כאשר:

int – פקודה המבצעת אינטגרציה ומחזירה את פתרון האינטגרל.

Int – פקודה המחזירה את ביטוי האינטגרל לא פתור. (שימושים לכך נראה בהמשך)

expr – ביטוי אלגברי שעליו עושים את האינטגרל.

x – המשתנה עבורו נבצע את האינטגרציה – אינטגרל לא מסוים.

x=a..b המשתנה עבורו נבצע את האינטגרציה בקטע [a,b] – האינטגרל המסוים

value(f);

כאשר f הוא ביטוי מתמטי כגון:

f=Int(...) f=Sum(...) f=Product(...) f=Limit(...) f=Normal(...)

הסבר יינתן בדוגמאות.

(הפקודות product , limit , normal

נלמדות בשיעור מספר 8 – נושאים בחשבון אינפיניטסימלי).

sum(f,k); sum(f,k=m..n);

Sum(f,k); Sum(f,k=m..n);

כאשר

sum – פקודה המחזירה את סכום של ביטוי.

Sum – פקודה המחזירה את ביטוי הסכום.

f – ביטוי מתמטי

k – אינדקס הסכימה

k=m..n – סכימה מ k=m עד k=n.

Doubleint(f,x,y);

Doubleint(f,x=a..b,y=c..d);

כאשר

f – הביטוי עליו מבצעים את האינטגרל

x – המשתנה הפנימי של האינטגרל

y – המשתנה החיצוני של האינטגרל

x=a..b,y=c..d – תחום עבור האינטגרל המסוים.

Tripleint(f,x,y);

Tripleint(f,x=a..b,y=c..d,z=e..f);

כאשר

f – הביטוי עליו מבצעים את האינטגרל

x – המשתנה הפנימי של האינטגרל

y – המשתנה החיצוני של האינטגרל

x=a..b,y=c..d,z=e..f – תחום עבור האינטגרל המסוים.

changevar( h(x)=g(t) , Int(f(x),x) , t );

changevar( h(x)=g(t) , Int(f(x),x=a..b) , t );

כאשר

h(x)=g(t) – החלפת כל ביטוי אלגברי h(x) להיות הביטוי האלגברי g(t).

כמובן שע"י ההחלפה, הביטוי dx יתחלף בביטוי מהצורה u(t)dt.

Int(f(x),x) – ביטוי של אינטגרל (לא פתור) ע"י המשתנה הישן x.

Int(f(x),x=a..b) – ביטוי של אינטגרל (לא פתור) ע"י המשתנה הישן x בקטע [a,b] .

כמובן שע"י ההחלפה, x=a..b ישתנה ל- t=c..d

t – המשתנה החדש שלפיו מבצעים את האינטגרל.

הערה:

אם לא כתבנו מתחילת העבודה את הפקודה with(student); או לחילופין עשינו restart; יש לכתוב with(student); לפני ביצוע הפקודה הבאה

הערה:

אם לא כתבנו מתחילת העבודה את הפקודה with(student); או לחילופין עשינו restart; יש לכתוב with(student); לפני ביצוע הפקודה הבאה

הערה:

אם לא כתבנו מתחילת העבודה את הפקודה with(student); או לחילופין עשינו restart; יש לכתוב with(student); לפני ביצוע הפקודה הבאה

intparts( Int(udv,x) , u );

כאשר

Int(udv,x) – הוא אינטגרל לפי x שמתפרק לשני הגורמים: u ו- dv

u – הביטוי באינטגרל שבשלב הבא יהפוך להיות du.

הערה:

אם לא כתבנו מתחילת העבודה את הפקודה with(student); או לחילופין עשינו restart; יש לכתוב with(student); לפני ביצוע הפקודה הבאה

rightbox(f(x),x=a..b,n,’shading’=color,);

middlebox(f(x),x=a..b,n,’shading’=color,);

leftbox(f(x),x=a..b,n,’shading’=color,);

כאשר

rightbox – משרטט קירוב ע"י מלבנים ימניים

(מלבנים שפינתם הימנית העליונה נמצאת על הגרף של הפונקציה)

middlebox – משרטט קירוב ע"י מלבני אמצעיים

(מלבנים שאמצע הצלע העליונה נמצאת על הגרף של הפונקציה)

leftbox – משרטט קירוב ע"י מלבנים שמאליים

(מלבנים שפינתם השמאלית העליונה נמצאת על הגרף של הפונקציה)

ארגומנטים חובה:

f(x) – ביטוי אלגברי עבורו רוצים לראות קירוב לאינטגרל.

x=a..b – משתנה האינטגרציה בקטע [a,b]

ארגומנטים רשות:

n – מספר המלבנים שנראה בקטע (– ברירת המחדל היא 4)

=color‘shadin’ – הצבע בו יופיעו המלבנים (– ברירת המחדל היא סוג של ירוק)

- אפשרויות של גרף כגון צבע הגרף וכו'

הרחבה על הפקודה plot נלמדת בשיעור 7 – גרפים

rightsum(f(x),x=a..b,n);

middlesum(f(x),x=a..b,n);

leftsum(f(x),x=a..b,n);

כאשר

f(x) – הפונקציה שעבורה רוצים לדעת קירוב לאינטגרל מסוים.

x=a..b – משתנה האינטגרציה בקטע [a,b]

n – מספר המלבנים. (כמו בפקודות box שלעיל, גם כאן ברירת המחדל היא 4.)

simpson(f(x),x=a..b,n);

trapezoid(f(x),x=a..b,n);

כאשר

f(x) – הפונקציה שעבורה רוצים לדעת קירוב לאינטגרל מסוים.

x=a..b – משתנה האינטגרציה בקטע [a,b]

n – מספר המלבנים. (כמו בפקודות box שלעיל, גם כאן ברירת המחדל היא 4.)

ApproximateInt(f(x),x=a..b,method=simpson,option);

ApproximateInt(f(x),x=a..b,method=trapezoid, option);

כאשר

f(x) – הפונקציה שעבורה רוצים לדעת קירוב לאינטגרל המסוים.

x=a..b – משתנה האינטגרציה בקטע [a,b]

metod=simpson/trapezoid – הכלל שלפיו יבוצע הקירוב.

option – אפשרויות נוספות לפקודה וביניהם:

output=plot מציג את הקירוב ע"י גרף וגם כותב את ערך הקירוב האינטגרל

output=sum מציג את הקירוב ע"י ביטוי של סכום

output=value מציג את ערך הקירוב (– ברירת המחדל)

partition=n קירוב ע"י חלוקה ל n מלבנים (– ברירת המחדל היא 10.)

convert(f,parfrac,x);

כאשר:

f – שבר של פולינומים.

parfrac – מילה שמורה שמשמעותה הפיכה של שבר כנ"ל לסכום של שברים פשוטים.

x – המשתנה של השבר. (– אם יש רק משתנה אחד אזי הוא ברירת המחדל)

quad(fun,a,b,tol);

כאשר

fun – היא הפונקציה עבורה רוצים לחשב אינטגרל מסוים.

פונקציה זו יכולה להילקח מקובץ M, ואז נכתוב @fun

או להיות פונקציה אנונימית ואז נכתוב fun

a – הגבול התחתון של האינטגרל המסוים.

b – הגבול העליון של האינטגרל המסוים.

tol – חסם השגיאה על התוצאה – ברירת המחדל היא 1.0e-6=0.000001

quadl(fun,a,b,tol);

כאשר

fun – היא הפונקציה עבורה רוצים לחשב אינטגרל מסוים.

פונקציה זו יכולה להילקח מקובץ M, ואז נכתוב @fun

או להיות פונקציה אנונימית ואז נכתוב fun

a – הגבול התחתון של האינטגרל המסוים.

b – הגבול העליון של האינטגרל המסוים.

tol – חסם השגיאה על התוצאה – ברירת המחדל היא 1.0e-6=0.000001

dblquad(fun,a,b,c,d,tol);

כאשר

fun – היא הפונקציה עבורה רוצים לחשב אינטגרל מסוים.

פונקציה זו יכולה להילקח מקובץ M, ואז נכתוב @fun

או להיות פונקציה אנונימית ואז נכתוב fun

a – הגבול התחתון של x באינטגרל המסוים.

b – הגבול העליון של x באינטגרל המסוים.

c – הגבול התחתון של y באינטגרל המסוים.

d – הגבול העליון של y באינטגרל המסוים.

tol – חסם השגיאה על התוצאה – ברירת המחדל היא 1.0e-6=0.000001

triplequad(fun,a,b,c,d,e,f,tol);

כאשר

fun – היא הפונקציה עבורה רוצים לחשב אינטגרל מסוים.

פונקציה זו יכולה להילקח מקובץ M, ואז נכתוב @fun

או להיות פונקציה אנונימית ואז נכתוב fun

a – הגבול התחתון של x באינטגרל המסוים.

b – הגבול העליון של x באינטגרל המסוים.

c – הגבול התחתון של y באינטגרל המסוים.

d – הגבול העליון של y באינטגרל המסוים.

e – הגבול התחתון של z באינטגרל המסוים.

f – הגבול העליון של z באינטגרל המסוים.

tol – חסם השגיאה על התוצאה – ברירת המחדל היא 1.0e-6=0.000001

תחילה נשרטט את הפונקציה (-לא חובה)

הערה:

אם לא כתבנו מתחילת העבודה את הפקודה with(student); או לחילופין עשינו restart; יש לכתוב with(student); לפני ביצוע הפקודה הבאה

הערה:

אם לא כתבנו מתחילת העבודה את הפקודה with(student); או לחילופין עשינו restart; יש לכתוב with(student); לפני ביצוע הפקודה הבאה

הערה:

אם לא כתבנו מתחילת העבודה את הפקודה with(student); או לחילופין עשינו restart; יש לכתוב with(student); לפני ביצוע הפקודה הבאה

הערה:

אם לא כתבנו מתחילת העבודה את הפקודה with(Student[Calculus1]); או לחילופין עשינו restart; יש לכתוב with(Student[Calculus1]); לפני ביצוע הפקודה הבאה

................
................

In order to avoid copyright disputes, this page is only a partial summary.

Google Online Preview   Download