תכנות נומרי עם Matlab ו-Octave/מערכים: הבדלים בין גרסאות בדף
תוכן שנמחק תוכן שנוסף
אין תקציר עריכה |
|||
שורה 11:
a=[]
==מערך מחרוזות ===
<source lang="text">
a=['s' 't' 'y']
</source>
== מערך חד מימדי ==
שורה 149 ⟵ 154:
== מערך דו מימדי ==
{{הארה
|פסקה זו דורשת ידע קודם במטריצות.}}
[[w:מטריצה|מטריצה]] היא מערך תאים בגודל m*n כאשר m הוא מספר השורות ו n הוא מספר העמודות.
דוגמה :אתחול מטריצה a בגודל 5*4 והכנסת המספר 1 למקום ה 4,5 :
<source lang="matlab">
>> a(4,5)=1
a =
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 1
>> whos a
*** local user variables:
Prot Name Size Bytes Class
==== ==== ==== ===== =====
rwd a 4x5 160 double
Total is 20 elements using 160 bytes
</source>
יצירת מטריצה דומה ליצירת וקטור כאשר להפרדה בין השורות משתמשים ב ;
<source lang="matlab">
x=[1 2;3 4]
x =
1 2
3 4
</source>
כאן יצרנו מטריצה בגודל 2*2 זוהי מטריצה ריבועית.
כלומר מטריצה בגודל m כאשר m הוא מספר השורות וגם העמודות, במילים אחרות, אורכה שווה לגובהה.
<source lang="matlab">
octave:30> whos x
*** local user variables:
Prot Name Size Bytes Class
==== ==== ==== ===== =====
rwd x 2x2 32 double
Total is 4 elements using 32 bytes
</source>
עכשיו ניצור אחת יותר גדולה. בגלל שאין לנו כוח להכניס איברים לכל המקומות, ניצור בצורה רנדומלית עם rand.
<source lang="matlab">
a=rand(5,7)
a =
0.8248817 0.2889077 0.7461950 0.8559394 0.6424179 0.8985183 0.8952427
0.4555631 0.8670079 0.2521041 0.0840872 0.7443703 0.3556846 0.7061898
0.3189548 0.4681194 0.9783496 0.3565062 0.7636891 0.9796930 0.0808279
0.8375179 0.6205069 0.4382116 0.2789763 0.7823746 0.4983560 0.3552753
0.8136271 0.5476563 0.7410189 0.0016889 0.2047131 0.4818841 0.3773963
</source>
הפונקציה rand יוצרת איברים רנדומלים לא שלמים, אבל ניתן ל"שפץ" אותם.
לדוגמא בין 1 ל 100
<source lang="matlab">
a=round(rand(5,7)*100)
a =
29 17 52 65 38 91 92
75 78 74 54 2 9 48
8 36 100 29 1 75 70
38 37 25 39 43 15 87
84 49 66 61 84 94 33
</source>
===פניה לאיברים===
אם אנו רוצים לפנות לאיבר מסוים או אפילו למטריצה פנימית ניתן לפנות לאינדקס ואף לשנות אותו.
<source lang="matlab">
>> a(2,5)
ans = 2
>> a(2:4,5:7)
ans =
2 9 48
1 75 70
43 15 87
>>a(2,7)=0
a =
29 17 52 65 38 91 92
75 78 74 54 2 9 0
8 36 100 29 1 75 70
38 37 25 39 43 15 87
84 49 66 61 84 94 33
</source>
פניה לשורה או עמודה שלמה באמצעות ':'
נקרא לשורה השניה
<source lang="matlab">
a(2,:)
ans =
75 78 74 54 2 9 0
</source>
ולעמודה השלישית
<source lang="matlab">
a(:,3)
ans =
52
74
100
25
66
</source>
נפנה לתת מטריצה מהאיבר במקום
<source lang="matlab">
a([3:end;4:6)
ans =
29 1 75
39 43 15
61 84 94
</source>
שימו לב לשימוש ב end, הביטוי end טוב למטריצות שתוכניות מבקשות מהמשתמש.
ניתן לפנות בצורה זו לביטויים שונים . לדוגמא : end-1 (השורה או העמודה לפני האחרונה)
פניה לאיבר במטריצה פרוסה:
ניתן לפנות לאיברים במטריצה לפי אינדקס אחד, בקריאה כזו התוכנה עוברת על העמודות מלמעלה למטה ומשמאל לימין.
לדוגמה הכנסת 1 לאיבר החמישי במטיצה 4*5
<source lang="matlab">
a(4,5)=0;
a(5)=1
a =
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
</source>
==פעולות חשבוניות בוקטורים ומטריצות==
{{להשלים}}
==
{{להשלים}}
=== שחלוף ===
במטריצה של מספרים שלמים, פעולת [[w:מטריצה משוחלפת|השחלוף]] (transpose בלעז) מחליפה את שורות המטריצה בעמודות שלה . שכלוף מבוצע ע"י הוספת גרש ( ' ) אחרי המטריצה.
<source lang="matlab">
octave:15> a = [
> 1, 0
> 2 3]
a =
1 0
2 3
octave:16> a'
ans =
1 2
0 3
</source>
=== מציאת דטרמיננטה ===
[[w:דטרמיננטה|דטרמיננטה]] של מטריצה הוא סקלר המתקבל מביצוע חישובים על המטריצה.
במטלב ואוקטב קיימת פונקציה המבצעת את החישוב על המטריצה ומחזירה את הדטרמיננטה הפונקציה נקראת בקיצור det.
נחשב דטרמיננטה של מטריצה :
<source lang="text">
octave:114> det([1 2 3;4 5 6;7 4 3])
ans = -6.0000
</source>
אם נשחלף את המטריצה הדטרמיננטה ישתנה?
<source lang="text">
octave:114> det([1 2 3;4 5 6;7 4 3]')
ans = -6.0000
</source>
כנראה שלא . שחלוף מטריצה לא משפיע על הדטרמיננטה.
== פונקציות לשימוש בוקטורים ומטריצות ==
=== reshape ===
מעצבת מטריצה או וקטור מחדש.
שימו לב שחייבת להיות התאמה במימדים של המטריצה או הוקטור המקורי ומטריצת היעד:
<source lang="matlab">
octave:5> a=[1,2,3;4,5,6;7,8,9];
octave:6> reshape(a,1,9)
ans =
1
</source>
=== find ===
מציאת ביטוי מסוים הקיים במטריצה או וקטור. מחזיר את האינדקס של האיבר המקיים את הביטוי.
<source lang="matlab">
octave:62> a=[6,4,3,9];
octave:63> find(a>3 & a<9)
ans =
1 2
</source>
=== prod ===
כפל אברי המטריצה.
מקבלת גם מימדים (אם נוסיף מימד שני =2 נקבל את החישוב לפי שורות)
<source lang="matlab">
octave:70> a=[2 2;2 2;3 3]
a =
2 2
2 2
3 3
octave:71> prod(a)
ans =
12 12
octave:72> prod(a,2)
ans =
4
4
9
</source>
=== rempt ===
=== sum ===
הפונקציה מחשבת סכום האיברים .
כאשר מוסיפים בפרמטר שני 2 החישוב יבוצע על השורות.
<source lang="matlab">
octave:32> a=[2,5;9,3]'
a =
2 9
5 3
octave:33> sum(a,1)
ans =
7 12
octave:34> sum(a,2)
ans =
11
8
</source>
=== cumsum ===
מחשבת סכום ומוסיפה לאברי השורה האחרונה או העמודה.
כאשר מוסיפים בפרמטר שני 2 החישוב יבוצע על השורות.
<source lang="matlab">
octave:35> cumsum(a)
ans =
2 9
7 12
octave:36> cumsum(a,2)
ans =
2 11
5 8
</source>
=== size ===
הפונקציה מחזירה את מימדי הוקטור או המטריצה.
<source lang="matlab">
>> x=1:9
x =
1 2 3 4 5 6 7 8 9
>> size(x)
ans =
1 9
>> x=[1:4;8:-1:5]
x =
1 2 3 4
8 7 6 5
>> size(x)
ans =
2 4
</source>
=== sort ===
סידור האיברים מהקטן לגדול.
כאשר מקבל פרמטר שני לביצוע הפעולה על השורות.
<source lang="matlab">
x=round(rand(3)*10)
x =
1 3 6
10 1 1
9 6 10
>> sort(x)
ans =
1 1 1
9 3 6
10 6 10
>> sort(x,2)
ans =
1 3 6
1 1 10
6 9 10
</source>
הכנסנו מטריצה רנדומלית לערך x . ביצענו פעולת מיון רגילה (על העמודות) ולאחר מכן פעולת מיון על השורות.
אם נוציא שני פרמטרים מהפונקציה הפרמטר השני יהיה האינדקס של השינויים.
<source lang="matlab">
[a,b]=sort(vec)
a =
5 5 8 9
b =
2 4 3 1
</source>
שימו לב שכאשר יש שני מספרים זהים התוכנה תסדר אותם לפי סדר הקריאה-מימין לשמאל.
=== max ===
מציאת הערך הגדול ביותר בוקטור והאינדקס שלו (אם מציבים לשתי ערכים).
במטריצה ימצא את הערכים הגדולים בכל עמודה והאינדקס שלהם (כנ"ל).
<source lang="matlab">
>>c =[16 2 3 13]
>>[d s]=max(c)
d = 16
s = 1
>>x=magic(4)
x =
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
>> [c v]=max(x)
c =
16 14 15 13
v =
1 4 4 1
</source
<source lang="matlab">
fliplr(x)
ans =
13 3 2 16
8 10 11 5
12 6 7 9
1 15 14 4
</source>
>
כדי למצוא את האיבר הגדול ביותר במטריצה נשתמש ב max(max(c))
===rand===
יצירת מטריצה שאיבריה רנדומליים (שברים עשרוניים) בגודל m*n או m (ריבועית).
ראו דוגמה [[תכנות נומרי עם Matlab ו-Octave/וקטורים ומטריצות#מטריצות|בפסקה של בניית מטריצות]].
=== fliplr ===
שינוי סדר האיברים מימין לשמאל
<source lang="matlab">
fliplr(x)
ans =
13 3 2 16
8 10 11 5
12 6 7 9
1 15 14 4
</source>
=== flipud ===
שינוי סדר האברים מלמעלה למטה.
<source lang="matlab">
flipud(x)
ans =
4 14 15 1
9 7 6 12
5 11 10 8
16 2 3 13
</source>
=== eye ===
יצירת [[w:מטריצת היחידה|מטריצת היחידה]]. שימו לב שאין צורך במימדי השורות והעמודות אלא רק באחד מהם מאחר ומדובר במטריצה ריבועית.
<source lang="matlab">
eyes(3)
ans =
1 0 0
0 1 0
0 0 1
</source>
=== zeros/ones ===
zeros-יצירת מטריצת אפסים.
<source lang="matlab">
zeros(3)
ans =
0 0 0
0 0 0
0 0 0
</source>
ones-יצירת מטריצת המורכבת מאברים שהם הספרה 1.
<source lang="matlab">
ones(3,2)
ans =
1 1
1 1
1 1
</source>
כאן רצינו מטריצה 3*2 של אחדים, ולכן הכנסנו עוד נתון לפונקציה (3,2) .
=== diag ===
הפונקציה מבצעת שני דברים:
* מוציאה אלכסון כלשהו ממטריצה (לאו דוקא המרכזי)
* מחזירה מטריצת אלכסון מוקטור (מטריצת אלכסון - כל האברים הם 0 מלבד האלכסון) .
<source lang="matlab">
x=round(rand(3,2)*10)
x =
9 0
5 7
1 8
diag(x)
ans =
9
7
diag(x,-1)
ans =
5
8
</source>
בשלב ראשון יצרנו מטריצה בגודל 3*2 עם איברים רנדומליים בין 1 ל 10.
לאחר מכן ביקשנו באמצעות diag את האלכסון הראשי וקיבלנו את הוקטור [7 9]. ביקשנו גם את הוקטור שמתחיל במקום ה 1- (הוקטור הראשי מתחלי ב 0) וקיבלנו את הוקטור [8 5].
מה יקרה עם נפעיל את הפונקציה על וקטור? במקרה הזה הפונקציה תיצור [[w:מטריצה אלכסונית|מטריצת אלכסון]].
<source lang="matlab">
diag([1 2 3 4])
ans =
1 0 0 0
0 2 0 0
0 0 3 0
0 0 0 4
diag(diag(x,-1),1)
ans =
0 5 0
0 0 8
0 0 0
</source>
במקרה השני השתמשנו באלכסון במקום ה 1- במטריצה x ויצרנו איתו מטריצה שהוא האלכסון שלה במקום ה - 1.
=== magic ===
הפונקציה יוצרת מטריצה שהיא ריבוע קסם (סכום כל שורה שווה לסכום כל עמודה ושווה לאלכסונים). המטריצה צריכה להיות ריבועית.
<source lang="matlab">
magic(4)
ans =
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
</source>
===det===
מציאת הדטרמיננט.
ראו פעולות חישוב.
===inv===
מציאת המטריצה ההפוכה
{{תכנות נומרי עם Matlab ו-Octave|מוגבל}}
| |||