Bir sayıyı C # 'da iki ondalık basamağa nasıl yuvarlarsınız?

Bunu Math.Roundfonksiyonunu kullanarak yapmak istiyorum

İşte bazı örnekler:

decimal a = 1.994444M;

Math.Round(a, 2); //returns 1.99

decimal b = 1.995555M;

Math.Round(b, 2); //returns 2.00

Ayrıca, aşağıdaki aşırı yüklenmeyle yuvarlanan / yuvarlanan bankacılara bakmak da isteyebilirsiniz:

Math.Round(a, 2, MidpointRounding.ToEven);

Burada daha fazla bilgi var .

Bunu dene:

twoDec = Math.Round(val, 2)

Şahsen hiçbir şeyi yuvarlamam. Yuvarlama yine de CS'de kırmızı bir ringa balığı olduğu için mümkün olduğunca kararlı tutun. Ancak, kullanıcılarınız için verileri biçimlendirmek istiyorsunuz ve bu string.Format("{0:0.00}", number)nedenle bunun iyi bir yaklaşım olduğunu düşünüyorum.

Bir dize istiyorsanız

> (1.7289).ToString("#.##")
"1.73"

Veya ondalık

> Math.Round((Decimal)x, 2)
1.73m

Ama hatırla! Yuvarlama dağıtıcı değildir, yani. round(x*y) != round(x) * round(y). Bu nedenle, bir hesaplamanın sonuna kadar herhangi bir yuvarlama yapmayın, aksi takdirde doğruluk kaybedersiniz.

Vikipedi'nin güzel bir sayfası var genel olarak yuvarlama var.

Tüm .NET (yönetilen) diller, ortak dil çalışma süresinin (CLR) yuvarlama mekanizmalarından herhangi birini kullanabilir. Örneğin, Math.Round () (yukarıda belirtildiği gibi) yöntemi, geliştiricinin yuvarlama türünü (Sıfırdan Eşit'e veya Sıfırdan Uzakta) belirtmesine olanak tanır. Convert.ToInt32 () yöntemi ve varyasyonları kullanımı yuvarlak için bile . Tavan () ve Kat () yöntemleri ile ilgili bulunmaktadır.

Özel sayısal biçimlendirmeyle de yuvarlayabilirsiniz .

Decimal.Round () öğesinin Math.Round () yönteminden farklı bir yöntem kullandığını unutmayın .

İşte olan kullanışlı pos bankerin yuvarlama algoritması t. Raymond'un yuvarlama hakkındaki mizahi yayınlarından birine bakın ...

// iki ondalık basamağa kadar dönüştürme

String.Format("{0:0.00}", 140.6767554);        // "140.67"
String.Format("{0:0.00}", 140.1);             // "140.10"
String.Format("{0:0.00}", 140);              // "140.00"

Double d = 140.6767554;
Double dc = Math.Round((Double)d, 2);       //  140.67

decimal d = 140.6767554M;
decimal dc = Math.Round(d, 2);             //  140.67

=========

// just two decimal places
String.Format("{0:0.##}", 123.4567);      // "123.46"
String.Format("{0:0.##}", 123.4);         // "123.4"
String.Format("{0:0.##}", 123.0);         // "123"

"0" ı "#" ile de birleştirebilir.

String.Format("{0:0.0#}", 123.4567)       // "123.46"
String.Format("{0:0.0#}", 123.4)          // "123.4"
String.Format("{0:0.0#}", 123.0)          // "123.0"

Ben eski bir soru biliyorum ama Matematik yuvarlak ve Dize biçimi yuvarlak arasında aşağıdaki farklar için lütfen unutmayın :

decimal d1 = (decimal)1.125;
Math.Round(d1, 2).Dump();   // returns 1.12
d1.ToString("#.##").Dump(); // returns "1.13"

decimal d2 = (decimal)1.1251;
Math.Round(d2, 2).Dump();   // returns 1.13
d2.ToString("#.##").Dump(); // returns "1.13"

Bu C # 'da 2 ondalık basamağa yuvarlamak içindir:

label8.Text = valor_cuota .ToString("N2") ;

VB.NET'te:

 Imports System.Math
 round(label8.text,2)

Bir sayıyı yuvarlamak istiyorsanız, aşağıdakilere bağlı olarak farklı sonuçlar elde edebilirsiniz: Math.Round () işlevini nasıl kullanacağınız (yuvarlama veya yuvarlama için), çiftler ve / veya kayan sayılarla çalışıyorsunuz ve orta nokta yuvarlamayı uygularsınız. Özellikle, içindeki işlemler veya yuvarlanacak değişken ile kullanıldığında bir işlemden gelir. Diyelim ki bu iki sayıyı çarpmak istiyorsunuz: 0.75 * 0.95 = 0.7125 . Sağ? C # içinde değil

Bakalım 3. ondalık sayıya yuvarlamak isterseniz ne olur:

double result = 0.75d * 0.95d; // result = 0.71249999999999991
double result = 0.75f * 0.95f; // result = 0.71249997615814209

result = Math.Round(result, 3, MidpointRounding.ToEven); // result = 0.712. Ok
result = Math.Round(result, 3, MidpointRounding.AwayFromZero); // result = 0.712. Should be 0.713

Gördüğünüz gibi, orta noktayı aşağı yuvarlamak istiyorsanız ilk Tur () doğrudur. Ama ikinci raunt (), yuvarlamak istiyorsanız yanlış.

Bu negatif sayılar için geçerlidir:

double result = -0.75 * 0.95;  //result = -0.71249999999999991
result = Math.Round(result, 3, MidpointRounding.ToEven); // result = -0.712. Ok
result = Math.Round(result, 3, MidpointRounding.AwayFromZero); // result = -0.712. Should be -0.713

Yani, IMHO, Math.Round () için gereksinimlerinize uygun kendi sarma işlevinizi oluşturmanız gerekir. Ben 'roundUp = true' parametresi sonraki büyük sayıya yuvarlamak anlamına gelir bir fonksiyon yarattı. Yani: 0.7125 mermi 0.713'e ve -0.7125 mermi -0.712'ye (çünkü -0.712> -0.713). Bu, oluşturduğum ve herhangi bir ondalık sayı için çalışıyor:

double Redondea(double value, int precision, bool roundUp = true)
{
    if ((decimal)value == 0.0m)
        return 0.0;

    double corrector = 1 / Math.Pow(10, precision + 2);

    if ((decimal)value < 0.0m)
    {
        if (roundUp)
            return Math.Round(value, precision, MidpointRounding.ToEven);
        else
            return Math.Round(value - corrector, precision, MidpointRounding.AwayFromZero);
    }
    else
    {
        if (roundUp)
            return Math.Round(value + corrector, precision, MidpointRounding.AwayFromZero);
        else
            return Math.Round(value, precision, MidpointRounding.ToEven);
    }
}

'Düzeltici' değişkeni, kayan veya çift sayı ile çalışmanın yanlışlığını düzeltmek içindir.

Kontrol etmek isteyebileceğiniz bir şey, Matematiğin Yuvarlama Mekanizmasıdır.

http://msdn.microsoft.com/en-us/library/system.midpointrounding.aspx

Bunun dışında * 100/100 üzerinde Math.Round (inputNumer, numberOfPlaces) yaklaşımını öneriyorum çünkü daha temiz.

Math.Round'u kullanarak yuvarlamak istediğiniz basamak sayısını belirtebilmeniz gerekir (YourNumber, 2)

Daha fazlasını buradan okuyabilirsiniz .

Math.Floor (123456.646 * 100) / 100 123456.64 döndürür

string a = "10.65678";

ondalık d = Math.Round (Convert.ToDouble (a.ToString ()), 2)

Ondalık bir değişkenim olduğu garip bir durum vardı, 55.50 serileştirirken her zaman varsayılan değeri matematiksel olarak 55.5 olarak ayarlar. Ancak, müşteri sistemimiz ciddi bir şekilde 55,50 bekliyor ve kesinlikle ondalık bekliyorlardı. Ben her zaman bir dize göndermek yerine sıfırlar ile 2 basamaklı yastıklı herhangi bir ondalık değeri dönüştürür aşağıdaki yardımcı yazmıştı.

public static class DecimalExtensions
{
    public static decimal WithTwoDecimalPoints(this decimal val)
    {
        return decimal.Parse(val.ToString("0.00"));
    }
}

Kullanım olmalı

var sampleDecimalValueV1 = 2.5m;
Console.WriteLine(sampleDecimalValueV1.WithTwoDecimalPoints());

decimal sampleDecimalValueV1 = 2;
Console.WriteLine(sampleDecimalValueV1.WithTwoDecimalPoints());

Çıktı:

2.50
2.00

  public double RoundDown(double number, int decimalPlaces)
        {
            return Math.Floor(number * Math.Pow(10, decimalPlaces)) / Math.Pow(10, decimalPlaces);
        }