संस्कृति की परवाह किए बिना दशमलव मान में दशमलव स्थानों की संख्या ज्ञात करें

Question 1

अगर एक दशमलव मान में दशमलव स्थानों की संख्या को बाहर निकालने के लिए एक संक्षिप्त और सटीक तरीका है, तो मैं सोच रहा हूं कि क्या विभिन्न संस्कृति जानकारी का उपयोग करना सुरक्षित होगा?

उदाहरण के लिए:
19.0 को 1 वापस करना चाहिए,
27.5999 को 4 वापस आना चाहिए,
19.12 को 2 वापस आना चाहिए,
आदि।

मैंने एक क्वेरी लिखी थी जिसने दशमलव स्थानों को खोजने के लिए एक स्ट्रिंग को विभाजित किया था:

int priceDecimalPlaces = price.ToString().Split('.').Count() > 1 
                  ? price.ToString().Split('.').ToList().ElementAt(1).Length 
                  : 0;

लेकिन मेरे साथ ऐसा होता है कि यह केवल उन क्षेत्रों में काम करेगा जो 'का उपयोग करते हैं।' एक दशमलव विभाजक के रूप में और इसलिए विभिन्न प्रणालियों में बहुत भंगुर है।

Question 2

मैंने इस मुद्दे को हल करने के लिए जो के तरीके का उपयोग किया :)

decimal argument = 123.456m;
int count = BitConverter.GetBytes(decimal.GetBits(argument)[3])[2];

Question 3

चूंकि आपूर्ति किए गए उत्तरों में से कोई भी जादू की संख्या "-0.01f" के लिए पर्याप्त नहीं था, जिसे दशमलव में परिवर्तित किया गया है .. यानी: GetDecimal((decimal)-0.01f);
मैं केवल यह मान सकता हूं कि 3 साल पहले हर किसी पर एक भारी दिमाग का वायरस हमला किया गया था :)
यहाँ वही है जो एक काम लगता है इस बुराई और राक्षसी समस्या को लागू करना, दशमलव स्थानों को गिनने की बहुत ही जटिल समस्या - बिंदु के बिना कोई स्ट्रिंग, कोई संस्कृतियाँ, बिट्स को गिनने की आवश्यकता नहीं है और न ही गणित के मंचों को पढ़ने की आवश्यकता है .. बस सरल 3 ग्रेड गणित।

public static class MathDecimals
{
    public static int GetDecimalPlaces(decimal n)
    {
        n = Math.Abs(n); //make sure it is positive.
        n -= (int)n;     //remove the integer part of the number.
        var decimalPlaces = 0;
        while (n > 0)
        {
            decimalPlaces++;
            n *= 10;
            n -= (int)n;
        }
        return decimalPlaces;
    }
}

private static void Main(string[] args)
{
    Console.WriteLine(1/3m); //this is 0.3333333333333333333333333333
    Console.WriteLine(1/3f); //this is 0.3333333

    Console.WriteLine(MathDecimals.GetDecimalPlaces(0.0m));                  //0
    Console.WriteLine(MathDecimals.GetDecimalPlaces(1/3m));                  //28
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)(1 / 3f)));     //7
    Console.WriteLine(MathDecimals.GetDecimalPlaces(-1.123m));               //3
    Console.WriteLine(MathDecimals.GetDecimalPlaces(43.12345m));             //5
    Console.WriteLine(MathDecimals.GetDecimalPlaces(0));                     //0
    Console.WriteLine(MathDecimals.GetDecimalPlaces(0.01m));                 //2
    Console.WriteLine(MathDecimals.GetDecimalPlaces(-0.001m));               //3
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)-0.00000001f)); //8
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)0.0001234f));   //7
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)0.01f));        //2
    Console.WriteLine(MathDecimals.GetDecimalPlaces((decimal)-0.01f));       //2
}

Question 4

मैं शायद @ निर्धारण के उत्तर में समाधान का उपयोग करूंगा ।

हालाँकि, जबकि दशमलव संरचना में दशमलव की संख्या प्राप्त करने की कोई विधि नहीं है, आप द्विआधारी प्रतिनिधित्व को निकालने के लिए Decimal.GetBits को कॉल कर सकते हैं , फिर पूर्णांक की संख्या की गणना करने के लिए पूर्णांक मान और पैमाने का उपयोग करें।

यह संभवतः एक स्ट्रिंग के रूप में प्रारूपण करने से अधिक तेज़ होगा, हालांकि आपको अंतर को नोटिस करने के लिए एक बहुत अधिक दशमलव का प्रसंस्करण करना होगा।

मैं एक अभ्यास के रूप में कार्यान्वयन को छोड़ दूंगा।

Question 5

Burn_LEGION की पोस्ट में दशमलव बिंदु दिखाए जाने के बाद अंकों की संख्या खोजने के लिए सबसे अच्छे समाधानों में से एक है ।

यहाँ मैं STSdb फोरम लेख के कुछ हिस्सों का उपयोग कर रहा हूँ: दशमलव बिंदु के बाद अंकों की संख्या ।

MSDN में हम निम्नलिखित स्पष्टीकरण पढ़ सकते हैं:

"एक दशमलव संख्या एक फ़्लोटिंग-पॉइंट मान है जिसमें एक चिन्ह, एक संख्यात्मक मान होता है, जहाँ मूल्य का प्रत्येक अंक 0 से 9 तक होता है, और एक स्केलिंग कारक जो एक अस्थायी दशमलव बिंदु की स्थिति को इंगित करता है जो अभिन्न और आंशिक को अलग करता है संख्यात्मक मान के कुछ हिस्से। "

और भी:

"दशमलव मान के द्विआधारी प्रतिनिधित्व में 1-बिट चिन्ह, 96-बिट पूर्णांक संख्या और 96-बिट पूर्णांक को विभाजित करने के लिए उपयोग किया जाने वाला स्केलिंग कारक होता है और निर्दिष्ट करता है कि इसका कौन सा भाग दशमलव अंश है। स्केलिंग कारक। अनुमानित रूप से संख्या 10, जो 0 से 28 तक के एक घातांक तक बढ़ा दी गई है। "

आंतरिक स्तर पर दशमलव मान चार पूर्णांक मानों द्वारा दर्शाया जाता है।

दशमलव आंतरिक प्रतिनिधित्व

आंतरिक प्रतिनिधित्व प्राप्त करने के लिए सार्वजनिक रूप से उपलब्ध GetBits फ़ंक्शन है। फ़ंक्शन एक int [] सरणी देता है:

[__DynamicallyInvokable] 
public static int[] GetBits(decimal d)
{
    return new int[] { d.lo, d.mid, d.hi, d.flags };
}

लौटे सरणी के चौथे तत्व में एक स्केल फैक्टर और एक चिन्ह होता है। और जैसा कि MSDN कहता है कि स्केलिंग फैक्टर संख्या 10 है, जो 0 से 28 तक के एक घातांक तक बढ़ा है। ठीक यही हमें चाहिए।

इस प्रकार, उपरोक्त सभी जांचों के आधार पर हम अपनी विधि का निर्माण कर सकते हैं:

private const int SIGN_MASK = ~Int32.MinValue;

public static int GetDigits4(decimal value)
{
    return (Decimal.GetBits(value)[3] & SIGN_MASK) >> 16;
}

यहां साइन को नजरअंदाज करने के लिए एक SIGN_MASK का उपयोग किया जाता है। तार्किक होने के बाद और हमने वास्तविक स्केल फैक्टर प्राप्त करने के लिए 16 बिट्स के साथ परिणाम को दाईं ओर स्थानांतरित कर दिया है। यह मान, अंततः दशमलव बिंदु के बाद अंकों की संख्या को इंगित करता है।

ध्यान दें कि यहाँ MSDN भी कहता है कि स्केलिंग फैक्टर किसी भी अनुगामी शून्य को दशमलव संख्या में संरक्षित करता है। ट्रेलिंग शून्य अंकगणितीय या तुलनात्मक संचालन में एक दशमलव संख्या के मूल्य को प्रभावित नहीं करते हैं। हालाँकि, ट्रेसिंग विधि द्वारा ट्रेलिंग जीरो को प्रकट किया जा सकता है यदि एक उपयुक्त प्रारूप स्ट्रिंग लागू किया जाता है।

यह समाधान सबसे अच्छा लगता है, लेकिन रुको, और भी बहुत कुछ है। C # में निजी विधियों का उपयोग करके हम झंडे के क्षेत्र तक सीधी पहुंच बनाने और अंतर सरणी के निर्माण से बचने के लिए अभिव्यक्ति का उपयोग कर सकते हैं:

public delegate int GetDigitsDelegate(ref Decimal value);

public class DecimalHelper
{
    public static readonly DecimalHelper Instance = new DecimalHelper();

    public readonly GetDigitsDelegate GetDigits;
    public readonly Expression<GetDigitsDelegate> GetDigitsLambda;

    public DecimalHelper()
    {
        GetDigitsLambda = CreateGetDigitsMethod();
        GetDigits = GetDigitsLambda.Compile();
    }

    private Expression<GetDigitsDelegate> CreateGetDigitsMethod()
    {
        var value = Expression.Parameter(typeof(Decimal).MakeByRefType(), "value");

        var digits = Expression.RightShift(
            Expression.And(Expression.Field(value, "flags"), Expression.Constant(~Int32.MinValue, typeof(int))), 
            Expression.Constant(16, typeof(int)));

        //return (value.flags & ~Int32.MinValue) >> 16

        return Expression.Lambda<GetDigitsDelegate>(digits, value);
    }
}

यह संकलित कोड GetDigits फ़ील्ड को सौंपा गया है। ध्यान दें कि फ़ंक्शन दशमलव मान को रेफरी के रूप में प्राप्त करता है, इसलिए कोई वास्तविक नकल नहीं की जाती है - केवल मूल्य के लिए एक संदर्भ। DecimalHelper से GetDigits फ़ंक्शन का उपयोग करना आसान है:

decimal value = 3.14159m;
int digits = DecimalHelper.Instance.GetDigits(ref value);

दशमलव मानों के लिए दशमलव बिंदु के बाद अंकों की संख्या प्राप्त करने के लिए यह सबसे तेज़ संभव विधि है।

Question 6

दशमलव के आंतरिक प्रतिनिधित्व पर भरोसा करना अच्छा नहीं है।

इस बारे में कैसा है:

    int CountDecimalDigits(decimal n)
    {
        return n.ToString(System.Globalization.CultureInfo.InvariantCulture)
                //.TrimEnd('0') uncomment if you don't want to count trailing zeroes
                .SkipWhile(c => c != '.')
                .Skip(1)
                .Count();
    }

Question 7

आप InvariantCulture का उपयोग कर सकते हैं

string priceSameInAllCultures = price.ToString(System.Globalization.CultureInfo.InvariantCulture);

एक और संभावना कुछ ऐसा करने की होगी:

private int GetDecimals(decimal d, int i = 0)
{
    decimal multiplied = (decimal)((double)d * Math.Pow(10, i));
    if (Math.Round(multiplied) == multiplied)
        return i;
    return GetDecimals(d, i+1);
}

Question 8

यहाँ पर ज्यादातर लोग इस बात से अनजान हैं कि दशमलव ट्रेलिंग जीरो को भंडारण और मुद्रण के लिए महत्वपूर्ण मानता है।

तो 0.1 m, 0.10 m और 0.100 m की तुलना बराबर हो सकती है, वे अलग-अलग तरीके से संग्रहित किए जाते हैं (क्रमशः मूल्य / स्केल 1/1, 10/2 और 100/3,), और क्रमशः 0.1, 0.10 और 0.100 के रूप में मुद्रित किया जाएगा। , द्वारा ToString()।

जैसे, "बहुत अधिक सटीक" रिपोर्ट करने वाले समाधान वास्तव में सही सटीकता की रिपोर्ट कर रहे हैं decimal।

इसके अलावा, गणित-आधारित समाधान (जैसे कि 10 की शक्तियों से गुणा करना) की संभावना बहुत धीमी होगी (अंकगणित के लिए डबल की तुलना में दशमलव ~ 40x धीमा है, और आप फ़्लोटिंग-पॉइंट में मिश्रण नहीं करना चाहते हैं क्योंकि यह अप्रासंगिकता को लागू करने की संभावना है )। इसी तरह, ट्रंकटिंग के साधन के रूप में intया उसके लिए कास्टिंग longत्रुटि-प्रवण है ( decimalउन दोनों की तुलना में बहुत अधिक रेंज है - यह लगभग 96-बिट पूर्णांक पर आधारित है)।

हालांकि, जैसा कि सुरुचिपूर्ण नहीं है, निम्नलिखित संभावना को प्राप्त करने के लिए सबसे तेज़ तरीके में से एक होगा (जब "शून्य स्थानों को छोड़कर दशमलव स्थान" के रूप में परिभाषित किया गया हो):

public static int PrecisionOf(decimal d) {
  var text = d.ToString(System.Globalization.CultureInfo.InvariantCulture).TrimEnd('0');
  var decpoint = text.IndexOf('.');
  if (decpoint < 0)
    return 0;
  return text.Length - decpoint - 1;
}

अपरिवर्तनीय संस्कृति एक 'की गारंटी देती है।' दशमलव बिंदु के रूप में, अनुगामी शून्य को छंटनी की जाती है, और फिर यह देखने की बात है कि दशमलव बिंदु के बाद कितने पद बने रहते हैं (यदि एक भी है)।

संपादित करें: बदले हुए प्रकार को इंट में बदलें

Question 9

और यहाँ एक और तरीका है, SqlDecimal प्रकार का उपयोग करें जिसमें दशमलव के दाईं ओर अंकों की गणना के साथ एक पैमाना गुण है। अपने दशमलव मान को SqlDecimal में जमा करें और फिर स्केल पर पहुँचें।

((SqlDecimal)(decimal)yourValue).Scale

Question 10

अब तक, लगभग सभी सूचीबद्ध समाधान जीसी मेमोरी आवंटित कर रहे हैं, जो कि चीजों को करने के लिए सी # तरीका है, लेकिन प्रदर्शन से दूर महत्वपूर्ण वातावरण में आदर्श है। (जो लोग लूप का आवंटन नहीं करते हैं और ज़ीरो को ध्यान में नहीं रखते हैं।)

तो जीसी एलोक्स से बचने के लिए, आप स्केल बिट्स को एक असुरक्षित संदर्भ में एक्सेस कर सकते हैं। यह नाजुक लग सकता है, लेकिन Microsoft के संदर्भ स्रोत के अनुसार , दशमलव का संरचनात्मक लेआउट अनुक्रमिक है और यहां तक कि इसमें एक टिप्पणी है, फ़ील्ड के क्रम को बदलने के लिए नहीं:

    // NOTE: Do not change the order in which these fields are declared. The
    // native methods in this class rely on this particular order.
    private int flags;
    private int hi;
    private int lo;
    private int mid;

जैसा कि आप देख सकते हैं, यहां पहला इंट झंडे का मैदान है। प्रलेखन से और जैसा कि अन्य टिप्पणियों में यहां बताया गया है, हम जानते हैं कि केवल 16-24 से बिट्स पैमाने को एन्कोड करते हैं और हमें 31 वें बिट से बचने की जरूरत है जो साइन को एनकोड करता है। चूंकि int 4 बाइट्स का आकार है, इसलिए हम इसे सुरक्षित रूप से कर सकते हैं:

internal static class DecimalExtensions
{
  public static byte GetScale(this decimal value)
  {
    unsafe
    {
      byte* v = (byte*)&value;
      return v[2];
    }
  }
}

बाइट्स सरणी या ToString रूपांतरणों का कोई GC आबंटन नहीं होने के कारण यह सबसे अच्छा प्रदर्शन समाधान होना चाहिए। मैंने इसे .Net 4.x और .Net 3.5 के खिलाफ यूनिटी 2019.1 में परीक्षण किया है। अगर कोई ऐसा संस्करण है जहाँ यह विफल होता है, तो कृपया मुझे बताएँ।

संपादित करें:

असुरक्षित कोड के बाहर व्यावहारिक रूप से समान पॉइंटर लॉजिक को प्राप्त करने के लिए एक स्पष्ट संरचना लेआउट का उपयोग करने की संभावना के बारे में याद दिलाने के लिए @Zastai के लिए धन्यवाद:

[StructLayout(LayoutKind.Explicit)]
public struct DecimalHelper
{
    const byte k_SignBit = 1 << 7;

    [FieldOffset(0)]
    public decimal Value;

    [FieldOffset(0)]
    public readonly uint Flags;
    [FieldOffset(0)]
    public readonly ushort Reserved;
    [FieldOffset(2)]
    byte m_Scale;
    public byte Scale
    {
        get
        {
            return m_Scale;
        }
        set
        {
            if(value > 28)
                throw new System.ArgumentOutOfRangeException("value", "Scale can't be bigger than 28!")
            m_Scale = value;
        }
    }
    [FieldOffset(3)]
    byte m_SignByte;
    public int Sign
    {
        get
        {
            return m_SignByte > 0 ? -1 : 1;
        }
    }
    public bool Positive
    {
        get
        {
            return (m_SignByte & k_SignBit) > 0 ;
        }
        set
        {
            m_SignByte = value ? (byte)0 : k_SignBit;
        }
    }
    [FieldOffset(4)]
    public uint Hi;
    [FieldOffset(8)]
    public uint Lo;
    [FieldOffset(12)]
    public uint Mid;

    public DecimalHelper(decimal value) : this()
    {
        Value = value;
    }

    public static implicit operator DecimalHelper(decimal value)
    {
        return new DecimalHelper(value);
    }

    public static implicit operator decimal(DecimalHelper value)
    {
        return value.Value;
    }
}

मूल समस्या को हल करने के लिए, आप के अलावा सभी क्षेत्रों दूर पट्टी सकता है Valueऔर Scaleलेकिन शायद यह किसी को उन सब के लिए उपयोगी हो सकता है।

Question 11

मैंने कल एक संक्षिप्त विधि लिखी है जो दशमलव स्थानों की संख्या को किसी भी स्ट्रिंग विभाजन या संस्कृतियों पर भरोसा किए बिना लौटाता है जो आदर्श है:

public int GetDecimalPlaces(decimal decimalNumber) { // 
try {
    // PRESERVE:BEGIN
        int decimalPlaces = 1;
        decimal powers = 10.0m;
        if (decimalNumber > 0.0m) {
            while ((decimalNumber * powers) % 1 != 0.0m) {
                powers *= 10.0m;
                ++decimalPlaces;
            }
        }
return decimalPlaces;

Question 12

मैं क्लेमेंट के उत्तर के समान कुछ का उपयोग कर रहा हूं:

private int GetSignificantDecimalPlaces(decimal number, bool trimTrailingZeros = true)
{
  string stemp = Convert.ToString(number);

  if (trimTrailingZeros)
    stemp = stemp.TrimEnd('0');

  return stemp.Length - 1 - stemp.IndexOf(
         Application.CurrentCulture.NumberFormat.NumberDecimalSeparator);
}

Application.CurrentCulture तक पहुँच प्राप्त करने के लिए System.Windows.Forms का उपयोग करना याद रखें

Question 13

तुम कोशिश कर सकते हो:

int priceDecimalPlaces =
        price.ToString(System.Globalization.CultureInfo.InvariantCulture)
              .Split('.')[1].Length;

Question 14

मैं अपने कोड में निम्नलिखित तंत्र का उपयोग करता हूं

  public static int GetDecimalLength(string tempValue)
    {
        int decimalLength = 0;
        if (tempValue.Contains('.') || tempValue.Contains(','))
        {
            char[] separator = new char[] { '.', ',' };
            string[] tempstring = tempValue.Split(separator);

            decimalLength = tempstring[1].Length;
        }
        return decimalLength;
    }

दशमलव इनपुट = 3.376; var instring = input.ToString ();

GetDecimalLength (इंस्ट्रिंग) को कॉल करें

Question 15

पुनरावृत्ति का उपयोग आप कर सकते हैं:

private int GetDecimals(decimal n, int decimals = 0)  
{  
    return n % 1 != 0 ? GetDecimals(n * 10, decimals + 1) : decimals;  
}

Question 16

string number = "123.456789"; // Convert to string
int length = number.Substring(number.IndexOf(".") + 1).Length;  // 6

Question 17

मैं इस विधि का उपयोग करने का सुझाव देता हूं:

    public static int GetNumberOfDecimalPlaces(decimal value, int maxNumber)
    {
        if (maxNumber == 0)
            return 0;

        if (maxNumber > 28)
            maxNumber = 28;

        bool isEqual = false;
        int placeCount = maxNumber;
        while (placeCount > 0)
        {
            decimal vl = Math.Round(value, placeCount - 1);
            decimal vh = Math.Round(value, placeCount);
            isEqual = (vl == vh);

            if (isEqual == false)
                break;

            placeCount--;
        }
        return Math.Min(placeCount, maxNumber); 
    }

Question 18

एक दशमलव विस्तार विधि के रूप में जो ध्यान में रखता है:

विभिन्न संस्कृतियाँ
पूर्ण संख्या
ऋणात्मक संख्या
दशमलव स्थान पर ट्रेलिंग सेट शून्य (जैसे 1.2300M 2 नहीं 4 लौटाएगा)

public static class DecimalExtensions
{
    public static int GetNumberDecimalPlaces(this decimal source)
    {
        var parts = source.ToString(CultureInfo.InvariantCulture).Split('.');

        if (parts.Length < 2)
            return 0;

        return parts[1].TrimEnd('0').Length;
    }
}