בתחילת שנת הלימודים שלי באסמבלי אני זוכר שהשתמשנו בנוסחא שנותנת לי לרוץ על עמודות ונוסחא שנותנת לי לרוץ על שורות במטריצה

מישהו זוכר? אני פשוט רוצה לפתור עכשיו איזה תרגיל שלוקח איבר IJ במטריצה ומכפיל אותו באיבר JI במטריצה באותו הגודל אחרת

ושכחתי

אשמח לעזרה

איזה אסמבלי?

לרוב כשמייצגים מערך דו מימדי במערך חד מימדי (בגודל COL*ROW) אז הגישה לאיבר ה-i,j מתבצעת באמצעות [arr[i+j*col

זה אסמבלי 8086 ואני צריך לעשות Aij * Bji אז אני רוצה לדעת את הנוסחא

אני חושב שאתה מדבר על לולאה בתוך לולאה.

תחפש את זה בגוגל ותקרא איך הרעיון עובד (זה לא מסובך, הכי קל להבין מדוגמאות של C אם כבר למדת).

באמסבלי זה מבוצע עם פקודות קפיצה, בד"כ יש את 2 הפקודות JNZ ו-JZ (קפוץ אם הגעת לאפס).

באופן כללי השיטה הולכת ככה:

אתה אמור להגדיר את אוגר האינדקס (זכור לי שזה CX, כי זה ה-counter) על עמודות, ומתחיל לספור אותו כלפי מטה.

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

Dimka אבל להזכירך באסמבלי אין עמודות, תכלס הכל מסודר בזיכרון בשורה אחת...

בגלל זה אם אני רוצה למשל לעבור על השורות מה שאני צריך לעשות זה כולה mov al,[si] that all וכמובן לקדם את הSI ואז אני מקבל את ערכי השורות..

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

אז תסתכל על מה שגיל אמר. אתה פשוט צריך להכניס את החישוב הזה לתוך התכנית שלך.

הבעיה שאין לי 2 מצביעים למערך , הנתונים היחידים שיש לי זה מצביע אחד שרץ על המערך שהוא כאילו הi שלי, אין לי j ,

אז לא הבנתי מה אתה רוצה לעשות.

יש לך מטריצה אחת? שתי מטריצות? מערך חד מימדי? שניים? מה אתה רוצה לעשות איתם?

יש לי 2 מטריצות דו מימדיות בתרגיל, אבל מן הסתם אין דבר כזה באסמבלי מערך דו מימדי, הם מסודרים בזיכרון בשורה, לדוגמא מטריצה שהיא בגודל 3 שורות ו3 עמודות במקטע המידע נראה מערך של 9 בתים.

עכשיו יש לי 2 מערכים כאלה שהם למעשה 2 מטריצות ריבועיות.. , על אחד אני צריך לרוץ על השורות וזה לא בעיה אני פשוט עושה פוינטר SI למשל ובעזרת מיעון עקיף אני שולף את הנתונים , רץ על השורות באותה מטריצה.

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

פה הבעיה שלי

יש לך i ו-j רק שלא ידעת מה הם.

ה-i מספר העמודה במטריצה וה-j פשוט רץ מ-0 ועד מספר השורות פחות אחד.

את כל זה אתה כמובן מוסיף ל-offset שמגדיר את תחילת המטריצה בזיכרון

לא הכי מובן לי

בזיכרון למשל יש לי מטריצה N על N בגודל 3 למשל אז יש לי Matrix db 12,2,33,45,5,6,7,8,9 אז אם אני רוצה להכפיל כל פעם את איבר ij באיבר ji אני צריך לעשות על אותו מערך 2 מצביעים ? למשל si מצביע שורות , ואז לרוץ מהאיבר הראשון עד לאחרון , אבל איך אני מיישם את העמודות... שם אני נתקע אשמח אם תסבירו לי בדוגמא ממשית

קוד ב-c:

int arr[] = {1,2,3,4,5,6,7,8,9};
int a = arr[1 + 0*3];
int b = arr[1 + 1*3];
int c = arr[1 + 2*3];

תנסה לתאר לי איך נראית המטריצה ואילו איברים נכנסים במשתנים a,b,c

מטריצה A

1 4 7

3- 5 17

2 10 81

מטריצה B

6 7 1

2 2 11

2 - 100 81

ומטריצה C באותו הגודל, במטריצה A אנחנו עוברים על השורות ובמטריצה B אנחנו עוברים על העמודות

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

data segment
A db 7,4,1,17,5,-3,81,10,2
B db 1,7,6,11,2,2,81,100,-2
C db 9 dup (?)


ends

עכשיו אם אני רוצה לעבור על כל מטריצה A על השורות שלה מה שאני עושה זה מעביר לSI את offset של A

מעביר לCX את הגודל של המטריצה שזה 9

ואז אני עושה 2 פקודות

mov dl,[si] , inc si

ואז בזמן שאני עושה LOOP יוצא לי שאני עובר על כל השורות

אבל במקביל אני צריך לעבור על מטריצה B ולא על שורות אלא על העמודות...

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

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

נערך 2014 במרץ 2511 שנים על-ידי bdoron

בכפל מטריצות לא מספיק לעבור על המטריצה רק פעם אחת. על כל עמודה ב-B אתה צריך לעבור על כל 3 השורות של A (ולהיפך, על כל שורה של A אתה צריך לעבור על כל עמודות B).

בשביל לעבור על עמודה פשוט צריך להגדיל את si כל איטרציה במספר האיברים בעמודה (במקרה הזה 3) במקום ב-1.

יואב אתה רוצה להגיד לי ש: אם למשל אני נמצא באיבר השני במטריצה A שזה האיבר במקום 01 ואני רוצה להגיע למקום 10 במטריצה B כל מה שאני צריך לעשות זה להגדיל את הSI ב3?

ואיך זה יכול להיות נכון... נגיד הגעתי לאיבר מספר 7 במערך , אני מוסיף לו 3 וחרגתי מהמערך

נערך 2014 במרץ 2511 שנים על-ידי bdoron