הצגת המקור של הדף "תכנות נומרי עם Matlab ו-Octave/מערכים"

{{תכנות נומרי עם Matlab ו-Octave}}

הקדמה
{{להשלים}}
בניה של מערך


== מערך חד מימדי ==
אחד השימושים במערך חד מימדי הוא ייצוג של וקטור מתמטי. כאשר למעשה הוקטור הוא בגודל 1*n כאשר n הוא מספר העמודות או התאים במערך.

{{הארה
|כדאי להרחיב את הידע ב[[מתמטיקה תיכונית/וקטורים|וקטורים מתמטיים]].}}


מערכים חד מימדיים בMatlab או Octave מייצגים, בין השאר, וקטורים מתמטיים (לדוגמה <math dir = "ltr>[1, 2, 4]</math>). 



אפשר לבנות מערך ע"י זוג סוגריים מרובעים, שביניהם איברים מופרדים ברווחים או פסיקים. לדוגמה:

<source lang="text">
octave:21> [1, 2, 6]
ans =

   1   2   6
</source>
מייצר וקטור בעל 3 איברים: 1, 2, ו6. 

=== אתחול מערך ===
{{להשלים}}
<source lang="text">

a=[]

</source>

===פעולות על וקטורים===

אפשר לקשר משתנה לוקטור, לדוגמה כך:
<source lang="text">
octave:22> x = [1, 2, 6]
x =

   1   2   6
</source>

ניגשים לאיבר בוקטור על ידי סוגריים עגולים. '''בניגוד''' לרוב שפות התכנות, האיבר הראשון בוקטור הוא באינדקס 1, לא 0. לדוגמה, כדי להפוך את איברו השלישי של הוקטור ל0, נרשום זאת:
<source lang="text">
octave:22>x(3) = 0
x =

   1   2   0
</source>

כדי לכפול כל אחד מאיברי וקטור במספר, משתמשים באופרטור {{קוד בשורה|.*}} (שימו לב לנקודה לפני הכוכבית). לדוגמה:
<source lang="text">
x .* 5
ans =

    5   10   0
</source>
בצורה דומה אפשר לחבר מספר לכל אחד מאיברי וקטור, לחסר מספר מכל אחד מאיברי וקטור, וכולי.



===יצירת וקטור בדילוגים===

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

<source lang = "text">
<first> : <skip> : <last>
</source>
כאשר:
*first הוא ערך האיבר הראשון
*skip הוא ערך הדילוג
*last הוא ערך האיבר האחרון

(אין צורך לסגור בסוגריים מרובעים.)


<source lang="text">

>> v=1:2:20
v =

   1   3   5   7   9  11  13  15  17  19

>> v=20:-0.5:15
v =

 Columns 1 through 8:

   20.000   19.500   19.000   18.500   18.000   17.500   17.000   16.500

 Columns 9 through 11:

   16.000   15.500   15.000
</source>
אם מדלגים ב-1 אפשר להשמיט את הפרמטר האמצעי (אך לא ב 1-).
<source lang = "text">
octave:12> 1:10
ans =

   1   2   3   4   5   6   7   8   9  10
</source>

=== יצירת וקטור ריק ===
כמו באתחול מערך, לפעמים צריך ליצור וקטור ריק שלתוכו יוכנס לאחר מכן. לשם כך משתמשים בסוגרים מרובעים ללא תוכן:
<source lang="text">
 s=[]
s = [](0x0)

</source>

==פונקציות לוקטורים==


=== linspace ===
בניית וקטור לפי: {{קוד בשורה|linspace (BASE, LIMIT, N)}}   . כאשר base הוא המספר ממנו מתחילים, limit זה מספר היעד ו n זה מספר הרווחים

<source lang="text">
octave:45> linspace(1,0.5,3)
ans =

   1.0000    0.7500    0.5000

</source>

=== logspace ===
כמו ב linspace רק שכאן החישוב הוא לפי בסיס לוגריתמי .

<source lang="text">
octave:46> logspace(2,4,5)
ans =

   1.0000e+02   3.1623e+02   1.0000e+03   3.1623e+03   1.0000e+04


</source>


=== length ===
הפונקציה מחזירה אורך של וקטור (וגם של משתנה מסוג string) .דוגמה: 

<source lang="text">
vec=1:5:100 
length(vec)
ans=
20
</source>

== מערך דו מימדי ==

{{הארה
|פסקה זו דורשת ידע קודם במטריצות.}}
[[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="text">
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   4   7   2   5   8   3   6   9

</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>



=== 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>


פונקציות נוספות ניתן לראות '''[[תכנות נומרי עם Matlab ו-Octave/נספחים#פונקציות למערכים|כאן]]'''

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

מערך תלת מימדי הו מהצורה:{{קוד בשורה| A(n,m,z)}}

כאשר:
*A-שם המערך התלת מימדי
*n-מספר השורות
*m-מספר העמודות
*z- האורך (מספר המטריצות n*m) 
ניתן במספר דרכים לאתחל מערך תלת מימדי:

לבנות בסיס בעזרת zeros או ones:
<source lang="text">
octave:19> a=zeros(3,3,3)
a =

ans(:,:,1) =

   0   0   0
   0   0   0
   0   0   0

ans(:,:,2) =

   0   0   0
   0   0   0
   0   0   0

ans(:,:,3) =

   0   0   0
   0   0   0
   0   0   0


</source>
לעצב מחדש מערך קיים עם reshpe:

<source lang="text">
octave:25> v=1:18;
octave:26> a=reshape(v,2,3,3)
a =

ans(:,:,1) =

   1   3   5
   2   4   6

ans(:,:,2) =

    7    9   11
    8   10   12

ans(:,:,3) =

   13   15   17
   14   16   18
</source>
{{שימו לב|מימדי המערך חייבים להתאים אחד לשני. אם בדוגמה  היינו מנסים (3,4,2) היתה מתקבל שגיאה. המערך הפרוס הוא כפולת המימדים <math>18=2*3*3</math>}}
{{משימה|כתבו מערך תלת מימדי3*3*3 של ערכים רנדומליים בין 9-1}}
{{מוסתר|פתרון| 
<source lang="text">
octave:26>ceil(rand(3,3,3)*9)
</source>
הסבר: כמו שאר פונקציות הבניה גם rand יכולה לקבל 3 מימדים. rand מחזירה שברים עשרוניים ולכן עיגלנו עם ceil כלומר לכיוון מעלה (אחרת גם 0 היה נכלל בתוצאות) וכפלנו עם 9 כדי ליצור מרווח מ 1 - 9 }}

{{תכנות נומרי עם Matlab ו-Octave|מוגבל}}
[[קטגוריה:תכנות נומרי עם Matlab ו-Octave|מערכים]]