6.16. עקומות ואינטגרציה

עמודי המתמטיקה כיסו פעולות שמקבלות מערך ומפיקות מערך (או סקלר) – חשבון, צמצומים, התפשטות (broadcasting). עמוד זה מכסה מחלקה שונה של פעולות: כאלה שמתייחסות למערך כאל פונקציה נדגמת ושואלות שאלות על הפונקציה עצמה. אינטרפולציה בין דגימות, התאמת עקומה אליהן, אינטגרציה תחתיהן, וקונבולוציה שלהן עם חוצץ אחר.

כל אלה מקבלות קלטי ndarray ומחזירות או סקלר מסוג float או ndarray מסוג float.

6.16.1. אינטרפולציה

interp() מבצעת אינטרפולציה לינארית חד-ממדית. xp הוא מערך חד-ממדי עולה-מונוטונית של ערכים בלתי-תלויים; fp הם הערכים התלויים התואמים; x הוא המקום שבו יש להעריך את האינטרפולנט:

xp = np.array([0.0, 1.0, 2.0, 3.0])
fp = np.array([10.0, 20.0, 25.0, 30.0])
x  = np.array([0.5, 1.5, 2.5])

np.interp(x, xp, fp)
# array([15.0, 22.5, 27.5])

מחוץ לטווח [xp[0], xp[-1]] התוצאה נגזרת ל-fp[0] ול-fp[-1] בהתאמה; מילות המפתח left= ו-right= עוקפות נקודות קצה אלה.

משמשת על המצלמה למיפוי מחדש של טבלת כיול למיקומי דגימה שרירותיים – טבלת טמפרטורה-למתח מתרמיסטור, עקומת תגובת פיקסל לא-לינארית, חיפוש גמא לכל ערוץ. קריאת ספרייה אחת, מעבר אחד על הקלטים, ללא לולאת Python.

6.16.2. התאמה והערכה של פולינום

polyfit() מתאימה פולינום מדרגה deg לנקודות הנתונים (x, y) בשיטת הריבועים הפחותים ומחזירה את המקדמים (הדרגה הגבוהה תחילה):

x = np.array([0.0, 1.0, 2.0, 3.0, 4.0])
y = np.array([0.0, 1.1, 3.9, 9.1, 15.8])

coeffs = np.polyfit(x, y, 2)
# array([1.0, 0.0, 0.0])  (approximately)

כאשר x מושמט, נעשה שימוש ב-range(len(y)) – שימושי להתאמת פולינום מהיר לחוצץ נדגם-באופן-סדיר ללא ציר-x משויך:

np.polyfit(y, 2)

polyval() מעריכה את הפולינום שמקדמיו הם p בנקודה x. הקלט x יכול להיות סקלר (מחזיר float) או ndarray (מחזיר ndarray):

p = np.polyfit(x, y, 2)
fitted = np.polyval(p, x)

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

6.16.3. קונבולוציה

convolve() מחזירה את הקונבולוציה הלינארית הבדידה באורך-מלא של שני מערכים חד-ממדיים. רק מצב full ממומש; אורך הפלט הוא len(a) + len(v) - 1. גזור את התוצאה כדי לקבל את אותו אפקט של המצבים same ו-valid ש-numpy של שולחן העבודה מציע:

a = np.array([1.0, 2.0, 3.0])
v = np.array([0.5, 0.5])

np.convolve(a, v)
# array([0.5, 1.5, 2.5, 1.5])

שימושית למסנני FIR קצרים ולגרעיני החלקה (קופסה, משולש, גאוסיאני) שבהם הקמת שרשרת SOS היא הגזמה. זמן הריצה פרופורציוני למכפלת אורכי שני המערכים – מתאים לגרעינים קצרים אך הופך במהירות ליקר יותר מקונבולוציית FFT עבור ארוכים.

6.16.4. אינטגרציה טרפזית

trapz() מבצעת אינטגרציה של פונקציה נדגמת לפי כלל הטרפז המורכב:

x = np.linspace(0, np.pi, num=128)
y = np.sin(x)
np.trapz(y, x)             # ~ 2.0

העבר dx= כאשר מרווח הדגימה אחיד ורק הצעד חשוב; העבר x= כאשר הדגימות אינן במרווחים שווים. הקריאה הנכונה לאינטגרציה של נתוני חיישן שכבר נלכדו, היכן שהצורה האנליטית אינה זמינה.

עבור נתוני דגימה שהוגבלו בתחום-תדר (חוצץ שמע לאחר מסנן נגד-עיוות, למשל), כלל הטרפז מתכנס כריבוע של מספר הדגימות, מה שאומר שהכפלת אורך החוצץ חותכת את השגיאה בפי ארבעה.

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