Question

Often I find myself having a expression where a division by int is a part of a large formula. I will give you a simple example that illustrate this problem:

int a = 2;
int b = 4;
int c = 5;
int d = a * (b / c);

In this case, d equals 0 as expected, but I would like this to be 1 since 4/5 multiplied by 2 is 1 3/5 and when converted to int get’s “rounded” to 1. So I find myself having to cast c to double, and then since that makes the expression a double also, casting the entire expression to int. This code looks like this:

int a = 2;
int b = 4;
int c = 5;
int d = (int)(a * (b / (double)c));

In this small example it’s not that bad, but in a big formula this get’s quite messy.

Also, I guess that casting will take a (small) hit on performance.

So my question is basically if there is any better approach to this than casting both divisor and result.

I know that in this example, changing a*(b/c) to (a*b)/c would solve the problem, but in larger real-life scenarios, making this change will not be possible.

EDIT (added a case from an existing program):

In this case I’m caclulating the position of a scrollbar according to the size of the scrollbar, and the size of it’s container. So if there is double the elements to fit on the page, the scrollbar will be half the height of the container, and if we have scrolled through half of the elements possible, that means that the scroller position should be moved 1/4 down so it will reside in the middle of the container. The calculations work as they should, and it displays fine. I just don’t like how the expression looks in my code.

The important parts of the code is put and appended here:

int scrollerheight = (menusize.Height * menusize.Height) / originalheight;
int maxofset = originalheight - menusize.Height;
int scrollerposition = (int)((menusize.Height - scrollerheight) * (_overlayofset / (double)maxofset));

originalheight here is the height of all elements, so in the case described above, this will be the double of menusize.Height.

Answer 1

First of all, C# truncates the result of int division, and when casting to int. There’s no rounding.

There’s no way to do b / c first without any conversions.