วิธีการปัดเศษกระบวนงานที่กำหนดเองของปฏิบัติ

การแปลบทความ การแปลบทความ
หมายเลขบทความ (Article ID): 196652 - ผลิตภัณฑ์ที่เกี่ยวข้องในบทความนี้
ขยายทั้งหมด | ยุบทั้งหมด

เนื้อหาบนหน้านี้

สรุป

ไม่มีหมายเลขของ algorithms การปัดเศษที่ต่างกันในผลิตภัณฑ์ของ Microsoft การปัดเศษ algorithms ช่วงจากการปัดเศษ Arithmetic ในฟังก์ชัน Round() แผ่นงานของ Excel เพื่อ Rounding ของ Banker ในฟังก์ชัน CInt(), CLng() และ Round() ใน Visual Basic สำหรับโปรแกรมประยุกต์ บทความนี้อธิบายสิ่งแตกต่างกัน Visual Basic สำหรับโปรแกรมประยุกต์ที่ดำเนินการฟังก์ชันการปัดเศษ และแสดงตัวอย่างของการใช้ฟังก์ชัน นอกจากนี้ บทความนี้ประกอบด้วยฟังก์ชันตัวอย่างที่ใช้ algorithms การปัดเศษที่แตกต่างกัน

ข้อมูลเพิ่มเติม

อธิบายการปัดเศษ

คุณต้องการปัดเศษเมื่อคุณต้องการแปลงความแม่นยำมากกว่าจำนวนที่เป็นหมายเลขของความแม่นยำกเก กรณีที่พบโดยทั่วไปมากที่สุดคือเมื่อคุณต้องการแปลงให้เป็นจำนวนข้อมูลเลขทศนิยมเป็นจำนวนเต็ม

การปัดเศษลง

รูปแบบที่ง่ายที่สุดของการปัดเศษเป็น truncation ตัวเลขใด ๆ หลังจากความแม่นยำที่ต้องการเพียงแค่จะถูกละเว้น ฟังก์ชัน VBA Fix() เป็นตัวอย่างของ truncation ตัวอย่างเช่น Fix(3.5) เป็น 3 และ Fix(-3.5)-3

ฟังก์ชัน Int() ปัดเศษลงถึงจำนวนสูงสุดเต็มน้อยกว่าค่า Int() และ Fix() ทำหน้าที่เหมือนกับตัวเลขที่เป็นค่าบวก - truncating - แต่ให้ผลลัพธ์ที่แตกต่างกันสำหรับหมายเลขที่เป็นค่าลบ: Int(-3.5) ให้-4

ฟังก์ชัน Fix() เป็นตัวอย่างของการปัดเศษ symmetric เนื่องจากจะมีผลกับ magnitude (ค่าสัมบูรณ์) ของหมายเลขที่เป็นค่าบวก และค่าลบในลักษณะเดียวกัน ฟังก์ชัน Int() เป็นตัวอย่างของการปัดเศษ asymmetric เนื่องจากจะมีผลกับ magnitude ของหมายเลขที่เป็นค่าบวก และค่าลบแตกต่างกัน

Excel มีฟังก์ชันของกระดาษคำนวณที่คล้ายกัน: Int(), Floor() และ RoundDown() Int() ทำงานในลักษณะเดียวกับ Int() ใดใน Visual Basic สำหรับโปรแกรมประยุกต์ Floor() truncates ค่าบวก แต่ไม่ได้ทำงานกับตัวเลขที่เป็นค่าลบ ฟังก์ชัน RoundDown() เป็นการทำงานแบบเดียวกับฟังก์ชัน Fix() VBA

Microsoft SQL Server มีฟังก์ชัน Round() ที่สามารถทำหน้าที่เหมือนกับฟังก์ชัน Fix() VBA sql Server ยังมี Floor() ฟังก์ชัน ซึ่งทำงานแบบเดียวกับฟังก์ชัน Int() VBA

การปัดเศษขึ้น

sql Server และ Excel ทั้งสองมีฟังก์ชันที่เรียกว่า Ceiling() ซึ่งเสมอปัดเศษค่าเศษส่วนอัพ (ค่าบวกเพิ่มเติม) ค่าถัดไป

visual Basic สำหรับโปรแกรมประยุกต์ที่ไม่มีฟังก์ชันปัดสายโทรศัพท์ที่สอดคล้องกัน อย่างไรก็ตาม สำหรับตัวเลขที่เป็นค่าลบ Fix() และ Int() สามารถใช้ในการปัดเศษ upward ในลักษณะต่าง ๆ

Fix() ปัดเศษไปยัง 0 (ขึ้นในควรสัมบูรณ์ แต่ลงในแง่ของ magnitude สัมบูรณ์) Fix(-3.5) คือ -3.5

Int() ปัดเศษจาก 0 (ขึ้นในแง่ของ magnitude สัมบูรณ์ แต่ลงในควรที่แน่นอน) Int(-3.5) คือ -4

การปัดเศษ arithmetic

เมื่อปัดเศษเสมอลง หรืออัพ หมายเลขที่เป็นผลลัพธ์ไม่ได้ใกล้เคียงที่จำเป็นต้องที่สุดกับหมายเลขต้นฉบับ ตัวอย่างเช่น ถ้าคุณปัด 1.9 ลงไป 1 ผลต่างมีขนาดล็อตใหญ่กว่าถ้าคุณปัดได้จนถึง 2 มีความง่ายในการดูว่า หมายเลขจาก 1.6 2.4 ควรถูกปัดเศษเป็น 2

อย่างไรก็ตาม สิ่งประมาณ 1.5 ซึ่งก็คือ equidistant ระหว่าง 1 และ 2 หรือ ตามแบบแผน หมายเลขวิธีครึ่งถูกปัดเศษขึ้น

คุณสามารถใช้การปัดเศษตัวเลขวิธีครึ่งในต้อง symmetric ซึ่ง-.5 ถูกปัดเศษลง -1 หรือ ใน ต้องมี asymmetric ซึ่ง-.5 จะปัดค่าเป็น 0

ฟังก์ชันต่อไปนี้ให้ symmetric ปัด arithmetic:
ฟังก์ชันของกระดาษคำนวณของ Excel Round()
ฟังก์ชัน SQL Server Round() สามารถทำการปัดเศษในการ arithmetic symmetric

ฟังก์ชันต่อไปนี้ให้ asymmetric ปัด arithmetic:
วิธีการ Round() ของไลบรารี Java Math

visual Basic สำหรับโปรแกรมประยุกต์ที่ไม่มีฟังก์ชันที่ทำการปัดเศษ arithmetic

การปัดเศษของ banker

เมื่อคุณเพิ่มค่าที่ถูกปัดเศษ เข้าด้วยกัน เสมอ ปัดเศษ.5 ในที่เดียวกันกับผลลัพธ์ทิศทางใน bias ที่ grows ด้วยหมายเลขที่มากกว่าคุณเพิ่มเข้าด้วยกัน วิธีการหนึ่งในการลด bias ไม่ มีการปัดเศษของ banker

ปัดเศษของ banker รอบ ๆ .5 ขึ้นบางครั้ง และในบางครั้งลง นี้คือการ ปัดเศษเป็นเลขคู่ใกล้เคียงที่สุด ดังนั้น 1.5 และ 2.5 ปัดเศษเป็น 2 และ 3.5 4.5 ทั้งสองปัดเศษเป็น 4 การปัดเศษของ banker คือ symmetric

ใน Visual Basic สำหรับโปรแกรมประยุกต์ ฟังก์ชันตัวเลขที่ต่อไปนี้ทำการปัดเศษของ banker: CByte(), CInt(), CLng(), CCur() และ Round()

ไม่มีฟังก์ชันการกระดาษคำนวณของ Excel ที่ทำการปัดเศษของ banker ได้

การปัดเศษแบบสุ่ม

การปัดเศษของ banker คู่สามารถ bias ผลรวม คุณสามารถใช้ขั้นตอนที่พิเศษเพื่อเอา bias โดย.5 ขึ้น หรือลงในแบบสุ่มอย่างที่ต้องการในการปัดเศษ ลดด้วยวิธีนี้ ถึงแม้ว่าข้อมูลถูก biased โดยเจตนา bias อาจถูกลง อย่างไรก็ตาม การใช้การปัดเศษแบบสุ่ม ด้วยข้อมูลการแจกจ่ายแบบสุ่มอาจทำ bias ที่มีขนาดใหญ่กว่าการปัดเศษของ banker การปัดเศษสุ่มอาจส่งผลในผลรวมที่แตกต่างกันสองบนข้อมูลเดียวกัน

ไม่มีผลิตภัณฑ์ของ Microsoft ใช้เรียงใด ๆ ของกระบวนการปัดเศษที่สุ่ม

สลับการปัดเศษ

การปัดเศษอื่นถูกปัดระหว่าง.5 ขึ้นและลง.5 บน successive โทรศัพท์

ไม่มีผลิตภัณฑ์ของ Microsoft ใช้ขั้นตอนการปัดเศษการสำรอง

ฟังก์ชัน Round() คือ ใช้ Inconsistently

ฟังก์ชัน Round() ไม่นำมาใช้ในต้องสอดคล้องกับผลิตภัณฑ์ของ Microsoft ที่แตกต่างกันสำหรับเหตุผลในอดีต

ตารางต่อไปนี้เกี่ยวข้องกับผลิตภัณฑ์เมื่อต้องการใช้งาน:
   Product                             Implementation
   ----------------------------------------------------------------------
   Visual Basic for Applications 6.0   Banker's Rounding
   Excel Worksheet                     Symmetric Arithmetic Rounding
   SQL Server                          Either Symmetric Arithmetic Rounding
                                       or Symmetric Round Down (Fix)
                                       depending on arguments

   Java Math library                   Asymmetric Arithmetic Rounding
				

The Round() function in Visual Basic 6.0 and Visual Basic for Applications 6.0 performs banker's rounding. It has an optional second argument that specifies the number of decimal digits to round to:
   Debug.Print Round(2.45, 1) returns 2.4.
				

Sample Data

The following table shows some sample data and the effects of various rounding methods on the numbers and totals generated.
   Number/Int./Fix/Ceiling/Asym. Arith./Sym. Arith./Banker's/Random/Alt.
   ---------------------------------------------------------------------
   -2.6   -3   -2  -2      -3          -3           -3       -3     -3
   -2.5   -3   -2  -2      -2          -3           -2       -2     -3
   -2.4   -3   -2  -2      -2          -2           -2       -2     -2
   -1.6   -2   -1  -1      -2          -2           -2       -2     -2
   -1.5   -2   -1  -1      -1          -2           -2       -1     -1
   -1.4   -2   -1  -1      -1          -1           -1       -1     -1
   -0.6   -1    0   0      -1          -1           -1       -1     -1
   -0.5   -1    0   0       0          -1            0       -1     -1
   -0.4   -1    0   0       0           0            0        0      0
    0.4    0    0   1       0           0            0        0      0
    0.5    0    0   1       1           1            0        1      1
    0.6    0    0   1       1           1            1        1      1
    1.4    1    1   2       1           1            1        1      1
    1.5    1    1   2       2           2            2        1      1
    1.6    1    1   2       2           2            2        2      2
    2.4    2    2   3       2           2            2        2      2
    2.5    2    2   3       3           3            2        3      3
    2.6    2    2   3       3           3            3        3      3
				

Total of all numbers:
   Number/Int./Fix/Ceiling/Asym. Arith./Sym. Arith./Banker's/Random/Alt.
   ---------------------------------------------------------------------
   0.0    -9   0   9       3            0           0        1      0
				

Total of all negative numbers:
   Number/Int./Fix/Ceiling/Asym. Arith./Sym. Arith./Banker's/Random/Alt.
   ---------------------------------------------------------------------
   -13.5  -18  -9  -9      -12          -15         -13      -13    -14
				

Total of all positive numbers:
   Number/Int./Fix/Ceiling/Asym. Arith./Sym. Arith./Banker's/Random/Alt.
   ---------------------------------------------------------------------
   13.5   9    9   18      15           15          13       14     14
				

The table shows the difference between the various rounding methods. For randomly distributed positive and negative numbers, Fix(), symmetric arithmetic rounding, banker's rounding, and alternating rounding provide the least difference from actual totals, with random rounding not far behind.

However, if the numbers are either all positive or all negative, banker's rounding, alternating rounding, and random rounding provide the least difference from the actual totals.

Sample User-Defined Rounding Functions

The sample code in the following Function Listing section provides sample implementations for each of the rounding types described.

The functions provided are:
   AsymDown      Asymmetrically rounds numbers down - similar to Int().
                 Negative numbers get more negative.

   SymDown       Symmetrically rounds numbers down - similar to Fix().
                 Truncates all numbers toward 0.
                 Same as AsymDown for positive numbers.

   AsymUp        Asymmetrically rounds numbers fractions up.
                 Same as SymDown for negative numbers.
                 Similar to Ceiling.

   SymUp         Symmetrically rounds fractions up - that is, away from 0.
                 Same as AsymUp for positive numbers.
                 Same as AsymDown for negative numbers.

   AsymArith     Asymmetric arithmetic rounding - rounds .5 up always.
                 Similar to Java worksheet Round function.

   SymArith      Symmetric arithmetic rounding - rounds .5 away from 0.
                 Same as AsymArith for positive numbers.
                 Similar to Excel Worksheet Round function.

   BRound        Banker's rounding.
                 Rounds .5 up or down to achieve an even number.
                 Symmetrical by definition.

   RandRound     Random rounding.
                 Rounds .5 up or down in a random fashion.

   AltRound      Alternating rounding.
                 Alternates between rounding .5 up or down.

   ATruncDigits  Same as AsyncTrunc but takes different arguments.
				

All of these functions take two arguments: the number to be rounded and an optional factor. If the factor is omitted, then the functions return an integer created by one of the above methods. If the factor is specified, the number is scaled by the factor to create different rounding effects. For example AsymArith(2.55, 10) produces 2.6, that is, it rounds to 1/factor = 1/10 = 0.1.

NOTE: A factor of 0 generates a run-time error: 1/factor = 1/0.

The following table shows the effects of various factors:
   Expression       Result  Comment
   --------------------------------------------------------------------
   AsymArith(2.5)     3     Rounds up to next integer.
   BRound(2.18, 20)   2.2   Rounds to the nearest 5 cents (1/20 dollar).
   SymDown(25, .1)   20     Rounds down to an even multiple of 10.
				

The exception to the above description is ADownDigits, which is a template function that allows you to specify the number of decimal digits instead of a factor.
   Expression            Result Comment
   ---------------------------------------------------------------------
   ADownDigits(2.18, 1)    2.1  Rounds down to next multiple of 10 ^ -1.
				

Function Listing


   Function AsymDown(ByVal X As Double, _
            Optional ByVal Factor As Double = 1) As Double
     AsymDown = Int(X * Factor) / Factor
   End Function

   Function SymDown(ByVal X As Double, _
            Optional ByVal Factor As Double = 1) As Double
     SymDown = Fix(X * Factor) / Factor
   '  Alternately:
   '  SymDown = AsymDown(Abs(X), Factor) * Sgn(X)
   End Function

   Function AsymUp(ByVal X As Double, _
            Optional ByVal Factor As Double = 1) As Double
   Dim Temp As Double
     Temp = Int(X * Factor)
     AsymUp = (Temp + IIf(X = Temp, 0, 1)) / Factor
   End Function

   Function SymUp(ByVal X As Double, _
            Optional ByVal Factor As Double = 1) As Double
   Dim Temp As Double
     Temp = Fix(X * Factor)
     SymUp = (Temp + IIf(X = Temp, 0, Sgn(X))) / Factor
   End Function

   Function AsymArith(ByVal X As Double, _
            Optional ByVal Factor As Double = 1) As Double
     AsymArith = Int(X * Factor + 0.5) / Factor
   End Function

   Function SymArith(ByVal X As Double, _
            Optional ByVal Factor As Double = 1) As Double
     SymArith = Fix(X * Factor + 0.5 * Sgn(X)) / Factor
   '  Alternately:
   '  SymArith = Abs(AsymArith(X, Factor)) * Sgn(X)
   End Function

   Function BRound(ByVal X As Double, _
            Optional ByVal Factor As Double = 1) As Double
   '  For smaller numbers:
   '  BRound = CLng(X * Factor) / Factor
   Dim Temp As Double, FixTemp As Double
     Temp = X * Factor
     FixTemp = Fix(Temp + 0.5 * Sgn(X))
     ' Handle rounding of .5 in a special manner
     If Temp - Int(Temp) = 0.5 Then
       If FixTemp / 2 <> Int(FixTemp / 2) Then ' Is Temp odd
         ' Reduce Magnitude by 1 to make even
         FixTemp = FixTemp - Sgn(X)
       End If
     End If
     BRound = FixTemp / Factor
   End Function

   Function RandRound(ByVal X As Double, _
            Optional ByVal Factor As Double = 1) As Double
   ' Should Execute Randomize statement somewhere prior to calling.
   Dim Temp As Double, FixTemp As Double
     Temp = X * Factor
     FixTemp = Fix(Temp + 0.5 * Sgn(X))
     ' Handle rounding of .5 in a special manner.
     If Temp - Int(Temp) = 0.5 Then
       ' Reduce Magnitude by 1 in half the cases.
       FixTemp = FixTemp - Int(Rnd * 2) * Sgn(X)
     End If
     RandRound = FixTemp / Factor
   End Function

   Function AltRound(ByVal X As Double, _
            Optional ByVal Factor As Double = 1) As Double
   Static fReduce As Boolean
   Dim Temp As Double, FixTemp As Double
     Temp = X * Factor
     FixTemp = Fix(Temp + 0.5 * Sgn(X))
     ' Handle rounding of .5 in a special manner.
     If Temp - Int(Temp) = 0.5 Then
       ' Alternate between rounding .5 down (negative) and up (positive).
       If (fReduce And Sgn(X) = 1) Or (Not fReduce And Sgn(X) = -1) Then
       ' Or, replace the previous If statement with the following to
       ' alternate between rounding .5 to reduce magnitude and increase
       ' magnitude.
       ' If fReduce Then
         FixTemp = FixTemp - Sgn(X)
       End If
       fReduce = Not fReduce
     End If
     AltRound = FixTemp / Factor
   End Function

   Function ADownDigits(ByVal X As Double, _
            Optional ByVal Digits As Integer = 0) As Double
     ADownDigits = AsymDown(X, 10 ^ Digits)
   End Function
				

NOTE: With the exception of Excel's MRound() worksheet function, the built- in rounding functions take arguments in the manner of ADownDigits, where the second argument specifies the number of digits instead of a factor.

The rounding implementations presented here use a factor, like MRound(), which is more flexible because you do not have to round to a power of 10. You can write wrapper functions in the manner of ADownDigits.

Floating Point Limitations

All of the rounding implementations presented here use the double data type, which can represent approximately 15 decimal digits.

Since not all fractional values can be expressed exactly, you might get unexpected results because the display value does not match the stored value.

For example, the number 2.25 might be stored internally as 2.2499999..., which would round down with arithmetic rounding, instead of up as you might expect. Also, the more calculations a number is put through, the greater possibility that the stored binary value will deviate from the ideal decimal value.

If this is the case, you may want to choose a different data type, such as Currency, which is exact to 4 decimal places.

You might also consider making the data types Variant and use CDec() to convert everything to the Decimal data type, which can be exact to 28 decimal digits.

Rounding Currency Values

When you use the Currency data type, which is exact to 4 decimal digits, you typically want to round to 2 decimal digits for cents.

The Round2CB function below is a hard-coded variation that performs banker's rounding to 2 decimal digits, but does not multiply the original number. This avoids a possible overflow condition if the monetary amount is approaching the limits of the Currency data type.
   Function Round2CB (ByVal X As Currency) As Currency
     Round2CB = CCur(X / 100) * 100
   End Function
				

Rounding Decimal Values

The following is an example of asymmetric arithmetic rounding using the Decimal data type:
   Function AsymArithDec(ByVal X As Variant, _
            Optional ByVal Factor As Variant = 1) As Variant
     If Not IsNumeric(X) Then
       AsymArithDec = X
     Else
       If Not IsNumeric(Factor) Then Factor = 1
       AsymArithDec = Int(CDec(X * Factor) + .5)
     End If
   End Function
				

Dropping Precision as a Shortcut in Rounding

ตาม taught ในโรงเรียน การปัดเศษเป็นปกติ arithmetic การปัดเศษโดยใช้หมายเลขที่เป็นค่าบวก มีชนิดนี้ของการปัดเศษ คุณเพียงต้องทราบหมายเลขการ 1 หลักในอดีตโดยที่คุณกำลังปัดเศษที่ ละเว้นการหลักที่ตำแหน่งทศนิยมแรกที่ผ่านมา ในอย่างอื่น ความแม่นยำหลุดเป็นทางลัดในการปัดเศษค่า

ตัวอย่างเช่น 2.5 และ 2.51 ปัดเศษ 3 ขณะ 2.4 และ 2.49 ปัดลงไปยัง 2

เมื่อคุณใช้การปัดเศษของ banker (หรือ.5 ในการปัดเศษขึ้น หรือลงวิธีอื่น ๆ) หรือ เมื่อคุณทำการปัดเศษตัวเลขเป็นค่าลบที่ใช้ asymmetric ปัด arithmetic ปล่อยความแม่นยำสามารถนำไปยังผลไม่ถูกต้องซึ่งคุณอาจไม่ปัดไปยังหมายเลขที่ใกล้เคียงที่สุด

ปัดตัวอย่างเช่น ด้วยการปัดเศษของ banker, 2.5 เศษลงไปรอบ ๆ 2.51 และที่ 2 ถึง 3

ด้วย asymmetric arithmetic ปัด -2.5 ปัดเศษสุด-2 ขณะ-2.51 ปัดเศษลงไป-3

ฟังก์ชันกำหนดโดยผู้ใช้ที่แสดงในบทความนี้นำความแม่นยำแบบเต็มของหมายเลขลงในบัญชีเมื่อทำการปัดเศษ

ข้อมูลอ้างอิง

Visual Basic ที่ช่วย รุ่น 6.0 หัวข้อ: Int แก้ไขฟังก์ชัน ฟังก์ชันการปัดเศษ

Microsoft Transact SQL ช่วย หัวข้อ: ฟังก์ชันการปัดเศษ ฟังก์ชันผลิต โคมฟังก์ชัน

(c) Microsoft Corporation 1998 สิทธิ์ทั้งหมดที่สำรองไว้ contributions โดย Malcolm Stewart, Microsoft Corporation

คุณสมบัติ

หมายเลขบทความ (Article ID): 196652 - รีวิวครั้งสุดท้าย: 7 มกราคม 2554 - Revision: 3.0
ใช้กับ
  • Microsoft Visual Basic Control Creation Edition
  • Microsoft Visual Basic 5.0 Learning Edition
  • Microsoft Visual Basic 5.0 Professional Edition
  • Microsoft Visual Basic 6.0 Professional Edition
  • Microsoft Visual Basic 5.0 Enterprise Edition
  • Microsoft Visual Basic for Applications 6.0
  • Microsoft SQL Server 6.0 Standard Edition
  • Microsoft SQL Server 6.5 Standard Edition
  • Microsoft SQL Server 7.0 Standard Edition
Keywords: 
kbhowto kbmt KB196652 KbMtth
แปลโดยคอมพิวเตอร์
ข้อมูลสำคัญ: บทความนี้แปลโดยซอฟต์แวร์การแปลด้วยคอมพิวเตอร์ของ Microsoft แทนที่จะเป็นนักแปลที่เป็นบุคคล Microsoft มีบทความที่แปลโดยนักแปลและบทความที่แปลด้วยคอมพิวเตอร์ เพื่อให้คุณสามารถเข้าถึงบทความทั้งหมดในฐานความรู้ของเรา ในภาษาของคุณเอง อย่างไรก็ตาม บทความที่แปลด้วยคอมพิวเตอร์นั้นอาจมีข้อบกพร่อง โดยอาจมีข้อผิดพลาดในคำศัพท์ รูปแบบการใช้ภาษาและไวยากรณ์ เช่นเดียวกับกรณีที่ชาวต่างชาติพูดผิดเมื่อพูดภาษาของคุณ Microsoft ไม่มีส่วนรับผิดชอบต่อความคลาดเคลื่อน ความผิดพลาดหรือความเสียหายที่เกิดจากการแปลเนื้อหาผิดพลาด หรือการใช้บทแปลของลูกค้า และ Microsoft มีการปรับปรุงซอฟต์แวร์การแปลด้วยคอมพิวเตอร์อยู่เป็นประจำ
ต่อไปนี้เป็นฉบับภาษาอังกฤษของบทความนี้:196652

ให้ข้อเสนอแนะ

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com