문화에 관계없이 소수점 이하 자릿수 찾기

다른 문화 정보에서 안전하게 사용할 수있는 소수 값 (정수)에서 소수 자릿수를 추출하는 간결하고 정확한 방법이 있는지 궁금합니다.

예를 들어
19.0은 1을,
27.5999는 4를,
19.12는 2를 반환해야합니다
.

소수점 이하 자릿수를 찾기 위해 마침표로 문자열을 분할하는 쿼리를 작성했습니다.

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

그러나 이것이 '.'를 사용하는 지역에서만 작동한다는 생각이 듭니다. 소수 구분 기호로 사용되므로 다른 시스템에서 매우 취약합니다.

이 문제를 해결하기 위해 Joe의 방법 을 사용 했습니다. :)

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

제공된 답변 중 어느 것도 10 진수로 변환 된 매직 넘버 "-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
}

나는 아마도 @fixagon의 대답 에서 해결책을 사용할 것입니다 .

그러나 Decimal 구조체에는 소수 자릿수를 가져 오는 메서드가 없지만 Decimal.GetBits 를 호출 하여 이진 표현을 추출한 다음 정수 값과 배율을 사용하여 소수 자릿수를 계산할 수 있습니다.

차이를 알아 차리려면 엄청난 양의 소수를 처리해야하지만 이것은 문자열로 포맷하는 것보다 빠를 것입니다.

구현은 연습으로 남겨 두겠습니다.

소수점 이하 자릿수를 찾는 가장 좋은 솔루션 중 하나는 burning_LEGION의 게시물에 나와 있습니다.

여기에 STSdb ​​포럼 기사의 일부를 사용하고 있습니다 . 소수점 이하 자릿수 .

MSDN에서 다음 설명을 읽을 수 있습니다.

"10 진수는 부호, 값의 각 숫자 범위가 0에서 9 사이 인 숫자 값, 정수와 소수를 구분하는 부동 소수점의 위치를 ​​나타내는 배율 인수로 구성된 부동 소수점 값입니다. 숫자 값의 일부. "

그리고 또한:

"Decimal 값의 이진 표현은 1 비트 부호, 96 비트 정수 및 96 비트 정수를 나누고 소수 부분을 지정하는 데 사용되는 배율 인수로 구성됩니다. 배율 인수는 다음과 같습니다. 암시 적으로 숫자 10, 0에서 28까지의 지수로 올렸습니다. "

내부 수준에서 10 진수 값은 4 개의 정수 값으로 표시됩니다.

내부 표현을 얻기 위해 공개적으로 사용 가능한 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은 배율 인수가 Decimal 숫자의 후행 0도 유지한다고 말합니다. 후행 0은 산술 또는 비교 연산에서 십진수 값에 영향을주지 않습니다. 그러나 적절한 형식 문자열이 적용되면 ToString 메서드에서 후행 0이 표시 될 수 있습니다.

이 솔루션은 최고의 솔루션처럼 보이지만 더 많은 것이 있습니다. 으로 C #에서 개인 방법에 접근 우리는 플래그 필드에 직접 액세스를 구축하고 int 배열을 구성 피하기 위해 표현식을 사용할 수 있습니다 :

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 필드에 할당됩니다. 함수는 10 진수 값을 ref로 수신하므로 실제 복사가 수행되지 않고 값에 대한 참조 만 수행됩니다. DecimalHelper에서 GetDigits 함수를 사용하는 것은 쉽습니다.

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

소수점 이하 자릿수를 구하는 가장 빠른 방법입니다.

소수의 내부 표현에 의존하는 것은 멋지지 않습니다.

이건 어때:

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

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

여기에있는 대부분의 사람들은 소수점이 후행 0을 저장 및 인쇄에 중요한 것으로 간주한다는 사실을 모르고있는 것 같습니다.

따라서 0.1m, 0.10m 및 0.100m은 동일하게 비교할 수 있으며, 다르게 저장되며 (각각 값 / 스케일 1/1, 10/2 및 100/3) 각각 0.1, 0.10 및 0.100으로 인쇄됩니다. , 작성자 : ToString().

따라서 "너무 높은 정밀도"를보고하는 솔루션은 실제로 의 용어 에 따라 정확한 정밀도를 보고합니다 decimal.

또한 수학 기반 솔루션 (예 : 10의 거듭 제곱으로 곱하기)은 매우 느릴 수 있습니다 (10 진수는 산술의 경우 double보다 ~ 40 배 느리며 부정확성을 도입 할 가능성이 있기 때문에 부동 소수점에서 혼합하는 것을 원하지 않습니다.) ). 마찬가지로 자르기 수단 으로 int또는 long자르기 수단으로 캐스팅하는 것은 오류가 발생하기 쉽습니다 ( decimal둘 중 어느 것보다 훨씬 더 넓은 범위를 가지며, 약 96 비트 정수를 기반으로 함).

우아하지는 않지만 다음은 정밀도를 얻는 가장 빠른 방법 중 하나 일 것입니다 ( "후행 0을 제외한 소수 자릿수"로 정의 된 경우).

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

불변 문화는 '.'를 보장합니다. 소수점으로 후행 0이 잘리고 소수점 뒤에 몇 자리가 남아 있는지 확인하는 문제입니다 (하나라도있는 경우).

편집 : 반환 유형을 int로 변경

그리고 여기에 또 다른 방법이 있습니다. 소수의 오른쪽 자릿수와 함께 scale 속성이있는 SqlDecimal 유형을 사용합니다. 10 진수 값을 SqlDecimal로 캐스팅 한 다음 Scale에 액세스합니다.

((SqlDecimal)(decimal)yourValue).Scale

지금까지 나열된 거의 모든 솔루션은 GC 메모리를 할당하고 있습니다. 이는 작업을 수행하는 C # 방식이지만 성능이 중요한 환경에서는 이상적이지 않습니다. (사용 루프를 할당하지 않고 후행 0을 고려하지 않는 것.)

따라서 GC 할당을 피하기 위해 안전하지 않은 컨텍스트에서 스케일 비트에 액세스 할 수 있습니다. 깨지기 쉬운 것처럼 들릴 수 있지만 Microsoft의 참조 소스 에 따라 decimal의 구조체 레이아웃은 Sequential이며 필드의 순서를 변경하지 않는 주석이 있습니다.

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

보시다시피 첫 번째 int는 flags 필드입니다. 문서와 여기 다른 주석에서 언급했듯이 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 할당이 없기 때문에 가장 성능이 좋은 솔루션입니다. Unity 2019.1에서 .Net 4.x 및 .Net 3.5에 대해 테스트했습니다. 이것이 실패하는 버전이 있으면 알려주십시오.

편집하다:

안전하지 않은 코드 외부에서 동일한 포인터 논리를 실제로 달성하기 위해 명시 적 구조체 레이아웃을 사용할 수 있음을 상기시켜 준 @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하지만 누군가가 그들 모두를 가지고 어쩌면 그것은 도움이 될 수 있습니다.

나는 이상적인 문자열 분할이나 문화에 의존하지 않고 소수점 이하 자릿수를 반환하는 간결한 작은 메서드를 어제 작성했습니다.

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;

Clement의 답변과 매우 유사한 것을 사용하고 있습니다.

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를 사용해야합니다.

당신은 시도 할 수 있습니다:

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

내 코드에서 다음 메커니즘을 사용합니다.

  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 (instring) 호출

재귀를 사용하면 다음을 수행 할 수 있습니다.

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

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

이 방법을 사용하는 것이 좋습니다.

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

다음을 고려하는 십진 확장 방법으로 :

• 다른 문화
• 정수
• 음수
• 소수점 자리에 후행 설정 0 (예 : 1.2300M은 4가 아닌 2를 반환 함)

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