stanford-oval/wikipedia huggingface dataset:
חצקל איש כסית
הערות שוליים

↑  חצקל איש כסית, במיזם "אישים" לתיעוד היצירה הישראלית
↑  חצקל ודוד בן-גוריון, בבלוג של ארכיון צה"ל
↑  תלמוד בבלי, מסכת ראש השנה, דף כ"ג, עמוד א'
↑  יעקב הכהן, שלושים למותו של "איש כסית" - חברים מספרים על חצקל, מעריב, 30 בינואר 1980
| --- | --- |
בקרת זהויות :  NLI: 987007316611605171  VIAF: 353149366317885601503   WorldCat (עם VIAF): 353149366317885601503
פסקל (שפת תכנות)

| --- | --- |
 פרדיגמות:  אימפרטיבית, מבנית
 תאריך השקה:  1970 
 מתכנן:  ניקלאוס וירת 
 מפתח:  ניקלאוס וירת
 גרסה אחרונה:  ‏ (1992)
 טיפוסיות:  סטטית, חזקה, בטוחה
 מימושים:  טורבו פסקל, דלפי, Gnu, Dev, FreePascal
 ניבים:  UCSD, Borland, Turbo
 הושפעה על ידי:  ALGOL
 השפיעה על:  Modula, Oberon, Object Pascal, Ada, Java, ויז'ואל בייסיק
 סיומת:  pp, p, pas 
 
פסקל (באנגלית: Pascal) היא שפת תכנות עילית, שפותחה בשנת 1970 על ידי ניקלאוס וירת, וקרויה על שמו של המתמטיקאי והפילוסוף בן המאה ה-17 בלז פסקל.
השפה תוכננה במטרה להקל על לימוד שפות תכנות ומדעי המחשב, ושימשה לפיתוח תוכנה ואף כשפה הסטנדרטית לתיאור אלגוריתמים עד אמצע שנות התשעים. תכנון השפה הושפע בעיקר משפת ALGOL, כמו שפות רבות אחרות. השפה מאפשרת תכנות מבני, תוך שימוש בשגרות, פונקציות ויצירת מבני נתונים מורכבים.
בגרסתה המקורית היו בשפה כשלים תכנוניים רבים, אך לא מעטים מהם שופרו עם הזמן בתקינה, ואחרים שופצו על ידי מפתחי המהדרים. פסקל השפיעה רבות על עולם התוכנה ועל שפות שהופיעו אחריה, כגון עדה, Java, Visual Basic ועוד.
היסטוריה

אף שבבסיסה השפה פרוצדורלית עם כל היכולות הידועות וכוללת בקרת זרימה, מבני נתונים, קבוצות ומצביעים, כבר בתחילת שנות ה־90 של המאה ה־20 היא הורחבה והוגמשה בתקן נוסף שהרחיב אותה בהרבה היבטים, כך שישנם שני תקנים לפסקל, תקן בסיסי ותקן מורחב.
שפת פסקל תוכננה במקור כדי שהיא תהווה מקור למידה לתחביר, לתכנות, פיתוח חשיבה וכבסיס ללימוד שפות אחרות - היות שהיא שפה בסיסית וקלה ללימוד. כך למשל שפה זו היוותה מקור השראה למתכננים של שפת ויזואל בייסיק, ותפיסות שהיו קיימות בה הועתקו לשפה זו.
בשל תפיסותיה ובהירות קוד המקור שלה, היא שימשה שפה לימודית באוניברסיטאות פרק זמן לא מבוטל. משרד החינוך הישראלי השתמש בשפת פסקל לבחינות הבגרות וללימוד בכיתות, במקביל לשפת C, עד שנת 2006. ההתאמה שלה ללמידה סייעה לה להפוך לשפה משפיעה, בשל העובדה שבוגרי תיכונים רבים בשנות השבעים, השמונים והתשעים של המאה ה-20 היו בעלי ידע בשפה זו.
בפועל השפה הייתה חזקה יותר מהשפה המתוקננת, הואיל והחברות שפיתחו סביבות פיתוח לשפה זו הרחיבו אותה ויצרו שפה גמישה וחזקה יותר, אך יכולות אלה גרמו לתלות במהדר הספציפי עבורו הן נכתבו. בין החברות שפיתחו מהדרים לשפה זו הייתה מיקרוסופט (עם Microsoft Pascal), אך הפופולרית שבהן הייתה חברת בורלנד שפיתחה בסביבת DOS סביבת פיתוח ומהדר בשם טורבו פסקל. בגרסה 5.5 היא הורחבה לתכנות מונחה עצמים ובגרסתה השביעית הוציאה גם סביבת פיתוח לחלונות 16 ביט בשם BPW. גרסה זו לא זכתה לפופולריות ועם עליית התפוצה של מערכת ההפעלה חלונות, טורבו פסקל ירד ממעמדו, ולמעשה הוחלף בסביבת הפיתוח הוויזואלית דלפי, שמשתמשת בפסקל כשפת הקוד הפנימית שלה. קיימות מספר סביבת פיתוח חופשיות לפסקל, אחת מהידועות בהן היא סביבה רב פלטפורמית של הקוד הפתוח בשם FreePascal.
מבנה התוכנית

לשפת פסקל צורה תחבירית מוגדרת היטב. כל תוכנית תכלול את המקטעים הבאים. ייתכנו מקטעים ריקים (אחד או יותר), מלבד גוף התוכנית שחייב להופיע.
שם התוכנית: המילה השמורה Program ולאחריה שם התוכנית.
ספריות חיצוניות: המילה השמורה Uses ולאחריה רשימת הספריות החיצוניות שהתוכנית עושה בהם שימוש. לדוגמה: גרפיקה, קריאות למערכת ההפעלה וכולי.
תוויות קפיצה: באמצעות המילה השמורה Label.
קבועים גלובליים: באמצעות המילה השמורה Const.
טיפוסי נתונים באמצעות המילה השמורה Type.
משתנים גלובליים באמצעות המילה השמורה Var.
פונקציות ושגרות (פרוצדורות) גלובליות באמצעות המילות השמורות Function ו- Procedure. (בשפות התכנות של היום אין הבחנה בין פונקציה לפרוצדורה, ההבדל ביניהן בפסקל הוא שפונקציה מחזירה ערך בעוד פרוצדורה לא מחזירה ערך)
גוף התוכנית המתחיל במילה השמורה Begin ומסתיים במילה השמורה End ולאחר מכן נקודה (".").
השפה אינה מבחינה בין אותיות קטנות וגדולות. לדוגמה, הפקודות: write, Write ו- wrITE הן זהות לחלוטין מבחינת השפה.
מבנה התוכנית > התוכנית "שלום עולם"

Program Hello_World;
Begin
 Writeln ('Hello World!');
End.
קוד זה יגרום להצגת "!Hello World" על המסך ולירידת הסמן לשורה הבאה.
פקודות בסיסיות

כל בלוק בשפה מתחיל במילה השמורה Begin ויסתיים במילה השמורה End ולאחריה נקודה. הפקודות בשפה מופרדות ביניהן בעזרת נקודה פסיק (כמו שפות רבות אחרות שהושפעו משפת Algol). בשל ההגדרה של הפקודות ב"מופרדות בנקודה פסיק" ולא "מסתיימות בנקודה פסיק", הוספה של נקודה פסיק לאחר הפקודה האחרונה תגרום לשגיאת הידור; מאפיין זה גרר ביקורת רבה. בסופה של התוכנית יש להוסיף תו נקודה במקום נקודה ופסיק. מחרוזת תוקף בגרש (') יחיד בלבד ולא בגרשיים (") כפי שמקובל בשפות תכנות אחרות. הערה תוקף בתווים (* בתחילתה והתווים *) בסופה.
פקודות בסיסיות > הגדרות והכרזות > קבוע

כדי להכריז על קטע זיכרון שתוכנו נשאר קבוע במהלך כל התוכנית, יש להשתמש במילה השמורה Const. לדוגמה:
Const
 Example1 : Boolean = False;
 Example2 : Array [3 .. 5] of Char = ('F', 'o', 'o');
פקודות בסיסיות > הגדרות והכרזות > משתנה

מערכת הטיפוסים של השפה היא בעלת טיפוסיות סטטית ובטוחה יחסית, כך שלא ניתן להמיר בין טיפוסי נתונים מובחנים. מאפיין זה סייע להקל על לימוד השפה, אך גרר ביקורת בשל הקושי הרב לבצע פעולות שבשפות אחרות (כגון שפת C) הן קלות לביצוע.
בפסקל ישנם כמה טיפוסי משתנים:
מספרים שלמים בגדלים שונים:
כל המספרים: ShortInt, Integer, LongInt. החל מגרסה 7 של טורבו פסקל נוסף Int64 (עבור כל מספר שלם, שערכו המוחלט אינו גדול מהחסם: 2 בחזקת 63, אם המספר שלילי; בעוד שאם המספר חיובי יש להפחית אחד מהחסם).
טווח המספרים החיוביים בלבד: Byte, Word.
מספר ממשיים בגדלים שונים: Comp ,Extended ,Double ,Single ,Real.
משתנה מסוג תו היכול להכיל תו ASCII יחיד: Char.
מחרוזת: String. המחרוזת יכולה להכיל רצף של תווים אלפא־נומריים באורך משתנה עד 255 תווים. עם זאת, ניתן להקטין ולהגביל את אורכה באופן הבא:
Type StringNine = String [9];
החל מגרסה 7 של טורבו פסקל נוספה מחרוזת NullTerminated שגודלה 65,535 תווים.
בוליאני: Boolean - משתנה היכול להכיל שני ערכים בלבד - "True" ו־"False" (בשונה מהמקובל בשפות אחרות כגון שפת C לא ניתן להגדיר למשתנה בוליאני ערכים באמצעות 0 ו־1).
ההכרזה על משתנה תתבצע באמצעות המילה השמורה Var לפני גוף התוכנית. ניתן לבצע הכרזה והשמת ערך בפקודה אחת, אך יש מהדרים שאינם תומכים באפשרות זו:
Var i : Integer = 0;
פקודות בסיסיות > הגדרות והכרזות > מערך

בפסקל ניתן ליצור מערכים מטיפוסי נתונים שונים כגון מספרים, מחרוזות, מצביעים ואף מבנה רשומות. כדי להכריז על מערך יש לציין את שמו, מספר איבריו וסוג הטיפוס של המערך, למשל, באופן הבא:
Var myArray : Array [0..261] of Char;
ניתן להגדיר טווח של איברי מערך לא רק באמצעות מספרים אלא אף באמצעות תווים. בדוגמה הבאה ייווצר מערך שגודלו יהיה בדיוק מספר האותיות שבא'-ב' הלועזי.
Var aLetters: Array ['A'..'Z'] of Char;
באמצעות התו פסיק ניתן ליצור מערכים רבי ממדים בסוגריים המרובעים שבהם אנו מגדירים את מספר האיברים. בדוגמה הבאה ניתן לראות מערך תלת־ממדי המייצג למעשה קובייה.
Var myArray : Array [0..10, 0..10, 0..10] of Char;
לפני השימוש במערך יש לאפס את המערך כדי לנקות אותו ממידע אקראי. כדי לגשת למידע במערך יש להשתמש בסוגריים מרובעים לאחר שם המערך, בהם אינדקס המיוצג על ידי מספר, אות או משתנה.
פקודות בסיסיות > הגדרות והכרזות > משתנה מורכב - רשומה

משתנה מסוג "רשומה" הוא משתנה שמוגדר על ידי המתכנת וכולל צירוף של מספר טיפוסי משתנים ביחד. הוא יכול להכיל בתוכו משתנים רגילים, מערכים ומצביעים. שימושים נפוצים הם במבנה ערכים טבלאי וברשימות מקושרות. הגדרת רשומה נעשית באמצעות המילים השמורות Record ו־End, בתוך קטע הקוד של Var. לדוגמה:
Var
 tW32FindData = Record
 iFileAttributes : LongInt;
 iCreationTime : Array [0..1] of LongInt;
 cFileName : Array [0..261] of Char;
 End;
ניתן ליצור מבנה של רשומה דינמית, שבה תתבצע הגדרה דינמית של המשתנים בזמן ריצה, כאשר המשתנים שברשומה ישתנו בהתאם לערכי שדה או שדות אחרים. הדבר נעשה באמצעות פקודת Case, בדומה לפקודת Case רגילה, יוכרזו משתנים שונים בכל תנאי, וכך מבנה השדות ישתנה מרשומה לרשומה, לפי הערכים שבפועל קיימים בהם.
ניתן להשתמש במילה With על מנת לקצר את הגישה במשתנה רשומה ולוותר על הקידומת של שם משתנה הרשומה, כך לאחר פקודת With אפשר לגשת ישירות למשתני הרשומה.
פקודות בסיסיות > הגדרות והכרזות > קבוצות

ניתן ליצור בפסקל אוסף של פריטים מכל סוג שהוא בתוך משתנה יחיד מסוג Set. מספר הפריטים המרבי הוא 256. ניתן לבצע פעולות שונות על קבוצות, כמו למשל בדיקה האם קבוצה מכילה או מוכלת בקבוצה אחרת, איחוד, חיסור וחיתוך בין הקבוצות. דוגמה להגדרת קבוצה:
Var
 TheSet : SET OF BaseType
 TheSet := [Element1, Element2, ... ElementN];
פקודות בסיסיות > הגדרות והכרזות > שגרה

שגרה (פרוצדורה) היא קטע ביצועי שאינו מחזיר ערך. שגרה מוגדרת באמצעות כותרת שבה המילה השמורה Procedure, שם השגרה, שמות וסוג הפרמטרים שהיא מקבלת. לאחר מכן ניתן להגדיר קבועים ומשתנים מקומיים. גוף השגרה תחום באמצעות המילים Begin ו־End. לדוגמה:
Procedure PrintManyTimes (t : integer; s : string);
 Var
 i : Integer;
 Begin
 For i := 1 To t Do
 Writeln (s);
 End;
שגרה זו מקבלת מספר (t) ומחרוזת (s). השגרה מדפיסה t פעמים את המחרוזת s.
פקודות בסיסיות > הגדרות והכרזות > פונקציה

פונקציה מוגדרת באמצעות כותרת שבה המילה השמורה Function, שם הפונקציה, שמות וסוג הפרמטרים שהיא מקבלת, וסוג תוכן שהיא מחזירה. בדומה לשגרה, לאחר מכן ניתן להגדיר קבועים ומשתנים מקומיים. גוף השגרה תחום באמצעות המילים Begin ו־End. עם זאת במהלך התוכנית יש לבצע השמת ערך לשמה של הפונקציה, פעולה שתגרום לפונקציה להחזיר ערך. לדוגמה:
Function Get_NumberCard (Num : Integer) : Integer;
 Var
 St1 : String;
 Number, Code : Integer;
 Begin
 St1 := Card_GetIdent(C, Num);
 St1 := Str_Get(St1, 2, '-');
 Val(St1, Number, Code);
 Get_NumberCard := Number;
 End;
פונקציה זו מקבלת מספר, קוראת בעצמה לפונקציות אחרות (שלא הוגדרו כאן) מהן היא מקבלת מידע, ולבסוף מחזירה מספר.
פקודות בסיסיות > כתיבה וקריאה

בפסקל, קלט ופלט אינטראקטיבי (למשתמש וממנו) מבוצע באמצעות השגרות Read ו־Write. קיימות גם השגרות ReadLn ו־WriteLn, המבצעות ירידת שורה לאחר ביצוע פעולת הכתיבה או הקריאה.
Read: קליטה של ערך. זוהי פקודה המורה למשתמש להזין ערך. הערך שיתקבל יושם לתוך המשתנה הנמצא בסוגריים.
Write: הדפסה של ערך ומידע. את המידע המודפס יש להכניס לסוגריים, כאשר המידע מופרד באמצעות פסיק ותחום בגרש יחיד. לדוגמה, אם בקוד הבא המשתנה iNum הוא המספר 8, אזי יודפס: "The Value of iNum is 8".
Write('The value of iNum is ', iNum);
פקודות בסיסיות > השמה

השמה נעשית באמצעות נקודתיים וסימן שווה ("=:"). כך לדוגמה, X := A + 5 הוא חיבור המשתנה A והמספר 5 והשמת התוצאה במשתנה X.
מבני בקרה > תנאי If...Then...Else

מבנה If...Then...Else מאפשר לבצע פקודות באופן בררני באמצעות התניה ולבצע הסתעפות של התוכנה לכיוונים שונים. אם התנאי לא התקבל ניתן לבצע פקודה חלופית באמצעות Else. ניתן לכתוב תנאי If מקוננים.
If Variable > Value Then
 Statement1
Else
 Statement2;
אין למקם את סימן הנקודה פסיק לאחר המילה Then או לפני ה-Else. ניתן להשתמש ב-Begin ו-End לשם ביצוע מספר פקודות מותנות (פקודה מורכבת).
מבני בקרה > תנאי Case...End

תנאי Case...End מאפשר ליצור תנאי מרובה על ערכים מטיפוס נתונים סדור מסוג מספרי או Char. היא יכולה לפעול על טווחי ערכים ואף טווחי משנה. בטורבו פסקל נוספה פקודת Else שאינה קיימת בשפה התקנית.
Case Variable of
 Value1: Statment1;
 Value2: Statment2
 Else Statment3;
End;
מבני בקרה > לולאות > לולאת For...Do

לולאת...For היא פקודה מחזורית המורה לבצע קטע קוד מספר פעמים קבוע מראש. בתחילת הפעלתה יש לקבוע את מספר הפעמים שהיא תתבצע. לדוגמה: For i := 1 To 7 Do. במקרה זה i הוא המשתנה המונה, והמניה תתבצע מ־1 עד ל־7. כברירת מחדל, פסקל תחזור רק על הפקודה שמיד לאחר הוראת הלולאה, בדומה לתנאי If. כדי לכלול מספר פקודות יש להשתמש במילים Begin ו־End.
For i := 1 to 10 Do
 Statement1;
מבני בקרה > לולאות > לולאת While...Do

לולאה זו היא פקודה המבצעת את קטע קוד כל עוד תנאי כלשהו מתקיים. היא נחשבת לגמישה יותר מכיוון שהיא יכולה לבחון תנאים שבזמן כתיבת התוכנית אינם ברורים כגון גודל של קובץ.
While Variable > Value Do
 Statement1;
מבני בקרה > לולאות > לולאת Repeat...Until

לולאה זו אף היא מתקיימת על פי תנאי. היא דומה ללולאת While...Do וההבדל העיקרי הוא שהתנאי מוערך רק לאחר ביצוע הקוד, ולכן תמיד יתבצע הקוד לפחות פעם אחת. הבדל נוסף הוא שלולאת While ממשיכה לרוץ כל עוד התנאי המוערך מתקיים (כלומר מקבל ערך "TRUE") ואילו לולאת Repeat ממשיכה לרוץ כל עוד התנאי המוערך לא מתקיים (כלומר מקבל ערך "False").
Repeat
 Statement1;
Until Variable > Value;
אופרטרים

אופרטורים אריתמטיים: חיבור (+), חיסור (-), כפל (*) וחילוק (/) פועלים באופן המקובל. אופרטור Div מחזיר את החלק השלם לאחר חילוק. אופרטור Mod מחזיר את השארית לאחר חילוק.
אופרטורים בוליאניים: או (Or), וגם (And), לא (Not), שווה ל- (=), שונה מ- (<>), גדול מ- (<), קטן מ- (>), גדול או שווה ל- (=<) וקטן או שווה ל- (=>).
אופרטורי קבוצות: מכיל את (=<), מוכל ב- (=>), שייך אל (in).
מצביעים והקצאה דינמית

פסקל תומכת בשימוש במצביעים ובהקצאת זיכרון דינמית. כדי ליצור ולהשתמש במצביעים יש להשתמש באופרטור ^. יצירת מצביע נעשית באמצעות שימוש באופרטור ^ בצידו השמאלי של המשתנה המוצבע, ואילו ביצוע פעולת השמה נעשית באמצעות שימוש באופרטור ^ בצידו הימני של המשתנה המצביע.
לדוגמה, כדי להגדיר מבנה ששמו MyRecord ובו שלושה משתנים, כאשר המשתנה RecPtr מצביע אליו, והוא גם משולב כאחד מאיבריו (ליישום של רשימה מקושרת), נכתוב את הקוד הבא:
Type
 String20 = String[20];
 RecPtr = ^MyRecord;
 MyRecord = Record
 Name: String20;
 Age: integer;
 Next: RecPtr
 End;
כדי להכריז על משתנה pb, מצביע מסוג MyRecord, יש לכתוב את הקוד הבא:
Var
 pb: RecPtr
יצירה של רשומה חדשה וביצוע השמה של שם, גיל ומצביע, כך שהמצביע יצביע לכלום, יש לכתוב את הפקודות הבאות:
New(pb);
pb^.Name := 'Eli Gold';
pb^.Age := 18;
pb^.Next := Nil;
עבודה עם קבצים

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

לפי תקן ISO הבסיסי בפסקל קיימות 35 מילים שמורות, לצורך שימושים מיוחדים של השפה כגון מזהים, אופרטורים, קבועים ופקודות תכנותיות. לא ניתן לכנות משתנים בשמות אלה. בתקן המורחב נוספו עוד 13 מילים נוספות.
מילים שמורות לפי מסמך 7185
and | array | begin | case | const | div |do | downto | else | end | file | for | function | goto | if | in | label | mod | nil | not | of | or | packed | procedure | program | record | repeat | set | then
| to | type | until | var | while | with.
תוספת של מילים שמורות לפי מסמך 10206
and then | bindable | export | import | module | only | or else | otherwise | pow | protected | qualifed | restricted | value |
בטורבו פסקל נוספו עוד מילים שמורות, בהן: Unit ו-Uses להגדרת שימוש ביחידות חיצוניות, XOR, InLine ו-Object ו-assign לייבוא, ייצוא וטיפול בקבצים שאינם pascal units
הרחבות לפסקל

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

Delphi
Kylix
Turbo Pascal 7
FreePascal
Virtual Pascal
Dev-Pascal
PalmOS Pascal Compiler
UltraPascal
TMT Pascal
GNU Pascal
HP Pascal Studio
PowerPascal
MPW Pascal
Pascal Pro Compiler
ראו גם

דלפי
טורבו פסקל
Lazarus
לקריאה נוספת

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

↑  Bill Catambay, ‏The Pascal Programming Language, באתר Pascal-Central, ‏9 במאי 2001
↑  Michael Lee Scott, ‏Programming language pragmatics, ‏Morgan Kaufmann,‏ 2000, עמוד 33, ISBN 1558604421
↑  Judith Mary Bishop, ‏Turbo Pascal precisely, ‏Addison-Wesley,‏ 1992, עמוד 54, ISBN 0201544490
| --- | --- |
בקרת זהויות :  NLI: 987007529588505171  BnF: cb11941547z (data)  LCCN: sh85098423  NKC: ph117098 
השפה פותחה בשנת 1970 על ידי ניקלאוס וירת, וקרויה על שמו של המתמטיקאי והפילוסוף בן המאה ה-17 בלז פסקל.
ג'יליאן קוקס

ג'יליאן קוקס (באנגלית: Jillian Cox; נולדה ב-18 ביולי 2005) היא שחיינית אמריקאית, אלופת עולם בבריכת 25 מטר (בודפשט 2024) במשחה שליחות 4x100 מטר חופשי וזוכת מדליית ארד באליפות עולם בבריכת 25 מטר (מלבורן 2022) במשחה שליחות 4x200 מטר חופשי.
ביוגרפיה

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

באליפות העולם בבריכת 25 מטר שנערכה במלבורן שבאוסטרליה בדצמבר זכתה במדליית ארד במשחה שליחות 4x200 מטר חופשי, לאחר ששחתה בשלב המוקדמות של המשחה. בנוסף, סיימה במקום שישי במשחה ל-800 מטר חופשי בתוצאה של 8:20.95 דקות, ובמקום שמיני במשחה ל-1500 מטר חופשי בתוצאה של 16:09.72 דקות.
ביוגרפיה > 2023

באליפות העולם שנערכה בפוקואוקה שביפן ביולי-אוגוסט סיימה במקום שישי במשחה ל-800 מטר חופשי בתוצאה של 8:19.73 דקות.
ביוגרפיה > 2024 > אלופת עולם בבריכת 25 מטר

באליפות העולם בבריכת 25 מטר שנערכה בבודפשט שבהונגריה בדצמבר זכתה במדליית זהב במשחה שליחות 4x100 מטר חופשי, לאחר ששחתה בשלב המוקדמות של המשחה.
שיאים אישיים > בריכה אולימפית

200 מטר חופשי: 1:58.47 דקות (2024)
400 מטר חופשי: 4:06.31 דקות (2024)
800 מטר חופשי: 8:19.73 דקות (2023)
1500 מטר חופשי: 16:07.29 דקות (2024)
שיאים אישיים > בריכת 25 מטר

200 מטר חופשי: 1:58.98 דקות (2022)
400 מטר חופשי: 4:05.50 דקות (2022)
800 מטר חופשי: 8:20.95 דקות (2022)
1500 מטר חופשי: 16:09.72 דקות (2022)
מטריצת פיזור

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

פיזור פיזיקלי הוא תופעה בה מספר חלקיקים מתחילים במצב בו הם רחוקים אחד מהשני, והאינטראקציה ביניהן חלשה ולא משמעותית, בתהליך הפיזור החלקיקים מתקרבים אחד לשני כך שהאינטראקציה בין החלקיקים משמעותית ומשפיעה על המערכת, ובסוף התהליך החלקיקים מתרחקים שוב אחד מהשני והאינטראקציה ביניהם שוב זניחה. בפרשנות הסטנדרטית של תורת הקוונטים, בהינתן מצב ראשוני מסוים, יכולים להתקבל אינספור מצבים סופיים שונים, ותורת הקוונטים מנבאת את הסיכוי לקבלת מצב סופי מסוים, הסיכוי הזה מבוטא באמצעות מטריצת הפיזור. את הסיכוי הזה שמוגדר בין מצבים קוונטיים ניתן להמיר לסיכוי של שני חלקיקים שנעו אחד לעבר השני לפני הפיזור לנוע בזווית מסוימת ביחס לכיוון תנועתם הראשונית לאחריו. סיכוי זה נקרא חתך הפעולה הדיפרנציאלי והוא התוצאה הבסיסית הנמדדת בניסויי פיזור בפיזיקת חלקיקים. אינטראקציות מסובכות יותר בין החלקיקים יכולות לגרום לכך שהחלקיקים לאחר הפיזור שונים מהחלקיקים לפני הפיזור - לדוגמה אלקטרון ופוזיטרון יכולים להיות המצב הראשוני, וכתוצאה מהאינטראקציה ביניהם המצב הסופי יכול לכלול שני פוטונים.
ניסויים רבים בפיזיקת חלקיקים הם ניסויי פיזור. לדוגמה, ניסוי רתרפורד שבוצע ב-1909 הוא ניסוי היסטרי חשוב שהוביל לגילוי מבנה האטום. בניסוי נורים חלקיקי אלפא לעבר אטומי זהב כאשר חלק מהחלקיקים יוצרים אינטראקציה עם גרעין האטום ומפוזרים כתוצאה מהאינטראקציה הזו. ניתן לחשוב על הניסוי כניסוי פיזור בו החלקיקים המשתתפים הם חלקיק אלפא וגרעין זהב.
עם פיתוחה של תורת הקוונטים בעשורים השני והשלישי של המאה ה-20, נוצר צורך בכלי חישובי שיאפשר מעבר מהתיאוריה הפיזיקלית הבסיסית לניבוי של תוצאת ניסוי שיאפשר לבחון את התיאוריה. חישובים של ניבויים כאלו בוצעו עבור ניסויי פיזור מסוימים באופן פרטני בהתאם לתיאוריה המוצגת. לדוגמה, משוואת דיראק שמהווה תיאוריה קוונטית לתיאור האלקטרון הוצגה ב-1928 כאשר בעת הצגתה דיראק התמקד בהשפעתה על רמות האנרגיה של אטום המימן. אפקט קומפטון הוא ניסוי בו פוטונים מפוזרים מאלקטרונים הנמצאים במטרה העשויה ממתכת. כבר ב-1922 הסביר קומפטון את הקשר בין זווית הפיזור לאנרגיה של האלקטרון המתפזר. עם זאת, הסיכוי להתפזרות בזווית מסוימת לא ניתן על-ידי קומפטון; כדי לחשב את הסיכוי הזה, יש צורך בשימוש בתיאוריה קוונטית של האלקטרון שהיא משוואת דיראק. את החישוב של הסיכוי הזה ביצעו קליין ונישינה לאחר גילוי משוואת דיראק, והסיכוי הזה נתון על-ידי נוסחת קליין-נישינה. החישוב הזה היה אפשרי בגלל שהפיזור הוא הליך פיזור פשוט יחסית, בו החלקיקים הראשוניים והסופיים הם אותם חלקיקים והם חלקיקים יסודיים. ניסויי פיזור מורכבים יותר, כמו פיזור של חלקיקי אלפא מאטומים קלים יחסית נותרו בעיה קשה מאוד לחישוב.
ב-1937 ג'ון וילר עבד על חישובים של ניסויי פיזור כאלה. במאמר שלו וילר התייחס למטריצת פיזור, שהיא מטריצה אוניטרית שערכיה מייצגים את הקשר בין מצבים ראשוניים למצבים סופיים. וילר גם חישב את הקשר בין איברי המטריצה לחתך הפעולה הדיפרנציאלי. ניסוח זה של מטריצת הפיזור דומה לאופן בו משתמשים במטריצה היום, ווילר נחשב למגלה התחום. בשנות ה-40, עם התחלת פיתוחה של תורת השדות הקוונטיים, ובעיות האינסופיים בתיאוריה ניסה ורנר הייזנברג להרחיב את תורת מטריצות הפיזור ולכתוב את כל תורת הקוונטים כנובעת ממטריצות הפיזור.
היום, מטריצות הפיזור מתוארות כתוצאה של חישובים בתורת השדות הקוונטים, וחישובים רבים נעשים באמצען. ישנו תהליך ברור לחישובם של מטריצות הפיזור מהלגרנז'יאן שמתאר את האינטראקציה בין החלקיקים ובאמצעות דיאגרמות פיינמן ניתן לקבל תוצאות מדויקות יותר ויותר.
פיתוח מתמטי בתורת שדות קוונטים > תמונת האינטראקציה

השלב הראשון בפיתוח מטריצת הפיזור הוא לפרק את ההמילטוניאן של המערכת לשני חלקים. חלק אחד המתאר את החלקיקים החופשיים וחלק אחר המתאר את האינטראקציה ביניהם. מבחינה מתמטית, נוח לבצע את הפירוק הזה באמצעות תמונת האינטראקציה, בתיאור זה מפרקים את ההמילטוניאן לשני החלקים הנפרדים {\hat {H}}={\hat {H}}_{0}+{\hat {V}} ומתקיים:
גם אופרטורים וגם פונקציות הגל תלויות בזמן
אופרטורים מתפתחים בזמן בהתאם לאיבר החופשי  {\hat {O}}_{I}=e^{i{\hat {H}}_{0}t}{\hat {O}}e^{-i{\hat {H}}_{0}t}
פונקציית הגל מתפתחת בזמן בהתאם לאיבר האינטראקציה  i{\frac {d}{dt}}|\psi _{I}(t)\rangle ={\hat {V}}_{I}|\psi (t)\rangle =e^{i{\hat {H}}_{0}t}{\hat {V}}e^{-i{\hat {H}}_{0}t}|\psi _{I}(t)\rangle
פיתוח מתמטי בתורת שדות קוונטים > תמונת האינטראקציה > פיזור בתמונת האינטראקציה

במקרה של מטריצת הפיזור החלקיקים הראשוניים הם בזמן מינוס אינסוף, ואילו המצבים הסופיים הם בזמן פלוס אינסוף. אלו ואלו מהווים מצבים עצמאיים של ההמילטוניאן החופשי  H_{0} ולכן יכולים להיות מוצגים כאופרטורי שדה המופעלים על הואקום החופשי. כלומר בזמן מינוס אינסוף עבור כל חלקיק בעל תנע מוגדר ניתן לכתוב:  \vert \mathbf {p} ^{\text{in}}\rangle =a_{\mathbf {p} }^{\dagger }\vert 0\rangle  ו- {\hat {H}}_{0}\vert \mathbf {p} ^{\text{in}}\rangle =E_{0}(\mathbf {p} )\vert \mathbf {p} ^{\text{in}}\rangle  ובזמן אינסוף אפשר לכתוב בדומה  \langle \mathbf {q} ^{\text{out}}\vert =\langle 0\vert a_{\mathbf {q} }. כדי לחשב את מטריצת המעבר יש לקדם בזמן את המצבים כלומר מטריצת המעבר היא לא  \langle \phi ^{\text{out}}\vert \psi ^{\text{in}}\rangle  אלא  \langle \phi ^{\text{out}}\vert {\hat {U}}(\infty ,-\infty )\vert \psi ^{\text{in}}\rangle  כאשר  {\hat {U}} הוא אופרטור הקידום בזמן.
פיתוח מתמטי בתורת שדות קוונטים > פיתוח דייסון

אופרטור הקידום בזמן בתמונת האינטראקציה מקיים את המשוואה:
i{\frac {d}{dt_{2}}}{\hat {U}}_{I}(t_{2},t_{1})={\hat {H}}_{I}(t_{2}){\hat {U}}_{I}(t_{2},t_{1})
עם תנאי השפה  {\hat {U}}(t_{1},t_{1})=I. מגדירים את הסידור בזמן  T המוגדר כך ש-  T[{\hat {A}}(t_{1}){\hat {B}}(t_{2})]={\hat {A}}(t_{1}){\hat {B}}(t_{2}) אם  t_{1}>t_{2} ו- T[{\hat {A}}(t_{1}){\hat {B}}(t_{2})]={\hat {B}}(t_{2}){\hat {A}}(t_{1}) אם  t_{2}>t_{1}. באופן דומה ניתן לסדר בזמן מכפלה של יותר משני אופרטורים כך שהם יהיה מסודרים מהמוקדם ביותר בצד ימין למאוחר ביותר בשמאל. לאחר הגדרה זו ניתן לכתוב  {\hat {U}}_{I}(t_{2},t_{1})=T\left[\exp \left(-i\int _{t_{1}}^{t_{2}}dt'H_{I}(t')\right)\right]. ביטוי זה ידוע כפיתוח דייסון, על שמו של פרימן דייסון. אופרטור הפיזור הוא קידום בזמן ממינוס אינסוף לאינסוף כלומר:  {\hat {S}}=T\left[\exp \left(-i\int _{-\infty }^{\infty }dt'H_{I}(t')\right)\right]=T\left[\exp \left(-i\int d^{4}z{\mathcal {H}}_{I}(z)\right)\right]=T\left[1-i\int d^{4}z{\mathcal {H}}_{I}(z)-{\frac {1}{2}}\int d^{4}zd^{4}w{\mathcal {H}}_{I}(z){\mathcal {H}}_{I}(w)+...\right]כאשר  {\mathcal {H}}_{I} היא צפיפות ההמילטוניאן. כאשר איבר האינטראקציה קטן ביחס להמילטוניאן החופשי הסדרים הבאים פחות חשובים וניתן לבצע פיתוח של סדר אחרי סדר של הביטוי כדי לקבל את מטריצת הפיזור.