# [pythran] Re: question on slice.hpp

• From: Mehdi Amini <mehdi.amini@xxxxxxxxxx>
• To: pythran@xxxxxxxxxxxxx
• Date: Thu, 04 Sep 2014 16:26:20 -0700

```Integer division is usually *slow*.
```
Converting an integer to a float is 1 cycle, a floating point division is 1 cycle, and integer division is 9 cycles (32 bits) or 59 to 134 cycles (64 bits).
```
Mehdi

PS: based on Ivy Bridge data from agner.org

On 9/4/14, 11:58 AM, Neal Becker wrote:
```
I think it is probably faster, avoiding int <-> float conversions, and potentially more accurate.
```

```
On Thu, Sep 4, 2014 at 2:56 PM, Pierrick Brunet <pierrick.brunet@xxxxxxxx <mailto:pierrick.brunet@xxxxxxxx>> wrote:
```
I think it is rounded up as the slice : 1:5:3 is 2 with a roundup
and 1 with a round down with your expression.

It looks like your formule have the same final behavior but need
more operation to perform it. Do you have any example where the
current function fail?

On 04/09/2014 20:32, Neal Becker wrote:
```
```    In pythran/pythonic/types/slice.hpp

long size() const
{
assert( not upper.is_none and not lower.is_none
and not step.is_none );
return std::max(0L, long(ceil(double(upper -
lower)/double(step))));
}

Maybe this should be:
(using python code here:)

def roundup_divide (a, b):
return (a + b - 1) // b

return std::max(0L, roundup_divide (upper-lower, step));

But on the other hand, did you really mean to roundup?  Should
the size of a slice be rounded down?

```
-- /Those who don't understand recursion are doomed to repeat it/
```

--
/Those who don't understand recursion are doomed to repeat it/
```
```
```