Jump to content

"array subscript is not an integer" função com matriz


Recommended Posts

Posted

Comecei a fazer um pequeno programa e logo no inicio me deparei com alguns erros desse gêreno. Mas consegui resolve-los. Porem, como é a primeira vez que mexo com matrizes em C, creio que não entendo bem sobre a sintaxe para comparações.

Alguem pode me ajudar com esse erro?

Linhas: 19,22,26,27

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int educate(int esperado[],int entrada[][]){

 float w1,w2,p1,p2,i;//P1 e P2 são os pesos inicias, w1 e w2 sofrerão atualizações.
 int y=2,esperd;
 float erro;
 double aprendizado =0.1;
 w1=rand()%5+1;
 w2=rand()%5+1;
 w1=w1/13.232;
 w2=w2/13.232;
 p1=w1;
 p2=w2;
 for(i=0;i<10;i++){
  esperd=esperado[i];
  while(y!=esperd){
   y=(w1*entrada[0][i])+(w2*entrada[1][i]);

   if (y!=esperd){
 erro=esperd-y;
 w1=w1+(aprendizado*erro*entrada[0][i]);
 w2=w2+(aprendizado*erro*entrada[1][i]);
   }
  printf("Erro: %f\n",erro);
  }
 }

}
int main(){

srand (time(NULL));
int entrada[1][9]; //matriz 2x10
int esperado[9];
int l,c;



for (l=0;l<2;l++){
 for (c=0;c<10;c++){
  printf("Entrada[%d][%d]: ",l,c);
  scanf("%d",&entrada[l][c]);
 }
}
for(l=0;l<10;l++){
 printf("Esperado[%d]",l);
 scanf("%d",&esperado[l]);
}
return EXIT_SUCCESS;
}
Posted

Nem acredito que o problema era esse 😞

Eu aqui achando que era porque estava comparando algo errado =/

Obrigado Hippy.

Agora surgiu um loop numa comparação entre floats...(código modificado)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int educate(float esperado[],float entrada[][9]){

 float w1,w2,p1,p2;//P1 e P2 são os pesos inicias, w1 e w2 sofrerão atualizações.
 int i;
 float y=2.0,esperd;
 float erro;
 double aprendizado =0.1;
 w1=rand()%5+1;
 w2=rand()%5+1;
 w1=w1/13.232;
 w2=w2/13.232;
 p1=w1;
 p2=w2;
 for(i=0;i<10;i++){

  esperd=esperado[i];
  while(y!=esperd){
   printf("Y=%f | Esperado: %f",y,esperd);
   y=(w1*entrada[0][i])+(w2*entrada[1][i]);
   if (y!=esperd){
 erro=esperd-y;
 w1=w1+(aprendizado*erro*entrada[0][i]);
 w2=w2+(aprendizado*erro*entrada[1][i]);
   }

  printf("Erro do esperado %d: %f\n",i,erro);
  printf("P1: %f\n",p1);
  printf("P2: %f\n",p2);
  printf("W1: %f\n",w1);
  printf("W2: %f\n",w2);
  printf("Soma: %f\n",w2+w1);
  }
 }

}
int main(){
srand (time(NULL));
float entrada[1][9]; //matriz 2x10
float esperado[9];
int l,c;



for (l=0;l<2;l++){
 for (c=0;c<10;c++){
  printf("Entrada[%d][%d]: ",l,c);
  scanf("%f",&entrada[l][c]);
 }
}
for(l=0;l<10;l++){
 printf("Esperado[%d]",l);
 scanf("%f",&esperado[l]);
}

educate(esperado,entrada);
return EXIT_SUCCESS;
}

quando y e esperd chegam nos mesmos valores o loop ainda continua...

Y=1.000000 | Esperado: 1.000000

Posted

nunca deves fazer comparação directa entre valores de vírgula flutuante

o que deves fazer será sempre fazer comparações de grandeza (>=, >, <= ou <)

mais não posso dizer porque não faço ideia o que o código deverá fazer

nota : para mais informação sobre valores de vírgula flutuante : http://en.wikipedia.org/wiki/Floating_point

IRC : sim, é algo que ainda existe >> #p@p
Posted

Ja tentei de diversas formas e o loop infinito acontece...

O que eu estou fazendo é um Perceptron.(tentando)

Dai esse while me garante que os cálculos de ajuste dos pesos sejam feitos até que a resposta gerada atraves dos calculos seja igual a resposta que eu quero.

Ou seja. quando y-esperd=0

mas por serem todos em float sempre ocorre esse loop =/

Posted

já leste o link que te apresentei ?

percebeste porque não se deve usar != ou == com valores de virgula flutuante ?

// valor de diferença do qual consideras que y == esperd
#define FP_COMPARE_THRESHOLD 0.001

while(   y < esperd - FP_COMPARE_THRESHOLD
     || y > esperd + FP_COMPARE_THRESHOLD) {
 // ...
}
IRC : sim, é algo que ainda existe >> #p@p
Posted

Sim eu percebi isso. Mas quando fui testar não coloquei a variável que você adicionou a pouco. Essa variavel retira o "erro" de que por ter um || entre as comparações ele não vai chegar y=0 certo?

Testei aqui e funcionou 🙂

Eu li o link que me mandou. Creio que devido ao stress não devo ter reparado em algo do gênero =/

Mais uma vez, obrigado Hippy 😉

Posted

Essa variavel retira o "erro" de que por ter um || entre as comparações ele não vai chegar y=0 certo?

tens de perceber que podes fazer muitas contas mas a probabilidade do resultado ser exactamente 0 é pequena devido ao problema de representação de um número e a sua implicação nas operações.

o que o código faz não é mais do que :

//  <-----+  |  +-------->
//  ######|  |  |#########
// -------+--+--+--------->
//        |     |
//       0-T   0+T
//
// enquanto o valor ficar dentro de um dos conjunto de valores do gráfico acima com :
//
// T = FP_COMPARE_THRESHOLD
// y - esperd =(tende para)=> 0

while(   y < esperd - FP_COMPARE_THRESHOLD
     || y > esperd + FP_COMPARE_THRESHOLD) {
 // ...
}
IRC : sim, é algo que ainda existe >> #p@p

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.