המשתמש יכול ליצור פונקציות בעצמו.

רצוי לבדוק לפני כן אם לא קיימת פונקציה מובנית שעושה אותה פעולה .

lookfor <ביטוי לבדיקה>

מבנה פונקציה[עריכה]

גם בפונקצית המובנות וגם בפונקציות שנכתבות ע"י המשתמש המבנה דומה:

דגשים:

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

<ערך יוצא1>=function(<פרמטר 1>,<פרמטר 2>)

ומה אם יש יותר מפרמטר יוצא אחד? במקרה הזה מחזירים ערכים ל2 פרמטרים.

[v c]=max(a)

הערכים היוצאים של הפונקציה max הם האיבר הגדול ביותר והאינדקס שלו.

כתיבת פונקציה[עריכה]

תחילה נפתח m file חדש.

function a=add(b)
%use: a=add(b)
for i:length(b)
a(i)=(b(i)+5)./4;
end

כאן יצרנו פונקציה בשם add שמקבלת וקטור b ויוצרת וקטור חדש בשם a שכל איבר בו שווה לאיבר המתאים בפונקציה b ועוד 5 וחלקי 4.

דגשים:

שימוש נרחב בתוך הפונקציה בהערות. כאשר ניתן לתוכנה פקודת help לפונקציה נקבל את הערות האלו.
שמירה של הפונקציה בשמה תבטיח שהתוכנה תמצא אותה בזמן הרצה. הפונקציה צריכה לשבת בספריה בה התוכנית שמריצה אותה יושבת.
פונקציות לרוב לא משתמשות בפקודות קלט (input) ופלט (disp ו fprintf). את הפקודות האלו עדיף להפעיל בתוכנית.

את הפונקציות ניתן להפעיל על כל משתנה אם הוא מהסוג הנדרש (כלומר לא משנה מה שמו). לדוגמה הפונקציה add מהדוגמא למעלה:

vector=1:2:10;
c=add(vector);
disp(c);

פקודות אינטראטיביות הקשורות לפונקציות[עריכה]

run name.m - הפקודה תריץ קובץ בשם name
save - שמירה של קובץ

פונקציות מתמטיות[עריכה]

ניתן לבנות פונקציות מתמטיות עם שימוש בתו @

מבנה:

<משתנה2><פעולות מתמטיות><משתנה1> (<משתנה2>,<משתנה1>)@=<שם הפונקציה>

נבנה פונקציה y=2+x

>>y = @(x) 2+x;

נבדוק x=2

>>y(2)
ans = 4

אם רוצים לראות את הפונקציה שיצרנו :

>>y
y =

@(x) 2 + x

כעת נבדוק מיהו y

octave:20> whos y

*** local user variables:

  Prot Name        Size                     Bytes  Class
  ==== ====        ====                     =====  ===== 
   rwd y           1x1                          0  function_handle

Total is 1 element using 0 bytes

שימו לב שאין השפעה על משתנה בשם x:

octave:39> x
error: `x' undefined near line 39 column 1

לא קיים משתנה בשם הזה. אם היה קיים, הוא לא היה מושפע מהפונקציה.

דוגמה נוספת:

octave:23> y=@(a,b) (a+b)^2
y =

@(a, b) (a + b) ^ 2
octave:26> y(1,2)
ans =  9

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

octave:32> y=@(a,b) (a+b)^2+ab
y =

@(a, b) (a + b) ^ 2 + ab

octave:33> y(1,4)
error: `ab' undefined near line 32 column 18
error: evaluating binary operator `+' near line 32, column 17
error: called from `?unknown?'

התוכנה לא מכירה את הביטוי ab ומתייחסת אלו בתור משתנה חדש

נשתמש בסימן הכפל:

octave:33> y=@(a,b) (a+b)^2+a*b
y =

@(a, b) (a + b) ^ 2 + a * b

octave:34> y(1,4)
ans =  29

נבדוק עם מספרים מרוכבים:

octave:27> y(5+2i,8)
ans =  165 +  52i

אם נרצה לבדוק על וקטור של, מה תהיה התוצאה?

octave:3> f=@(x,y) x.^2+2.*y+1;
octave:4> x=1:2:8;y=x;
octave:5>xy=f(x,y)
ans =

    4   16   36   64

כלומר, ניתן להפעיל את הפונקציה על וקטורים.

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

octave:12> x=1:2:8;y=x;
octave:13> f=x.^2+2.*y+1
f =

    4   16   36   64

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

octave:45> f=@(a)sort(sort(a)')';
octave:46> f(magic(5))
ans =

    1    2    3    4    5
    6    7    8    9   10
   11   12   13   14   15
   16   17   18   19   20
   21   22   23   24   25

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

הפרק הקודם:
לולאות

פונקציות

הפרק הבא:
מחרוזות