troncature nombre décimal non Arrondir

Question

Possible en double:
c# - How do I round a decimal value to 2 decimal places (for output on a page)

Je veux tronquer les décimales comme ci-dessous

-à-dire

• 2,22939393 -> 2,229
• 2,22977777 -> 2,229

Answer 1

double d = 2.22977777; 
d = ((double) ((int) (d * 1000.0)))/1000.0 ; 

Bien sûr, cela ne fonctionnera pas si vous essayez de tronquer erreur d'arrondi, mais cela devrait fonctionner correctement avec les valeurs que vous donnez dans vos exemples. Voir les deux premières réponses à this question pour plus de détails sur les raisons pour lesquelles cela ne fonctionnera pas parfois.

Answer 2

Vous pouvez utiliser Math.Round:

decimal rounded = Math.Round(2.22939393, 3); //Returns 2.229 

Ou vous pouvez utiliser ToString avec la N3 numeric format.

string roundedNumber = number.ToString("N3"); 

EDIT: Puisque vous ne voulez pas arrondi, vous pouvez facilement utiliser Math.Truncate:

Math.Truncate(2.22977777 * 1000)/1000; //Returns 2.229 

Answer 3

De quel format voulez-vous la sortie?

Si vous êtes satisfait avec une chaîne, puis le code suivant considèrent C#:

double num = 3.12345; 
num.ToString("G3"); 

Le résultat sera « 3,12 ».

Ce lien peut être utile si vous utilisez .NET. J'espère que cela aide .... mais à moins que vous identifiez que le langage que vous utilisez et le format dans lequel vous voulez la sortie, il est difficile de suggérer une solution appropriée.

Answer 4

Essayez ceci:

decimal original = GetSomeDecimal(); // 22222.22939393 
int number1 = (int)original; // contains only integer value of origina number 
decimal temporary = original - number1; // contains only decimal value of original number 
int decimalPlaces = GetDecimalPlaces(); // 3 
temporary *= (Math.Pow(10, decimalPlaces)); // moves some decimal places to integer 
temporary = (int)temporary; // removes all decimal places 
temporary /= (Math.Pow(10, decimalPlaces)); // moves integer back to decimal places 
decimal result = original + temporary; // add integer and decimal places together 

Il peut être writen plus courte, mais cela est plus descriptif.

EDIT: court chemin:

decimal original = GetSomeDecimal(); // 22222.22939393 
int decimalPlaces = GetDecimalPlaces(); // 3 
decimal result = ((int)original) + (((int)(original * Math.Pow(10, decimalPlaces))/(Math.Pow(10, decimalPlaces)); 

Answer 5

Peut-être une autre solution rapide pourrait être:

>>> float("%.1f" % 1.00001) 
1.0 
>>> float("%.3f" % 1.23001) 
1.23 
>>> float("%.5f" % 1.23001) 
1.23001 

Answer 6

Oublier tout simplement vérifier cette

double num = 2.22939393; 
num = Convert.ToDouble(num.ToString("#0.000")); 

Answer 7

Une fonction tronquer une nombre arbitraire de nombres décimaux:

public decimal Truncate(decimal number, int digits) 
{ 
    decimal stepper = (decimal)(Math.Pow(10.0, (double)digits)); 
    int temp = (int)(stepper * number); 
    return (decimal)temp/stepper; 
} 

Answer 8

Voici une méthode d'extension qui ne souffre pas de débordement d'entier (comme le font certaines des réponses ci-dessus). Il met également en cache certaines puissances de 10 pour l'efficacité.

static double[] pow10 = { 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10 }; 
public static double Truncate(this double x, int precision) 
{ 
    if (precision < 0) 
     throw new ArgumentException(); 
    if (precision == 0) 
     return Math.Truncate(x); 
    double m = precision >= pow10.Length ? Math.Pow(10, precision) : pow10[precision]; 
    return Math.Truncate(x * m)/m; 
} 

Answer 9

Essayez cette

double d = 2.22912312515; 
int demention = 3; 
double truncate = Math.Truncate(d) + Math.Truncate((d - Math.Truncate(d)) * Math.Pow(10.0, demention))/Math.Pow(10.0, demention); 

Answer 10

Ceci est similaire à la suggestion TCKS ci-dessus, mais en utilisant math.truncate plutôt que des conversions int

VB: mais vous aurez l'idée

Private Function TruncateToDecimalPlace(byval ToTruncate as decimal, byval DecimalPlaces as integer) as double 
dim power as decimal = Math.Pow(10, decimalplaces) 
return math.truncate(totruncate * power)/power 
end function