```
@wtf= 751 / 750
returns 1 in the view
@wtf= 3 / 750
returns 0 in the view
@wtf= 749 / 750
returns 0 in the view.
```

can somebody explain what’s going on here. i’m just trying to calculate

percents.

```
@wtf= 751 / 750
returns 1 in the view
@wtf= 3 / 750
returns 0 in the view
@wtf= 749 / 750
returns 0 in the view.
```

can somebody explain what’s going on here. i’m just trying to calculate

percents.

Morgan M. wrote:

`@wtf= 751 / 750 returns 1 in the view @wtf= 3 / 750 returns 0 in the view @wtf= 749 / 750 returns 0 in the view.`

can somebody explain what’s going on here. i’m just trying to calculate

percents.

Apparently if you add a .0 it turns it into a precise number

Morgan M. wrote:

Morgan M. wrote:

`@wtf= 751 / 750 returns 1 in the view @wtf= 3 / 750 returns 0 in the view @wtf= 749 / 750 returns 0 in the view.`

can somebody explain what’s going on here. i’m just trying to calculate

percents.Apparently if you add a .0 it turns it into a precise number

In ruby there are two kinds of numbers (really more than that, but let’s

just leave it at two for now) Fixnums and Floats. Fixnums are basically

whole numbers or integers. Floats are any numbers with decimal places

in them. Whenever you do math between two Fixnums, ruby assumes that

you want a fixnum as an answer, and it will only provide a fixnum as a

result. This is incredibly useful when working with arrays, because if

an array is length 9 and you divide that by 2, you get 4, which is a

usable index for an array. 4.5 wouldn’t be. However if any math

operation involve one number that is a float, the answer will be a

float. So 1 (Fixnum) / 2 (Fixnum) = 0 (Fixnum). But 1.0 (Float) / 2

(Fixnum) = 0.5 (Float).

Is that clear?

Morgan M. wrote:

`returns 0 in the view.`

can somebody explain what’s going on here. i’m just trying to calculate

percents.

Ruby performs integer division when the numerator and the denominator

are both integers. If either is a floating point number, it will perform

floating point division. Therefore, simply call .to_f on either side of

the division and you will get a floating point number.

-Justin

On Fri, Jan 22, 2010 at 9:02 PM, Morgan M. [email protected]

wrote:

Morgan M. wrote:

`@wtf= 751 / 750 returns 1 in the view @wtf= 3 / 750 returns 0 in the view`

i’m just trying to calculate percents.

Apparently if you add a .0 it turns it into a precise number

http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_stdtypes.html

$ irb

irb(main):001:0> 1.class

=> Fixnum

irb(main):002:0> 1.0.class

=> Float

On Fri, Jan 22, 2010 at 7:57 PM, Morgan M. [email protected]

wrote:

`returns 0 in the view.`

## can somebody explain what’s going on here. i’m just trying to calculate

percents.Posted via http://www.ruby-forum.com/.

First an example. Lets say you were managing a school, you had two

Philosophy courses, the first course has 1 student, the second course

has 6

students. You want to balance them, how do you do this? With 7 students

total, and 2 courses, 7/2 is 3.5, so we chop one student in half and put

3.5

students into each course. Unfortunately, students who have been chopped

in

half tend to be poor learners (and the janitor hates cleaning up blood).

So

instead, you put 3 in the first course, and 4 in the second.

In this case, we have 7/2, and expect 3 and 4, rather than 3.5 and 3.5

So why do you get the results you do in your examples? It has to do with

how

variables are stored. In lower level languages, the program has to know

ahead of time what kind of number to expect (because of how memory is

managed), so you specifically declare to the translator what kind of

variables you are storing. When you declare something as an int, it

cannot

then become a float, because that is not what you have declared (it is

fixed

at the time that the program code is generated, and can’t change at run

time

if you get 10/6 instead of 10/5, this is called static).

So when you say 1/2, the answer may be 0.5, but that is a number with a

decimal place (called float, which stands for floating point, meaning

that

the decimal place can move around between digits, for example 1.23 vs

12.3),

but the variable you are storing it in may be an integer, so it has no

way

to store this float. In order to store it, the result is made into an

integer by removing everything after the decimal place (known as

truncating).

This is how things have been for a very long time, and now that dynamic

languages are becoming popular, they are largely maintaining this

behaviour,

because integers and floats are typically used in very different ways,

so it

would complicate a lot of situtions if they could switch back and forth

without you explicitly saying it should be allowed. For example, if you

have

some code that you want to be executed some number of times that was

calculated (called a loop), then if the calculation returns 5 it is

straight

forward, but it could come back as 5.2 or 5.3, or some other non

integer.

What does it mean to execute code 5.3 times? In places where discrete

quantities are expected, how do they deal with the remainder? It does

not

make sense to have 4.5 students in a class, and it does not make sense

to

execute the code 5.3 times. We expect integer quantities.

So in most languages, integers and floats are considered to be separate

things, and will not switch back and forth unless you specifically say

to do

so.

In 751 / 750, those are both integers, the interpreter assumes that if

you

are dividing two integers, you want the result to be an integer as well,

since the result is about 1.0013 it simply truncates the remainder,

leaving

one. When you say 749/750, it does the same thing, but this time the

result

is about 0.9987, so it truncates the remainder, leaving zero.

This is one facet of the issue, but the other is that it is not simple

to go

from floating point back to integer. A number like 1/3 is 0.3 with the

three

repeating. This cannot be represented with any finite number of digits,

so

if you multiplied it by three, expecting to get one again, how would you

know that the next digit after the last one was also a three? How would

you

go from that number back to the integer one? For example, if floating

point

numbers could store 4 decimal places, then 16667/50000, and 8333/25000,

and

1/3 would all look like 0.3333, but only the last one should return the

integer 1, when multiplied by 3. So there are issues with converting

from

floats back to integers as well.

We could just make all numbers floating points, or even generalize them

to

more abstract representations, such as stored functions like the square

root

of 2 (which has an infinite number of non-repeating digits), but then it

would be difficult to quickly compare them to other numbers, and we

couldn’t

know how much room they take to store (necessary in many languages, and

for

lots of useful things. For example, to access databases quickly, we need

to

know how much room a given field takes so we can calculate the location

of

the next field and go there directly without looking at all the

information

in between. Or so we can make sure that there will be enough room to

store

it on the device we have selected). We also wouldn’t be able to quickly

do

heavy math operations on these abstract representations. So we accept a

representation that is not precise, the float. It’s a trade off. But it

prevents us from knowing for sure that 0.3333 times 3 is 1, so generally

we

do not allow conversion to floating points unless that is really what we

need for the given step. We keep track of where we want our integers,

and

where we want our floats.

You can see, there is a lot of ambiguity with numbers, and numbers that

track their decimal place are used in very different ways than integer

numbers, which are usually selected because they come in discrete

quantities.

This is why we consider the two to be different, which is why the

interpreter does not immediately convert integer numbers into floating

point

numbers, which is why 751/750 is one, and 749/750 is zero. Integer

divided

by integer assumes the result should be integer, but 751/750.0 is

1.00133333333333, because one of the parameters was a float, so it

assumes a

float result is acceptable.

Most languages behave in this manner.

Hope that helps, just remember when dividing integers, the remainder

will be

truncated, so if you need the remainder, convert one of the arguments to

a

float first.

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

Sponsor our Newsletter | Privacy Policy | Terms of Service | Remote Ruby Jobs