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
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);
}
}
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
}
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.
Examples:
1000000000000000000000.toStringAsExponential(3); // 1.000e+21
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
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
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);
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));
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 works pretty well
var price=99.012334554
price = price.roundTodouble();
print(price); // 99.01
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
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
}
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
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.
Source: Stackoverflow.com