Cắt bớt hai chữ số thập phân mà không làm tròn số

Giả sử tôi có giá trị là 3,4679 và muốn 3,46, làm thế nào tôi có thể cắt bớt đến hai chữ số thập phân mà không làm tròn số?

Tôi đã thử những cách sau nhưng cả ba đều cho tôi 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));
}

Điều này trả về 3,46, nhưng chỉ có vẻ bẩn một số cách:

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

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

Lưu ý rằng các phân số như thế này không thể được biểu diễn chính xác bằng dấu phẩy động.

Sẽ hữu ích hơn nếu có một hàm đầy đủ để sử dụng trong thế giới thực để cắt bớt một số thập phân trong C #. Điều này có thể được chuyển đổi thành một phương thức mở rộng thập phân khá dễ dàng nếu bạn muốn:

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

Nếu bạn cần VB.NET, hãy thử điều này:

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

Sau đó, sử dụng nó như vậy:

decimal result = TruncateDecimal(0.275, 2);

hoặc là

Dim result As Decimal = TruncateDecimal(0.275, 2)

Sử dụng toán tử mô đun:

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

kết quả: 0,54

Phương pháp phổ biến và nhanh chóng (không có Math.Pow()/ nhân) cho 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;
}

Một vấn đề với các ví dụ khác là chúng nhân giá trị đầu vào trước khi chia nó. Có một trường hợp cạnh ở đây mà bạn có thể làm tràn số thập phân bằng cách nhân đầu tiên, một trường hợp cạnh, nhưng một cái gì đó tôi đã gặp. Sẽ an toàn hơn nếu xử lý riêng phần phân số như sau:

    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;
    }

Tôi sẽ để lại lời giải cho các số thập phân.

Một số giải pháp cho số thập phân ở đây dễ bị tràn (nếu chúng ta chuyển một số thập phân rất lớn và phương pháp sẽ cố gắng nhân nó lên).

Giải pháp của Tim Lloyd được bảo vệ khỏi bị tràn nhưng nó không quá nhanh.

Giải pháp sau nhanh hơn khoảng 2 lần và không gặp sự cố tràn:

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));
}

Đây là một câu hỏi cũ, nhưng nhiều nhà cảm xạ không thực hiện tốt hoặc tràn cho những con số lớn. Tôi nghĩ câu trả lời của D. Nesterov là câu trả lời hay nhất: mạnh mẽ, đơn giản và nhanh chóng. Tôi chỉ muốn thêm hai xu của mình. Tôi đã thử với các số thập phân và cũng kiểm tra mã nguồn . Từ public Decimal (int lo, int mid, int hi, bool isNegative, byte scale) tài liệu xây dựng .

Biểu diễn nhị phân của số Thập phân bao gồm dấu 1 bit, số nguyên 96 bit và hệ số tỷ lệ được sử dụng để chia số nguyên và chỉ định phần nào của nó là phân số thập phân. Hệ số tỷ lệ ngầm hiểu là số 10 được nâng lên thành số mũ nằm trong khoảng từ 0 đến 28.

Biết được điều này, cách tiếp cận đầu tiên của tôi là tạo một cái khác decimalcó tỷ lệ tương ứng với các số thập phân mà tôi muốn loại bỏ, sau đó cắt bớt nó và cuối cùng tạo một số thập phân với tỷ lệ mong muốn.

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);
    }

Phương pháp này không nhanh hơn D. Nesterov và nó phức tạp hơn, vì vậy tôi đã chơi xung quanh nhiều hơn một chút. Tôi đoán rằng việc phải tạo một auxiliar decimalvà lấy các bit hai lần sẽ làm cho nó chậm hơn. Trong lần thử thứ hai, tôi đã tự mình thao tác các thành phần được trả về bởi phương thức Decimal.GetBits (Decimal d) . Ý tưởng là chia các thành phần cho 10 lần nếu cần và giảm tỷ lệ. Mã dựa trên (nhiều) phương thức 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;
    }

Tôi chưa thực hiện các bài kiểm tra hiệu suất nghiêm ngặt, nhưng trên bộ vi xử lý Intel Core i3 MacOS Sierra 10.12.6, 3.06 GHz và nhắm mục tiêu .NetCore 2.1, phương pháp này có vẻ nhanh hơn nhiều so với D. Nesterov (tôi sẽ không đưa ra con số vì , như tôi đã đề cập, các bài kiểm tra của tôi không nghiêm ngặt). Ai thực hiện điều này là tùy thuộc vào việc đánh giá xem liệu hiệu suất có được đền đáp cho sự phức tạp của mã thêm vào hay không.

Liệu nó có giúp hiệu quả với anh không?

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

Sẽ ((long)(3.4679 * 100)) / 100.0cung cấp cho những gì bạn muốn?

Đây là một phương pháp mở rộng:

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

Nếu bạn không lo lắng quá nhiều về hiệu suất và kết quả cuối cùng của bạn có thể là một chuỗi, thì cách tiếp cận sau sẽ có thể khắc phục được các vấn đề về độ chính xác nổi:

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);
}

Đây là cách tôi triển khai hàm TRUNC

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);
}

cái này thì sao?

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

Ngoài các giải pháp trên, có một cách khác mà chúng ta có thể đạt được.

    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

Trong một số điều kiện, điều này có thể đủ.

Tôi có giá trị thập phân của SubCent = 0,0099999999999999999999999999M có xu hướng định dạng thành | SubCent: 0,010000 | qua string.Format("{0:N6}", SubCent );và nhiều lựa chọn định dạng khác.

Yêu cầu của tôi là không làm tròn giá trị SubCent, nhưng cũng không ghi lại mọi chữ số.

Những điều sau đây đáp ứng yêu cầu của tôi:

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

Trả về chuỗi: | SubCent: 0,0099999 |

Để điều chỉnh giá trị có một phần nguyên, sau đây là một bắt đầu.

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

Trả về chuỗi:

valFmt4 = "567890.00999999"

tôi đang sử dụng hàm này để cắt bớt giá trị sau số thập phân trong một biến chuỗi

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;
        }
    }

Đây là những gì tôi đã làm:

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

trừ hai số đã nhập mà không làm tròn lên hoặc xuống các số thập phân. bởi vì các giải pháp khác không làm việc cho tôi. không biết nó có hiệu quả với những người khác không, tôi chỉ muốn chia sẻ điều này :) Hy vọng nó có hiệu quả với những ai đang tìm giải pháp cho một vấn đề tương tự như của tôi. Cảm ơn

Tái bút: Tôi là người mới bắt đầu nên vui lòng chỉ ra vài điều về điều này. : D điều này là tốt nếu bạn đang thực sự giao dịch với tiền, nguyên nhân từ xu phải không? nó chỉ có 2 chữ số thập phân và làm tròn nó là một không.

        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);

public static decimal TruncateDecimalPlaces(this decimal value, int precision)
    {
        try
        {
            step = (decimal)Math.Pow(10, precision);
            decimal tmp = Math.Truncate(step * value);
            return tmp / step;
        }
        catch (OverflowException)
        {
            step = (decimal)Math.Pow(10, -1 * precision);
            return value - (value % step);
        }
    }

Trên thực tế, bạn muốn 3,46 từ 3,4679. Đây chỉ là biểu diễn của các ký tự nên không liên quan gì đến hàm toán học, hàmath không nhằm mục đích thực hiện công việc này. Đơn giản chỉ cần sử dụng mã sau.

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

Mã trên có thể được sửa đổi cho bất kỳ số nào Đặt mã sau vào sự kiện nhấp vào nút

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

Thế còn

var i = Math.Truncate(number);

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