Obtenir le nombre de chiffres avant le point décimal

Au lieu de la conversion en chaîne de caractères, vous pouvez aussi diviser le nombre par 10 jusqu'à ce qu'il est égal à 0. Intéressant, c'est que les opérations mathématiques sur les décimales sont beaucoup plus lent que la conversion du décimal à une chaîne et le retour de la longueur (voir les repères ci-dessous).

Cette solution ne permet pas d'utiliser les Mathématiques-méthodes qui prennent un double comme entrée; de sorte que tous opérations sont effectuées sur des décimales et pas de casting est impliqué.

using System;

public class Test
{
    public static void Main()
    {
        decimal dec = -12345678912345678912345678912.456m;
        int digits = GetDigits(dec);
        Console.WriteLine(digits.ToString());
    }

    static int GetDigits(decimal dec)
    {
        decimal d = decimal.Floor(dec < 0 ? decimal.Negate(dec) : dec);
        //As stated in the comments of the question, 
        //0.xyz should return 0, therefore a special case
        if (d == 0m)
            return 0;
        int cnt = 1;
        while ((d = decimal.Floor(d / 10m)) != 0m)
            cnt++;
        return cnt;
    }
}

De sortie est 29. Pour exécuter cet exemple, visiter ce lien.

Côté remarque: certains tests montrent des résultats surprenants (10k pistes):

• while ((d = decimal.Floor(d /10m)) != 0m): 25ms
• while ((d = d /10m) > 1m): 32ms
• ToString avec les Mathématiques-double-opérations: 3ms
• ToString avec décimale-opérations: 3ms
• BigInt (voir réponse de @Heinzi): 2ms

Également à l'aide de nombres aléatoires au lieu de toujours la même valeur (pour éviter la mise en cache de la virgule à la conversion de chaîne de caractères) a montré que la chaîne méthodes sont beaucoup plus rapides.

Je préfère le suivant à la place de casting pour int pour s'assurer que vous pouvez également gérer les grands nombres (par exemple,decimal.MaxValue):

Math.Truncate ( Math.Abs ( decValue ) ).ToString( "####" ).Length

Voici un récursives exemple (surtout pour le fun).

void Main()
{
    digitCount(0.123M); //0
    digitCount(493854289.543354345M); //10
    digitCount(4937854345454545435549.543354345M); //22
    digitCount(-4937854345454545435549.543354345M); //22
    digitCount(1.0M); //1
    //approximately the biggest number you can pass to the function that works.
    digitCount(Decimal.MaxValue + 0.4999999M); //29
}

int digitCount(decimal num, int count = 0)
{
    //divided down to last digit, return how many times that happened
    if(Math.Abs(num) < 1)
        return count;
    return digitCount(num/10, ++count); //increment the count and divide by 10 to 'remove' a digit
}

Si vous avez un penchant pour les petits nombres, vous pouvez utiliser quelque chose de plus simple comme ça.

Elle est divisée en deux méthodes, de sorte que la première méthode est plus petit et peut être insérée.

Rendement est à peu près la même que la solution avec les Log10, mais sans les erreurs d'arrondi. La Méthode utilisant Log10, est toujours le plus rapide (un peu) plus spécialement pour les nombres > 1 million de dollars.

    public static int CountNrOfDigitsIfs(decimal d) {
var absD = Math.Abs(d);
//1
if (absD < 10M) return 1;
//2
if (absD < 100M) return 2;
//3
if (absD < 1000M) return 3;
//4
if (absD < 10000M) return 4;
return CountNrOfDigitsIfsLarge(d);
}
private static int CountNrOfDigitsIfsLarge(decimal d) {
//5
if (d < 100000M) return 5;
//6
if (d < 1000000M) return 6;
//7
if (d < 10000000M) return 7;
//8
if (d < 100000000M) return 8;
//9
if (d < 1000000000M) return 9;
//10
if (d < 10000000000M) return 10;
//11
if (d < 100000000000M) return 11;
//12
if (d < 1000000000000M) return 12;
//13
if (d < 10000000000000M) return 13;
//14
if (d < 100000000000000M) return 14;
//15
if (d < 1000000000000000M) return 15;
//16
if (d < 10000000000000000M) return 16;
//17
if (d < 100000000000000000M) return 17;
//18
if (d < 1000000000000000000M) return 18;
//19
if (d < 10000000000000000000M) return 19;
//20
if (d < 100000000000000000000M) return 20;
//21
if (d < 1000000000000000000000M) return 21;
//22
if (d < 10000000000000000000000M) return 22;
//23
if (d < 100000000000000000000000M) return 23;
//24
if (d < 1000000000000000000000000M) return 24;
//25
if (d < 10000000000000000000000000M) return 25;
//26
if (d < 100000000000000000000000000M) return 26;
//27
if (d < 1000000000000000000000000000M) return 27;
//28
if (d < 10000000000000000000000000000M) return 28;
return 29; //Max nr of digits in decimal
}

Ce code est généré en utilisant le suivant modèle T4:

<#
const int SIGNIFICANT_DECIMALS = 29;
const int SPLIT = 5;
#>
namespace Study.NrOfDigits {
static partial class DigitCounter {
public static int CountNrOfDigitsIfs(decimal d) {
var absD = Math.Abs(d);
<#          
for (int i = 1; i < SPLIT; i++) { //Only 29 significant digits
var zeroes = new String('0', i);
#>
//<#= i #>
if (absD < 1<#= zeroes #>M) return <#= i #>;
<# 
}
#>
return CountNrOfDigitsIfsLarge(d);
}
private static int CountNrOfDigitsIfsLarge(decimal d) {
<#          
for (int i = SPLIT; i < SIGNIFICANT_DECIMALS; i++) { //Only 29 significant digits
var zeroes = new String('0', i);
#>
//<#= i #>
if (d < 1<#= zeroes #>M) return <#= i #>;
<# 
}
#>
return <#= SIGNIFICANT_DECIMALS #>; //Max nr of digits in decimal
}
}
}

Cela va faire si vous ne voulez vraiment pas à utiliser la méthode Log (qui OMI est le meilleur moyen). C'est à propos de la façon la plus claire que je peux penser de cette opération à l'aide ToString():

Math.Abs(val).ToString("f0", CultureInfo.InvariantCulture).Length

Ou alternativement, si vous ne voulez pas compter 0.123M comme ayant un chiffre:

Math.Abs(val).ToString("#", CultureInfo.InvariantCulture).Length

Donc, j'ai couru en avant, et résolu avec ce code:

SqlDecimal d = new SqlDecimal(467.45M);
int digits = d.Precision - d.Scale;

SqlDecimal fait partie de la System.Data.SqlTypes espace de noms. "Précision" est le nombre total de chiffres significatifs, tout en "Échelle" est le nombre de chiffres après le point décimal.

Maintenant, je connais une objection à aller dans cette voie, c'est que SqlDecimal partie de la SQL Server-code spécifique. C'est un point valide, mais je tiens également à souligner que c'est une partie de l' .NET framework lui-même, et ce, depuis au moins la version 1.1, il me semble qu'il serait encore applicable quel que soit le code, il est en train de faire.

J'ai regardé sous le capot avec un décompilateur (JetBrains' dotPeek dans cet exemple), pour voir si peut-être le code pour le calcul de la précision et de l'échelle pourrait être extraite facilement et simplement, sans tirant dans SqlDecimal. Le code pour calculer l'échelle est très simple, mais la méthode pour calculer la précision est non-trivial, donc si c'était moi, je venais de passer par SqlDecimal.

TLDR toutes les autres réponses. J'ai écrit ceci en PHP, et le calcul serait le même. (Si je savais que C# j'aurais écrit dans cette langue.)

$input=21689584.999;
$input=abs($input);
$exp=0;
do{
$test=pow(10,$exp);
if($test > $input){
$digits=$exp;
}
if($test == $input){
$digits=$exp+1;
}
$exp++;
}while(!$digits);
if($input < 1){$digits=0;}
echo $digits;

Je n'en doute pas, il ya une meilleure façon, mais je voulais la jeter dans mon $.02

EDIT:

Je php-isés le code je l'ai mentionné dans mes commentaires, mais fait disparaître avec l'int de conversion.

function digitCount($input){
$digits=0;
$input=abs($input);
while ($input >= 1) {
$digits++;
$input=$input/10;
//echo $input."<br>";
}
return $digits;   
}
$big=(float)(PHP_INT_MAX * 1.1);
echo digitCount($big);

Utiliser le modulo, je ne suis pas un programmeur C#, mais je suis sûr que cette solution de travail:

double i = 1;
int numberOfDecimals = 0;
while (varDouble % i != varDouble)
{
numberOfDecimals++;
i*=10;
}
return numberOfDecimals;

Si vous traiter de zéros ou de l'absence de zéros en tant que numéro 1, c'est OK. Si vous voulez zéro retour zéro ou le manque de zéro retour zéro, alors il ya quelques cas de travail qui ne devrait pas être trop dur à ajouter. Aussi, si la valeur Absolue de gérer les nombres négatifs. Ajouté que les cas de test ainsi.

        const decimal d = 123.45m; 
const decimal d1 = 0.123m;
const decimal d2 = .567m;
const decimal d3 = .333m;
const decimal d4 = -123.45m;
NumberFormatInfo currentProvider = NumberFormatInfo.InvariantInfo;
var newProvider = (NumberFormatInfo) currentProvider.Clone();
newProvider.NumberDecimalDigits = 0;
string number = d.ToString("N", newProvider);  //returns 123 =  .Length = 3
string number1 = d1.ToString("N", newProvider); //returns 0 = .Length = 1
string number2 = d2.ToString("N", newProvider); //returns 1 =  .Length = 1
string number3 = d3.ToString("N", newProvider); //returns 0 =  .Length = 1
string number4 = Math.Abs(d4).ToString("N", newProvider); //returns 123 =  .Length = 3

Ici est un peu la solution finale, si vous trouvez un cas de test qui ne fonctionne pas, faites le moi savoir. Il doit retourner 3,0,0,0,3 pour le cas de test fourni.

        public static int NumbersInFrontOfDecimal(decimal input)
{
NumberFormatInfo currentProvider = NumberFormatInfo.InvariantInfo;
var newProvider = (NumberFormatInfo)currentProvider.Clone();
newProvider.NumberDecimalDigits = 0;
var absInput = Math.Abs(input);
var numbers =  absInput.ToString("N", newProvider);
//Handle Zero and < 1
if (numbers.Length == 1 && input < 1.0m)
{
return 0;
}
return numbers.Length;
}

Afin d'obtenir une précision et culturellement agnostique de la réponse, je ne la suivante:

1. Utilisation System.Numerics.BigInteger, dont le constructeur accepte une virgule et ne pas semblent produire toutes les erreurs d'arrondi.
2. Utilisation BigInteger.Abs() pour enlever tout signe.
3. Utilisation BigInteger.ToString() avec le "#" format pour supprimer toutes les séparateurs qui pourrait se produire.

Code

decimal num = 123213123.123123M;
int length = BigInteger.Abs((BigInteger)num).ToString("#").Length;

Les autres solutions de perdre chiffres si le nombre est trop grand.

public int Digits(Decimal i)
{
NumberFormatInfo format = CultureInfo.CurrentCulture.NumberFormat;
var str = Math.Abs(i).ToString().Replace(format.NumberGroupSeparator, "");
var index = str.IndexOf(format.NumberDecimalSeparator);
var digits = index == -1 ? str.Length : index;
}

Je n'ai pas testé, mais j'aimerais garder simple et à faire:

decimal value = 467.45;
string str = Convert.toString(value); //convert your decimal type to a string
string[] splitStr = str.split('.'); //split it into an array (use comma separator assuming you know your cultural context)
Console.WriteLine(splitStr[0].Count); //get the first element. You can also get the number of figures after the point by indexing the next value in the array.

Ce ne gère pas les nombres négatifs. Si vous vous souciez de ceux d'en envisager de prendre la valeur absolue. En outre, si vous voulez 0 avant la virgule à pas comptés, alors vous pouvez simplement utiliser une instruction if pour vérifier.