CODEWITHSUNDEEP
c++python
Peter Greaves
Peter Greaves

Reputation: 327

Trouble translating c++ with pre and post increment operators to python

I'm trying to work out what the equivalent a[++j]=*pr++; in the following code (which comes from a MatLab mex file) is in Python. I've found out that 'pr' is a pointer to the first element of the input array, but I can't get my head around what is happening to j. Can someone explain what is happening there in simple terms without pointers etc?

rf3(mxArray *array_ext, mxArray *hs[]) {
double *pr, *po, a[16384], ampl, mean;
int tot_num, index, j, cNr;
mxArray *array_out;

tot_num = mxGetM(array_ext) * mxGetN(array_ext);
pr = (double *)mxGetPr(array_ext);

array_out = mxCreateDoubleMatrix(3, tot_num-1, mxREAL);
po = (double *)mxGetPr(array_out);

j = -1;
cNr = 1;
for (index=0; index<tot_num; index++) {
    a[++j]=*pr++;
    while ( (j >= 2) && (fabs(a[j-1]-a[j-2]) <= fabs(a[j]-a[j-1])) ) {
        ampl=fabs( (a[j-1]-a[j-2])/2 );
        switch(j)
{
            case 0: { break; }
            case 1: { break; }
            case 2: {
                mean=(a[0]+a[1])/2;
                a[0]=a[1];
                a[1]=a[2];
                j=1;
                if (ampl > 0) {
                    *po++=ampl;
                    *po++=mean;
                    *po++=0.50;
                }
                break;
            }
            default: {
                mean=(a[j-1]+a[j-2])/2;
                a[j-2]=a[j];
                j=j-2;
                if (ampl > 0) {
                    *po++=ampl;
                    *po++=mean;
                    *po++=1.00;
                    cNr++;
                }
                break;
            }
        }
    }
}
for (index=0; index<j; index++) {
    ampl=fabs(a[index]-a[index+1])/2;
    mean=(a[index]+a[index+1])/2;
    if (ampl > 0){
        *po++=ampl;
        *po++=mean;
        *po++=0.50;
    }
}
/* you can free the allocated memeory */
/* for array_out data                 */
  mxSetN(array_out, tot_num - cNr);
  hs[0]=array_out;
}

Upvotes: 0

Views: 216

Answers (3)

ratatoskr
ratatoskr

Reputation: 437

You specifically asked about:

a[++j]=*pr++;

j is being incremented before the assignment. In python the left hand side would be:

a[j+1]

and you would also then need to increment j before you use it next:

j += 1

The right hand side simply accesses the current position and then increments the position in the array. In python you would probably just use an iterator for your array.

BTW, you might find it difficult to do a line-by-line 'translation' of the code. I would suggest writing down the steps of the algorithm and then tackling it fresh in python, if that is what you need.

Upvotes: 2

Dan
Dan

Reputation: 4502

In Python, there aren't pointers, so how you translate this will depend on how you decide to represent pr. If you think of the pointer as a copy of the list pr = array_ext[:], the line you've highlighted would be something like

j = j + 1
a[j] = pr.pop(0)

For greater efficiency (and a closer parallel to what the C code is doing), you could use pr as an index into the list array_ext, starting it at 0. Then, the line you highlighted does this:

j = j + 1
a[j] = array_ext[pr]
pr = pr + 1

Upvotes: 1

SigTerm
SigTerm

Reputation: 26409

Here's what happens:

  1. Increment j by 1
  2. assign to a[j] value pointed at by pr
  3. increment pr.

In this order.

Upvotes: 5

Related Questions