Hi guys
Got a Ruby book yesterday from Santa, and am a bit stuck 
Searched the pickaxe and some Perl books (left over after an earlier
failed attempt at programming), and this list and Googled and found
nothing useful.
Some examples might make the question clear:
Let's say that after a calculation I get 4.1200056 and I want to round
it up to 5.
When the calculation comes to a number like 4.0 I want it left at 4.
The way I've been dealing with it is that after I get a figure like,
let's say, 7.312456 I turn it into an integer (it then becomes 7) and
then I add 1 getting, in this case, the round number 8.
This works fine except on the occasions when the answer to the
calculation is already a round number like, let's say 6 or 6.0. Turning
it into an integer keeps it 6 but adding 1 makes it a 7. In such a case
I need it to stay at 6.
So, when it's got some figures (other than a single zero) after the
decimal point I want to round it up to a whole number (no decimal point)
but when it has only a single zero after the decimal point I want it
left alone except to have the decimal point and the zero disappear.
Sorry if there is a lack of clarity.
Appreciate any help
all the best
Dermot
Hi!
You can use the 'ceil'-method:
(4.1).ceil # => 5
(4.7).ceil # => 5
(4.0).ceil # => 4
fyi: there is also the floor method which always returns the lower number:
(4.1).floor # => 4
(4.7).floor # => 4
(4.0).floor # => 4
greetz!
Jeroen
路路路
On 2006-12-26 14:00, Dermot Moynihan wrote:
Let's say that after a calculation I get 4.1200056 and I want to round
it up to 5.
When the calculation comes to a number like 4.0 I want it left at 4.
Thanks Jeroen.
Been doing a bit of reading on 'ceil' and 'floor' and am wondering if
you have to know the actual number you are going to be working on in
order to use them. Because I don't know what that number will be. Did
you skim read that post - I gave some examples to try to make that
point. Or have I just misunderstood how to use 'ceil' or 'floor'.
I would have thought this would be a fairly mundane task. After all if
one wants 1 and a bit ice creams or whatever, he must get two not one.
So, rounding up is surely pretty important.
Been experimenting with a thing called 'round' but that rounds up if the
figure after the decimal point is .5 or greater, otherwise it rounds
down. But I need it always UP if there is greater than zero after the
decimal.
Just to sum up again: what I'm looking for is a way of always rounding
up a floating point number that arrives after some calculations. The
answer will vary as a result of the figures used in the calculation varying.
e.g. if the final number is 6.1234 I want it rounded up to 7.
If the final number is 23.025875 I want it rounded up to 24.
However, if 17.0 then have it stay 17.
Or if 21.0 stay 21. And so on.
I suppose what I need is some way of saying:
IF the answer is a floating point decimal number round it up.
If there is nothing after the decimal point (e.g. 46.0) leave it alone (46).
Thanks for your help.
Dermot
Jeroen Budts wrote:
路路路
On 2006-12-26 14:00, Dermot Moynihan wrote:
Let's say that after a calculation I get 4.1200056 and I want to round
it up to 5.
When the calculation comes to a number like 4.0 I want it left at 4.
Hi!
You can use the 'ceil'-method:
(4.1).ceil # => 5
(4.7).ceil # => 5
(4.0).ceil # => 4
fyi: there is also the floor method which always returns the lower number:
(4.1).floor # => 4
(4.7).floor # => 4
(4.0).floor # => 4
greetz!
Jeroen
Dermot Moynihan wrote:
Been doing a bit of reading on 'ceil' and 'floor' and am wondering if
you have to know the actual number you are going to be working on in
order to use them.
Not at all.
x = 3.2
y = 15.7 * x
p y, y.ceil
#=> 50.24
#=> 51
I would have thought this would be a fairly mundane task. After all if
one wants 1 and a bit ice creams or whatever, he must get two not one.
So, rounding up is surely pretty important.
You're right, it is mundane. Ruby provides convenient methods for
making the mundane easy.
I suppose what I need is some way of saying:
IF the answer is a floating point decimal number round it up.
If there is nothing after the decimal point (e.g. 46.0) leave it alone (46).
As Jeroen pointed out, ceil is the answer here.
Yeah, the ceil method always rounds a float up to the next integer
apparently.
C:\ruby\programs>irb
irb(main):001:0> miscNum = 4.0
=> 4.0
irb(main):002:0> miscNum.ceil
=> 4
irb(main):003:0> miscNum = 4.01
=> 4.01
irb(main):004:0> miscNum.ceil
=> 5
路路路
On 12/26/06, Dermot Moynihan <der_moyn@onetel.com> wrote:
Thanks Jeroen.
Been doing a bit of reading on 'ceil' and 'floor' and am wondering if
you have to know the actual number you are going to be working on in
order to use them. Because I don't know what that number will be. Did
you skim read that post - I gave some examples to try to make that
point. Or have I just misunderstood how to use 'ceil' or 'floor'.
I would have thought this would be a fairly mundane task. After all if
one wants 1 and a bit ice creams or whatever, he must get two not one.
So, rounding up is surely pretty important.
Been experimenting with a thing called 'round' but that rounds up if the
figure after the decimal point is .5 or greater, otherwise it rounds
down. But I need it always UP if there is greater than zero after the
decimal.
Just to sum up again: what I'm looking for is a way of always rounding
up a floating point number that arrives after some calculations. The
answer will vary as a result of the figures used in the calculation
varying.
e.g. if the final number is 6.1234 I want it rounded up to 7.
If the final number is 23.025875 I want it rounded up to 24.
However, if 17.0 then have it stay 17.
Or if 21.0 stay 21. And so on.
I suppose what I need is some way of saying:
IF the answer is a floating point decimal number round it up.
If there is nothing after the decimal point (e.g. 46.0) leave it alone
(46).
Thanks for your help.
Dermot
Dermot Moynihan wrote:
Thanks Jeroen.
Been doing a bit of reading on 'ceil' and 'floor' and am wondering if
you have to know the actual number you are going to be working on in
order to use them. Because I don't know what that number will be. Did
you skim read that post - I gave some examples to try to make that
point. Or have I just misunderstood how to use 'ceil' or 'floor'.
No, you don't need to know the number in advance.
Here's the doc for the ceil method. Look at the first two examples. Can you think of any numbers for which it will not do what you need?
ruby$ ri Float#ceil
------------------------------------------------------------- Float#ceil
flt.ceil => integer
路路路
------------------------------------------------------------------------
Returns the smallest Integer greater than or equal to flt.
1.2.ceil #=> 2
2.0.ceil #=> 2
(-1.2).ceil #=> -1
(-2.0).ceil #=> -2
Dermot Moynihan wrote:
Thanks Jeroen.
Just to sum up again: what I'm looking for is a way of always rounding
up a floating point number that arrives after some calculations. The
answer will vary as a result of the figures used in the calculation varying.
e.g. if the final number is 6.1234 I want it rounded up to 7.
If the final number is 23.025875 I want it rounded up to 24.
However, if 17.0 then have it stay 17.
Or if 21.0 stay 21. And so on.
I suppose what I need is some way of saying:
IF the answer is a floating point decimal number round it up.
If there is nothing after the decimal point (e.g. 46.0) leave it alone (46).
Thanks for your help.
Dermot
To me it appears that what you wan is ceil ... it alway rounds up
1.000000001.ceil => 2
1.0.ceil => 1
To round down, use floor
1.99999999.floor => 1
2.0.floor => 2
there's also round ... which rounds up if the fractional part is >=
0.5 otherwise rounds down
2.5.round => 3
2.49999999.round => 2
note that ceil, floor, and round have no effect on integer
5.ceil => 5 5.floor => 5, 5.round => 5
pick the method whose behavior you want
hi,
this might help
hope this is what you want and if i understood your point
just beautify the method try
irb(main):008:0> def try(x)
irb(main):009:1> if Integer(x)==x
irb(main):010:2> p x
irb(main):011:2> else
irb(main):012:2* x=Integer(x)+1
irb(main):013:2> p x
irb(main):014:2> end
irb(main):015:1> end
=> nil
irb(main):016:0> try(10.0001)
11
=> nil
irb(main):017:0> try(10.0)
10.0
=> nil
irb(main):018:0> try(10)
10
=> nil
irb(main):019:0>
regards
gaurav v bagga
Thanks bbiker. Also, further thanks to Gaurav and Phrogz, for supplying
additional very welcome pointers.
Problem sorted and put to bed.
All the very best
Dermot
bbiker wrote:
路路路
Dermot Moynihan wrote:
Thanks Jeroen.
Just to sum up again: what I'm looking for is a way of always rounding
up a floating point number that arrives after some calculations. The
answer will vary as a result of the figures used in the calculation varying.
e.g. if the final number is 6.1234 I want it rounded up to 7.
If the final number is 23.025875 I want it rounded up to 24.
However, if 17.0 then have it stay 17.
Or if 21.0 stay 21. And so on.
I suppose what I need is some way of saying:
IF the answer is a floating point decimal number round it up.
If there is nothing after the decimal point (e.g. 46.0) leave it alone (46).
Thanks for your help.
Dermot
To me it appears that what you wan is ceil ... it alway rounds up
1.000000001.ceil => 2
1.0.ceil => 1
To round down, use floor
1.99999999.floor => 1
2.0.floor => 2
there's also round ... which rounds up if the fractional part is >=
0.5 otherwise rounds down
2.5.round => 3
2.49999999.round => 2
note that ceil, floor, and round have no effect on integer
5.ceil => 5 5.floor => 5, 5.round => 5
pick the method whose behavior you want
Thanks Jeroen, Phrogz, Jason, Timothy and Gaurav and anybody who took
the time to read that post. Got it sorted. As emphasised (sometimes I
need a thing beaten into me), 'ceil' did the trick.
Gaurav, interestingly, if I try your suggestion 10.0000000000000001
still gives me 10.
Removing one of the zeros gives me the required 11. Must be to do with
the number of places after the decimal point that are counted. Using
SciTE rather than irb it seems to see even less places. I doubt that it
would ever be an issue but good to know anyway.
Thanks for your efforts. Been playing around with what you wrote and
trying to understand what you did. Very interesting.
Learned a lot from all your posts. Even that p can be written instead of
puts!
Wonderful support you give here.
All the best
Dermot
gaurav bagga wrote:
路路路
hi,
this might help
hope this is what you want and if i understood your point
just beautify the method try
irb(main):008:0> def try(x)
irb(main):009:1> if Integer(x)==x
irb(main):010:2> p x
irb(main):011:2> else
irb(main):012:2* x=Integer(x)+1
irb(main):013:2> p x
irb(main):014:2> end
irb(main):015:1> end
=> nil
irb(main):016:0> try(10.0001)
11
=> nil
irb(main):017:0> try(10.0)
10.0
=> nil
irb(main):018:0> try(10)
10
=> nil
irb(main):019:0>
regards
gaurav v bagga
hi,
聽聽聽聽that was good to know
聽聽聽irb(main):001:0> o=10.0000000000000001
=> 10.0
irb(main):002:0> o.class
=> Float
irb(main):003:0> 10.0000000000000001.class
=> Float
irb(main):004:0> 10.00000000000000000000000000000000000000000000000001.class
=> Float
irb(main):005:0> 10.00000000000000000000000000000000000000000000000001
=> 10.0
irb(main):008:0>
10.6856856856856856856755555555555555555555555555555555555551
=> 10.6856856856857
irb(main):009:0>
10.6856856856856156856755555555555555555555555555555555555551
=> 10.6856856856856
irb(main):010:0>
never thought what happens when floats get this way "
10.00000000000000000000000000000000000000000000000001"
regards
gaurav
Dermot Moynihan wrote:
Learned a lot from all your posts. Even that p can be written instead of
puts!
For what it's worth, the 'p' method spits out the result of calling
#inspect on each argument, while the 'puts' method spits out the result
of calling #to_s on each argument.
For numbers, the two are identical; not so for other beasts. For
example:
puts "Hello"
#=> Hello
p "Hello"
#=> "Hello"
puts ['a',1,false,/hello/]
#=> a
#=> 1
#=> false
#=> (?-mix:hello)
p ['a',1,false,/hello/]
#=> ["a", 1, false, /hello/]
For many objects, the result of calling #inspect is a string that is
more like source code (though it doesn't have to be) and generally
gives you a better idea of the structure of the object.
hi,
if you get such numbers in your calculations then
irb(main):012:0> 10.0000000000000001.ceil
=> 10
irb(main):013:0>
10.0000000000000001 i copied what you supplied
anyone experience enough in ruby can you explain how ruby handles floats i
bean big floats
this thread has raised doubts in my mind
i'll appreciate if any one replies to this query of mine
regards
gaurav
hi,
i went through http://en.wikipedia.org/wiki/Floating_Point got answer
regards
gaurav