How to turn equation with decrementing indexing into math equation with summation?

Question

Similar to this question: Turn while loop into math equation?, I have the following nested loop that I am trying to convert into a math equation as I need to write this up in a format that doesn't look like code. I believe I am going to need some type of summation equation.

Here is the code:

int num = 0;
for (int i = nr - 1; i >= 0; i--) {
    for (int j = nc - 1; j >= 0; j--) {
        ela[i][j] = num;
        eha[i][j] = num + ea[i][j] - 1;
        num += ea[i][j];                    
    }
}

I know that summations start from a lower bound and continue to a higher bound, so I'm not quite sure how to apply a summation here since I start from a higher index and continue to a lower index.

I'm not sure why I'm getting downvoted, as the question I referenced is very similar to mine, has the same tags and is upvoted 14 times. Please comment below if I can improve my question somehow.

Update:

I was able to update the formula as follows:

nr = 50;
nc = 10;

num = sum[ea[i,j],i=0,nr-1,j=0,nc-1]; // correct based upon nr, nc and ea
for (int i = 0; i < nr; i) {
    for (int j = 0; j < nc; j++) {
        num = num - ea[i,j];
        ela[i][j] = num;
        eha[i][j] = num + ea[i,j] - 1;                              
    }
}

@LogicStuff I think those are what he would like to express as functions. — SirGuy, Jul 06 '16 at 19:19
@LogicStuff, ela and eha are variables that are set by this loop. — Veridian, Jul 06 '16 at 19:21
The [background question](http://stackoverflow.com/questions/38230743/how-to-turn-for-loop-into-a-math-equation) — Weather Vane, Jul 06 '16 at 19:26
Who cares which way the index is going if you don't modify `ea`? — Mad Physicist, Jul 06 '16 at 20:08
@MadPhysicist The `way the index is going` matters because of `num` which is a *reverse* partial sum. — dxiv, Jul 06 '16 at 21:14
So `ea` is a scalar now, no longer an array? This changes the question altogether. It's generally better advised to make up your mind *before* posting. — dxiv, Jul 06 '16 at 21:47
@dxiv, I modified it to simplify the problem. I didn't change my mind. apologies for any confusion this may have caused you. I'll revert it back for you. — Veridian, Jul 06 '16 at 21:52
@Veridian Was just pointing out that it's a quite different problem if all `ea[i][j]` have the same value. For one example, `num` can be calculated directly from `i, j` in that case. — dxiv, Jul 06 '16 at 21:55

score 1 · Answer 1 · answered Jul 06 '16 at 20:14

If the problem is just with how to express the sum when you're looping the other direction, you can change your code to:

int num = 0;
for (int i = 0; i < nr; i++) {
    for (int j = 0; j < nc; j++) {
        ela[nr - i][nc - j] = num;
        eha[nr - i][nc - i] = num + ea[nr - i][nc - j] - 1;
        num += ea[nr - i][nc - j];                    
    }
}

I'm not saying you have to change your code to this, but from here it should be more obvious how to change this to use summation notation.

score 1 · Accepted Answer · 2016-07-07T07:38:44.760

1

If I am right, you can transcribe the effect as

You can describe this as the matrix ela being a 2D suffix sum of the matrix ea (for every element, sum of the elements that follow in the lexicographical ordering), while eha is the sum of matrices ela and ea minus all ones.

edited Jul 07 '16 at 07:38

answered Jul 07 '16 at 07:18

score -1 · Answer 3 · answered Jul 06 '16 at 21:41

It's hard to tell without any context, but the code in question becomes more intelligible if you think of the arrays as vectors enumerating the elements in reverse order, row-major. The code below is functionally equivalent to the original one posted, but arguably easier to follow.

// n.b. ela[nr - 1 - i][nc - 1 - j] == rela(nc * i + j);
int &rela(int k) { return ela[nr - 1 - k / nc][nc - 1 - k % nc]; }
int &reha(int k) { return elh[nr - 1 - k / nc][nc - 1 - k % nc]; }
int &rea(int k)  { return  ea[nr - 1 - k / nc][nc - 1 - k % nc]; }

for (int k = 0, sum = 0; k < nr * nc - 1; k++) {
    rela(k) = sum;
    sum += rea(k);
    reha(k) = sum - 1;
}

In plain English, rela(k) is the partial sum of rea elements 0 ... k-1 and reha(k) is one less than the partial sum of rea elements 0 ... k (also, rela(k) == reha(k - 1) + 1 for k > 0).

Technically, this description could be translated back in terms of the 2d arrays, but it becomes rather messy quickly.

How to turn equation with decrementing indexing into math equation with summation?

3 Answers3