More of a math question

I have a var called i that is a counter in a loop. I need to know everytime it hits a number that is divisable by 32 without reseting the counter. So I need to know when it hits 32, 64, 96, 128, 160, etc. This can go up to 8,000 or so. Anyone got some spiffy formula that can help me out?

Code:

---

for (int i = 0; i < 5795279; ++i)
{
    if (i % 32 == 0)
    {
          // i is divisible by 32.
    }
}

---

The modulo operator (a % b) returns the remainder after a is divided by b. so when there is no remainder, i is divisible by 32.

I'm sure you could also do it by looking at the bits, which would be faster, but I can't think how right now.

I had thought of that, but I really didnt want to waste cycles looping. I was thinking there must be a better way.

Am I missing something? Just put this inside your loop:

Code:

---

    if (counter % 32 == 0)
    {
          // counter is divisible by 32.
    }

---

it won't modify the counter variable.

Sorry, my mistake I misread what you wrote. Thanks

Since 32 is a power of two, it can be made far faster by writing
if((i & 0x1F) == 0)

though a good compiler should do that on its own. The % is more readable.

Quote:

---

Originally posted by CornedBee
Since 32 is a power of two, it can be made far faster by writing
if((i & 0x1F) == 0)

though a good compiler should do that on its own. The % is more readable.

---

could you explain what does the (i & 0x1F) == 0) really do please?
i can see 1F = 31 but what more?

CornedBee is talking about what I mentioned in my first post, checking the bits of the number, which is probably far faster.

0x1F = 31 = (MSB first) 0000 0000 0001 1111

if (number & 0x1F) will only return != 0 if number has one of the five lowest bits set. Since all multiples of 32 will never have these bits set, it's a good test.
IE:

0000 0000 0010 0000 [32] &
0000 0000 0001 1111 [31]
===================
0000 0000 0000 0000 [00]

0000 0000 0010 0100 [36] &
0000 0000 0001 1111 [31]
===================
0000 0000 0000 0100 [04]

the & operator is called bitwise and, and performs the boolean and operation on each bit of its operands and result corresponding bit, all encoded as digits in the binary integers.

for efficiency use nested loops for this sort of things, let the inner loop go 32 cycles, or less as by avoided ifs in loops, better pipelining...

Using bitwise is a bit faster. I can tell by how much, but it cut a couple of seconds off.

are you sure you're incrementing the same variable? nested loops should be faster, unless you do 32 times more work without the ifs

ok here's some sample code

Code:

---

x=8000;
while (x-=32){
 y=32;
  while (y--){
  }
 //here goes code you'd have in the ifs
}

---

I dont think nested would be better in this case. I am looping through a rather large vector of a ton of data, using an iterator, which is being dumped to an excel spread sheet. I need to know when I hit 32 because thats where the break in the data needs to happen on each page, thats all. So I think nesting would just make it more complex.

well in case you want to keep it readable, then do so. it should be though, less efficient

Actually that doesnt take really that much time. I need to shave more time off the creating of the final vector. Thats what takes the most time. But thats going to have to wait for another time, I got a dead line.

i%32 should not be any slower than 1&31, any decent compiler will optimize the first statement to the last. You shouldn't waste your time optimizing details like this.

its the conditionals that slow you down, dunno if compilers break them down though, you could check the output asm code