Rounding up to n decimal places?

[madscijr]

I'm trying to figure out how to round numbers (single or double precision) up to a certain number of decimal places.
For example 0.035 rounded to 2 places should be 0.04.

I did some searching on the forums for how to round,
and found examples with INT and division, like:
INT(number * 100)/100

where you just use a number with the number of zeros you want in place of 100.
I made a test program (below) to test this,
but that method seems to just truncate down to the given number of places.

How would you round up?

Code: QB64: [Select]

1. ' ################################################################################################################################################################
2. ' Rounding test
3. ' ################################################################################################################################################################
4.  
5. ' a$=string, i%=integer, L&=long, s!=single, d#=double
6.  
7. ' BOOLEAN CONSTANTS
8. CONST FALSE = 0
9. CONST TRUE = NOT FALSE
10.  
11. ' GLOBAL VARIABLES
12. DIM ProgramPath$
13. DIM ProgramName$
14. ProgramName$ = MID$(COMMAND$(0), _INSTRREV(COMMAND$(0), "\") + 1)
15. ProgramPath$ = LEFT$(COMMAND$(0), _INSTRREV(COMMAND$(0), "\"))
16.  
17. ' START THE MAIN PROGRAM
18. main ProgramName$
19.  
20. ' FINISH UP
21. SYSTEM ' return control to the operating system
22. PRINT ProgramName$ + " finished."
23. END
24.  
25. ' /////////////////////////////////////////////////////////////////////////////
26. ' Rounding and math.
27. ' http://www.[abandoned, outdated and now likely malicious qb64 dot net website - don’t go there]/forum/index_PHPSESSID_gulg2aoa966472fnfhjkgp4i35_topic_14266-0/
28. '
29. ' Any number x can be rounded to n digits:
30. '   roundedValue = INT(x*10^n + 0.5) / 10^n
31. ' for scientific rounding you use:
32. '   roundedValue = CINT(x*10^n) / 10^n
33. ' Difference between Normal and Scientific Rounding:
34. '   Normal     Rounds digits 1,2,3, and 4 down.
35. '              Rounds digits 5,6,7,8, and 9 up.
36. '   Scientific Rounds digits 1,2,3, and 4 down.
37. '              Rounds digiits 6,7, 8, and 9 up.
38. '              Rounds 5 to the nearest even number.
39.  
40. ' Quote from: SMcNeill on May 16, 2017, 06:57:17 pm
41. ' Can also try:
42. '     INT(number * 100)/100
43. ' Now that worked.
44. '     STR$(INT(myprice * 100) / 100)
45. ' Perfectly drops all the numbers to 2 decimal places.
46. ' What a relief. Thank you so much and everyone else who gave advice. :)
47.  
48. SUB main (ProgName$)
49.     DIM RoutineName AS STRING:: RoutineName = "main"
50.     DIM in$
51.  
52.     DIM arrOutput(100, 2) AS STRING ' arrOutput(line#, column#)
53.     DIM s1! ' original value
54.     DIM s2! ' rounded value
55.     DIM d1# ' original value
56.     DIM d2# ' rounded value
57.     DIM iLine1 AS INTEGER ' # output lines column 1 (single)
58.     DIM iLine2 AS INTEGER ' # output lines column 2 (double)
59.     DIM iColumn AS INTEGER ' which column # to output to
60.     DIM iMaxLines AS INTEGER ' # of output lines (whichever is biggest)
61.  
62.     CLS
63.     iMaxLines = 0
64.     PRINT "This code truncates or rounds down."
65.     PRINT "How do we round _UP_ to a given # of decimal places?"
66.     PRINT "eg. rounding 0.308 to 2 places should output 0.31"
67.     PRINT
68.  
69.     ' ROUND SINGLE PRECISION NUMBERS TO 2 DECIMAL PLACES
70.     iColumn = 1
71.     iLine1 = 1: arrOutput(iLine1, iColumn) = "SINGLE TO 2 DECIMAL PLACES"
72.     iLine1 = 2: arrOutput(iLine1, iColumn) = RightPadString$("Original", 10, " ") + "    " + RightPadString$("Rounded", 10, " ")
73.     FOR s1! = 0.3 TO 0.4 STEP 0.008
74.         iLine1 = iLine1 + 1
75.         s2! = INT(s1! * 100) / 100
76.         arrOutput(iLine1, iColumn) = RightPadString$(cstr$(s1!), 10, " ") + " -> " + RightPadString$(cstr$(s2!), 10, " ")
77.     NEXT s1!
78.     iMaxLines = iLine1
79.  
80.     ' ROUND DOUBLE PRECISION NUMBERS TO 3 DECIMAL PLACES
81.     iColumn = 2
82.     iLine2 = 1: arrOutput(iLine2, iColumn) = "DOUBLE TO 3 DECIMAL PLACES"
83.     iLine2 = 2: arrOutput(iLine2, iColumn) = RightPadString$("Original", 10, " ") + "    " + RightPadString$("Rounded", 10, " ")
84.     FOR d1# = 0.03 TO 0.04 STEP 0.0008
85.         iLine2 = iLine2 + 1
86.         d2# = INT(d1# * 1000) / 1000
87.         arrOutput(iLine2, iColumn) = RightPadString$(cstr$(d1#), 10, " ") + " -> " + RightPadString$(cstr$(d2#), 10, " ")
88.         IF iLine2 > iLine1 THEN
89.             iMaxLines = iLine2
90.             arrOutput(iLine2, 1) = ""
91.         END IF
92.     NEXT d1#
93.    
94.     ' SHOW OUTPUT
95.     FOR iLine1 = 1 TO iMaxLines
96.         PRINT RightPadString$(arrOutput(iLine1, 1), 30, " ") + "    " + RightPadString$(arrOutput(iLine1, 2), 30, " ")
97.     NEXT iLine1
98.  
99.     PRINT
100.     INPUT "PRESS <ENTER> TO CONTINUE", in$
101. END SUB ' main
102.  
103. ' /////////////////////////////////////////////////////////////////////////////
104.  
105. FUNCTION RightPadString$ (myString$, toWidth%, padChar$)
106.     RightPadString$ = LEFT$(myString$ + STRING$(toWidth%, padChar$), toWidth%)
107. END FUNCTION ' RightPadString$
108.  
109. ' /////////////////////////////////////////////////////////////////////////////
110.  
111. FUNCTION cstr$ (myValue)
112.     'cstr$ = LTRIM$(RTRIM$(STR$(myValue)))
113.     cstr$ = _TRIM$(STR$(myValue))
114. END FUNCTION ' cstr$
115.  

[bplus]

There is round Keyword check Wiki, might be _round

I have this but for rounding you have to add 1/2 of 10 ^ DP to x so better copy x before you change in function and it is passed back changed:

Code: QB64: [Select]

1. FUNCTION xDP$ (x, DP)
2.     DIM test$, p AS LONG
3.     test$ = _TRIM$(STR$(INT(x * 10 ^ DP) / 10 ^ DP))
4.     p = INSTR(test$, ".")
5.     IF p = 0 AND DP <> 0 THEN test$ = test$ + "." + STRING$(DP, "0")
6.     IF p AND DP = 0 THEN test$ = LEFT$(test$, LEN(test$) - 1)
7.     xDP$ = test$
8. END FUNCTION
9.  

Untested (gotta go soon):

Code: QB64: [Select]

1. 'just cut the decimal places down to DP amount if more
2. FUNCTION xDP$ (xx, DP)
3.     DIM test$, p AS LONG, x
4.     x = xx + .5 * 1/(10 ^ DP)
5.     test$ = _TRIM$(STR$(INT(x * 10 ^ DP) / 10 ^ DP))
6.     p = INSTR(test$, ".")
7.     IF p = 0 AND DP <> 0 THEN test$ = test$ + "." + STRING$(DP, "0")
8.     IF p AND DP = 0 THEN test$ = LEFT$(test$, LEN(test$) - 1)
9.     xDP$ = test$
10. END FUNCTION
11.  

EDIT: crap it's .5 * (1/10^DP)

[bplus]

Dang cant quit now, this is looking OK so far:

Code: QB64: [Select]

1. REDIM dp AS LONG
2. DO
3.     INPUT "Number to round "; n
4.     INPUT "Number of decimal places "; dp
5.     PRINT xDP$(n, dp)
6. LOOP
7. FUNCTION xDP$ (xx, DP)
8.     DIM test$, p AS LONG, x
9.     x = xx + .5 * 1 / (10 ^ DP)
10.     test$ = _TRIM$(STR$(INT(x * 10 ^ DP) / 10 ^ DP))
11.     p = INSTR(test$, ".")
12.     IF p = 0 AND DP <> 0 THEN test$ = test$ + "." + STRING$(DP, "0")
13.     IF p AND DP = 0 THEN test$ = LEFT$(test$, LEN(test$) - 1)
14.     xDP$ = test$
15. END FUNCTION
16.  

[Pete]

You could string round...

Code: QB64: [Select]

1. INPUT "a number: "; num
2. n$ = LTRIM$(STR$(num))
3. IF INSTR(n$, ".") AND RIGHT$(n$, 1) <> "." THEN
4.     IF RIGHT$(n$, 1) >= "5" THEN ' round up
5.         c$ = LTRIM$(STR$(10 - VAL(MID$(n$, LEN(n$), 1))))
6.         FOR i = LEN(n$) TO 1 STEP -1
7.             IF MID$(n$, i, 1) >= "0" AND MID$(n$, i, 1) <= "9" THEN
8.                 x = VAL(c$) + VAL(MID$(n$, i, 1))
9.                 IF x > 9 THEN x = x - 10: c$ = "1" ELSE c$ = ""
10.                 MID$(n$, i, 1) = LTRIM$(STR$(x))
11.                 IF c$ = "" THEN EXIT FOR
12.             END IF
13.         NEXT
14.     END IF
15.  
16.     num = VAL(c$ + n$)
17. END IF
18.  
19. PRINT num
20.  
21. PRINT: RUN
22.  

Now that's on the fly, and not from my string number routine. I'm so old, I can't even tell you if it's the same method or not, but it's more fun to code than it is to paste. If anyone finds a flaw in the above, let me know. I'm not sure it's bullet proof. I can tell you I didn't bother bullet proofing for bad input.

Pete

[SMcNeill]

Sometimes, you guys make things entirely too  complicated.

Code: QB64: [Select]

1. PRINT Round(4.2345, 2)
2. PRINT Round(4.2345, 3)
3. PRINT
4. PRINT RoundUp(4.2345, 2)
5. PRINT RoundUp(4.2345, 3)
6. PRINT
7. PRINT RoundDown(4.2345, 2)
8. PRINT RoundDown(4.2345, 3)
9. PRINT
10.  
11. PRINT Round_Scientific(4.205, 2)
12. PRINT Round_Scientific(4.215, 2)
13. PRINT Round_Scientific(4.225, 2)
14. PRINT Round_Scientific(4.235, 2)
15. PRINT Round_Scientific(4.245, 2)
16.  
17. FUNCTION Round## (num##, digits%)
18.     Round## = INT(num## * 10 ^ digits% + .5) / 10 ^ digits%
19. END FUNCTION
20.  
21. FUNCTION RoundUp## (num##, digits%)
22.     RoundUp## = _CEIL(num## * 10 ^ digits%) / 10 ^ digits%
23. END FUNCTION
24.  
25. FUNCTION RoundDown## (num##, digits%)
26.     RoundDown## = INT(num## * 10 ^ digits%) / 10 ^ digits%
27. END FUNCTION
28.  
29. FUNCTION Round_Scientific## (num##, digits%)
30.     Round_Scientific## = _ROUND(num## * 10 ^ digits%) / 10 ^ digits%
31. END FUNCTION

There ya go!  Three functions to either round naturally (0 - 0.4999999999999999999999 rounds down, 0.5 - 0.99999999999999999 rounds up), always round down, or always round up, to whatever number of digits you desire.

EDIT:  Modified to add another option to round scientific, since you had it's description included in your example.

[bplus]

Sometimes, you guys make things entirely too  complicated.

Yeah, yeah, I was looking over that code of mine and going yuck myself. I think I would like to see 0's out to decimal places instead of nothing.

[SMcNeill]

Yeah, yeah, I was looking over that code of mine and going yuck myself. I think I would like to see 0's out to decimal places instead of nothing.

That's a job for formatting and printing at display time, not calculation time.  ;)

[madscijr]

you have to add 1/2 of 10 ^ DP to x
...
EDIT: crap it's .5 * (1/10^DP)

I think I got it - thanks!

Code: QB64: [Select]

1. ' ################################################################################################################################################################
2. ' Rounding test
3. ' ################################################################################################################################################################
4.  
5. ' BOOLEAN CONSTANTS
6. CONST FALSE = 0
7. CONST TRUE = NOT FALSE
8.  
9. ' GLOBAL VARIABLES a$=string, i%=integer, L&=long, s!=single, d#=double
10. DIM ProgramPath$: ProgramPath$ = LEFT$(COMMAND$(0), _INSTRREV(COMMAND$(0), "\"))
11. DIM ProgramName$: ProgramName$ = MID$(COMMAND$(0), _INSTRREV(COMMAND$(0), "\") + 1)
12.  
13. ' START THE MAIN PROGRAM
14. main ProgramName$
15.  
16. ' FINISH UP
17. SYSTEM ' return control to the operating system
18. PRINT ProgramName$ + " finished."
19. END
20.  
21. ' /////////////////////////////////////////////////////////////////////////////
22. ' Rounding and math.
23. ' http://www.[abandoned, outdated and now likely malicious qb64 dot net website - don’t go there]/forum/index_PHPSESSID_gulg2aoa966472fnfhjkgp4i35_topic_14266-0/
24. '
25. ' Rounding up to n decimal places?
26. ' https://www.qb64.org/forum/index.php?topic=3605.0
27.  
28. ' Quote from: SMcNeill on May 16, 2017, 06:57:17 pm
29. ' Can also try:
30. '     INT(number * 100)/100
31. ' Now that worked.
32. '     STR$(INT(myprice * 100) / 100)
33. ' Perfectly drops all the numbers to 2 decimal places.
34. ' What a relief. Thank you so much and everyone else who gave advice. :)
35.  
36. ' Quote from: bplus on Today at 02:13:29 PM
37. ' There is round Keyword check Wiki, might be _round
38. ' you have to add 1/2 of 10 ^ DP to x
39. ' EDIT: crap it's .5 * (1/10^DP)
40.  
41. SUB main (ProgName$)
42.     DIM RoutineName AS STRING:: RoutineName = "main"
43.     DIM in$
44.  
45.     DIM arrOutput(100, 2) AS STRING
46.     DIM s1!
47.     DIM s2!
48.     DIM d1#
49.     DIM d2#
50.     DIM iLine1 AS INTEGER
51.     DIM iLine2 AS INTEGER
52.     DIM iColumn AS INTEGER
53.     DIM iMaxLines AS INTEGER
54.     DIM dp% ' # decimal places
55.  
56.     CLS
57.     iTotal = 0
58.     PRINT "Rounds single and double precision numbers."
59.     PRINT "Thanks to SMcNeill, bplus, and Pete for your help."
60.     PRINT
61.  
62.     ' ROUND SINGLE PRECISION NUMBERS TO 3 DECIMAL PLACES
63.     iColumn = 1
64.     iLine1 = 1: arrOutput(iLine1, iColumn) = "SINGLE TO 3 DECIMAL PLACES"
65.     iLine1 = 2: arrOutput(iLine1, iColumn) = RightPadString$("Original", 10, " ") + "    " + RightPadString$("Rounded", 10, " ")
66.     dp% = 3
67.     FOR s1! = 0.3 TO 0.4 STEP 0.008
68.         iLine1 = iLine1 + 1
69.         s2! = s1! + (.5 * (1 / (10 ^ dp%)))
70.         s2! = INT(s2! * (10 ^ dp%)) / (10 ^ dp%)
71.         arrOutput(iLine1, iColumn) = RightPadString$(SngToStr$(s1!), 10, " ") + " -> " + RightPadString$(SngToStr$(s2!), 10, " ")
72.     NEXT s1!
73.     iMaxLines = iLine1
74.  
75.     ' ROUND DOUBLE PRECISION NUMBERS TO 3 DECIMAL PLACES
76.     iColumn = 2
77.     iLine2 = 1: arrOutput(iLine2, iColumn) = "DOUBLE TO 3 DECIMAL PLACES"
78.     iLine2 = 2: arrOutput(iLine2, iColumn) = RightPadString$("Original", 10, " ") + "    " + RightPadString$("Rounded", 10, " ")
79.     dp% = 3
80.     FOR d1# = 0.03 TO 0.04 STEP 0.0008
81.         iLine2 = iLine2 + 1
82.         d2# = d1# + (.5 * (1 / (10 ^ dp%)))
83.         d2# = INT(d2# * (10 ^ dp%)) / (10 ^ dp%)
84.         arrOutput(iLine2, iColumn) = RightPadString$(DblToStr$(d1#), 10, " ") + " -> " + RightPadString$(DblToStr$(d2#), 10, " ")
85.  
86.         IF iLine2 > iLine1 THEN
87.             iMaxLines = iLine2
88.             arrOutput(iLine2, 1) = ""
89.         END IF
90.     NEXT d1#
91.  
92.     FOR iLine1 = 1 TO iMaxLines
93.         PRINT RightPadString$(arrOutput(iLine1, 1), 30, " ") + "    " + RightPadString$(arrOutput(iLine1, 2), 30, " ")
94.     NEXT iLine1
95.  
96.     PRINT
97.     INPUT "PRESS <ENTER> TO CONTINUE", in$
98. END SUB ' main
99.  
100. ' /////////////////////////////////////////////////////////////////////////////
101. ' Scientific notation - QB64 Wiki
102. ' https://www.qb64.org/wiki/Scientific_notation
103.  
104. ' Example: A string function that displays extremely small or large exponential decimal values.
105.  
106. FUNCTION DblToStr$ (n#)
107.     value$ = UCASE$(LTRIM$(STR$(n#)))
108.     Xpos% = INSTR(value$, "D") + INSTR(value$, "E") 'only D or E can be present
109.     IF Xpos% THEN
110.         expo% = VAL(MID$(value$, Xpos% + 1))
111.         IF VAL(value$) < 0 THEN
112.             sign$ = "-": valu$ = MID$(value$, 2, Xpos% - 2)
113.         ELSE valu$ = MID$(value$, 1, Xpos% - 1)
114.         END IF
115.         dot% = INSTR(valu$, "."): L% = LEN(valu$)
116.         IF expo% > 0 THEN add$ = STRING$(expo% - (L% - dot%), "0")
117.         IF expo% < 0 THEN min$ = STRING$(ABS(expo%) - (dot% - 1), "0"): DP$ = "."
118.         FOR n = 1 TO L%
119.             IF MID$(valu$, n, 1) <> "." THEN num$ = num$ + MID$(valu$, n, 1)
120.         NEXT
121.     ELSE DblToStr$ = value$: EXIT FUNCTION
122.     END IF
123.     DblToStr$ = _TRIM$(sign$ + DP$ + min$ + num$ + add$)
124. END FUNCTION ' DblToStr$
125.  
126. ' /////////////////////////////////////////////////////////////////////////////
127. ' Scientific notation - QB64 Wiki
128. ' https://www.qb64.org/wiki/Scientific_notation
129.  
130. ' Example: A string function that displays extremely small or large exponential decimal values.
131.  
132. FUNCTION SngToStr$ (n!)
133.     value$ = UCASE$(LTRIM$(STR$(n!)))
134.     Xpos% = INSTR(value$, "D") + INSTR(value$, "E") 'only D or E can be present
135.     IF Xpos% THEN
136.         expo% = VAL(MID$(value$, Xpos% + 1))
137.         IF VAL(value$) < 0 THEN
138.             sign$ = "-": valu$ = MID$(value$, 2, Xpos% - 2)
139.         ELSE valu$ = MID$(value$, 1, Xpos% - 1)
140.         END IF
141.         dot% = INSTR(valu$, "."): L% = LEN(valu$)
142.         IF expo% > 0 THEN add$ = STRING$(expo% - (L% - dot%), "0")
143.         IF expo% < 0 THEN min$ = STRING$(ABS(expo%) - (dot% - 1), "0"): DP$ = "."
144.         FOR n = 1 TO L%
145.             IF MID$(valu$, n, 1) <> "." THEN num$ = num$ + MID$(valu$, n, 1)
146.         NEXT
147.     ELSE SngToStr$ = value$: EXIT FUNCTION
148.     END IF
149.     SngToStr$ = _TRIM$(sign$ + DP$ + min$ + num$ + add$)
150. END FUNCTION ' SngToStr$
151.  
152. ' /////////////////////////////////////////////////////////////////////////////
153. ' By sMcNeill from https://www.qb64.org/forum/index.php?topic=896.0
154.  
155. FUNCTION IsNum% (text$)
156.     DIM a$
157.     DIM b$
158.     a$ = _TRIM$(text$)
159.     b$ = _TRIM$(STR$(VAL(text$)))
160.     IF a$ = b$ THEN
161.         IsNum% = TRUE
162.     ELSE
163.         IsNum% = FALSE
164.     END IF
165. END FUNCTION ' IsNum%
166.  
167. ' /////////////////////////////////////////////////////////////////////////////
168.  
169. FUNCTION RightPadString$ (myString$, toWidth%, padChar$)
170.     RightPadString$ = LEFT$(myString$ + STRING$(toWidth%, padChar$), toWidth%)
171. END FUNCTION ' RightPadString$
172.  
173. ' /////////////////////////////////////////////////////////////////////////////
174.  
175. FUNCTION cstr$ (myValue)
176.     'cstr$ = LTRIM$(RTRIM$(STR$(myValue)))
177.     cstr$ = _TRIM$(STR$(myValue))
178. END FUNCTION ' cstr$
179.  

[madscijr]

Sometimes, you guys make things entirely too  complicated.
...
There ya go!  Three functions to either round naturally (0 - 0.4999999999999999999999 rounds down, 0.5 - 0.99999999999999999 rounds up), always round down, or always round up, to whatever number of digits you desire.

Wow, that's nice and simple, thanks!
One question: your functions receive and return type FLOAT.
What would the best way to handle a case where you want to pass in a single or double precision?
Would you have to convert the value to float, pass it in, then convert it back, or can the values be passed/returned as is?
Or would it be better to make copies of each of those functions for single and double precision?
Thanks again...

[Pete]

I haven't used _CEIL before, but doesn't that have a limit of 15 decimal places?

Pete

[SMcNeill]

Wow, that's nice and simple, thanks!
One question: your functions receive and return type FLOAT.
What would the best way to handle a case where you want to pass in a single or double precision?
Would you have to convert the value to float, pass it in, then convert it back, or can the values be passed/returned as is?
Or would it be better to make copies of each of those functions for single and double precision?
Thanks again...

SINGLE, DOUBLE, and _FLOAT are all floating-point precision variable types.  The only difference in them is how much precision and how large a value they can hold.

If they were used for transportation, you could think of them as a compact car, a luxury suv, and a bus.  Now, ANY of those will let one person drive them to go to and from work, but the cost in resources (gas, in this case) for using them is going to be a little different. 

On the other hand, one person can ride a bus, but 32 people could never pack in a compact car!

So, if you think of your variable types like this, you can see why I chose to use _FLOAT.  A FLOAT will work just fine with SINGLE, or DOUBLE values, and the increase in memory usage will only be 28-bytes at most, and even then, those are temporary bites used, as they’re freed the moment you exit the function and get the return value.

Now, you COULD write it as a function that uses SINGLE variables, just to only use 4-bytes of memory, instead of the 32 that a float uses), but you’d always be stuck with the limits of a SINGLE’s precision.

Since the resource usage is temporary, and a trivial amount in this case (in relation to a programs overall memory allowable), I just chose to make the function a bus so it can always carry the maximum amount of passengers, and then I’ll never need to worry about swapping out to a larger vehicle.

[madscijr]

SINGLE, DOUBLE, and _FLOAT are all floating-point precision variable types.  The only difference in them is how much precision and how large a value they can hold.
...
Since the resource usage is temporary, and a trivial amount in this case (in relation to a programs overall memory allowable), I just chose to make the function a bus so it can always carry the maximum amount of passengers, and then I’ll never need to worry about swapping out to a larger vehicle.

Sounds good to me. I liked your analogy of the compact car & bus. Maybe make the luxury SUV a pimpmobile!

Thanks again, and to everyone else who helped.

[SMcNeill]

I haven't used _CEIL before, but doesn't that have a limit of 15 decimal places?

Pete

INT always rounds down.  _CEIL always rounds up.  The limit is going to be based on your variable type.

[Pete]

It's good to have, especially with QB64's INTEGER 64 variable type. Still, I just stick with strings when it comes to math. That's only limited by system memory.

Nice set of non-string functions, though!

Pete

[bplus]

@Pete how many lines of code for your String math tools?

Mine ran about 300 not counting comments and demo's and helper subs.
https://www.qb64.org/forum/index.php?topic=2921.msg121886#msg121886

So is yours bigger than mine?