תחביר
התחביר ליצירת מערך המכיל מספרים מרוכבים הוא כדלקמן:
שיטה 1:
1j * np. לסדר ( גודל )התחביר שניתן לעיל 1j הוא החלק הדמיוני מה שאומר שאנו יוצרים מערך של מספרים מרוכבים, כאשר np.arrang היא הפונקציה שמספקת NumPy ליצירת מערך לטווח מוגדר. Size, המציין את גודל המערך, מועבר לפונקציה.
שיטה 2:
לְמָשָׁל מַעֲרָך ( [ Re+Re*Im , Re+Re*Im , … ] )בתחביר זה, np.arrray היא הפונקציה שמאפשרת לנו ליצור מערך אך איננו יכולים להעביר אליו את הטווח. אנחנו פשוט מעבירים אליו ערכים 'נ' פעמים. בפונקציה, עברנו את 'Re' שמציין מספרים ממשיים ומוסיפים אותם ל-'Im' מספר דמיוני בכפולה של מספר ממשי. אנחנו יכולים להעביר ערכים דמיוניים ל-n פעמים.
דוגמה מס' 01:
כפי שאנו יודעים NumPy תומך גם במספרים מרוכבים ומספק מגוון שיטות מרובות ליישם ולתפעל מספרים מרוכבים. בדוגמה למטה, ניישם שתי דרכים ליצירת מערכים המכילים מספרים מרוכבים. כדי ליישם פונקציות NumPy, תן לנו לייבא תחילה את ספריית NumPy בתור np. לאחר מכן, נאתחל מערך בשם 'array_a' אליו נקצה את הפונקציה np.arange() שתכיל את המספרים המרוכבים. והטווח של המערך יהיה '8'. בשורה הבאה, יצרנו מערך נוסף בשם 'array_b' אליו העברנו מערך של מספרים מרוכבים על ידי העברת הערכים המרוכבים ישירות אליו. בסופו של דבר, הדפסנו את המערך המורכב שיצרנו בשתי השיטות.
יְבוּא רדום כפי ש לְמָשָׁל
array_a = 1j * np. לסדר ( 8 )
array_b = לְמָשָׁל מַעֲרָך ( [ שתיים +1d , 3 +4j , 5 +2j , 1 +6j ] )
הדפס ( 'מערך מורכב באמצעות פונקציית arange()' , array_a )
הדפס ( 'מערך מורכב באמצעות פונקציית np.array()' , array_b )
כפי שמוצג בקטע למטה היא התוצאה של הקוד שביצענו. אנו יכולים לראות שיצרנו שני מערכים בעלי טווח של מספרים מרוכבים מ-0j עד 7j. באחר, עברנו את הטווח האקראי של מספרים מרוכבים בגודל 4.
שיטה 3:
לְמָשָׁל מורכב ( Re+Re*Im )בתחביר שניתן לעיל, np.complex() היא המחלקה המובנית שמסופקת על ידי חבילת Python NumPy המאפשרת לנו לאחסן ערכים מורכבים.
דוגמה מס' 02:
דרך נוספת ליצור מערך מורכב של NumPy היא שימוש במחלקה complex() של NumPy. Complex class() משמש לאחסון מספרים מרוכבים ומחזיר את האובייקט המורכב בו נוכל להשתמש מספר פעמים בתוך הקוד הבודד. כעת, כאשר אנו מיישמים את המחלקה complex() נייבא תחילה את חבילת ה-Numpy שלנו. לאחר מכן, נאתחל מערך שאליו העברנו מחלקה מורכבת המשתמשת בכוכבית '*' כדי להעביר אובייקט ממחלקה מורכבת() שאליו העברנו את '3+1j'. באמצעות הפונקציה arrange() יצרנו מערך בגודל 5. לבסוף, רק הצגנו את הפלט של הקוד שבו יצרנו מערך מורכב באמצעות המחלקה complex() .
יְבוּא רדום כפי ש לְמָשָׁלמַעֲרָך = לְמָשָׁל מורכב ( 3 +1d ) *לְמָשָׁל. לסדר ( 5 )
הדפס ( 'מערך מורכב באמצעות מחלקה np.complex()' , מַעֲרָך )
כפי שמוצג באיור למטה, יצרנו מערך של מספרים מרוכבים. אבל דבר נוסף שאנו יכולים לשים לב באיור הוא שהערך הקבוע אינו מבוצע ברציפות מכיוון שהעברנו את '3+1j' למחלקה מורכבת() כלומר מספר שלוש יתווסף לכל ערכי הקבועים הבאים.
שיטה 4:
לְמָשָׁל יחידות ( צוּרָה , dtype = אף אחד , להזמין = 'ג' , * , כמו = אף אחד )בשיטה זו np.ones(), אנו מציינים מערך של מספרים מרוכבים באמצעות הפרמטר dtype במערך NumPy. Np.ones() משמש להחזרת מערך חדש המכיל 1s. לפונקציה np.ones(), העברנו ארבעה פרמטרים 'shape', המשמשים להגדרת צורת המערך בין אם היא '2', '3' או אחרת. ה-'dtype' הוא סוג הנתונים. במקרה שלנו נשתמש בסוג נתונים מורכב. ה'סדר' מגדיר האם המערך הוא חד מימדי, דו או רב מימדי.
דוגמה מס' 03:
תן לנו ליישם את שיטת ones() כדי לקבל מושג טוב יותר על איך זה עובד תוך שימוש במספרים מרוכבים. כדי ליישם שיטה זו, תנו לנו לייבא תחילה את חבילות NumPy שלנו שמסופקות על ידי Python. לאחר מכן, ניצור מערך אליו נעביר את הפונקציה np.ones() אליה העברנו שני פרמטרים. הראשון הוא '4' כלומר גודל המערך יהיה 4 והשני הוא 'dtype' שהוא מורכב. משמעות הדבר היא, שאנו הולכים ליצור מערך של מספרים מרוכבים מסוג נתונים. הכפלת הפונקציה ones() עם הערך '2' פירושה שהמספר האמיתי שלנו יהיה '2'. בסופו של דבר, הדפסנו את המערך שיצרנו באמצעות הצהרת print.
יְבוּא רדום כפי ש לְמָשָׁלמַעֲרָך = לְמָשָׁל יחידות ( 4 , dtype = מורכב ) * שתיים
הדפס ( 'מערך מורכב באמצעות פונקציית np.ones()' , מַעֲרָך )
כפי שמוצג להלן, הפלט של הקוד שלנו מבוצע בהצלחה ובו יש לנו מערך חד מימדי המכיל 4 ערכים מורכבים עם מספר ממשי 2.
דוגמה מס' 04:
הבה ניישם כעת דוגמה נוספת בה ניצור מערך של מספרים מרוכבים ונדפיס את החלקים המדומים והממשיים של המספרים המרוכבים. תחילה נייבא את ספריית NumPy, ולאחר מכן ניצור מערך אליו העברנו '6' ערכים מורכבים למערך בשם 'מערך' כלומר '56+0j, 27+0j, 68+0j, 49+0j, 120+0j , 4+0j'. בשורה הבאה, פשוט הדפסנו את המערך. כעת, אנו מדפיסים ערכים דמיוניים ואמיתיים של המערך המורכב.
Numpy מספק פונקציה מובנית עבור שתי הפעולות המוצגות למטה. הראשון שמקבל את החלק הדמיוני הוא 'array_name.imag' כאשר הערך לפני הנקודה הוא המערך שממנו עלינו לקבל את החלק הדמיוני. והשני שמקבל את החלק האמיתי הוא 'array_name.real'. במקרה שלנו, השם של מערך הוא 'מערך' ולכן העברנו את הצהרת ההדפסה, את שם המערך ואת מילת המפתח כדי לקבל את שני האלמנטים.
יְבוּא רדום כפי ש לְמָשָׁלמַעֲרָך = לְמָשָׁל מַעֲרָך ( [ 56 .+ 0 . י , 27 .+ 0 . י , 68 .+ 0 . י , 49 .+ 0 . י , 120 .+ 0 . י , 3 + 4 . י ] )
הדפס ( 'מערך מקורי:x' , מַעֲרָך )
הדפס ( 'חלק אמיתי מהמערך:' )
הדפס ( מַעֲרָך . אמיתי )
הדפס ( 'חלק דמיוני של המערך:' )
הדפס ( מַעֲרָך . image )
כפי שמוצג בקטע למטה, הפלט שבו החלק הדמיוני והממשי של המערך המורכב מבוצע בהצלחה. כאשר החלקים האמיתיים הם '56', '27', '68', '120' ו-'3'. והחלקים הדמיוניים הם '0'.
סיכום
במאמר זה, דנו בקצרה במספרים מרוכבים וכיצד אנו יכולים ליצור מערכים מורכבים באמצעות הפונקציות המובנות של NumPy. תיארנו מספר פונקציות המאפשרות לנו ליצור מערכים מורכבים על ידי יישום דוגמאות מרובות כדי להבין טוב יותר.