שלום לכולם.

לפני שאפרוש בפניכם את הבעיה, ראוי לציין שאני מתכנת יחסית מתחיל ב- #C ובכלל בסביבת Windows.

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

הבנתי ממקורות שונים ש- #C מאפשר שימוש ברדיאנים בלבד ולא במעלות, ולכן הייתי צריך לבצע פעולת המרה.

התוצאות היו לא כמצופה, ולכן החלטתי לבדוק את שיטת החישוב של #C באמצעות קוד פשוט:

Math.Cos(270 * Math.PI / 180) 0

(התעלמו מה- 0 בהתחלה)

התוצאה של הביטוי אמורה להיות 0 בדיוק, אך התוצאה המתקבלת היא 0.0000000001836- ...

מה הסיבה לכך?

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

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

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

אגב, תנסה גם להחליף את סדר הפעולות (קודם כל תחלק ב-180 ואח"כ תכפיל בפאי), אולי זה גם ישפר קצת את רמת הדיוק.

תודה רבה על התגובה!

אני חייב לומר לך משהו:

לא מקובל עליי השימוש שלך בביטוי "שיפור תוצאה". התוצאה שאני אמור לקבל היא חד משמעית. בטריגונומטריה הקוסינוס של 270 מעלות הוא 0 מדויק. אני לא אמור למצוא דרכים לשפר את התוצאה, כי יש תוצאה אחת בלבד לביטוי הזה. גם כשאני עושה במחשבון מדעי פשוט את ההמרה לרדיאנים, התשובה היא 0 מדויק. אם אתה אומר לי שאין פתרון אחר חוץ משיפור או עיגול, אז #C היא שפה על הפנים (וזה כמובן לא הגיוני).

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

רעיונות חדשים אולי?

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

זה לא קשור לשפה, זה קשור למחשב, תמיד יהיה שגיאה יחסית.

\עריכה

שכחתי לכתוב, אין לי מושג ב-C#, אני בעיקר עובד ב-++C, C, אבל אני מניח שזה אותו דבר, לא יזיק לבצע את החישובים על משתנים יותר "טובים"... תבצע את החישוב בנפרד ואז תשלח אותו, ותבצע אותו ב-DOUBLE או המקבילה שלו ב-C#, ובכל מקרה, תצטרך לבצע חיתוך, כי אין הגיון למס' 0.00000000000000000000000000000000000000000000006 וזה עדיין יכול לשגע את המחשב, בעיקר בחלוקה או מכפלה.

^^ מחזק. שים לב שיתכן גם שהמחשבון שלך מבצע פעולות עיגול שהמחשב לא.

חוץ מזה, אם החלפת את סדר הפעולות ויצא לך 1- (שזה הקוסינוס של 180, לא 270) אז עשית משהו לא נכון (ניחוש שלי, עשית 270/180 במקום 270.0/180.0)

תגובה ל- yfital:

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

Console.WriteLine(270 * Math.PI / 180);

במקרה זה הורדתי את הקוסינוס, והפלט יוצא 4.712389 (בדיוק כפי שיוצא במחשבון מדעי). זה הערך של 270 ברדיאנים. כאשר נעשה קוסינוס לערך הזה, נקבל 0.

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

Console.WriteLine(Math.Cos(270 * Math.PI / 180));

התוצאה היא רחוקה מלהיות 0 כמובן.

לא התעסקתי כאן עם משתנים, אז היכן הבעיה בכל זאת?

תגובה ל- שניצל:

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

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

Console.WriteLine(Math.Cos(270.0 / 180.0 * Math.PI));

יכול להיות שצורת השימוש שלי ב- Math.Cos היא לא נכונה. אתה יכול להפנות אותי למקום (ב- #C עצמה) שבו ניתן לראות תחביר של פונקציות וכו'?

תודה לשניכם!

1. לתגובה אלי

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

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

השימוש נראה לי נכון, תבצע CASTING פנימי לכל פונקציה לDOUBLE.

ב-C פשוט רושמים (DOUBLE) לפני הפעולה יעני

Console.WriteLine (Math.Cos((DOUBLE)(270...)));

אני לא מבין למה אתה מתווכח.

ככה עובדים מחשבים.

מה לעשות, המחשב לא יכול לדייק במאה אחוז כשמדובר בחישובים של שברים.

חפש ב-msdn את Math.Cos, ותגלה שאתה משתמש בו בדיוק איך שאמורים להשתמש בו.

כפי שצויין מעלי,

תנסה להשתמש ב casting לפונקציה עצמה, אם אני לא טועה אתה צריך להשתמש ב float double.

וד"א, זה שאתה לא מכריז על משתנה לא אומר שאתה לא משתמש באחד, מזה פרמטר בדיוק? משתנה.

הפונקציה מקבלת פרמטרים (שאלו משתנים) ב TYPES מסוימים, INT STRING FLOAT OBJECT וכו'..

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

כאשר מדובר בחישובים יחסית מסובכים (מספיק להכניס לתוך השורה שעושה קוסינוס איזה חישוב), אז C# עלולה לעשות כל מיני המרות משלה לסוגי משתנים, ואז לעיתים ערכים מתעגלים לערכים שונים, ולכן עלולות להיווצר טעויות בחישוב. אז דבר ראשון הייתי ממליץ לך להכניס את החישוב הראשוני לתוך משתנה (אני חושב שdouble יהיה אידיאלי, תקנו אותי אם אני טועה), ורק לאחר מכן לעשות עליו את הmath.cos (ככה גם בזמן דיבאג תוכל לבדוק שהחישוב נכון, כאשר תראה את הערך של המשתנה שלך, לפני הcos).

חוץ מזה, הרצתי חיפוש קצר בגוגל, ועלו לי כמה תוצאות. אולי כדאי שתעיין בהן:

http://www.java2s.com/Code/CSharp/Language-Basics/ConvertingDegreestoRadians.htm

http://www.java2s.com/Code/CSharp/Language-Basics/ConvertingRadianstoDegrees.htm

אומנם כתוב java, אבל מדובר בדוגמאות קוד של C#.

אני לא בדקתי את הנכונות של הקוד, כי ת'כלס עבר לא מעט זמן מההתעסקות האחרונה שלי בנושאים האלה.

אגב, השורת חיפוש שלי בגוגל הייתה פשוטה: degrees to radians c sharp

נסה לחפש, אולי תמצא פתרון טוב יותר.

צודק, double יהיה יותר אידאלי פה, תוקן.

(משום מה הייתי בטוח שאין בכלל double ב c# והתבלבתי עם שפה אחרת.. כנראה שלא :)

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

תנסה את זה:

Console.WriteLine((double)Math.Cos((double)270.0 / 180.0 * Math.PI));

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

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

אין צורך בהמרה, כי ב-#C כל השברים הם double כברירת מחדל (וכמובן הפונקציות הסטנדרטיות שמטפלות בשברים מקבלות double ולא float).

השאלה היא האם ספריית ה-MATH נכתבה ב-C# NATIVE או הומרה מ-C,C++, כי אם כן, יכול להיות שזה יעשה קצת בלאגן.

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

אם זה לא פותר, אין לך ברירה ותאלץ לעגל

למה שזה יעשה בלאגן? גם ב-++C הפונקציות הטריגונומטריות עובדות עם double.