(no subject)

[davv]

I do not like the Allman style, either.

I would write something more here, but... *grumble grumble* (The logical part of myself is even a bit surprised at how much I dislike it.)

Comments

[lhexa]

Speaking of ugly code: I just wrote a program with for loops thirteen deep. The relativistic expression the program is meant to evaluate takes up four lines of scratch paper. And if this expression comes out zero, like several simpler ones have before, I'll hit my head against the desk. :P

[davv]

Speaking of ugly code: I just wrote a program with for loops thirteen deep.

This is where I reach for Recursion, but maybe the program isn't large enough to justify doing it right :)

What does that expression calculate?

[lhexa]

I don't think recursion can be used here, but I did notice a repeated expression that I can place in a separate set of loops, to reduce the main one to nine loops deep. But the next try will be a different expression, anyway.

The expression is the bracket of two potential invariants, which has to be nonzero (or invertible, if you use more than two) if I am to be able to form a Dirac bracket (which is a way of restricting an original, too-powerful bracket). I'm working with relativistic expressions, so there are summed indices all over the place -- thirteen, in this case. When I wrote down the expression I made it up to pi in the Greek letters.

Also, it turned out to be zero. :P

[davv]

Also, it turned out to be zero. :P

Alas!

I don't think recursion can be used here, but I did notice a repeated expression that I can place in a separate set of loops, to reduce the main one to nine loops deep.

I was thinking more generally. Say you have something like:

for (int a = minA; a < maxA; ++a) {
     for (int b = minB; b < maxA; ++b) { ...

           ultimate_value = f(ultimate_value, a, b, ...);
     }
}

Then you could do this recursively by defining a maximum, minimum, and current array, e.g.

int minima[N] = {minA, minB, ...};
int maxima[N] = {maxA, maxB, ...};
int current[N];

and then you can recurse:

void lotsaloops(int current_position, int max_position, int & ultimate_value, 
    int * minima, int * maxima, int * current) {

    if (current_position == max_position) {
        ultimate_value = f(ultimate_value, current[0], current[1], ...); 
    } else {
        for (current[current_position] = minima[current_position]; 
            current[current_position] < maxima[current_position]; 
            ++current[current_position]) {

            lotsaloops(current_position+1, max_position, ultimate_value,
                minima, maxima, current);
        }
    }
}

... but if you're going that route, I imagine you'll get better results by moving to a functional language and using functions that work on functions. Doing this kind of "virtual looping" can get quite ugly, as well, if you need to calculate things at intermediate loop levels.

[lhexa]

My subsequent attempt succeeded!

Anyway, it looks like doing it that way sacrifices readability for brevity, so it doesn't seem worthwhile here. I can see it being the only viable option when you don't know beforehand how many loops deep your program will go, however.

[davv]

Yeah, or when you're working in some sort of language with higher-order functions. Although I don't know the functional approach as well as I'd wish, I imagine you'd just use fold over a list of values - or a function represented as such a list.

And congrats! I thought the zero meant that you couldn't use your approach at all, not that your implementation was wrong :)

[lhexa]

And congrats! I thought the zero meant that you couldn't use your approach at all, not that your implementation was wrong :)

No, your first thought was correct, but I found a different set of invariants that did give a nonzero bracket.