DorLev&RoeyDvir-Final.ipynb

Kernel: SageMath (stable)

import sympy as sp
from sympy.plotting import plot
sp.init_printing()
%matplotlib -- inline

מטריצות

מטריצה היא מבנה מלבני שממדיו הם $m\times n$ של גדלים $a_{ij}$. האינדקס $i$ מציין את השורה והאינדקס $j$ מציין את מספר העמודה. $$\begin{pmatrix} a_{11} & a_{12} \dotsm & a_{1n} \\ a_{21} & a_{22} \dotsm & a_{2n} \\ \vdots & \vdots & \vdots \\ a_{m1} & a_{m2} \dotsm & a_{mn} \end{pmatrix}$$
מספר השורות הוא $m$ ומספר העמודות הוא $n$.

במידה ו-$m$ שווה ל- $n$ $(m=n)$ המטריצה מכונה מטריצה ריבועית.

שתי מטריצות A ו-B יחשבו כשוות אם ורק אם $a_{ij}=b_{ij}$ . פרוש הדבר כי לשתי המטריצות אותו מספר שורות, אותו מספר עמודות וששני איברים הנמצאים באותו המקום שווים.

החיבור של שתי מטריצות $m\times n$ (שתי מטריצות בעלות אותו מספר שורות ואותו מספר עמודות) מוגדר כמטריצה C שאבריה מוגדרים על ידי $c_{ij}=a_{ij}+b_{ij}$ . במקרה זה נכתוב: C=B+A. חיבור מטריצות הוא חילופי: A+B=B+A. ניתן לחבר רק מטריצות שמימדיהן זהים.

הכפל של מטריצה A בסקלר c מסומן כ- cA והוא מטריצה שכל אחד מאיבריה מוכפל בסקלר c.

המכפלה המטריציונית של המטריצה $m\times n$ במטריצה $n\times p$ (מספר העמודות במטריצה אחת שווה למספר השורות במטריצה שניה) מוגדר בצורה $AB=[a_{ij}b_{jk}]$.

דוגמה לכפל מטריצות: $$\begin{pmatrix} 4 & -9\\ 1 & 2\\ 0 & 1 \end{pmatrix}\cdot \begin{pmatrix} 2 & 1 \\ -2 & 1 \end{pmatrix}=\begin{pmatrix} 4\cdot 2 +(-9)\cdot(-2) & 4\cdot 1 +(-9)\cdot 1\\ 1\cdot2+2\cdot(-2) & 1\cdot1 +2\cdot1\\ 0\cdot2+1\cdot(-2) & 0\cdot 1+1\cdot 1\end{pmatrix}=\begin{pmatrix} 26 & -5\\-2 & 3\\ -2 & 1 \end{pmatrix}$$

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

אלגברה של מטריצות

1. ייבאו את המחלקה sympy ותנו לה את השם sp.
הערה
ניתן להגדיר מטריצה באמצעות הפקודה:

sp.Matrix([[list1],[list2]…[listn]])

כל שורה במטריצה מוקלדת כרשימה. למשל הייתם יכולים להגדיר את המטריצה A באמצעות הפקודה:

A=sp.Matrix([[4,-9, 0],[1,2, -0.5],[0,1,2]])

2. הגדירו בסביבת העבודה שלכם את שתי המטריצות A ו-B שלמטה: $$A=\begin{pmatrix} 4 & -9 & 0\\ 1 & 2 &-0.5\\ 0 & 1 & 2\end{pmatrix}$$ $$B=\begin{pmatrix} 2 & 6\\ 1 & 3\\ -1 & 0.8\end{pmatrix}$$

import sympy as sp
A=sp.Matrix([[4,-9,0],[1,2,-0.5],[0,1,2]])
B=sp.Matrix([[2,6],[1,3],[-1,0.8]])
A

$$\left[\begin{matrix}4 & -9 & 0\\1 & 2 & -0.5\\0 & 1 & 2\end{matrix}\right]$$

3. כתבו קטע קוד המייצר את המטריצה הבאה:
$$\begin{pmatrix} 1 & 2 & 3 & 4 & 5 \\ 1 & 4 & 9 & 16 & 25 \\1 & 8 & 27 & 64 & 125\end{pmatrix}$$

יש חוקיות בכל שורה. זהו אותה והשתמשו בה.

l=[]
l2=[]
l3=[]
for i in range(1,5):
    l.append(i)
    l2.append(i**2)
    l3.append(i**3)
A=sp.Matrix([l,l2,l3])
A

Matrix([
[1, 2,  3,  4],
[1, 4,  9, 16],
[1, 8, 27, 64]])

4. הסימן לכפל מטריצות ב- sympy הוא כוכבית (*). חשבו בעזרת נייר ועיפרון את:$$A*B$$ $$2*A$$ $$A*B+B$$ אמתו את תשובותיכם באמצעות sympy.

A=sp.Matrix([[4,-9,0],[1,2,-0.5],[0,1,2]])
B=sp.Matrix([[2,6],[1,3],[-1,0.8]])
AB=A*B
AB
A2=2*A
ABB=A*B+B

5. נתונות המטריצות $$D=\begin{pmatrix} 5 & 6 \\ 7 & 8 \end{pmatrix}$$ $$C=\begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix}$$ חשבו בעזרת sympy פעם את $D*C$ ופעם את $C*D$. מה המסקנה? האם כפל מטריצות הוא חילופי?

D=sp.Matrix([[5,7],[7,8]])
C=sp.Matrix([[1,2],[3,4]])
DC=D*C
CD=C*D
CD
כפל המטריצות הוא לא חלופי (המיקום של כל איבר משנה)#

$$\left[\begin{matrix}19 & 23\\43 & 53\end{matrix}\right]$$

מטריצת יחידה היא מטריצה ריבועית (מספר השורות שווה למספר העמודות ) המקיימת: אם $i=j$ אזי $a_{ij}=1$ אחרת $a_{ij}=0$. בעזרת הפונקציה $sp.eye(n)$ אפשר להגדיר מטריצת יחידה שמימדיה הם $n\times n$.

6. הגדירו מטריצת יחידה שמימדייה הם $3\times 3$ וסמנו אותה באות I.

I=sp.eye(3)
I

$$\left[\begin{matrix}1 & 0 & 0\\0 & 1 & 0\\0 & 0 & 1\end{matrix}\right]$$

7. חשבו את המכפלה $A*I$ ואת המכפלה $I*A$.ְ מה המסקנה?

AI=A*I
AI
IA=I*A
IA
#שכשהמטריצה ריקה כפל המטריצות הוא כן חלופי

8. מצאו מטריצה $C$ כך שהמכפלה $C*A$ תיתן מטריצה שכל איבר בשורה הראשונה שלה גדול פי-3 מהאיבר המתאים ב- $A$ ושכל האיברים בשורה השניה והשלישית שלה זהים לאיברים המתאימים במטריצה $A$.

גישה לשורה או עמודה ספציפית:
הפקודה $A.row(i)$ מחזירה מטריצת שורה שהיא השורה ה-$i$ של המטריצה $A$ ואילו הפקודה $A.col(i)$ מחזירה מטריצת עמודה שהיא העמודה ה- $i$ של המטריצה $A$

C=sp.Matrix([[3,1,1],[3,1,1],[3,1,1]])

9. הקלידו את שורת הקוד:

M=sp.MatrixSymbol('a',3,3)

לאחר מכן הקלידו

M=sp.Matrix(S*M)

הפונקציה $sp.MatrixSymbol('a',k,j)$ יוצרת מטריצה סימבולית, המכילה k שורות ו- j עמודות.

כדי לגשת לאבר $a_{i,j}$ במטריצה משתמשים ב:

A[i,j]

ראו כאן:

http://docs.sympy.org/latest/modules/matrices/matrices.html

10. הגדירו את המטריצה $S=\begin{pmatrix} 1 & 0 & 1\\0 &1&0\\0&0&1 \end{pmatrix}$. במקום להקליד כל שורה בניפרד, צרו מטריצת יחידה בגודל $3\times 3$ ושנו את האיבר המתאים בשורה מספר אפס ובעמודה מספר 2 ל-1.

import sympy as sp
sp.init_printing
S=sp.eye(3)
S[0,2]=1
M=sp.MatrixSymbol('a',3,3)
M=sp.Matrix(S*M)
display(M)

Matrix([
[a[0, 0] + a[2, 0], a[0, 1] + a[2, 1], a[0, 2] + a[2, 2]],
[          a[1, 0],           a[1, 1],           a[1, 2]],
[          a[2, 0],           a[2, 1],           a[2, 2]]])

11. חשבו את המכפלה $S*M$. במטריצה המתקבלת מה הקשר בין השורה הראשונה, לשורות של M ? (המטריצה M הוגדרה בשאלה 9)

שימו לב: התוצאה שלכם צריכה להיות בצורת מטריצה!

H=S*M
H
#שבכל איבר שבו הנקודה בציר האיקס שווה ל2 במטריצה החדשה האיי מוכפל ב2

Matrix([
[a[0, 0] + 2*a[2, 0], a[0, 1] + 2*a[2, 1], a[0, 2] + 2*a[2, 2]],
[            a[1, 0],             a[1, 1],             a[1, 2]],
[            a[2, 0],             a[2, 1],             a[2, 2]]])

12. חשבו את המכפלה $M*S$. מה מייחד את המטריצה המתקבלת?

import sympy as sp
M=sp.MatrixSymbol('a',3,3)
S=sp.eye(3)
M=sp.Matrix(S*M)
H=S*M
H
#שבכל איבר שבו הנקודה בציר האיקס שווה ל2 במטריצה החדשה האיי מוכפל ב2

Matrix([
[a[0, 0], a[0, 1], a[0, 2]],
[a[1, 0], a[1, 1], a[1, 2]],
[a[2, 0], a[2, 1], a[2, 2]]])

13. מצאו מטריצה $C$ כך שהמכפלה $C*M$ תיתן מטריצה שכל איבר בשורה השניה שלה שווה לסכום האיברים בעמודה המתאימה של המטריצה $M$. השורה הראשונה והשלישית של המכפלה זהות לשורות המתאימות של המטריצה C.

C=sp.Matrix([[1,1,1],[3,3,3],[1,1,1]])
C*M

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-1-412ffe156f7b> in <module>()
----> 1 C=sp.Matrix([[Integer(1),Integer(1),Integer(1)],[Integer(3),Integer(3),Integer(3)],[Integer(1),Integer(1),Integer(1)]])
      2 C*M
NameError: name 'sp' is not defined

14. בדקו מה מחזירה הפונקציה:

  sp.Matrix(3,4,lambda k,n : k+n)

sp.Matrix(3,4,lambda k,n : k+n)

Matrix([
[0, 1, 2, 3],
[1, 2, 3, 4],
[2, 3, 4, 5]])

קיראו עוד על השימוש בפונקציות פייתון וב-lambda לצורך יצירת מטריצות כאן: http://docs.sympy.org/latest/modules/matrices/matrices.html

15. צרו מטריצה 4×5 שכל איבר בה שווה לסכום ריבועי השורה והעמודה של המקום בו הוא נמצא.

sp.Matrix(4,5,lambda k,n : k**2+n**2)

16.בדקו מה מחזירה הפונקציה

sp.Matrix(4,4,range(16))

sp.Matrix(4,4,range(16))

מטריצה הופכית:
המטריצה ההופכית של מטריצה ריבועית $D$ מוגדרת כמטריצה שהמכפלה שלה ב- $D$ נותנת מטריצת יחידה. בספר או במחברת מסמנים את המטריצה ההופכית של $D$ בצורה $D^{-1}$. ב- sympy, אם $A$ היא מסוג $MutableMatrix$ , במילים אחרות נוצרה בעזרת הפונקציה $Matrix$ ההופכי שלה ניתן על ידי השיטה $A.inv()$. ההופכי של מטריצה מסוג $SymbolicMatrix$ ניתן על ידי $A.I$.

הגדירו את המטריצה

M=sp.MatrixSymbol('a',3,3)

השתמשו בפקודה type כדי לגלות מהו הסוג של המטריצות A ו-M

A=sp.Matrix(5,5,lambda m,n:sp.Rational(1,(1+m+n)))
M=sp.MatrixSymbol('a',3,3)
S=sp.eye(3)
M=sp.Matrix(S*M)
type(M), type(A)

(sympy.matrices.dense.MutableDenseMatrix,
 sympy.matrices.dense.MutableDenseMatrix)

17. צרו את המטריצה

A=sp.Matrix(5,5,lambda m,n:sp.Rational(1,(1+m+n)))

מה עושה הפונקציה sp.Rational?

מצאו את ההופכי שלה וחשבו את מכפלת ההופכי של $A$ ב- $A$. האם הסדר במכפלה הזו חשוב?

A=sp.Matrix(5,5,lambda m,n:sp.Rational(1,(1+m+n)))
B=A.inv()
A=sp.Matrix(5,5,lambda m,n:sp.Rational(1,(1+m+n)))
D=A*B
D
#הסדר במכפלה הזאת לא חשוב

Matrix([
[1, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 1, 0],
[0, 0, 0, 0, 1]])

18. הגדירו מטריצה בשם $InvS$ שהיא ההופכית ל-$S$, והראו כי תוצאת המכפלה המטריציונית של $InvS$ בתוצאת המכפלה $S*M$ היא $M$.

$S^{-1}*(S*M)$

שימו לב לסדר הפעולות

S=sp.eye(3)
InvS=S.inv()
M=sp.MatrixSymbol('a',3,3)
M=sp.Matrix(S*M)
New_M=(S*M)*InvS
display(New_M)
display(M)

Matrix([
[a[0, 0], a[0, 1], a[0, 2]],
[a[1, 0], a[1, 1], a[1, 2]],
[a[2, 0], a[2, 1], a[2, 2]]])

Matrix([
[a[0, 0], a[0, 1], a[0, 2]],
[a[1, 0], a[1, 1], a[1, 2]],
[a[2, 0], a[2, 1], a[2, 2]]])

19. לאוביקט מסוג $MutableMatrix$ סדרת פונקציות הפועלות על שורות של מטריצה. בדקו מה עושה כל אחת מפונקציות הבאות: row_swap, row_insert ו- row_del

http://docs.sympy.org/latest/tutorial/matrices.html

#row_del-deletes a row
#row_swap-swaps between two rows
#row_insert-adds a row

20. בדקו מה עושות הפונקציות ones ו-zeros.

#ones-creates a matrix filled with ones
#zeros-creates a matrix filled with zeros

21. הראו כי במטריצה שלמטה כל איבר בשורה השלישית שווה לסכום שני האיברים שמעליו. (קבלו True אם זה נכון)$$\begin{pmatrix} 1&0&1\\0&2&2\\1&2&3 \end{pmatrix}$$

קיראו למטריצה הזו D

D=sp.Matrix([[1,0,1],[0,2,2],[1,2,3]])
colNum = 3
for i in range(3):
    if D[2,i] != D[1,i] + D[0,i]:
        x=False
x = True
x

True

22. האם למטריצה מהתרגיל הקודם יש מטריצה הופכית ?

#K = D.inv(), the output is error and the matrix D can't be inverted

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

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

D.det()

D=sp.Matrix([[1,0,1],[0,2,2],[1,2,3]])
mat = D.det()
mat

0

23. האם המטריצה שמשמאל היא סינגולרית? $\begin{pmatrix}2&4&5&4\\1&9&5&8\\5&5&5&0\\6&9&0&9\end{pmatrix}$

import sympy as sp
D=sp.Matrix([[2,4,5,4],[1,9,5,8],[5,5,5,0],[6,9,0,9]])
mat = D.det()
mat
# The martix isn't singular

-1080

מטריצת החילוף
מטריצה ששורותיה הוחלפו בעמודותיה מכונה מטריצת חילוף (transpose ). ב- sympy נמצא את מטריצת החילוף של המטריצה A באמצעות הפקודה

A.T

24. מצאו מטריצת חילוף למטריצה בתרגיל הקודם

D.T

Matrix([
[2, 1, 5, 6],
[4, 9, 5, 9],
[5, 5, 5, 0],
[4, 8, 0, 9]])

25. ניתן לראות וקטור כאילו זו מטריצת השורה $F=[Fx,Fy,Fz]$. מצאו למה שווה המכפלה $F*F.T$. (התשובה היא סקלר)

import sympy as sp
Fx,Fy,Fz=sp.symbols("Fx Fy Fz")
F=sp.Matrix([[Fx,Fy,Fz]])
X = F*F.T
X[0,0]

Fx**2 + Fy**2 + Fz**2

26. בדקו מה הערך של $a$ לאחר הרצת משפט ההשמה שבהמשך

a=sp.symbols('a0:3')

a=sp.symbols('a0:3')
a

(a0, a1, a2)

27.ניתן להתייחס לכל שורה במטריצה כאילו היא וקטור. נתונה מטריצה D. כמו כן נתונים שלושת הווקטורים: (a0,a1,a2) ,(b0,b1,b2) ו- (c0,c1,c2) . בנו מטריצה D בה כל אחת משלושת השורות היא אחד משלושת הווקטורים. הכפילו את המטריצה D במטריצת החילוף שלה. מה מתאר כל איבר במטריצת התוצאה?

a=sp.symbols('a0:3')
b=sp.symbols('b0:3')
c=sp.symbols('c0:3')
D=sp.Matrix([a,b,c])
mat = D*D.T
mat

Matrix([
[a0**2 + a1**2 + a2**2, a0*b0 + a1*b1 + a2*b2, a0*c0 + a1*c1 + a2*c2],
[a0*b0 + a1*b1 + a2*b2, b0**2 + b1**2 + b2**2, b0*c0 + b1*c1 + b2*c2],
[a0*c0 + a1*c1 + a2*c2, b0*c0 + b1*c1 + b2*c2, c0**2 + c1**2 + c2**2]])

28. בדקו כיצד פועלת הפונקציה randMatrix. בידקו מה הם המשתנים האופציונליים שהפונקציה הזו יכולה לקבל

#המטריצה מקבלת את כמות העמודות והשורות, בין משתנה אחד לשניים מסוג אינטיג׳ר
#r, c=None, min=0, max=99, seed=None, symmetric=False, percent=100, prng=None)

29. צרו פונקציה המקבלת שלושה מספרים שלמים n, m ו-L ומחזירה מטריצה של מספרים שלמים אקראיים שלמים בתחום שבין 0 ל- L ומימדיה הם $m\times n$.

def GetMat(L,m,n):
    import sympy as sp
    F=sp.randMatrix(n,m,0,L)
    return(F)
display(GetMat(1000,5,5))

Matrix([
[365, 616, 187,  57, 795],
[568, 421,  35, 252, 508],
[869, 227, 726, 166, 935],
[784, 281, 523, 697, 369],
[914, 195, 757, 681, 506]])