floating-accuracy

So, I am planning to make an application (PHP/MySQL) which deals a lot with money, and I am thinking about how to store and operate with the money, referring to PHP float data type and MySQL decimal. I was thinking of two options. One of them is to operate and store money in integer cents format ($dollars * 100) in order not to deal with float inprecisions and to store it in the DB as integer too. The other one is to store in DB as decimal and to use BC Math in PHP for calculations. So I googled all the night to find out which is the best option to use and didn't find a clear answer. The only

I see that for the following code produces the result as below, any idea on why is the output like this? #include <stdio.h> #include <math.h> int main() { int i = 0; for(i = 0; i < 10; i++) { printf("%d\t\t\t%d\t\t\t", i, (int)pow(10, i)); printf("%f\n", pow(10, i)); } return 0; } Outputs: 0 1 1.000000 1 10 10.000000 2 99 100.000000 3 1000 1000.000000 4 9999 10000.000000 5 100000 100000.000000 6 1000000 1000000.000000 7 9999999 10000000.000000 8 99999999 100000000.000000 9 999999999 1000000000.000000 Use the round() function before casting to int , else the trailing digits will just get

I have an input floating point value that is 0.0f <= value < 1.0f (note less than one). When multiplying this value up to a larger range, naturally the floating point precision is decreased meaning the value can end up outside of the equivalent range. For example if I start off with a value such as: 0.99999983534521f Then multiply it by 100, I get: 100.000000000000f Which is fine, but how do I then reduce the floating point representation to be the nearest floating point value that is still less than 100? I found this little manual trick: union test { int integer; float floating; }; test value

Is there a "best practice" for less-than-equal comparisons with floating point number after a series of floating-point arithmetic operations? I have the following example in R (although the question applies to any language using floating-point). I have a double x = 1 on which I apply a series of additions and subtractions. In the end x should be exactly one but is not due to floating-point arithmetic (from what I gather). Here is the example: > stop_times <- seq(0.25, 2, by = .25) > expr <- expression(replicate(100,{ x <- 1 for(i in 1:10) { tmp <- rexp(1, 1) n <- sample.int(1e2, 1) delta <-

I'm running into a baffling issue with a basic MySQL query. This is my table: id | rating 1 | 1317.17 2 | 1280.59 3 | 995.12 4 | 973.88 Now, I'm attempting to find all rows where the rating column is larger than a certain value. If I try the following query: SELECT * FROM (`users`) WHERE `rating` > '995.12' It correctly returns 2 . But, if I try SELECT * FROM (`users`) WHERE `rating` > '973.88' it returns 4 ! So it's as if it thinks the 973.88 in the table is greater than 973.88, but it doesn't make the same mistake with 995.12. This happens regardless of whether I run the query from a PHP

I'm having trouble understanding the output of this program int main() { double x = 1.8939201459282359e-308; double y = 4.9406564584124654e-324; printf("%23.16e\n", 1.6*y); printf("%23.16e\n", 1.7*y); printf("%23.16e\n", 1.8*y); printf("%23.16e\n", 1.9*y); printf("%23.16e\n", 2.0*y); printf("%23.16e\n", x + 1.6*y); printf("%23.16e\n", x + 1.7*y); printf("%23.16e\n", x + 1.8*y); printf("%23.16e\n", x + 1.9*y); printf("%23.16e\n", x + 2.0*y); } The output is 9.8813129168249309e-324 9.8813129168249309e-324 9.8813129168249309e-324 9.8813129168249309e-324 9.8813129168249309e-324 1.8939201459282364e