How to omit something from a loop?

Question

        for (int k = 0; k < 32;k++)
        {
            for (int j = 0; j < 32; j++)
            {

                double Score = (user0[k] * user0[j] + user1[k] * user1[j] + user2[k] * user2[j] + user3[k] * user3[j] + user4[k] * user4[j] + user5[k] * user5[j] + user6[k] * user6[j] +
                    user7[k] * user7[j] + user8[k] * user8[j] + user9[k] * user9[j] + user10[k] * user10[j] + user11[k] * user11[j] + user12[k] * user12[j] + user13[k] * user13[j] + user14[k] * user14[j] + user15[k] * user15[j] + user16[k] * user16[j] + user17[k] * user17[j] +
                    user18[k] * user18[j] + user19[k] * user19[j] + user20[k] * user20[j] + user21[k] * user21[j] + user22[k] * user22[j] + user23[k] * user23[j] +
                    user24[k] * user24[j] + user25[k] * user25[j] + user26[k] * user26[j] + user27[k] * user27[j] + user28[k] * user28[j] + user29[k] * user29[j] +
                    user30[k] * user30[j] + user31[k] * user31[j]) / ((Math.Sqrt(user0[k] * user0[k] + user1[k] * user1[k] + user2[k] * user2[k] + user3[k] * user3[k] + user4[k] * user4[k] + user5[k] * user5[k] + user6[k] * user6[k] + user7[k] * user7[k] + user8[k] * user8[k] + user9[k] * user9[k] +
                    user10[k] * user10[k] + user11[k] * user11[k] + user12[k] * user12[k] + user13[k] * user13[k] + user14[k] * user14[k] + user15[k] * user15[k] + user16[k] * user16[k] + user17[k] * user17[k] +
                    user18[k] * user18[k] + user19[k] * user19[k] + user20[k] * user20[k] + user21[k] * user21[k] + user22[k] * user22[k] + user23[k] * user23[k] + user24[k] * user24[k] +
                    user25[k] * user25[k] + user26[k] * user26[k] + user27[k] * user27[k] + user28[k] * user28[k] + user29[k] * user29[k] + user30[k] * user30[k] + user31[k] * user31[k])) * (Math.Sqrt(user0[j] * user0[j] + user1[j] * user1[j] + user2[j] * user2[j] + user3[j] * user3[j] +
                    user4[j] * user4[j] + user5[j] * user5[j] + user6[j] * user6[j] + user7[j] * user7[j] + user8[j] * user8[j] + user9[j] * user9[j] + user10[j] * user10[j] + user11[j] * user11[j] +
                    user12[j] * user12[j] + user13[j] * user13[j] + user14[j] * user14[j] + user15[j] * user15[j] + user16[j] * user16[j] + user17[j] * user17[j] +
                    user18[j] * user18[j] + user19[j] * user19[j] + user20[j] * user20[j] + user21[j] * user21[j] + user22[j] * user22[j] + user23[j] * user23[j] + user24[j] * user24[j]
                    + user25[j] * user25[j] + user26[j] * user26[j] + user27[j] * user27[j] + user28[j] * user28[j] + user29[j] * user29[j] + user30[j] * user30[j] + user31[j] * user31[j])));


                if (Score > simScore)
                {
                    simScore = Score;
                }


            }

If I wanted to have the loop not calculated when k=j, how do I go about doing this? My code calculations are messed up when the loop is calculated when k=j since it will take the greatest value from 32 results and if the k=j loop is calculated, the greatest value will always be the j=k case.

Answer 1

Not sure if that is OCD, but you forced me to show you this:

double[,] user = new double[32,32];

for (int k = 0; k < 32; k++)
{
    for (int j = 0; j < 32; j++)
    {
        if (k == j)
            continue;
        double Score = 0.0;
        for (int i = 0; i < 32; i++)
        {

                Score = (user[i,k] * user[i,j])  /  Math.Sqrt(user[i,k] * user[i,k]) *  Math.Sqrt(user[i,j] * user[i,j] );

                if (Score > simScore)
                {
                    simScore = Score;
                }
        }
    }


}

Answer 2

Use Continue :

Continue alters control flow. It is often found in loop bodies. It allows you to skip the execution of the rest of the iteration. It jumps immediately to the next iteration in the loop. This keyword is often useful in while-loops.

while (true)
    {
        // Get a random number.
        int value = random.Next();
        // If number is divisible by two, skip the rest of the iteration.
        if ((value % 2) == 0)
        {
        continue;
        }
        // If number is divisible by three, skip the rest of the iteration.
        if ((value % 3) == 0)
        {
        continue;
        }
        Console.WriteLine("Not divisible by 2 or 3: {0}", value);
        // Pause.
        Thread.Sleep(100);
    }

Answer 3

use continue, in your loop:

for (int k = 0; k < 32; k++)
{
    for (int j = 0; j < 32; j++)
    {
        if (k == j)
            continue;

        // ...
    }
}