Dúvida com array!

[marassi]

Fala galera. Tô fazendo um programa que no final tem que “e1” e “e2” igual 0. Para isso fiz um looping com diversas expressões. Bem, ele faz a primeira volta no looping tranquila, mas quando ele volta ele usa os mesmo valores que eu determinei no começo. Eu queria ,que após fazer o prmiero looping, os valores que o “ndwh” recebeu fossem passados para “wt” , no começo do outro looping. Também gostaria que “ndw0h” fizesse a mesma coisa, só que o “w0” recebesse o valor. Como Faço isso??
Vlw galera

[code]
imports…
public class Neural2{

public static void main(String[] args){



double[] t = {1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0};

double[] h = {1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1};

double[] wt = {0.1, 0.2, 0.2, 0.2, 0.1, 0.1, 0.2, 0.2, 0.2, 0.1, 0.1, 0.2, 0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.2, 0.2, 0.2, 0.2, 0.1, 0.1};

double[] dwt = new double[25];

double[] ndwt = new double[25];
double[] wh = new double[25];
double[] dwh = new double[25];
double[] ndwh = new double[25];



double n = 0.2, w0 = 0.1, netj = 0, e1, e2, dw0t, dw0h, ndw0t, ndw0h;

int cnt = 0, y = 0, d;



do{

for(int i = 0; i<=24; i++)
{
    wt[i] = ndwh[i];
}


    //PRIMEIRA ENTRADA.....................................................

d = 1;



// cálculo do netj

for(int i = 0; i <= 24; i++)

{

    netj += t[i]*wt[i];

 }

netj += 1*w0;



//cálculo da saída y



if (netj >=0)

y = 1;



else    

y = 0;



//cáculo do erro



e1 = d - y;



//cálculo das variações



for(int i = 0; i <= 24; i++)

{

    dwt[i] = n * e1 * t[i];    

}

dw0t = n * e1 * 1;

//cálculo dos novos pesos

for(int i = 0; i<= 24; i++)
{
    ndwt[i] = dwt[i] + wt[i];
}

ndw0t = dw0t + w0;


// SEGUNDA ENTRADA......................................................................................

d = 0;
netj = 0 ;

for (int i =0; i<= 24; i++)
{
    wh[i] = ndwt[i];
}

w0 = ndw0t;

    // cálculo do netj
for(int i = 0; i<=24; i++)
{
    netj += wh[i]*h[i];
}

netj += 1*w0;



//cálculo da saída y



if (netj >=0)

y = 1;



else    

y = 0;



//cáculo do erro



e2 = d - y;



//cálculo das variações



for(int i = 0; i <= 24; i++)

{

    dwh[i] = n * e2 * h[i];    

}

dw0h = n * e2 * 1;

//cálculo dos novos pesos

for(int i = 0; i<= 24; i++)
{
    ndwh[i] = dwh[i] + wh[i];
}    

ndw0h = dw0h + w0;

cnt +=1;



}while((e1 != 0)||(e2 != 0));


System.out.println("Numero de ciclos " +cnt );

 }

}[/code]

[ViniGodoy]

O que o programa deveria fazer?
O que diabos é “e1” e “e2”?

Dê nomes descritivos para suas variáveis. Para mim, é impossível saber o que o vetor “ndwh” deveria guardar, ou que valores ele deveria conter.
Divida seu programa em funções, com nomes que descreve o que elas fazem. Ou, no mínimo, faça comentários que realmente expliquem o que você quer obter.

Desse jeito aí, não dá para entender nada.

[andredecotia]

Viny, bom dia,

por favor, em que situação usa-se um array bidimensional?

[ViniGodoy]

Sempre que você quiser representar informação na forma de “linha/coluna”.

[marassi]

Blz. Bem, em resumo o programa tem que ir fazendo loopings até os erros “e1” e “e2” ficarem iguais a zero. Isso é um programa de redes neurais.
Primeiro calculo o “netj” com “t[]” e “wt”, que já recebem seus valores nas sua criações. Depois adicino ao "netj "mais um resultado, que é o de “1*w0”. Depois passo o “netj”, com os valores recebidos, em um if e else. Após eu achar o meu “y”, calculo o meu primeiro erro “e1”, com o “y” e “d” que vale 1. Depois de encontrar o erro, calculo os “dwt[]” com: o “n” que vale 0.2, o “e1” e os valores de “t[]”. Faço a mesma coisa com o “dw0”. Agora calculo os “ndwt[]” e depois o “ndw0”.
Depois de fazer tudo isso, ele vai pra segunda entrada de valores, que são os de “h[]”. Antes disso, os valores que eu achei em "ndwt[] " eu passo para o “wh[]”, pois ele não tem valores. Passo tbm o valor achado em “ndw0” para o “w0”. Calculo de novo o “netj”, só que agora com os valores “wh[]” e “h[]”. Acho o “y” , com o novo “netj”. Depos calculo o erro 2 “e2”, com y e o valor de “d”, que agora é 0. Calculo agora o “dwh[]” e depois o “dw0”. Calculo depois os valores de "ndwh[] e “ndw0”.
Os valores de “ndwh” e “ndw0” no final do primeiro looping devem ser passados para o “wt[]” e “w0” que farão o segundo looping. Acontecerá o novo looping pq o “e1” e “e2” não forão iguais a 0. Esse programa continuará achando valores e repassando para as outras variáveis até que encontre “e1” e “e2” iguais a 0. Minha dúvida é que quando vai começar o segundo looping “ndwh[]” não passa os valores para “wt[]”, nem “ndw0” passa “w0”. Como resolvo esse problema?
Tireis algumas coisas daquele programa. Desculpem pelos erros.

[code]public class Neural2{

public static void main(String[] args){



double[] t = {1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0};

double[] h = {1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1};

double[] wt = {0.1, 0.2, 0.2, 0.2, 0.1, 0.1, 0.2, 0.2, 0.2, 0.1, 0.1, 0.2, 0.1, 0.2, 0.1, 0.2, 0.1, 0.1, 0.1, 0.2, 0.2, 0.2, 0.2, 0.1, 0.1};

double[] dwt = new double[25];

double[] ndwt = new double[25];

double[] wh = new double[25];

double[] dwh = new double[25];

double[] ndwh = new double[25];



double n = 0.2, w0 = 0.1, netj = 0, e1, e2, dw0, ndw0;

int cnt = 0, y = 0, d;



do{



    //PRIMEIRA ENTRADA.....................................................

d = 1;



// cálculo do netj

for(int i = 0; i <= 24; i++)

{

    netj += t[i]*wt[i];

 }

netj += 1*w0;



//cálculo da saída y



if (netj >=0)

y = 1;



else    

y = 0;



//cáculo do erro1



e1 = d - y;



//cálculo dos dwt e dw0



for(int i = 0; i <= 24; i++)

{

    dwt[i] = n * e1 * t[i];    

}



dw0 = n * e1 * 1;



//cálculo de ndwt w ndw0



for(int i = 0; i<= 24; i++)

{

    ndwt[i] = dwt[i] + wt[i];

}



ndw0 = dw0 + w0;





// SEGUNDA ENTRADA......................................................................................



d = 0;

netj = 0 ;


//Passagem de ndwt para wh e de ndw0 para w0

for (int i =0; i<= 24; i++)

{

    wh[i] = ndwt[i];

}



w0 = ndw0;



    // cálculo do netj

for(int i = 0; i<=24; i++)

{

    netj += wh[i]*h[i];

}



netj += 1*w0;



//cálculo da saída y



if (netj >=0)

y = 1;



else    

y = 0;



//cáculo do erro2



e2 = d - y;



//cálculo de dwh[] e dw0



for(int i = 0; i <= 24; i++)

{

    dwh[i] = n * e2 * h[i];    

}



dw0 = n * e2 * 1;



//cálculo de ndwh e ndwo



for(int i = 0; i<= 24; i++)

{

    ndwh[i] = dwh[i] + wh[i];

}    



ndw0 = dw0 + w0;


// fim do looping. Se ele não ensontrou os erros iguais a 0, ele fará tudo de novo

cnt +=1;





}while((e1 != 0)||(e2 != 0));



System.out.println("Numero de ciclos " +cnt );

 }

}[/code]

[entanglement]

Ao fazer contas com double, nunca suponha que é possível calcular até algo chegar a zero (exatamente zero). Por exemplo, se e = 1.0 - 37 * (1.0 / 37.0), você vai ver que esse valor é matematicamente zero, mas ao fazer contas ele não é zero.

Em vez disso, estipule um valor que seja considerado como zero (também chamado de “épsilon” em cálculo numérico). Se |e| < 0.00000000001, por exemplo, então você considera que deve terminar seu cálculo.

Em Java:

double epsilon = 1E-7; // digamos - você precisa ajustar este valor de acordo com seus dados e seu algoritmo
do {
    ....
} while (Math.abs (e1) > epsilon && Math.abs (e2) > epsilon);

[marassi]

double epsilon = 1E-7; // digamos - você precisa ajustar este valor de acordo com seus dados e seu algoritmo do { .... } while (Math.abs (e1) > epsilon && Math.abs (e2) > epsilon);

No caso, como eu faria para dizer que 0.00000000001 vale zero?
Na declaração do epsilon vc está fazendo isso?