Zwei Dezimalstellen ohne Rundung abschneiden

Nehmen wir an, ich habe einen Wert von 3,4679 und möchte 3,46. Wie kann ich das auf zwei Dezimalstellen kürzen, ohne aufzurunden?

Ich habe folgendes versucht, aber alle drei geben mir 3,47:

void Main()
{
    Console.Write(Math.Round(3.4679, 2,MidpointRounding.ToEven));
    Console.Write(Math.Round(3.4679, 2,MidpointRounding.AwayFromZero));
    Console.Write(Math.Round(3.4679, 2));
}

Dies gibt 3,46 zurück, scheint aber nur ein bisschen schmutzig zu sein wie:

void Main()
{
    Console.Write(Math.Round(3.46799999999 -.005 , 2));
}

value = Math.Truncate(100 * value) / 100;

Beachten Sie, dass solche Brüche im Gleitkomma nicht genau dargestellt werden können.

Es wäre nützlicher, eine vollständige Funktion für die reale Verwendung des Abschneidens einer Dezimalstelle in C # zu haben. Dies könnte ziemlich einfach in eine Dezimalerweiterungsmethode konvertiert werden, wenn Sie möchten:

public decimal TruncateDecimal(decimal value, int precision)
{
    decimal step = (decimal)Math.Pow(10, precision);
    decimal tmp = Math.Truncate(step * value);
    return tmp / step;
}

Wenn Sie VB.NET benötigen, versuchen Sie Folgendes:

Function TruncateDecimal(value As Decimal, precision As Integer) As Decimal
    Dim stepper As Decimal = Math.Pow(10, precision)
    Dim tmp As Decimal = Math.Truncate(stepper * value)
    Return tmp / stepper
End Function

Dann benutze es so:

decimal result = TruncateDecimal(0.275, 2);

oder

Dim result As Decimal = TruncateDecimal(0.275, 2)

Verwenden Sie den Moduloperator:

var fourPlaces = 0.5485M;
var twoPlaces = fourPlaces - (fourPlaces % 0.01M);

Ergebnis: 0,54

Universelle und schnelle Methode (ohne Math.Pow()/ Multiplikation) für System.Decimal:

decimal Truncate(decimal d, byte decimals)
{
    decimal r = Math.Round(d, decimals);

    if (d > 0 && r > d)
    {
        return r - new decimal(1, 0, 0, false, decimals);
    }
    else if (d < 0 && r < d)
    {
        return r + new decimal(1, 0, 0, false, decimals);
    }

    return r;
}

Ein Problem bei den anderen Beispielen ist, dass sie den Eingabewert multiplizieren, bevor sie geteilt werden. Hier gibt es einen Kantenfall, bei dem Sie die Dezimalzahl überlaufen können, indem Sie zuerst einen Kantenfall multiplizieren, aber etwas, auf das ich gestoßen bin. Es ist sicherer, den Bruchteil wie folgt separat zu behandeln:

    public static decimal TruncateDecimal(this decimal value, int decimalPlaces)
    {
        decimal integralValue = Math.Truncate(value);

        decimal fraction = value - integralValue;

        decimal factor = (decimal)Math.Pow(10, decimalPlaces);

        decimal truncatedFraction = Math.Truncate(fraction * factor) / factor;

        decimal result = integralValue + truncatedFraction;

        return result;
    }

Ich werde die Lösung für Dezimalzahlen verlassen.

Einige der Lösungen für Dezimalstellen hier neigen zum Überlaufen (wenn wir eine sehr große Dezimalzahl übergeben und die Methode versucht, sie zu multiplizieren).

Die Lösung von Tim Lloyd ist vor Überlauf geschützt, aber nicht zu schnell.

Die folgende Lösung ist ungefähr zweimal schneller und hat kein Überlaufproblem:

public static class DecimalExtensions
{
    public static decimal TruncateEx(this decimal value, int decimalPlaces)
    {
        if (decimalPlaces < 0)
            throw new ArgumentException("decimalPlaces must be greater than or equal to 0.");

        var modifier = Convert.ToDecimal(0.5 / Math.Pow(10, decimalPlaces));
        return Math.Round(value >= 0 ? value - modifier : value + modifier, decimalPlaces);
    }
}

[Test]
public void FastDecimalTruncateTest()
{
    Assert.AreEqual(-1.12m, -1.129m. TruncateEx(2));
    Assert.AreEqual(-1.12m, -1.120m. TruncateEx(2));
    Assert.AreEqual(-1.12m, -1.125m. TruncateEx(2));
    Assert.AreEqual(-1.12m, -1.1255m.TruncateEx(2));
    Assert.AreEqual(-1.12m, -1.1254m.TruncateEx(2));
    Assert.AreEqual(0m,      0.0001m.TruncateEx(3));
    Assert.AreEqual(0m,     -0.0001m.TruncateEx(3));
    Assert.AreEqual(0m,     -0.0000m.TruncateEx(3));
    Assert.AreEqual(0m,      0.0000m.TruncateEx(3));
    Assert.AreEqual(1.1m,    1.12m.  TruncateEx(1));
    Assert.AreEqual(1.1m,    1.15m.  TruncateEx(1));
    Assert.AreEqual(1.1m,    1.19m.  TruncateEx(1));
    Assert.AreEqual(1.1m,    1.111m. TruncateEx(1));
    Assert.AreEqual(1.1m,    1.199m. TruncateEx(1));
    Assert.AreEqual(1.2m,    1.2m.   TruncateEx(1));
    Assert.AreEqual(0.1m,    0.14m.  TruncateEx(1));
    Assert.AreEqual(0,      -0.05m.  TruncateEx(1));
    Assert.AreEqual(0,      -0.049m. TruncateEx(1));
    Assert.AreEqual(0,      -0.051m. TruncateEx(1));
    Assert.AreEqual(-0.1m,  -0.14m.  TruncateEx(1));
    Assert.AreEqual(-0.1m,  -0.15m.  TruncateEx(1));
    Assert.AreEqual(-0.1m,  -0.16m.  TruncateEx(1));
    Assert.AreEqual(-0.1m,  -0.19m.  TruncateEx(1));
    Assert.AreEqual(-0.1m,  -0.199m. TruncateEx(1));
    Assert.AreEqual(-0.1m,  -0.101m. TruncateEx(1));
    Assert.AreEqual(0m,     -0.099m. TruncateEx(1));
    Assert.AreEqual(0m,     -0.001m. TruncateEx(1));
    Assert.AreEqual(1m,      1.99m.  TruncateEx(0));
    Assert.AreEqual(1m,      1.01m.  TruncateEx(0));
    Assert.AreEqual(-1m,    -1.99m.  TruncateEx(0));
    Assert.AreEqual(-1m,    -1.01m.  TruncateEx(0));
}

Dies ist eine alte Frage, aber viele Antworten funktionieren bei großen Zahlen nicht gut oder laufen nicht über. Ich denke, die Antwort von D. Nesterov ist die beste: robust, einfach und schnell. Ich möchte nur meine zwei Cent hinzufügen. Ich habe mit Dezimalstellen herumgespielt und auch den Quellcode überprüft . Aus der public Decimal (int lo, int mid, int hi, bool isNegative, byte scale) Konstruktordokumentation .

Die binäre Darstellung einer Dezimalzahl besteht aus einem 1-Bit-Vorzeichen, einer 96-Bit-Ganzzahl und einem Skalierungsfaktor, mit dem die Ganzzahl geteilt und angegeben wird, welcher Teil davon ein Dezimalbruch ist. Der Skalierungsfaktor ist implizit die Zahl 10, die auf einen Exponenten im Bereich von 0 bis 28 angehoben wird.

In diesem Wissen bestand mein erster Ansatz darin, eine andere zu erstellen, decimalderen Skalierung den Dezimalstellen entspricht, die ich verwerfen wollte, sie dann abzuschneiden und schließlich eine Dezimalstelle mit der gewünschten Skalierung zu erstellen.

private const int ScaleMask = 0x00FF0000;
    public static Decimal Truncate(decimal target, byte decimalPlaces)
    {
        var bits = Decimal.GetBits(target);
        var scale = (byte)((bits[3] & (ScaleMask)) >> 16);

        if (scale <= decimalPlaces)
            return target;

        var temporalDecimal = new Decimal(bits[0], bits[1], bits[2], target < 0, (byte)(scale - decimalPlaces));
        temporalDecimal = Math.Truncate(temporalDecimal);

        bits = Decimal.GetBits(temporalDecimal);
        return new Decimal(bits[0], bits[1], bits[2], target < 0, decimalPlaces);
    }

Diese Methode ist nicht schneller als die von D. Nesterov und komplexer, also habe ich ein bisschen mehr herumgespielt. Ich vermute, dass decimales langsamer wird, wenn man ein Auxiliar erstellen und die Bits zweimal abrufen muss. Bei meinem zweiten Versuch habe ich die von der Decimal.GetBits (Decimal d) -Methode zurückgegebenen Komponenten selbst manipuliert . Die Idee ist, die Komponenten so oft wie nötig durch 10 zu teilen und den Maßstab zu reduzieren. Der Code basiert (stark) auf der Methode Decimal.InternalRoundFromZero (ref Decimal d, int decimalCount) .

private const Int32 MaxInt32Scale = 9;
private const int ScaleMask = 0x00FF0000;
    private const int SignMask = unchecked((int)0x80000000);
    // Fast access for 10^n where n is 0-9        
    private static UInt32[] Powers10 = new UInt32[] {
        1,
        10,
        100,
        1000,
        10000,
        100000,
        1000000,
        10000000,
        100000000,
        1000000000
    };

    public static Decimal Truncate(decimal target, byte decimalPlaces)
    {
        var bits = Decimal.GetBits(target);
        int lo = bits[0];
        int mid = bits[1];
        int hi = bits[2];
        int flags = bits[3];

        var scale = (byte)((flags & (ScaleMask)) >> 16);
        int scaleDifference = scale - decimalPlaces;
        if (scaleDifference <= 0)
            return target;

        // Divide the value by 10^scaleDifference
        UInt32 lastDivisor;
        do
        {
            Int32 diffChunk = (scaleDifference > MaxInt32Scale) ? MaxInt32Scale : scaleDifference;
            lastDivisor = Powers10[diffChunk];
            InternalDivRemUInt32(ref lo, ref mid, ref hi, lastDivisor);
            scaleDifference -= diffChunk;
        } while (scaleDifference > 0);


        return new Decimal(lo, mid, hi, (flags & SignMask)!=0, decimalPlaces);
    }
    private static UInt32 InternalDivRemUInt32(ref int lo, ref int mid, ref int hi, UInt32 divisor)
    {
        UInt32 remainder = 0;
        UInt64 n;
        if (hi != 0)
        {
            n = ((UInt32)hi);
            hi = (Int32)((UInt32)(n / divisor));
            remainder = (UInt32)(n % divisor);
        }
        if (mid != 0 || remainder != 0)
        {
            n = ((UInt64)remainder << 32) | (UInt32)mid;
            mid = (Int32)((UInt32)(n / divisor));
            remainder = (UInt32)(n % divisor);
        }
        if (lo != 0 || remainder != 0)
        {
            n = ((UInt64)remainder << 32) | (UInt32)lo;
            lo = (Int32)((UInt32)(n / divisor));
            remainder = (UInt32)(n % divisor);
        }
        return remainder;
    }

Ich habe keine strengen Leistungstests durchgeführt, aber auf einem MacOS Sierra 10.12.6, 3.06 GHz Intel Core i3-Prozessor und Targeting .NetCore 2.1 scheint diese Methode viel schneller zu sein als die von D. Nesterov (ich werde seitdem keine Zahlen mehr angeben Wie bereits erwähnt, sind meine Tests nicht streng. Es liegt an jedem, der dies implementiert, zu bewerten, ob sich die Leistungssteigerungen für die zusätzliche Codekomplexität auszahlen oder nicht.

würde das für dich funktionieren?

Console.Write(((int)(3.4679999999*100))/100.0);

Würden Sie ((long)(3.4679 * 100)) / 100.0geben, was Sie wollen?

Hier ist eine Erweiterungsmethode:

public static decimal? TruncateDecimalPlaces(this decimal? value, int places)
    {
        if (value == null)
        {
            return null;
        }

        return Math.Floor((decimal)value * (decimal)Math.Pow(10, places)) / (decimal)Math.Pow(10, places);

    } // end

Wenn Sie sich nicht zu viele Sorgen um die Leistung machen und Ihr Endergebnis eine Zeichenfolge sein kann, ist der folgende Ansatz für Probleme mit schwebender Genauigkeit unempfindlich:

string Truncate(double value, int precision)
{
    if (precision < 0)
    {
        throw new ArgumentOutOfRangeException("Precision cannot be less than zero");
    }

    string result = value.ToString();

    int dot = result.IndexOf('.');
    if (dot < 0)
    {
        return result;
    }

    int newLength = dot + precision + 1;

    if (newLength == dot + 1)
    {
        newLength--;
    }

    if (newLength > result.Length)
    {
        newLength = result.Length;
    }

    return result.Substring(0, newLength);
}

Hier ist meine Implementierung der TRUNC-Funktion

private static object Tranc(List<Expression.Expression> p)
{
    var target = (decimal)p[0].Evaluate();

    // check if formula contains only one argument
    var digits = p.Count > 1
        ? (decimal) p[1].Evaluate()
        : 0;

    return Math.Truncate((double)target * Math.Pow(10, (int)digits)) / Math.Pow(10, (int)digits);
}

was ist damit?

Function TruncateDecimal2(MyValue As Decimal) As Decimal
        Try
            Return Math.Truncate(100 * MyValue) / 100
        Catch ex As Exception
            Return Math.Round(MyValue, 2)
        End Try
End Function

Abgesehen von den oben genannten Lösungen gibt es noch einen anderen Weg, den wir erreichen können.

    decimal val=23.5678m,finalValue;

    //take the decimal part    
     int decimalPos = val.ToString().IndexOf('.');
     string decimalPart = val.ToString().Substring(decimalPosition+1,val.ToString().Length);
    //will result.56
   string wholePart=val.ToString().Substring(0,decimalPos-1);
   //concantinate and parse for decimal.
  string truncatedValue=wholePart+decimalPart;//"23.56"
  bool isDecimal=Decimal.tryParse(truncatedValue,out finalValue);//finalValue=23.56

Unter bestimmten Umständen kann dies ausreichen.

Ich hatte einen Dezimalwert von SubCent = 0,0099999999999999999999999999M , der dazu neigt, auf | SubCent: 0,010000 | zu formatieren überstring.Format("{0:N6}", SubCent ); und viele andere Formatierungsoptionen.

Meine Anforderung war nicht, den SubCent-Wert zu runden, sondern auch nicht jede Ziffer zu protokollieren.

Folgendes erfüllte meine Anforderung:

string.Format("SubCent:{0}|", 
    SubCent.ToString("N10", CultureInfo.InvariantCulture).Substring(0, 9));

Was die Zeichenfolge zurückgibt: | SubCent: 0.0099999 |

Um den Wert mit einem ganzzahligen Teil aufzunehmen, ist das Folgende ein Anfang.

tmpValFmt = 567890.0099999933999229999999M.ToString("0.0000000000000000000000000000");
decPt = tmpValFmt.LastIndexOf(".");
if (decPt < 0) decPt = 0;
valFmt4 = string.Format("{0}", tmpValFmt.Substring(0, decPt + 9));

Welches gibt die Zeichenfolge zurück:

valFmt4 = "567890.00999999"

Ich benutze diese Funktion, um Wert nach Dezimalstelle in einer Zeichenfolgenvariablen abzuschneiden

public static string TruncateFunction(string value)
    {
        if (string.IsNullOrEmpty(value)) return "";
        else
        {
            string[] split = value.Split('.');
            if (split.Length > 0)
            {
                string predecimal = split[0];
                string postdecimal = split[1];
                postdecimal = postdecimal.Length > 6 ? postdecimal.Substring(0, 6) : postdecimal;
                return predecimal + "." + postdecimal;

            }
            else return value;
        }
    }

Das habe ich getan:

        c1 = a1 - b1;
        d1 = Math.Ceiling(c1 * 100) / 100;

Subtrahieren von zwei eingegebenen Zahlen, ohne die Dezimalstellen auf- oder abzurunden. weil die anderen Lösungen bei mir nicht funktionieren. Ich weiß nicht, ob es für andere funktionieren wird, ich möchte dies nur teilen :) Ich hoffe, es funktioniert auch für diejenigen, die eine Lösung für ein ähnliches Problem wie ich finden. Vielen Dank

PS: Ich bin ein Anfänger, also zögern Sie nicht, darauf hinzuweisen. : D Das ist gut, wenn Sie tatsächlich mit Geld zu tun haben, wegen der Cent, oder? Es hat nur 2 Dezimalstellen und die Rundung ist ein Nein Nein.

        public static void ReminderDigints(decimal? number, out decimal? Value,  out decimal? Reminder)
        {
            Reminder = null;
            Value = null;
            if (number.HasValue)
            {
                Value = Math.Floor(number.Value);
                Reminder = (number - Math.Truncate(number.Value));
            }
        }



        decimal? number= 50.55m;             
        ReminderDigints(number, out decimal? Value, out decimal? Reminder);

Eigentlich willst du 3.46 von 3.4679. Dies ist nur eine Darstellung von Zeichen. Es gibt also nichts mit der mathematischen Funktion zu tun. Die Math-Funktion ist nicht für diese Arbeit vorgesehen. Verwenden Sie einfach den folgenden Code.

Dim str1 As String
str1=""
str1 ="3.4679" 
  Dim substring As String = str1.Substring(0, 3)

    ' Write the results to the screen.
    Console.WriteLine("Substring: {0}", substring)

Or 
    Please use the following code.
Public function result(ByVal x1 As Double) As String 
  Dim i as  Int32
  i=0
  Dim y as String
  y = ""
  For Each ch as Char In x1.ToString
    If i>3 then
     Exit For
    Else
    y + y +ch
    End if
    i=i+1
  Next
  return y
End Function

Der obige Code kann für beliebige Zahlen geändert werden. Fügen Sie den folgenden Code in ein Schaltflächenklickereignis ein

Dim str As String 
str= result(3.4679)
 MsgBox("The number is " & str)

wie wäre es mit

var i = Math.Truncate(number);

var r = i + Math.Truncate((number - i) * 100) / 100;