গোল না করে দুটি দশমিক স্থান ছাঁটাই করুন

Question 1

আসুন বলি যে আমার মান 3.4679 আছে এবং 3.46 চাই, আমি কীভাবে দুটি দশমিক জায়গায় কাটাতে পারি যে গোল না করে?

আমি নিম্নলিখিতটি চেষ্টা করেছি তবে তিনটিই আমাকে ৩.4747 দিয়েছে:

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

এটি ৩.4646 ফিরিয়ে দেয় তবে কিছুটা নোংরা মনে হয় কীভাবে:

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

Question 2

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

সাবধান থাকবেন যে এর মতো ভগ্নাংশগুলি ভাসমান স্থলে সঠিকভাবে উপস্থাপন করা যায় না।

Question 3

সি # তে দশমিকের কাটা রিয়েল-ওয়ার্ল্ড ব্যবহারের জন্য একটি সম্পূর্ণ ফাংশন ব্যবহার করা আরও কার্যকর হবে। আপনি চাইলে এটি দশমিক এক্সটেনশন পদ্ধতিতে রূপান্তরিত হতে পারে:

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

আপনার যদি ভিবি.এনইটি প্রয়োজন হয় তবে এটি ব্যবহার করে দেখুন:

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

তারপরে এটির মতো ব্যবহার করুন:

decimal result = TruncateDecimal(0.275, 2);

বা

Dim result As Decimal = TruncateDecimal(0.275, 2)

Question 4

মডুলাস অপারেটরটি ব্যবহার করুন:

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

ফলাফল: 0.54

Question 5

এর জন্য সর্বজনীন এবং দ্রুত পদ্ধতি ( Math.Pow()গুণ / ছাড়াই ) 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;
}

Question 6

অন্যান্য উদাহরণগুলির সাথে একটি সমস্যা হ'ল তারা ভাগ করার আগে ইনপুট মানকে গুণ করে । এখানে একটি প্রান্তের কেস রয়েছে যা আপনি দশমিকের ওভারফ্লো করতে পারেন, প্রথমে একটি কিনার কেস, তবে কিছু আমি পেরিয়ে এসেছি। ভগ্নাংশের অংশটি আলাদাভাবে মোকাবেলা করা আরও নিরাপদ:

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

Question 7

আমি দশমিক সংখ্যার জন্য সমাধানটি ছেড়ে দেব।

এখানে দশমিকের জন্য কয়েকটি সমাধান ওভারফ্লো প্রবণ (যদি আমরা একটি খুব বড় দশমিক সংখ্যা পাস করি এবং পদ্ধতিটি এটির গুণক করার চেষ্টা করবে)।

টিম লয়েডের সমাধান ওভারফ্লো থেকে সুরক্ষিত তবে এটি খুব দ্রুত নয়।

নিম্নলিখিত সমাধানটি প্রায় 2 গুণ দ্রুত এবং এতে ওভারফ্লো সমস্যা নেই:

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

Question 8

এটি একটি পুরানো প্রশ্ন, তবে অনেক আনোসার খুব ভাল সংখ্যার জন্য ভাল সঞ্চালন বা ওভারফ্লো করে না। আমি মনে করি ডি নেস্টারভ উত্তরটি সবচেয়ে ভাল: শক্ত, সহজ এবং দ্রুত। আমি কেবল আমার দুটি সেন্ট যুক্ত করতে চাই। আমি দশমিকের সাথে প্রায় খেলেছি এবং উত্স কোডটিও দেখেছি । থেকে public Decimal (int lo, int mid, int hi, bool isNegative, byte scale) কন্সট্রাকটর ডকুমেন্টেশন ।

দশমিক সংখ্যার বাইনারি উপস্থাপনায় একটি 1-বিট চিহ্ন, একটি 96-বিট পূর্ণসংখ্যার সংখ্যা এবং একটি পূর্ণমান সংখ্যাটি ভাগ করতে ব্যবহৃত স্কেলিং ফ্যাক্টর এবং এর অংশটি দশমিক ভগ্নাংশ নির্দিষ্ট করে। স্কেলিং ফ্যাক্টরটি সুস্পষ্টভাবে 0 থেকে 28 এর মধ্যে কোনও এক্সপোনেন্টকে উত্থাপিত 10 নম্বর।

এটি জানতে পেরে আমার প্রথম পদ্ধতির মধ্যে অন্যটি তৈরি করা হয়েছিল decimalযার স্কেল আমি যে দশমিকের সাথে বাতিল করতে চাইছিলাম তার সাথে মিলে যায়, তারপরে এটি কেটে ফেলুন এবং শেষ পর্যন্ত পছন্দসই স্কেল সহ দশমিক তৈরি করুন।

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

এই পদ্ধতিটি ডি নেস্টারভের চেয়ে দ্রুত নয় এবং এটি আরও জটিল, তাই আমি আরও কিছুটা বেশি খেলেছি। আমার অনুমান যে একটি সহায়ক তৈরি করা decimalএবং বিট দু'বার পুনরুদ্ধার করা এটি ধীর করে দিচ্ছে। আমার দ্বিতীয় প্রচেষ্টায়, আমি নিজেই ডেসিমাল.গেটবিটস (দশমিক d) পদ্ধতি দ্বারা ফিরে আসা উপাদানগুলিকে চালিত করেছিলাম। ধারণাটি হ'ল উপাদানগুলি প্রয়োজন হিসাবে 10 বার হিসাবে বিভক্ত করা এবং স্কেল হ্রাস করা। কোডটি দশমিকের উপর ভিত্তি করে (ভারীভাবে) ইনটার্নালআউন্ডআউন্ড্রোমজিরো (রেফ ডেসিমাল ডি, ইন্টি ডেসিমাল কাউন্ট) পদ্ধতিতে ।

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

আমি কঠোর পারফরম্যান্স পরীক্ষা করিনি, তবে একটি ম্যাকওএস সিয়েরা 10.12.6, 3,06 গিগাহার্টজ ইন্টেল কোর আই 3 প্রসেসর এবং লক্ষ্যবস্তুতে। নেটকোর 2.1 এই পদ্ধতিটি ডি নেস্টারভের চেয়ে অনেক দ্রুত বলে মনে হচ্ছে (যেহেতু আমি সংখ্যা দেব না) , যেমনটি আমি বলেছি, আমার পরীক্ষাগুলি কঠোর নয়)। পারফরম্যান্স লাভ কোড যুক্ত জটিলতার জন্য প্রদান করে কি না তা মূল্যায়নের জন্য যে কেউ এটি প্রয়োগ করে এটি নির্ভর করে।

Question 9

এই আপনার জন্য কাজ করবে?

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

Question 10

((long)(3.4679 * 100)) / 100.0আপনি চান কি দিতে হবে?

Question 11

এখানে একটি এক্সটেনশন পদ্ধতি রয়েছে:

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

Question 12

আপনি যদি পারফরম্যান্স সম্পর্কে খুব বেশি চিন্তা না করেন এবং আপনার শেষ ফলাফলটি একটি স্ট্রিং হতে পারে তবে নীচের পদ্ধতিটি ভাসমান নির্ভুলতার ইস্যুগুলির জন্য স্থিতিস্থাপক হবে:

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

Question 13

এখানে আমার টিআরএনসি ফাংশনের বাস্তবায়ন

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

Question 14

এই সম্পর্কে কি?

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

Question 15

উপরের সমাধানগুলি ছাড়াও, আমরা আরও একটি উপায় অর্জন করতে পারি।

    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

Question 16

কিছু শর্তে এটি যথেষ্ট হতে পারে।

আমার সাবসেন্ট = 0.009999999999999999999999999999M এর দশমিক মান ছিল যা | সাবসেন্ট: 0.010000 | এ রূপান্তর করতে পারে মাধ্যমে string.Format("{0:N6}", SubCent );এবং অন্যান্য অনেক ফর্ম্যাটিং পছন্দ।

আমার প্রয়োজনটি সাবসেন্টের মানটি গোল করার নয়, তবে প্রতিটি সংখ্যায় লগ করাও ছিল না।

নিম্নলিখিত আমার প্রয়োজনীয়তা পূরণ করেছে:

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

যা স্ট্রিংটি প্রদান করে: | সাবসেন্ট: 0.0099999 |

একটি পূর্ণসংখ্যার অংশ থাকা মানটি সমন্বিত করার জন্য নিম্নলিখিতটি একটি সূচনা।

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

যা স্ট্রিংটি প্রদান করে:

valFmt4 = "567890.00999999"

Question 17

আমি স্ট্রিং ভেরিয়েবলের দশমিকের পরে মান কেটে ফেলতে এই ফাংশনটি ব্যবহার করছি

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

Question 18

আমি এটিই করেছি:

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

দশমিকের বৃত্তাকার বা নিচে গোল না করে দুটি ইনপুটযুক্ত সংখ্যা বিয়োগ করা। কারণ অন্যান্য সমাধানগুলি আমার পক্ষে কাজ করে না। এটি অন্যের পক্ষে কাজ করবে কিনা জানি না, আমি কেবল এটি ভাগ করে নিতে চাই :) আশা করি এটি আমার জন্য অনুরূপ সমস্যার সমাধান খুঁজছেন তাদের জন্য কাজ করে। ধন্যবাদ

পিএস: আমি একজন শিক্ষানবিস তাই এ সম্পর্কে কিছু জানাতে নির্দ্বিধায়। : ডি এটি ভাল যদি আপনি আসলে অর্থের মোকাবেলা করছেন, কেন সেন্টের কারণ? এটিতে কেবলমাত্র 2 দশমিক স্থান এবং এটি গোলাকার কোনও নম্বর নয়।

Question 19

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

Question 20

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

Question 21

আসলে আপনি 3.4679 থেকে 3.46 চান। এটি কেবল অক্ষরের প্রতিনিধিত্ব। সুতরাং গণিত ফাংশনটির সাথে কিছুই করার নেই ath ম্যাথ ফাংশনটি এই কাজটি করার উদ্দেশ্যে নয়। কেবল নিম্নলিখিত কোডটি ব্যবহার করুন।

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

উপরের কোডটি যে কোনও সংখ্যার জন্য সংশোধন করা যেতে পারে নিম্নলিখিত কোডটি একটি বোতাম ক্লিক ইভেন্টে রাখুন

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

Question 22

কি সম্পর্কে

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