int main()
{
//Constantes
char const nome_arquivo[] = "./6ex_matriz.txt";
//Inicializa variaveis
float matrizBuffer[100][100];
int iA, jA;
//Le a matriz A do arquivo para um buffer
le_matriz(nome_arquivo, matrizBuffer, &iA, &jA);
if(iA != jA)
{
printf("A matriz fornecida nao e quadrada, como propoe o problema");
exit(1);
}
//Agora que conhece o tamanho inicializa a matriz
float matrizA[iA][jA];
//E em seguida copia os valores
copia_matriz(matrizBuffer, iA, jA, matrizA);
//Verifica se a matriz é simetrica
verifica_simetria(iA, jA, matrizA);
}
int main(){
le_matriz();
printf("Soma dos elementos da diagonal : %d " , calcula_soma());
}
int main(void){
int n;
printf("Digite o tamanho da matriz: ");
scanf("%d",&n);
int **m = cria_matriz(n);
le_matriz(m,n);
imprime_matriz(m,n);
exercicio_a(m,n,3);
exercicio_b(m,n);
exercicio_c(m,n,3);
exercicio_c(m,n,1);
exercicio_d(m,n);
return 0;
}
// funcao que le arquivo contendo automato e monta a estrutura
void le_automato(automato *A , FILE *arq3 ){
char x[TAMANHO_MAX_NOME_ELEMENTO];
int i=0,j=0;
int tamanho;
fscanf(arq3, "%s", &x);
(*A).numero_submaquinas=0; // inicio tem 0 submaquinas
strncpy ( (*A).submaquina_primaria , x, sizeof(tipo_elemento_matriz_trasicao) ); // le submaquina primaria do arquivo
strncpy ( (*A).submaquina_atual , x, sizeof(tipo_elemento_matriz_trasicao) ); // submaquina primaria é a que começa
while(x[0]!=';'){
strncpy ( (*A).nome_submaq[i] , x, sizeof(tipo_elemento_matriz_trasicao) ); //copia nome das submaquinas
i++;
(*A).numero_submaquinas++;
fscanf(arq3, "%s", &x);
}
tamanho=(*A).numero_submaquinas;
fscanf(arq3, "%s", &x);
strncpy (&(*A).estado_atual, x, sizeof(tipo_elemento_matriz_trasicao) );
while(tamanho!=0){
strncpy (&(*A).sub_maquina[j].estado_inicial, x, sizeof(tipo_elemento_matriz_trasicao) ); // le estado inicial de cada submaquina
le_matriz(&(*A).sub_maquina[j] , arq3 ); //constroi a matriz das submaquinas
fscanf(arq3, "%s", &x);
j++;
tamanho--;
}
}
int main()
{ FILE *arq1,*arq2,*arq3;
char nomeEntrada[20],nomeCadeiaEntrada[20],nomeAutomato[20];
char existe_transicao;
char estado_atual_lexico[TAMANHO_MAX_NOME_ELEMENTO];
char caractere_lido;
char cadeia_parcial[TAMANHO_MAX_NOME_ELEMENTO];
char token[TAMANHO_MAX_NOME_ELEMENTO];
Pilha Pilha_maquinas,Pilha_estado;
Pilha1 P;
sub_maquina Ana_lexico;
automato Automato;
int termo_cadeia_parcial=0;
int i;
printf("Digite o nome do arquivo de entrada(lexico): ");
scanf("%s",nomeEntrada);
printf("Digite o nome do arquivo que contem a cadeia de entrada: ");
scanf("%s",nomeCadeiaEntrada);
printf("Digite o nome do arquivo que contem o automato de pilha: ");
scanf("%s",nomeAutomato);
arq1= fopen(nomeEntrada,"r");
arq2= fopen(nomeCadeiaEntrada,"r");
arq3= fopen(nomeAutomato,"r");
Ana_lexico.quantidade_de_transicoes=0; //inicializa quantidade de transicoes do analisador lexico
P.topo=-1; //pilha vazia
Pilha_maquinas.topo=-1;// pilha maquinas vazia
Pilha_estado.topo=-1;//pilha estado vazia
fscanf(arq1, "%s", &Ana_lexico.estado_inicial);
strcpy(estado_atual_lexico, Ana_lexico.estado_inicial); // estado_atual_lexico deve ser inicializado
le_matriz(&Ana_lexico , arq1); //constroi a matriz do analisador lexico partindo do arquivo q contem as transiçoes
le_automato(&Automato , arq3); //constroi automato partindo do arquivo de texto
printf("\n| estado | submaquina | token | novo estado | Pilha_submaq | Pilha_estado_retorno |");
printf("\n|--------------------------------------------------------------------------------------------------------|");
fscanf(arq2, "%c", &caractere_lido);
while(caractere_lido==' '||caractere_lido=='\n'){ // se ler espaço ou enter ignora
fscanf(arq2, "%c", &caractere_lido);
}
while(caractere_lido!='&'){ //arquivo com cadeia de entrada deve terminar com &
//le caracteres de entrada, se termo
if(P.topo==-1){ //se pilha vazia
existe_transicao= busca_e_realiza_transicao( &Ana_lexico , &estado_atual_lexico , caractere_lido);
if(existe_transicao=='F'){
empilha1(caractere_lido,&P);
strcpy (token , estado_atual_lexico);
strcpy (estado_atual_lexico , Ana_lexico.estado_inicial);
for(i=0;i<14;i++){
token[i]=token[i+1];
}
cadeia_parcial[termo_cadeia_parcial]='\0'; //termina string
//chama analisador sintatico
busca_e_realiza_transicao_automato( &Automato ,token , &Pilha_maquinas, &Pilha_estado, cadeia_parcial);
termo_cadeia_parcial=0;
}
if(existe_transicao=='T'){
cadeia_parcial[termo_cadeia_parcial]=caractere_lido;
termo_cadeia_parcial++;
fscanf(arq2, "%c", &caractere_lido);
while(caractere_lido==' '||caractere_lido=='\n'){// se ler espaço ou enter ignora
fscanf(arq2, "%c", &caractere_lido);
}
}
}
if(P.topo!=-1){
termo_cadeia_parcial=0;
desempilha1(&caractere_lido, &P);
cadeia_parcial[termo_cadeia_parcial]=caractere_lido;
existe_transicao= busca_e_realiza_transicao( &Ana_lexico , &estado_atual_lexico , caractere_lido);
if(existe_transicao=='F'){
empilha1(caractere_lido,&P);
strcpy (estado_atual_lexico , Ana_lexico.estado_inicial);
strcpy (token , estado_atual_lexico);
for(i=0;i<14;i++){
token[i]=token[i+1];
}
cadeia_parcial[termo_cadeia_parcial]='\0'; //termina string
//chama analisador sintatico
busca_e_realiza_transicao_automato( &Automato ,token , &Pilha_maquinas, &Pilha_estado, cadeia_parcial);
termo_cadeia_parcial=0;
}
if(existe_transicao=='T'){
cadeia_parcial[termo_cadeia_parcial]=caractere_lido;
termo_cadeia_parcial++;
fscanf(arq2, "%c", &caractere_lido);
while(caractere_lido==' '||caractere_lido=='\n'){// se ler espaço ou enter ignora
fscanf(arq2, "%c", &caractere_lido);
}
}
}
if(caractere_lido=='&'){
strcpy (token , estado_atual_lexico);
for(i=0;i<14;i++){
token[i]=token[i+1];
}
cadeia_parcial[termo_cadeia_parcial]='\0'; //termina string
//chama analisador sintatico
busca_e_realiza_transicao_automato( &Automato ,token , &Pilha_maquinas, &Pilha_estado, cadeia_parcial);
}
}
fclose(arq1);
fclose(arq2);
fclose(arq3);
printf("\n");
system("pause");
return 0;
}
int main(){
le_matriz();
imprime_transposta();
}
int main()
{
char acao;
num_matriz k, k1, k2, k3;
int m, n, i, j;
float x;
matriz a[num_nomes];
while (true)
{
scanf("%c", &acao);
printf("ação: %c", acao);
switch (acao)
{
case 'r':
le_nome(&k); prox_linha();
printf(" %c\n", min_nome+k);
le_matriz(&a[k]);
break;
case 'z':
le_nome(&k); scanf("%d %d", &m, &n); prox_linha();
printf(" %c %d %d\n", min_nome+k, m, n);
inicializa(&a[k], m, n);
break;
case 'v':
le_nome(&k); scanf("%d %d", &i, &j); prox_linha();
printf(" %c %d %d\n", min_nome+k, i, j);
printf(" %c[%d,%d] = %8.2f\n", min_nome+k, i, j, valor(&(a[k]), i, j));
break;
case 'a':
le_nome(&k); scanf("%d %d %f", &i, &j, &x); prox_linha();
printf(" %c %2d %2d %8.2f\n", min_nome+k, i, j, x);
atribui(&a[k], i, j, x);
break;
case 's':
le_nome(&k1); le_nome(&k2); le_nome(&k3); prox_linha();
printf(" %c %c %c\n", min_nome+k1, min_nome+k2, min_nome+k3);
soma(&a[k1], &a[k2], &a[k3]);
break;
case 'm':
le_nome(&k1); le_nome(&k2); le_nome(&k3); prox_linha();
printf(" %c %c %c\n", min_nome+k1, min_nome+k2, min_nome+k3);
multiplica(&a[k1], &a[k2], &a[k3]);
break;
case 't':
le_nome(&k1); le_nome(&k2); prox_linha();
printf(" %c %c\n", min_nome+k1, min_nome+k2);
transpoe(&a[k1], &a[k2]);
break;
case 'w':
le_nome(&k); prox_linha();
printf(" %c\n", min_nome+k);
imprime_matriz(&a[k]);
break;
case 'x':
printf("\n");
bapply(bprint);
printf("fim da execução.\n");
exit(0);
break;
case '#':
{ int c;
do
{ c = getchar(); putchar(c); }
while ((c != '\n') && (c != EOF));
}
break;
case 'l':
le_nome(&k); prox_linha();
printf(" %c\n", min_nome+k);
libera(&a[k]);
break;
default:
{ erro("ação inválida"); }
} /* switch */
} /* while */
bapply(bprint);
return 0;
} /* main */
int main(int argc[], char *argv[]){
int dimensao;
float **matriz;
float *vetorIndependente;
int i, j, t, l, status_t, tam, *vet;
int linha = 0;
pid_t pid = 1;
printf("Digite o dimensao da matriz seguido dos elementos e do vetor independente:");
scanf("%d", &dimensao);
int TAM_BUFFER = dimensao+3;
matriz = le_matriz(dimensao, dimensao);
vetorIndependente = le_vetor(dimensao);
//criação dos filhos
int REF = 1;
int inicio = 0;
while(REF != dimensao){
int fd[2];
float buffer[TAM_BUFFER];
if(pipe(fd) == -1) printf("Erro na funcao que cria o descritor de arquivo!\n");
for(i=0; i<(dimensao-REF); i++){
if(pid!=0){
sleep(10);
pid = fork();
inicio = i+REF; // inicio vai determinar a linha que será usada como referencia
}
}
if(pid == 0){
float constante = (matriz[inicio][REF-1]) / (matriz[REF-1][REF-1]);
float *vetor_auxiliar;
vetor_auxiliar = calloc(dimensao+2,sizeof(float));
int w = REF-1;
for(i=(REF-1); i<dimensao; i++){
vetor_auxiliar[w] = matriz[inicio][i] - ((matriz[REF-1][i])*constante);
w++;
}
vetor_auxiliar[w] = vetorIndependente[inicio] - ((vetorIndependente[REF-1])*constante);
vetor_auxiliar[w+1] = inicio;
close(fd[0]);
write(fd[1], vetor_auxiliar, (TAM_BUFFER)*sizeof(float));
exit(0);
sleep(5);
}
// FIM DA EXECUÇÃO DOS FILHOS
if (pid != 0){
close(fd[1]);
for (l=0; l<dimensao-REF; l++){
read(fd[0], buffer, sizeof(buffer));
linha = (buffer[dimensao+1]);
int y = 0;
for(i=0; i<dimensao+1; i++){
matriz[linha][i] = buffer[y];
y++;
}
vetorIndependente[linha] = buffer[dimensao];
}
}
REF += 1;
}
sleep(5);
// REALIZANDO A ELIMINAÇÃO
float *vetor_resultados = NULL;
vetor_resultados = (float *) calloc(dimensao, sizeof(float));
float soma = 0;
for (i = dimensao; i>0; i=i-1){
soma = vetorIndependente[i-1];
for (j=i; j<dimensao; j++){
soma += (matriz[i-1][j]*vetor_resultados[j]) * (-1);
}
vetor_resultados[i-1] = soma / matriz[i-1][i-1];
}
// REALIZANDO A ELIMINAÇÃO
printf("\n");
//Imprimindo o vetor resultado
for(i=0; i<dimensao; i++){
printf("%f ",vetor_resultados[i]);
}
free_matrix(dimensao, matriz);
free_vector(vetorIndependente);
return 0;
}
