Hi Harjo,
You can use: ```
Number(Math.round(4.725+‘e2’)+‘e-2’)
Or in a function with support for negative numbers:
function round(value, decimals) {
result = Number(Math.round(Math.abs(value)+‘e’+decimals)+‘e-’+decimals)
if (value<0) {return result*-1} else {return result}
}
Rounding is kind of formatting, so it is something “to display”
That means to me the number that you want to format, must become a String, it can’t be a number after rounding because you still have a problem it must fit into the floating point notation (that changes the number again)
so in the 4.725 if you try to round that by first doing *100
472.5
if you round that:
473 (as a whole number)
if you then divide this again by 100
then it very like becomes:
4.72999999
so you see again 4.72
you really should avoid rounding like this, it makes no sense to me to do that.
Because i guess you really want to round to display the value to a user (not to calculate with it because then i do hope you don’t make a financial product…)
so in pseudo code when rounding and going from a number to a string:
var x = 4.725
var y = x * 100; (472.5)
var z = Math.round(y); (473 as a whole number)
var asString = z.toString(); “473”
now calculate a position (how long the string is where the comma must be)
var position = 1; (hard coded for now)
var roundedDisplay = asString .substr(0, position) + “,” + asString .substr(position);
I guess if you DO use it to make a financial product you can always let ‘the Pros’ handle it (i.e. not JavaScript, but your database)
function roundValue(value, decimals) {
// sadly PostgreSQL doesn't allow type modifiers to be placeholders so we must concatenate this in the string :(
var _ds = databaseManager.getDataSetByQuery("myConnection", "SELECT CAST(? AS NUMERIC(15," + decimals + "))", [value], -1);
if (_ds.getException()) {
throw _ds.getException();
}
return _ds.getValue(1, 1);
// NOTE: adjust your datatype casting to match your vendors datatypes (numeric vs number, etc.)
}
roundValue(-8.055, 2)
-8.06
roundValue(4.725, 2)
4.73
Hope this helps
Need a string?
Number(Math.round(4.725+'e2')+'e-2').toString()
The way I see it, exponentials are the perfect solution. What am I missing?
jcompagner:
Rounding is kind of formatting, so it is something “to display”;
I do not agree, because a currency value from “real life” should be represented the same in the database.
Otherwise you get problems at once when you have two invoices with VAT-values of e.g. 8.055 and then want to SUM them to calculate your obligation to pay towards the fiscal authorities.
So best would be numeric type for storage, with two fixed decimals.
However in case of storage as floating-point, 8.0600000001 or 8.059999999 is still much better than the wrong value of 8.055, because there is just no half cent in real life.
So I also do not see why rounding should return the type string.
the problem is that rounding in the floating point notation that javascript uses is just not really 100% possible
how ever you round it can be that you round to for example 7.25 (because it was 7.245) but 7.25 is in floating point notation: 7.2499999999999
So it is still not correct if after that you just show the 2 decimals…
i guess in this scenario you kind of want to make it 7.2500000001 …
So lets say you you want to round up after 2 decimals, that kind of means just added 0.005 to it right?
Problem is that 0.005 in js can be 0.0049999
So if you have 7.245 then it would be 7.2499999 and it still wont work…
So lets say we first go to a real integer values:
7.245 * 1000 = 7245
then we add that 0.005 (which is now just 5)
so that kind of works now:
7250
but now divided it again by 1000
then you would think you would get: 7.250
problem is this is suddenly an floating point notation again and you could get: 7.249999999
back to square one…
So maybe we should just not add 5 to it but 5.1
then we would get
7250.1 / 1000 that should result in at least 7.250something
i think this should work, but maybe you guys can think if we then cross boundaries the other way (so we round up to soon what we don’t intent to)
like input is:
7.244999999999
how should that round? do you really look only that the 0.004 and see that should not round up. or should you really first look at that 0.0009 and first round that up? so it rolls up to the . and then it does become 7.245 and because of that 7.25? Or should that stay 7.24?
Because if the above should become 7.25 also
then we can do the thing above i guess
*1000 = 7244.9999 + 5.1 = 7250.09999 that will be then 7.250099999
if that shouldn’t be rounded to 7.25 then i guess we need:
7244 (and round that to an integer, so remove the .99999) and then add 5.1 so we get: 7249.1 and that will then be 7.24911111 (so rounded to 7.24)
We use our own rounding function throughout our whole Servoy application where rounding is needed, for example rounding to euro cents.
Just counted: used > 2000 times in our code…
lwjwillemsen:
We use our own rounding function throughout our whole Servoy application where rounding is needed, for example rounding to euro cents.
Just counted: used > 2000 times in our code…
Are you willing to share?
i guess the best thing is to store just “cents” in the database…
Not “euros,cents”
jcompagner:
i guess the best thing is to store just “cents” in the database…
Not “euros,cents”
come on… Really???
Sorry… this is too silly!
Same problem, you still have to calculate the VAT and round to whole cents…
You won’t believe it, Harjo, but I currently wrote nearly the same:
“Looks very complicated, this matter.
Maybe one solution would be to just store everything in cents instead of Euros, so that one can use only integers.”
omar:
Same problem, you still have to calculate the VAT and round to whole cents…
True, but you could use integers in JavaScript, too, which have their counterparts as integers in the database.
For calculations you would need a temporary variable that can handle decimals.
However in my feeling that is not very practical in programming, so I overall agree with Harjo.
It’s no rocket science, just maths and google on “javascript rounding”.
Here our function (we extended the function with the optional parameter _round_part) :
function svy_utl_round(_val, _nr_decs, _round_part) {
if (_val === null) {
return null
}
var _res = _val
if (_val < 0) {
_res = - _val
}
if (_round_part) {
_res = Math.round(_res / _round_part) * _round_part
}
var _pow = _nr_decs ? Math.pow(10, _nr_decs) : 1
_res = _res * _pow
_res = Math.round(_res) / _pow
if (_val < 0) {
_res = - _res
}
return _res
}
lwjwillemsen:
It’s no rocket science, just maths and google on “javascript rounding”.Here our function (we extended the function with the optional parameter _round_part) :
function svy_utl_round(_val, _nr_decs, _round_part) {
if (_val === null) {
return null
}
var _res = _val
if (_val < 0) {
_res = - _val
}
if (_round_part) {
_res = Math.round(_res / _round_part) * _round_part
}
var _pow = _nr_decs ? Math.pow(10, _nr_decs) : 1
_res = _res * _pow
_res = Math.round(_res) / _pow
if (_val < 0) {
_res = - _res
}
return _res
}
Oke Lambert, it IS rocketscience, did you try to round: 4.725 with your method?? it also returns 4.72
and 4.725 is not the only value what is failing
The fact that JavaScript always treats it as a float is the issue here. Just pass it off to the database as I already posted.
Edit: or perhaps Java can do it better? Plugin idea, anyone ?
ROCLASI:
The fact that JavaScript always treats it as a float is the issue here. Just pass it off to the database as I already posted.Edit: or perhaps Java can do it better? Plugin idea, anyone ?
That’s a solution, but how will perfom that, if you use this in a lot calculations?
So far, this method is working for me:
function core_round_money(vValue) {
if(vValue<0) {
return Math.round((vValue - 0.00000001) * 100) / 100;
} else {
return Math.round((vValue + 0.00000001) * 100) / 100;
}
}
I can’t find ANY example that fails…
Harjo:
That’s a solution, but not practical, you can’t (or must not) with every calculation or rounding query the database)
Sorry, I fail to follow the logic here… Not practical? Can’t? Must not ?
ROCLASI:
Sorry, I fail to follow the logic here… Not practical? Can’t? Must not ?
I have edited my sentence
Oke Lambert, it IS rocketscience, did you try to round: 4.725 with your method??
it also returns 4.72
and 4.725 is not the only value what is failing
Thanks Harjo, did not realize that!
I have added the 0.00000001 addition after the multiplying with 100 in my function.
I believe that is numerical better.
Thanks again for the eye opener!
This works for me:
function roundPrecision(_nNumber, _nPrecision) {
_nPrecision = _nPrecision || 0;
if(_nNumber == null) {
return null;
}
var _nMultiplier = Math.pow(10 ,_nPrecision),
_nRoundedNumber = +( Math.abs(_nNumber) * _nMultiplier ).toFixed( _nPrecision );
_nRoundedNumber = Math.round( _nRoundedNumber );
return _nRoundedNumber / _nMultiplier * (_nNumber < 0 ? -1 : 1);
}