# [dart] How do you round a double in Dart to a given degree of precision AFTER the decimal point?

Given a double, I want to round it to a given number of points of precision after the decimal point, similar to PHP's round() function.

The closest thing I can find in the Dart docs is double.toStringAsPrecision(), but this is not quite what I need because it includes the digits before the decimal point in the total points of precision.

For example, using toStringAsPrecision(3):

``````0.123456789 rounds to 0.123
9.123456789 rounds to 9.12
98.123456789 rounds to 98.1
987.123456789 rounds to 987
9876.123456789 rounds to 9.88e+3
``````

As the magnitude of the number increases, I correspondingly lose precision after the decimal place.

This question is related to `dart` `precision` `double-precision`

The modified answer of @andyw using Dart Extension methods:

``````extension Precision on double {
double toPrecision(int fractionDigits) {
double mod = pow(10, fractionDigits.toDouble());
return ((this * mod).round().toDouble() / mod);
}
}
``````

Usage:

``````var latitude = 1.123456;
var latitudeWithFixedPrecision = latitude.toPrecision(3); // Outputs: 1.123
``````

This works pretty well

``````var price=99.012334554
price = price.roundTodouble();
print(price); // 99.01
``````

Above solutions do not work for all cases. What worked for my problem was this solution that will round your number (0.5 to 1 or 0.49 to 0) and leave it without any decimals:

Input: 12.67

``````double myDouble = 12.67;
var myRoundedNumber; // Note the 'var' datatype

// Here I used 1 decimal. You can use another value in toStringAsFixed(x)
myRoundedNumber = double.parse((myDouble).toStringAsFixed(1));
myRoundedNumber = myRoundedNumber.round();

print(myRoundedNumber);
``````

Output: 13

This link has other solutions too

You can use `toStringAsFixed` in order to display the limited digits after decimal points. `toStringAsFixed` returns a decimal-point string-representation. `toStringAsFixed` accepts an argument called `fraction Digits` which is how many digits after decimal we want to display. Here is how to use it.

``````double pi = 3.1415926;
const val = pi.toStringAsFixed(2); // 3.14
``````

``````double value = 2.8032739273;
String formattedValue = value.toStringAsFixed(3);
``````

I think the accepted answer is not the perfect solution because it converts to `string`.

If you don't wanna convert to `string` and back to a `double` use `double.toPrecision(decimalNumber)` from GetX package.

If you don't wanna use GetX just for this (I highly recommend GetX, it will change your life with flutter) you can copy and paste this.

``````import 'dart:math';

extension Precision on double {
double toPrecision(int fractionDigits) {
var mod = pow(10, fractionDigits.toDouble()).toDouble();
return ((this * mod).round().toDouble() / mod);
}
}
``````

``````var price = 99.012334554;
price = price.toStringAsFixed(2);
print(price); // 99.01
``````

That is the ref of dart. ref: https://api.dartlang.org/stable/2.3.0/dart-core/num/toStringAsFixed.html

Just write this extension on double

``````extension Round on double {
double roundToPrecision(int n) {
int fac = pow(10, n);
return (this * fac).round() / fac;
}
}
``````

Above solutions do not appropriately round numbers. I use:

``````double dp(double val, int places){
double mod = pow(10.0, places);
return ((val * mod).round().toDouble() / mod);
}
``````

See the docs for num.toStringAsFixed().

String toStringAsFixed(int fractionDigits)

Returns a decimal-point string-representation of this.

Converts this to a double before computing the string representation.

• If the absolute value of this is greater or equal to 10^21 then this methods returns an exponential representation computed by this.toStringAsExponential().

Examples:

``````1000000000000000000000.toStringAsExponential(3); // 1.000e+21
``````
• Otherwise the result is the closest string representation with exactly fractionDigits digits after the decimal point. If fractionDigits equals 0 then the decimal point is omitted.

The parameter fractionDigits must be an integer satisfying: 0 <= fractionDigits <= 20.

Examples:

``````1.toStringAsFixed(3);  // 1.000
(4321.12345678).toStringAsFixed(3);  // 4321.123
(4321.12345678).toStringAsFixed(5);  // 4321.12346
123456789012345678901.toStringAsFixed(3);  // 123456789012345683968.000
1000000000000000000000.toStringAsFixed(3); // 1e+21
5.25.toStringAsFixed(0); // 5
``````

``````void main() {
int decimals = 2;
int fac = pow(10, decimals);
double d = 1.234567889;
d = (d * fac).round() / fac;
print("d: \$d");
}
``````

Prints: 1.23

To round a double in Dart to a given degree of precision AFTER the decimal point, you can use built-in solution in dart `toStringAsFixed()` method, but you have to convert it back to double

``````void main() {
double step1 = 1/3;
print(step1); // 0.3333333333333333

String step2 = step1.toStringAsFixed(2);
print(step2); // 0.33

double step3 = double.parse(step2);
print(step3); // 0.33
}

``````

`num.toStringAsFixed()` rounds. This one turns you num (n) into a string with the number of decimals you want (2), and then parses it back to your num in one sweet line of code:

``````n = num.parse(n.toStringAsFixed(2));
``````

If you don't want any decimals when the resulting decimals are all zeroes, something like this would work:

``````String fixedDecimals(double d, int decimals, {bool removeZeroDecimals = true}){
double mod = pow(10.0, decimals);
double result = ((d * mod).round().toDouble() / mod);
if( removeZeroDecimals && result - (result.truncate()) == 0.0 ) decimals = 0;
return result.toStringAsFixed(decimals);
}
``````

This will simply output `9` instead of `9.00` if the input is `9.004` and you want 2 decimals.

I used the `toStringAsFixed()` method, to round a number to specific numbers after the decimal point EX:

``````double num = 22.48132906
``````

and when I rounded it to two numbers like this:

``````print(num.toStringAsFixed(2)) ;
``````

It printed `22.48`

and when I rounded to one number, it printed `22.5`

Define an extension:

``````extension Ex on double {
double toPrecision(int n) => double.parse(toStringAsFixed(n));
}
``````

Usage:

``````void main() {
double d = 2.3456789;
double d1 = d.toPrecision(1); // 2.3
double d2 = d.toPrecision(2); // 2.35
double d3 = d.toPrecision(3); // 2.345
}
``````