Comment puis-je itération entre 32 options binaires?

J'ai un problème d'optimisation où j'ai 5 variables: A, B1, B2, C1, C2. J'essaie d'optimiser ces 5 variables pour obtenir la plus petite valeur carrée de la somme de racine que je peux. J'ai quelques techniques d'optimisation qui fonctionnent bien, mais celle-ci en particulier me donne des problèmes.

Je veux explorer toutes les 32 options de changement de variables et choisir la plus petite valeur RSS. Ce que je veux dire par ceci est chaque variable peut soit être +/- un incrément. Et chaque choix conduit à 2 autres choix, avec 5 variables qui sont 32 choix. (2 ^ 5) P>

Pour clarifier, je n'aijoute pas mes variables: A, B1, B2, etc., je suis incrémenté / les décrémentant par un montant arbitraire. A +/- x, b1 +/- x2, etc. Et j'essaie de déterminer quelle combinaison d'incrémentation / décrémentation de mes 5 variables de 5 variables reviendront la valeur carrée de la somme de racine la plus basse. P>

//Settign all possible solutions to be iterated through later.
double[] levelA = new double[2];
double[] levelB = new double[2];
double[] levelC = new double[2];
double[] levelD = new double[2];
double[] levelE = new double[2];

levelA[0] = a + incA;
levelA[1] = a - incA;
levelB[0] = b + incB;
levelB[1] = b - incB;
levelC[0] = c + incC;
levelC[1] = c - incC;
levelD[0] = d + incD;
levelD[1] = d - incD;
levelE[0] = e + incE;
levelE[1] = e - incE;

double[] rootSumAnswers = new double[32];
int count = 0;

for(int i = 0; i < 2; i ++)
{
    for(int k = 0; k < 2; k++)
    {
        for(int j = 0; j < 2; j ++)
        {
            for(int n = 0; n < 2; n++)
            {
                for(int m = 0; m < 2; m++)
                {
                    rootSumAnswers[count++] = calcRootSum(levelA[i], levelB[k], levelC[j], levelD[n], levelE[m]);

                }
            }
        }
    }
}

//Finally, i find the minimum of my root sum squares and make that change permanent, and do this again.