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

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.

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

कुछ उदाहरण:

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

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

• 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

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

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.

<कोड> 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

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.