/*multiplica duas matrizes e guarda o resultado em uma matriz resultante*/ void multiplica_matrizes(void) { Matriz matriz_A = {NULL,1,1}, matriz_B = {NULL,1,1}, matriz_Mult = {NULL,1,1}; ushort i,j,k; uchar flag = TRUE; while(flag) { ler_matriz(&matriz_A);/*le valores para linha e coluna e aloca memoria para a matriz*/ ler_matriz(&matriz_B);/*le valores para linha e coluna e aloca memoria para a matriz*/ if(matriz_A.col != matriz_B.row)/*verifica se a multiplicaccao e possivel*/ { printf("\nErro o numero de linhas de colunas de A tem que ser igual ao numero de linhas de B\n"); libera_matriz(matriz_A.address, &(matriz_A.row));/*libera a memoria alocada anteriormente*/ libera_matriz(matriz_B.address, &(matriz_B.row));/*libera a memoria alocada anteriormente*/ } else flag = FALSE; } preenche_matriz(&matriz_A);/*preenche as entradas da matriz com valores via teclado*/ preenche_matriz(&matriz_B);/*preenche as entradas da matriz com valores via teclado*/ matriz_Mult.row = matriz_A.row; matriz_Mult.col = matriz_B.col; matriz_Mult.address = aloca_matriz(&(matriz_Mult.row),&(matriz_Mult.col));/*aloca memoria para a matriz_Mult*/ inicializa_matriz(&matriz_Mult); for(i = 0; i < matriz_Mult.row; i++) for(j = 0; j < matriz_Mult.col; j++) for(k = 0; k < matriz_A.col; k++)/*k < matriz_B->row tambem esta correto*/ *(*(matriz_Mult.address + i) + j) += (*(*(matriz_A.address + i) + k)) * (*(*(matriz_B.address + k) + j)); imprime_matriz(&matriz_A); imprime_matriz(&matriz_B); imprime_matriz(&matriz_Mult); libera_matriz(matriz_A.address,&(matriz_A.row)); libera_matriz(matriz_B.address,&(matriz_B.row)); libera_matriz(matriz_Mult.address,&(matriz_Mult.row)); }
//---------------------------------------------- // Nome: jogar // Desc: Realiza os principais comandos do jogo //---------------------------------------------- int jogar() { ALLEGRO_BITMAP *botao_ok = al_load_bitmap("images/ok button.jpg"); // Cria e carrega arquivo ok button.jpg ALLEGRO_BITMAP *botao_start = al_load_bitmap("images/start button.jpg"); // Cria e carrega arquivo start button.jpg int **matriz; // Para alocação dinâmica de matrizes deve-se criar um ponteiro para ponteiro int tamanho_matriz = (dificuldade * 10); // Variável criada apenas para melhoria do código al_clear_to_color(al_map_rgb(255, 255, 255)); // limpa a tela e a pinta toda de branco al_draw_bitmap(botao_ok, LARGURA_MAX / 1.12, ALTURA_MAX / 1.07, NULL); // Desenha o botão voltar, necessário para poder continuar o programa sem precisar sair al_draw_bitmap(botao_start, LARGURA_MAX / 1.12, ALTURA_MAX / 1.31, NULL); // Desenha o botão voltar, necessário para poder continuar o programa sem precisar sair matriz = aloca_matriz(tamanho_matriz); // Chama a função para Alocar a matriz imprime_matriz(matriz, dificuldade); // Chama a função para desenhar a matriz na tela escreve_jogar(matriz); // É esta a função que pede para o usuário entrar com os dados do jogo, assim como atualizar a matriz desenhada libera_matriz(matriz, tamanho_matriz); // Chama a função para liberar a memória ocupada pela matriz al_destroy_bitmap(botao_ok); // finaliza o BITMAP botao_ok para não ocupar espaço na memória al_destroy_bitmap(botao_start); // finaliza o BITMAP botao_ok para não ocupar espaço na memória return 0; }
/* Execucao */ int main(){ Elemento **matriz; /* Matriz do jogo */ int n_linhas, n_colunas, jogada_i, jogada_j, tmp; int elementos_revelados=0, total_minas=0, jogadas_validas=0; char resultado='i', /* Jogador não ganhou nem perdeu */ aux; scanf("%d %d", &n_colunas, &n_linhas); matriz=aloca_matriz(n_linhas, n_colunas); capta(matriz, n_linhas, n_colunas, &total_minas); /* Capta a matriz passada na entrada e conta o total de minas */ contar_bombas_vizinhas(matriz, n_linhas, n_colunas); aux=getchar(); while(aux!=EOF){ /* Lemos as jogadas validas ate o fim do arquivo */ ungetc(aux, stdin); scanf("%d %d", &jogada_i, &jogada_j); tmp = executar_jogada(matriz, n_linhas, n_colunas, jogada_i-1, jogada_j-1); if(tmp != -1){ /* Nao executa jogadas iguais */ jogadas_validas++; elementos_revelados = elementos_revelados + tmp; /* Adiciona caracteres revelados na jogada */ if(tmp==0){ /* Jogador perdeu */ resultado='p'; elementos_revelados+=1; break; } if(elementos_revelados+total_minas == n_linhas*n_colunas){ /* "n_linhas*n_colunas" = total de elementos */ resultado='v'; /* Jogador ganhou */ break; } } do{ aux=getchar(); } while (aux=='\n'); } printf("Minas: %d\n", total_minas); printf("Jogadas: %d\n", jogadas_validas); printf("Revelados: %d\n", elementos_revelados); if(resultado=='v') printf("Resultado: =)\n"); if(resultado=='p') printf("Resultado: =(\n"); if(resultado=='i') printf("Resultado: ?\n"); imprime_matriz(matriz, n_linhas, n_colunas, resultado); libera_matriz(matriz, n_linhas); /* Libera toda memoria alocada */ return 0; }
void crea_operador(triangulo * tr, matriz * op) { double scale; matriz C; matriz InvC; matriz Cb; matriz Sxx; matriz Sxy; matriz Syy; inicializa_matriz_c(&C,2); inicializa_matriz_c(&Cb,2); inicializa_matriz_c(&InvC,2); inicializa_matriz_c(&Sxx,3); inicializa_matriz_c(&Sxy,3); inicializa_matriz_c(&Syy,3); C.v[0][0]=tr->v[1][0]-tr->v[0][0]; C.v[0][1]=tr->v[2][0]-tr->v[1][0]; C.v[1][0]=tr->v[1][1]-tr->v[0][1]; C.v[1][1]=tr->v[2][1]-tr->v[1][1]; scale=1.0/(C.v[0][0]*C.v[1][1]-C.v[0][1]*C.v[1][0]); printf("Matriz afin:\n"); muestra_matriz(&C); printf("\n"); InvC.v[0][0]= C.v[1][1]; InvC.v[0][1]=-C.v[0][1]; InvC.v[1][0]=-C.v[1][0]; InvC.v[1][1]=C.v[0][0]; escala_matriz(&InvC,scale); printf("Matriz Inversa:\n"); muestra_matriz(&InvC); printf("\n"); Cb.v[0][0]=InvC.v[0][0]*InvC.v[0][0]+InvC.v[0][1]*InvC.v[0][1]; Cb.v[0][1]=InvC.v[0][0]*InvC.v[1][0]+InvC.v[0][1]*InvC.v[1][1]; Cb.v[1][0]=InvC.v[1][0]*InvC.v[0][0]+InvC.v[0][1]*InvC.v[1][1]; Cb.v[1][1]=InvC.v[1][0]*InvC.v[1][0]+InvC.v[1][1]*InvC.v[1][1]; muestra_matriz(&Cb); Sxx.v[1][0]=-1.0; Sxx.v[1][1]=2.0; Sxx.v[1][2]=-1.0; escala_matriz(&Sxx,Cb.v[0][0]); muestra_matriz(&Sxx); Sxy.v[0][0]=-1.0; Sxy.v[0][1]= 1.0; Sxy.v[1][0]= 1.0; Sxy.v[1][1]=-2.0; Sxy.v[1][2]= 1.0; Sxy.v[2][1]= 1.0; Sxy.v[2][2]=-1.0; escala_matriz(&Sxy,0.5*(Cb.v[1][0]+Cb.v[0][1])); muestra_matriz(&Sxy); Syy.v[0][1]=-1.0; Syy.v[1][1]= 2.0; Syy.v[2][1]=-1.0; escala_matriz(&Syy,Cb.v[1][1]); muestra_matriz(&Syy); suma_matrices(op,&Sxx); suma_matrices(op,&Sxy); suma_matrices(op,&Syy); libera_matriz(&C); libera_matriz(&Cb); libera_matriz(&Sxx); libera_matriz(&Sxy); libera_matriz(&Syy); }
void multigrid(malla * u, malla *f, matriz *op, double * max) { int i,j; if(u->nivel==1) { /* Escalar el operador al nivel */ matriz op_n; /* Inicializamos el operador */ inicializa_matriz(&op_n,3); copia_matriz(op,&op_n); escala_matriz(&op_n,pow((u->dimension-1),2)); /* Construimos el sistema a resolver */ double A[3][3]; A[0][0]=op_n.v[1][1]; A[0][1]=op_n.v[2][1]; A[0][2]=op_n.v[2][2]; A[1][0]=op_n.v[0][1]; A[1][1]=op_n.v[1][1]; A[1][2]=op_n.v[1][2]; A[2][0]=op_n.v[0][0]; A[2][1]=op_n.v[1][0]; A[2][2]=op_n.v[1][1]; double B[3]; B[0] = f->v[2][1]-op_n.v[1][2]*u->v[2][2] -op_n.v[0][1]*u->v[1][1] -op_n.v[0][0]*u->v[1][0] -op_n.v[1][0]*u->v[2][0]; B[1] = f->v[3][1]-op_n.v[0][0]*u->v[2][0] -op_n.v[1][0]*u->v[3][0] -op_n.v[2][1]*u->v[4][1]; B[2] = f->v[3][2]-op_n.v[0][1]*u->v[2][2] -op_n.v[1][2]*u->v[3][3] -op_n.v[2][2]*u->v[4][3] -op_n.v[2][1]*u->v[4][2]; /* Hacemos eliminación gausiana */ A[1][1]=A[1][1]-A[0][1]*A[1][0]/A[0][0]; A[1][2]=A[1][2]-A[0][2]*A[1][0]/A[0][0]; B[1]=B[1]-B[0]*A[1][0]/A[0][0]; A[2][1]=A[2][1]-A[0][1]*A[2][0]/A[0][0]; A[2][2]=A[2][2]-A[0][2]*A[2][0]/A[0][0]; B[2]=B[2]-B[0]*A[2][0]/A[0][0]; A[2][2]=A[2][2]-A[1][2]*A[2][1]/A[1][1]; B[2]=B[2]-B[1]*A[2][1]/A[1][1]; /* Resolvemos */ u->v[3][2]=B[2]/A[2][2]; u->v[3][1]=(B[1]-A[1][2]*u->v[3][2])/A[1][1]; u->v[2][1]=(B[0]-A[0][2]*u->v[3][2]-A[0][1]*u->v[3][1])/A[0][0]; } else { /* Escalar el operador al nivel */ matriz op_n; /* Definicion de las mallas */ malla d; /* Para almacenar el defecto */ malla d_; /* Para almacenar el defecto restringido */ malla v; malla v_; /* Inicializacióm mallas*/ inicializa_malla_c(&d,u->nivel); inicializa_malla_c(&d_,u->nivel-1); inicializa_malla_c(&v,u->nivel); inicializa_malla_c(&v_,u->nivel-1); inicializa_matriz(&op_n,3); copia_matriz(op,&op_n); printf("sf=pow(%d,2)",u->dimension-1); escala_matriz(&op_n,pow((u->dimension-1),2)); /* Suavizado */ muestra_malla(u); printf("After smooth %f\n ",op_n.v[1][1]); suaviza_r(u,f,&op_n); suaviza_g(u,f,&op_n); suaviza_b(u,f,&op_n); muestra_malla(u); /* Defecto */ defecto(u,f,&d,&op_n); printf("After defect %f\n ",op_n.v[1][1]); muestra_malla(&d); /* Restringimos */ restringe(&d,&d_); /* Rellamada a multigrid */ multigrid(&v_,&d_,op,max); /* Interpolamos */ interpola(&v_,&v); /* Sumamos */ suma_mallas(u,&v); /* Postsuavizamos */ suaviza_r(u,f,&op_n); suaviza_g(u,f,&op_n); suaviza_b(u,f,&op_n); /* En la malla mas alta, comprobamos cómo va la cosa */ if(u->nivel==2) { /* Calculamos el defecto */ defecto(u,f,&d,&op_n); for(i=0;i<u->dimension;i++) { for(j=0;j<i;j++) { if(fabs(d.v[i][j])>max[0]) { max[0]=fabs(d.v[i][j]); } } } } /* Liberacion de recursos */ libera_matriz(&op_n); libera_malla(&d); libera_malla(&d_); libera_malla(&v); libera_malla(&v_); } }