תוכנית לחישוב זמן על ידי מרחק ומהירות

in put

33 distance

speed 5

לפי החישוב שלי

33:5=6.6

6 שעות

אז החסרתי את השעות -6 והכפלתי ב 60 כדי לקבל את הדקות

שזה אמור להיות 0.6*60=36

פה הבעיה שלי הדפסתי את זה וזה באמת מגיע ל 36 אבל אחרי שאני מעבר את זה ל Int int minutes = (int)time; זה מדפיס 35

למה זה קורה??

static void tar3()
{
Console.WriteLine("enter the distance to ur destination");
double dis = double.Parse(Console.ReadLine());
Console.WriteLine("enter the velocity(speed)");
double speed = double.Parse(Console.ReadLine());
double time = dis / speed;
int hourse = (int)time;
Console.WriteLine("hourse:");
Console.WriteLine(hourse);
Console.WriteLine("minutes");
time = (time - (double)hourse)*60;
Console.WriteLine(time); //for testing int minutes = (int)time;
Console.WriteLine(minutes);
Console.WriteLine("sec");
time = (time - (double)minutes) * 60;
int sec = (int)time;
Console.WriteLine(sec);
}

ערוך בבקשה את הכותרת כך שתכיל את נושא הת'רד.

ולשאלתך: המחשב לא כזה טוב בחישובים שקשורים ל-doubleים - יש לו בעיות דיוק. לדוגמה, בקוד שלך time לא שווה ל-36 בדיוק, אלא ל-35.99999 בערך, ואז כשהוא מעוגל למטה זה יוצא 35. כשאתה מדפיס את time אז הוא יודע להתחשב בזה ומעגל אותו ל-36, אבל בחישובים הוא משתמש בערך המדויק שלו.

בשביל לדעת מה הערך המדויק שלו אתה יכול להשתמש בדיבאגר (שים breakpoint בשורה כלשהי בקוד אחרי שהערך הושם ב-time, ואז תצביע על המשתנה time עם העכבר - ה-visual studio יראה לך את הערך המדויק שלו).

אבל

0.6*60=36

לא 35.99999

מממ בדקתי בכמה מחשבונים

וזה אמור להיות מספר שלם

לא כל כך מבין למה זה מחזיר 35.99999

נכון, אבל המחשב לא יודע להחזיק את המספר 0.6 (אנחנו יודעים להציג אותו באמצעות נקודה עשרונית כי אנחנו סופרים בבסיס 10, אבל המחשב סופר בבסיס 2).

נניח לרגע שהמחשב עובד בבסיס 10 (כמונו) ואני אתן דוגמה שתהיה יותר ברורה. נסתכל על הקוד הבא:

double x = 1.0 / 3.0;
double y = x * 3.0;

אז הערך של x אמור להיות 1/3, והערך של y אמור להיות 1. אבל המחשב לא יודע לעשות חישובים עם שברים פשוטים. הוא יודע לעבוד רק עם נקודה עשרונית.

איך מייצגים שליש באמצעות שבר עשרוני? ...0.33333333333 (אינסוף פעמים 3). אבל המחשב לא יכול לייצג באמת אינסוף פעמים 3, אז הוא מציג את זה באמצעות מספר סופי של 3. אז נקבל משהו בסגנון x=0.333333333333 (מספר סופי כלשהו של 3). כשנחשב y=x*3 אז בעצם נקבל y=0.999999999999 במקום y=1!

יש כל מיני פונקציות שיודעות להתמודד עם שגיאות העיגול האלה - לדוגמה, Console.WriteLine יודעת לעגל כשצריך, ולכן אם נעשה (Console.WriteLine(y היא תדע להדפיס 1 ולא 0.999999999999. אבל אם נמיר את y ל-int נקבל 0, ולא 1, כי פונקצית ההמרה לא מתמודדת עם שגיאת העיגול.

עכשיו, בחזרה למקרה שלנו - המחשב, כאמור, לא עובד בבסיס 10 אלא בבסיס 2. זה אומר שהוא לא מסוגל לייצג שברים מסויימים כמו שאנחנו יכולים לייצג - ובין השברים האלה נמצא 0.6.

בכל מקרה, אני ממליץ לך לקרוא עוד על נקודה צפה בויקיפדיה (בעברית ובאנגלית).

"כי פונקצית ההמרה לא מתמודדת עם שגיאת העיגול."

כן זאת הבעיה עכשיו היה לי יותר קל לחפש פיתרון שאני יודע בדיוק איפה הבעיה

עזר לי תודה

זה הבעייה של ייצוג המספר על ידי הנקודה הצפה.

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

אם תקלוט את המספרים בתור int ולא בתור float אז תוכל לפתור את הבעיה בקלות.

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

אם הדיוק מפריע לך אז אפשר לקלוט מרחק במטרים במקום בקילומטרים וכדומה.

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

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

הא? איך בדיוק? חלוקה של מספרים שלמים מביאה תוצאה שהיא גם מספר שלם, כלומר תמיד מעוגל למטה. אם נשתמש במספרים שלמים נקבל 33/5=6.

נכון, ואז אתה עושה:

33 % 5 * 60 / 5
OR:
x % v * 60 / v; //when x is the distance and v is the velocity.

ומגלה כמה דקות זה לוקח, וכן הלאה.

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

בדיקה אם המספר זוגי או לא ולהתנהג בהתאם.

בהחלט אפשר ליצור טיפוס חדש.

משהו שיהיה דומה ל-int של פייתון - מספר שלם בגודל לא מוגבל + האינדקס של הנקודה העשרונית.

או הצעה חלופית: להחזיק מונה ומכנה (בשביל נקודה עשרונית המכנה פשוט יהיה חזקה של 10). ואז קל לממש את פעולות החשבון.

הכל פונקציה של דיוק אל מול יעילות.