Math.Floor () और Math के बीच अंतर। Truncate ()

Math.Floor() </के बीच क्या अंतर है ए> और Math.Truncate() .NET में?

0
जोड़ा संपादित
विचारों: 18
आपको 10 साल के बाद वास्तव में इसकी आवश्यकता है? जबरदस्त हंसी
जोड़ा लेखक L_Church, स्रोत
क्यों 10 साल बाद एक बक्षीस है? पहले से ही कई जवाब हैं। क्या मैं यहाँ कुछ याद कर रहा हूँ?
जोड़ा लेखक Puddle, स्रोत
जैसे गणित। फ्लोर (5.4) = 5 गणित। छंटनी (5.4) = 5
जोड़ा लेखक subramani, स्रोत

8 उत्तर

Math.Floor rounds down, Math.Ceiling rounds up, and Math.Truncate rounds towards zero. Thus, Math.Truncate is like Math.Floor for positive numbers, and like Math.Ceiling for negative numbers. Here's the reference.

For completeness, Math.Round rounds to the nearest integer. If the number is exactly midway between two integers, then it rounds towards the even one. Reference.

यह भी देखें: पैक्स डायब्लो का उत्तर । अत्यधिक सिफारिशित!

0
जोड़ा
गणित वर्ग में (int) बराबर क्या है?
जोड़ा लेखक Lei Yang, स्रोत
(int) myDouble (int) Math से अलग होता है। टंकण (myDouble) ?
जोड़ा लेखक mpen, स्रोत
@ क्रिस, मेरा सुझाव है कि आप राउंड के अपने विवरण को ठीक करें, गोल करने के दो तरीके हैं (AwayFromZero और ToEven) और यह निकटतम पूर्णांक तक नहीं जाता है क्योंकि यह भी fractional rounding कर सकता है।
जोड़ा लेखक paxdiablo, स्रोत
तो बस मूल प्रश्न पर एक छोटा सा जोड़ - Math.runcate के बीच क्या अंतर है और केवल एक दशमलव या दोहरी int कास्टिंग? क्या यह शून्य की ओर भी नहीं होगा?
जोड़ा लेखक Noam Gal, स्रोत

कुछ उदाहरण:

Round(1.5) = 2
Round(2.5) = 2
Round(1.5, MidpointRounding.AwayFromZero) = 2
Round(2.5, MidpointRounding.AwayFromZero) = 3
Round(1.55, 1) = 1.6
Round(1.65, 1) = 1.6
Round(1.55, 1, MidpointRounding.AwayFromZero) = 1.6
Round(1.65, 1, MidpointRounding.AwayFromZero) = 1.7

Truncate(2.10) = 2
Truncate(2.00) = 2
Truncate(1.90) = 1
Truncate(1.80) = 1
0
जोड़ा

एमएसडीएन के विवरण के लिए इन लिंक का पालन करें:

  • Math.Floor, which rounds down towards negative infinity.
  • Math.Ceiling, which rounds up towards positive infinity.
  • Math.Truncate, which rounds up or down towards zero.
  • Math.Round, which rounds to the nearest integer or specified number of decimal places. You can specify the behavior if it's exactly equidistant between two possibilities, such as rounding so that the final digit is even ("Round(2.5,MidpointRounding.ToEven)" becoming 2) or so that it's further away from zero ("Round(2.5,MidpointRounding.AwayFromZero)" becoming 3).

निम्नलिखित चित्र और तालिका मदद कर सकती है:

-3        -2        -1         0         1         2         3
 +--|------+---------+----|----+--|------+----|----+-------|-+
    a                     b       c           d            e

                       a=-2.7  b=-0.5  c=0.3  d=1.5  e=2.8
                       ======  ======  =====  =====  =====
Floor                    -3      -1      0      1      2
Ceiling                  -2       0      1      2      3
Truncate                 -2       0      0      1      2
Round (ToEven)           -3       0      0      2      3
Round (AwayFromZero)     -3      -1      0      2      3

ध्यान दें कि round ऐसा लगता है कि यह बहुत अधिक शक्तिशाली है, क्योंकि यह दशमलव स्थानों की एक विशिष्ट संख्या के लिए गोल कर सकता है। सभी अन्य शून्य दशमलव के लिए हमेशा दौर। उदाहरण के लिए:

n = 3.145;
a = System.Math.Round (n, 2, MidpointRounding.ToEven);       // 3.14
b = System.Math.Round (n, 2, MidpointRounding.AwayFromZero); // 3.15

अन्य कार्यों के साथ, आपको एक ही प्रभाव प्राप्त करने के लिए गुणा / विभाजित ट्रिकरी का उपयोग करना होगा:

c = System.Math.Truncate (n * 100) / 100;                    // 3.14
d = System.Math.Ceiling (n * 100) / 100;                     // 3.15
0
जोड़ा
धन्यवाद, @dtroy, मुझे उस मोड का उपयोग करने की आवश्यकता नहीं थी और, जब मैंने पाठ को सही तरीके से दस्तावेज किया, तो मुझे पूरी तरह से गलत उदाहरण मिल गए। उम्मीद है कि अब तय है।
जोड़ा लेखक paxdiablo, स्रोत
@ रिचिबैन, गोल कोड में अंतिम अंक की संपत्ति के रूप में यहां तक ​​कि के बारे में सोचें, अर्थात् संपूर्ण संख्या का एक बहु होना चाहिए दो। वैसे, खेद है कि आपको वापस आने में इतना समय लगा, आशा है कि आप मेरी प्रतिक्रिया के लिए बस इंतज़ार कर बैठे नहीं थे :-)
जोड़ा लेखक paxdiablo, स्रोत
पैक्स, मुझे लगता है कि आपको इसके साथ गलती हुई है: राउंड (अवेफ्रोज़ेरो) -3 -2 1 2 3 मठ। राउंड (-1.2, मिडपॉइंट राउंडिंग। अवेफ्रोज़ेरो) == -1 मठ। राउंड (0.3, मिडपॉइंट राउंडिंग। अवेफ्रोज़ेरो) == 0.0 आदि ..
जोड़ा लेखक dtroy, स्रोत
इस तरह के पुराने प्रश्न पर टिप्पणी करने के लिए खेद है, लेकिन मुझे यह पूछना है: आप दो दशमलव स्थानों पर "ToEven" कैसे गोल कर सकते हैं? निश्चित रूप से अजीब और यहां तक ​​कि केवल पूर्णांक पर लागू होते हैं?
जोड़ा लेखक Richiban, स्रोत

Math.Floor() rounds toward negative infinity

Math.Truncate rounds up or down towards zero.

उदाहरण के लिए:

Math.Floor(-3.4)     = -4
Math.Truncate(-3.4)  = -3

जबकि

Math.Floor(3.4)     = 3
Math.Truncate(3.4)  = 3
0
जोड़ा

Math.floor sliiiide to the left...
Math.ceil sliiiide to the right...
Math.truncate criiiiss crooooss (floor/ceil always towards 0)
Math.round cha cha, real smooth... (go to closest side)

चलो काम पर चलें! (?? _?)

To the left... Math.floor
Take it back now y'all... --
Two hops this time... -=2

हर कोई आपके हाथ लपेटता है ??

आप कितना गिर सकते हैं? क्या आप कम नीचे जा सकते हैं? floor के लिए सभी तरह से?

if (this == "wrong")
    return "i don't wanna be right";

Math.truncate(x) is also the same as int(x).
by removing a positive or negative fraction, you're always heading towards 0.

0
जोड़ा

<�कोड> math.floor()

निर्दिष्ट संख्या से कम या उसके बराबर सबसे बड़ा पूर्णांक देता है।

MSDN system.math.floor

<�कोड> math.truncate()

किसी संख्या के अभिन्न अंग की गणना करता है।

MSDN system.math.truncate

Math.Floor(2.56) = 2
Math.Floor(3.22) = 3
Math.Floor(-2.56) = -3
Math.Floor(-3.26) = -4

Math.Truncate(2.56) = 2
Math.Truncate(2.00) = 2
Math.Truncate(1.20) = 1
Math.Truncate(-3.26) = -3
Math.Truncate(-3.96) = -3

In addition Math.Round()

   Math.Round(1.6) = 2
   Math.Round(-8.56) = -9
   Math.Round(8.16) = 8
   Math.Round(8.50) = 8
   Math.Round(8.51) = 9
0
जोड़ा

Math.Floor(): Returns the largest integer less than or equal to the specified double-precision floating-point number.

Math.Round(): Rounds a value to the nearest integer or to the specified number of fractional digits.

0
जोड़ा
ओपी ने floor() और truncate() के बीच अंतर के बारे में पूछा, फ़्लोर() और round() </ code >।
जोड़ा लेखक Robert Columbia, स्रोत

वे सकारात्मक संख्या के साथ कार्यात्मक रूप से समकक्ष हैं। अंतर यह है कि वे नकारात्मक संख्याओं को कैसे संभालेंगे।

उदाहरण के लिए:

Math.Floor(2.5) = 2
Math.Truncate(2.5) = 2

Math.Floor(-2.5) = -3
Math.Truncate(-2.5) = -2

MSDN links: - Math.Floor Method - Math.Truncate Method

अनुलेख गणित से सावधान रहें। यह हो सकता है कि आप जो उम्मीद कर रहे हों वह हो।

"मानक" राउंडिंग परिणाम प्राप्त करने के लिए:

float myFloat = 4.5;
Console.WriteLine( Math.Round(myFloat) ); // writes 4
Console.WriteLine( Math.Round(myFloat, 0, MidpointRounding.AwayFromZero) ) //writes 5
Console.WriteLine( myFloat.ToString("F0") ); // writes 5
0
जोड़ा