Thread: swap dynamically allocated arrays

Why the following codes don't produce the same results?

declaration (common part)

Code:

double **before, **temp;
before = malloc(N * sizeof(double *));
for ( i = 0; i < M; i++)
{
    before[i] = malloc(M * sizeof(double));
}

double **after;
after = malloc(N * sizeof(double *));
for ( i = 0; i < M; i++)
{
    after[i] = malloc(M * sizeof(double));
}

First code (we are only interested in before getting the values of after.

Code:

// for each line in the array
for (i = 0; i < n; i++)
{
        // for each column in the array
        for (j = 0; j < m ; j++)
        {
            before[i][j] = after[i][j];
        }
}

Second try:

Code:

temp = before;
before = after;
after = temp;

The second try seems not to work properly. Why? Shouldn't they produce the same results?

>The second try seems not to work properly.

How so?

Code:

    for (k = 0; diff > epsilon && k <= 1000; k++)
    {
        diff = 0;
        // for each line in the array
        for (i = 1; i < n - 1; i++)
        {
            // for each column in the array
            for (j = 1; j < m - 1; j++)
            {
                // calculate the values according to Jacobi's algorithm
                after[i][j] = 0.25 * (before[i - 1][j] + before[i + 1][j] + before[i][j - 1] + before[i][j + 1]);

                /* calculate the difference of the new value in comparison with the previous one
                 * and keep only the greatest difference */
                if (absolute(after[i][j] - before[i][j]) > diff)
                {
                    diff = absolute(after[i][j] - before[i][j]);
                }
            }
        }

        // for each line in the array
        for (i = 1; i < n - 1; i++)
        {
            // for each column in the array
            for (j = 1; j < m - 1; j++)
            {
                before[i][j] = after[i][j];
            }
        }

doesn't seem to produce the same results as:

Code:

    for (k = 0; diff > epsilon && k <= 1000; k++)
    {
        diff = 0;
        // for each line in the array
        for (i = 1; i < n - 1; i++)
        {
            // for each column in the array
            for (j = 1; j < m - 1; j++)
            {
                // calculate the values according to Jacobi's algorithm
                after[i][j] = 0.25 * (before[i - 1][j] + before[i + 1][j] + before[i][j - 1] + before[i][j + 1]);

                /* calculate the difference of the new value in comparison with the previous one
                 * and keep only the greatest difference */
                if (absolute(after[i][j] - before[i][j]) > diff)
                {
                    diff = absolute(after[i][j] - before[i][j]);
                }
            }
        }

        temp = before;
        before = after;
        after = temp;
    }

In the first version, 'after' remains the same and its content is copied into before, in the second version 'before' and 'after' are exchanged so the content of after does change. As you're still using 'after' in your algorithm, you get different results.

But as you can see, I don't use the elements of the array after in the program. I merely write in the array after the results, so I don't care what were its previous values.
What I am really interested in, is before to contain the updated values.

But as you can see, I don't use the elements of the array after in the program

Indeed, I misread the code, please ignore my comment on that.

There is an index error in your arrays init. :

Code:

before = malloc(N * sizeof(double *));
for ( i = 0; i < M; i++)
{
...
after = malloc(N * sizeof(double *));
for ( i = 0; i < M; i++)
{
...

but I'm not convinced it would lead to the problem discussed here.

doesn't seem to produce the same results as:...

Could you detail that? how do you check the result? The method should work anyway, there must be a bug somewhere.

Problem solved.
I have found the error. The swapping had been done fine. The problem was in the initialization of the two arrays. I wasn't careful with the values at the first and last row/column.