MidpointRounding MidpointRounding MidpointRounding MidpointRounding Enum

Definice

Určuje, jak by metody matematického zaokrouhlení měly zpracovat číslo, které je mezi dvěma čísly.Specifies how mathematical rounding methods should process a number that is midway between two numbers.

public enum class MidpointRounding
[System.Runtime.InteropServices.ComVisible(true)]
public enum MidpointRounding
type MidpointRounding = 
Public Enum MidpointRounding
Dědičnost
MidpointRoundingMidpointRoundingMidpointRoundingMidpointRounding
Atributy

Pole

AwayFromZero AwayFromZero AwayFromZero AwayFromZero 1

Když je číslo uprostřed mezi dvěma ostatními, zaokrouhlí se na nejbližší číslo, které je mimo nulu.When a number is halfway between two others, it is rounded toward the nearest number that is away from zero.

ToEven ToEven ToEven ToEven 0

Když je číslo uprostřed mezi dvěma ostatními, zaokrouhluje se směrem k nejbližšímu sudé číslu.When a number is halfway between two others, it is rounded toward the nearest even number.

ToNegativeInfinity ToNegativeInfinity ToNegativeInfinity ToNegativeInfinity 3

Když je číslo uprostřed mezi dvěma ostatními, zaokrouhlí se na výsledek nejbližší k výsledku, který je větší než nekonečně přesný výsledek.When a number is halfway between two others, it is rounded toward the result closest to and no greater than the infinitely precise result.

ToPositiveInfinity ToPositiveInfinity ToPositiveInfinity ToPositiveInfinity 4

Když je číslo uprostřed mezi dvěma ostatními, zaokrouhlí se na výsledek nejbližší k výsledku, který je menší než nekonečně přesný výsledek.When a number is halfway between two others, it is rounded toward the result closest to and no less than the infinitely precise result.

ToZero ToZero ToZero ToZero 2

Když je číslo uprostřed mezi dvěma ostatními, zaokrouhlí se na výsledek nejbližší k výsledku, který není větší než nekonečně přesný výsledek.When a number is halfway between two others, it is rounded toward the result closest to and no greater in magnitude than the infinitely precise result.

Příklady

Následující příklad kódu ukazuje Round metodu ve spojení ToEven s výčtem.The following code example demonstrates the Round method in conjunction with the ToEven enumeration.

// This example demonstrates the Math.Round() method in conjunction 
// with the MidpointRounding enumeration.
using namespace System;

void main()
{
    Decimal result = (Decimal) 0.0;
    Decimal posValue = (Decimal) 3.45;
    Decimal negValue = (Decimal) -3.45;

    // By default, round a positive and a negative value to the nearest
    // even number. The precision of the result is 1 decimal place.
    result = Math::Round(posValue, 1);
    Console::WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
    result = Math::Round(negValue, 1);
    Console::WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue);
    Console::WriteLine();

    // Round a positive value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    result = Math::Round(posValue, 1, MidpointRounding::ToEven);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
        result, posValue);
    result = Math::Round(posValue, 1, MidpointRounding::AwayFromZero);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
        result, posValue);
    Console::WriteLine();

    // Round a negative value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    result = Math::Round(negValue, 1, MidpointRounding::ToEven);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
        result, negValue);
    result = Math::Round(negValue, 1, MidpointRounding::AwayFromZero);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
        result, negValue);
    Console::WriteLine();
}

/*
This code example produces the following results:

3.4 = Math.Round( 3.45, 1)
-3.4 = Math.Round(-3.45, 1)

3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

*/
decimal result = 0.0m;
decimal posValue =  3.45m;
decimal negValue = -3.45m;

// By default, round a positive and a negative value to the nearest even number. 
// The precision of the result is 1 decimal place.

result = Math.Round(posValue, 1);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
result = Math.Round(negValue, 1);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue);
Console.WriteLine();

// Round a positive value to the nearest even number, then to the nearest number away from zero. 
// The precision of the result is 1 decimal place.

result = Math.Round(posValue, 1, MidpointRounding.ToEven);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", result, posValue);
result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", result, posValue);
Console.WriteLine();

// Round a negative value to the nearest even number, then to the nearest number away from zero. 
// The precision of the result is 1 decimal place.

result = Math.Round(negValue, 1, MidpointRounding.ToEven);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", result, negValue);
result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", result, negValue);
Console.WriteLine();
/*
This code example produces the following results:

3.4 = Math.Round( 3.45, 1)
-3.4 = Math.Round(-3.45, 1)

3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

*/
' This example demonstrates the Math.Round() method in conjunction 
' with the MidpointRounding enumeration.
Imports System

Class Sample
    Public Shared Sub Main() 
        Dim result As Decimal = 0D
        Dim posValue As Decimal = 3.45D
        Dim negValue As Decimal = -3.45D
        
        ' By default, round a positive and a negative value to the nearest even number. 
        ' The precision of the result is 1 decimal place.
        result = Math.Round(posValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue)
        result = Math.Round(negValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue)
        Console.WriteLine()
        
        ' Round a positive value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        result = Math.Round(posValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", _
                           result, posValue)
        result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", _
                           result, posValue)
        Console.WriteLine()
        
        ' Round a negative value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        result = Math.Round(negValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", _
                            result, negValue)
        result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", _
                           result, negValue)
        Console.WriteLine()
    
    End Sub 'Main
End Class 'Sample
'
'This code example produces the following results:
'
' 3.4 = Math.Round( 3.45, 1)
'-3.4 = Math.Round(-3.45, 1)
'
' 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
' 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)
'
'-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
'

Poznámky

Použijte MidpointRounding s příslušnými přetíženími Math.Round k poskytnutí větší kontroly nad procesem zaokrouhlení.Use MidpointRounding with appropriate overloads of Math.Round to provide more control of the rounding process.

Operace zaokrouhlení přebírá původní číslo s implicitní nebo specifikovanou přesností; prověřuje další číslici, která je zvýšena na tuto přesnost plus jedna. a vrátí nejbližší číslo se stejnou přesností jako původní číslo.A rounding operation takes an original number with an implicit or specified precision; examines the next digit, which is at that precision plus one; and returns the nearest number with the same precision as the original number. U kladných čísel, pokud je další číslice od 0 do 4, nejbližší číslo je směrem k zápornému nekonečnu.For positive numbers, if the next digit is from 0 through 4, the nearest number is toward negative infinity. Pokud je další číslice od 6 do 9, nejbližší číslo je směrem k kladnému nekonečnu.If the next digit is from 6 through 9, the nearest number is toward positive infinity. Pro záporná čísla, pokud je další číslice od 0 do 4, nejbližší číslo je směrem k kladnému nekonečnu.For negative numbers, if the next digit is from 0 through 4, the nearest number is toward positive infinity. Pokud je další číslice od 6 do 9, nejbližší číslo je směrem k zápornému nekonečnu.If the next digit is from 6 through 9, the nearest number is toward negative infinity.

V předchozích případech MidpointRounding výčet nemá vliv na výsledek operace zaokrouhlení.In the previous cases, the MidpointRounding enumeration does not affect the result of the rounding operation. Pokud je však další číslice 5, což je střední hodnota mezi dvěma možnými výsledky, přičemž všechny zbývající číslice jsou nula nebo žádné zbývající číslice nejsou k dispozici, nejbližší číslo je nejednoznačné.However, if the next digit is 5, which is the midpoint between two possible results, and all remaining digits are zero or there are no remaining digits, the nearest number is ambiguous. V tomto případě MidpointRounding vám výčet umožňuje určit, zda operace zaokrouhlení vrátí nejbližší číslo směrem od nuly nebo nejbližší sudé číslo.In this case, the MidpointRounding enumeration enables you to specify whether the rounding operation returns the nearest number away from zero or the nearest even number.

Následující tabulka ukazuje výsledky zaokrouhlování některých záporných a kladných čísel ve spojení s hodnotami MidpointRounding.The following table demonstrates the results of rounding some negative and positive numbers in conjunction with the values of MidpointRounding. Přesnost použitá k zaokrouhlení čísel je nulová, což znamená, že číslo po desetinném bodě ovlivní operaci zaokrouhlení.The precision used to round the numbers is zero, which means the number after the decimal point affects the rounding operation. Například pro číslo-2,5 je číslice po desetinné čárkě 5.For example, for the number -2.5, the digit after the decimal point is 5. Vzhledem k tomu, že tato číslice představuje střední bod, MidpointRounding můžete použít hodnotu k určení výsledku zaokrouhlení.Because that digit is the midpoint, you can use a MidpointRounding value to determine the result of rounding. Je-li zadán parametr AwayFromZero, je vrácena hodnota-3, protože se jedná o nejbližší číslo od nuly s přesností nula.If AwayFromZero is specified, -3 is returned because it is the nearest number away from zero with a precision of zero. Je-li zadána hodnota ToEven, je vrácena hodnota-2, protože se jedná o nejbližší sudé číslo s přesností nula.If ToEven is specified, -2 is returned because it is the nearest even number with a precision of zero.

Původní čísloOriginal number AwayFromZeroAwayFromZero ToEvenToEven
3.53.5 44 44
2.82.8 33 33
2.52.5 33 22
2.12.1 22 22
-2,1-2.1 -2-2 -2-2
-2,5-2.5 -3-3 -2-2
-2,8-2.8 -3-3 -3-3
-3,5-3.5 -4-4 -4-4

Platí pro