V!OLADOR

Bom, Dev-C++ não é um compilador, é apenas um editor de texto. Você deve saber qual o compilador ele usa pra compilar seus códigos. Talvez o erro esteja aqui: Veja, x é um int e fi->fim é um ponteiro do tipo NO, logo você não pode fazer comparações x<=fi->fim. Seria como comparar uma maçã e uma pera, não faz sentido.

Bom, na verdade, agora há um erro: você guardou a base e o expoente nas variáveis b e e, mas deu as variáveis bas e exp, que estão vazias, pra função potencia. Talvez o que queira seja, por exemplo, scanf("%d", &bas); De fato esse código não deveria compilar porque você também esqueceu de declarar b e e. E por ultimo, o enunciado do problema exige que a base seja um numero real, não um inteiro como está a usar. Por fim, ao invés de ler o expoente, leia um expoente máximo, e use um loop pra varrer os expoentes entre 0 e o máximo desejado.

Dicas: usar um laço for duplo (o externo pras linhas enquanto o interno controla as colunas) e o formatador \n de maneira inteligente na hora da impressão.

Mas por que? você fez quase tudo certo. Basta substituir 2 por a, como pediu a questão. E mover o calculo pra uma função uma própria independente da main. Algo como, float my_pow(const float a, const int n) Apenas lembre-se de que pot deve ser real, float ou double.

Basta remover o operador & em printf("\t%d", &R[i][j]); Você gostaria de imprimir o valor em (i, j) e não o endereço dele.

Acho que há um erro de lógica acima. Veja, v possui a soma das N linhas, logo v possui M elementos, cada qual com o total das linhas pra uma determinada coluna. Então o índice de v não seria i mas j. Ou seja, v[j] += A[i*M+j]; Por sinal, lembre-se de inicializar v[j] antes da soma, for (j=0; j<M; j++) { v[j] = 0.0f; for ( i=0; i<N; i++) { /* soma das N linhas para a coluna j aqui */ } }

Talvez você não precise de tantos blocos if. Apenas calcule a diferença absoluta com a função fabs, por exemplo, const float diff = fabs(A[i] - B[i]); if (diff > max) max = diff; A função fabs está na biblioteca math.h. Mas talvez haja um erro no seguinte: você está comparando sempre os mesmo elementos de A e B, ou seja o mesmo i pra ambos. Talvez você precise fixar o índice de A, e usar um novo índice para escanear B. Ou seja, pra cada elemento de A, testa-se contra todos os elementos de B. Digamos que j seja o índice de B, então: const float diff = fabs(A[i] - B[j]);

Com todo prazer. Quais as suas duvidas? posta sua analise e te ajudamos na correção. Não precisa escrever código, parece que você só precisa descrever o funcionamento desses três programas.

Bom, parece algum tipo de avaliação ou teste. Não seria, portanto, antiético que fizéssemos o teste por você? Poderia passar a impressão equivocada, ao seu chefe, de que você sabe algo que não sabe.

Você pode implementar uma matriz usando um vetor normal. Por exemplo, numa matriz 3 por 3, do tipo a b c d e f g h i os elementos podem ser agrupados num vetor convencional: a b c d e f g h i Se o numero de linhas é N e o numero de colunas é M, então float *matrix = new float[N*M]; E o elemento a com coordenadas (n, m) pode ser encontrado com uma fórmula mágica: a = matrix[n*N + m]; Essa técnica chama-se ordenamento row-major. De fato você pode reduzir qualquer tensor com varias dimensões num vetor 1D. Assim, pra uma matriz A e uma matriz B, a soma C seria algo tão simples quanto for (int n = 0; n < N; ++n) { for (int m = 0; m < M; ++m) { C[n*N + m] = A[n*N + m] + B[n*N + m]; } } E quando N = M, tudo torna-se ainda mais simples (e extremamente eficiente): for (int n = 0; n < N*M; ++n) { C[n] = A[n] + B[n]; } E por fim, como é um projeto em C++, você poderia empacotar os vetores, a inicialização de elementos, os operadores, destruição dos ponteiros etc. numa classe. Não é necessariamente importante mas dá o charme de C++.

Bom, não sei se estou interpretando o enunciado corretamente, , mas aparentemente você não precisa inverter os valores na memoria e depois imprimir. Basta imprimir ao contrário. Então você poderia simplesmente inverter o for: for(i = (T - 1); i > -1; --i)

Ok, ainda há vários erros mas não relacionados com paralelismo e, sim, C básico. Quando eu sugeri usar a função rand, estava subentendido que você deveria consultar a documentação dessa função antes de usá-la. Basta um google em "como usar C rand". Você precisa inicializar o gerador de números aleatórios produzidos por rand, antes de chamá-la pela primeira vez, e isso é efeito com a função srand. Então, chame srand antes do primeiro laço for, mas não apenas copie e cole "srand" aleatoriamente no código, procure ler como usá-la. Por coincidência debatemos noutro tópico, semana passada, como rand e srand funcionam. Dê uma olhadinha lá: Ler tamanho da entrada para criar vetores Esse trecho, continua errado: #pragma omp parallel shared(V, fatorial) private(i, fatorial_local) { #pragma omp parallel for default(none) shared(V) for (int i = 0; i < N; i++) { V[i] = rand(); } } Por sinal, o mesmo erro de antes, você continua abrindo mais de uma zona paralela, com uma dentro da outra, sem necessidade. Releia minha ultima resposta e remova o bloco mais externo: #pragma omp parallel shared(V, fatorial) private(i, fatorial_local) { } E, por fim, esse trecho não tem lógica: double f; /* ... */ #pragma omp parallel for default(none) shared(V) for (int i = 0; i < N; i++) { double f = fatorial * V[i]; } printf("Fatorial é: %f\n", f); Você está apenas copiando e colando os exemplos que digitei anteriormente mas sem pensar. Por que declarar f dentro do for se já foi declarado no inicio do programa? qual dos dois você quer escrever com o printf? se você não sabe, pois a maquina tampouco vai saber. O que o compilador está escrevendo na tela é o primeiro f, que nunca foi utilizado. Além disso, você tem N fatoriais pra escrever na tela, então, mantendo printf fora do laço for, você só vai escrever efetivamente o ultimo fatorial, N - 1. Mova o printf pra dentro do laço for. Pra usar a função factorial, você precisa chamá-la pra cada um dos i elementos de V, f = factorial(V[i]);

Praticamente o mesmo tema foi debatido noutro tópico, semana passada. Várias sugestões foram cogitadas por lá (em C, mas C++ seria uma opção igualmente boa se usada com cautela). Tópico: Desenvolvimento de Sistema Operacional

Esse é todo o código? porque, em caso positivo, tá visivelmente incompleto. Você deve criar a função factorial por conta própria. Ela não existe nas bibliotecas que você incluiu no projeto, stdio.h, stdlib.h e omp.h. Algo como double factorial(const int n) { if (n == 0) return 1; return n*factorial(n - 1); } main() { /* o resto do programa */ } Mas depois de criar um método pra calcular o fatorial, é ainda pouco provável que esteja correto. Dois problemas graves existem. Primeiro a questão pede pra preencher o vetor V com valores aleatórios. Mas isso V[i] = i*V[i-1]; não apenas não é aleatório, pelo contrario, gera sempre os mesmo números, como também tem um erro: quando i = 0, ou seja no primeiro passo, i - 1 está fora do intervalo de N elementos. O intervalo de V é (0, N - 1). Caso queira uma solução simples pra gerar números aleatórios você poderia utilizar a função rand, conhece? Outro problema, a seguinte construção está ruim: #pragma omp parallel shared(V, fatorial) private(i, fatorial_local) { #pragma omp parallel for default(none) shared(V) #pragma omp parallel for default(none) shared(V) } Veja, você abriu um bloco em paralelo com a primeira pragma, usando omp parallel e logo em seguida abriu mais duas zonas paralelas dentro da primeira. O numero de threads que a sua CPU pode executar simultaneamente é fixa. Você está sobrecarregando as threads e a performance do código vai ser horrível, se funcionar (não vai porque a logica tampouco está correta). Reveja minha primeira resposta, na qual propus duas zonas paralelas independentes, ou seja, /* executando sequencialmente aqui com 1 thread */ #pragma omp parallel for default(none) shared(V) for (int i = 0; i < N; i++) { /* executando em paralelo aqui com varias threads */ } /* executando sequencialmente aqui com 1 thread novamente */ #pragma omp parallel for default(none) shared(V) for (int i = 0; i < N; i++) { /* executando em paralelo aqui com varias threads novamente */ } /* executando sequencialmente aqui com 1 thread novamente */ Na primeira zona em paralelo você cria N elementos aleatórios e armazena em V, na segunda você calcula o fatorial de cada um deles. A maneira que você tentou pode funcionar com algumas modificações mas seria necessário introduzir conceitos mais complicados e não é necessário pro objetivo que você deseja atingir.

Eu concordo com você, @KXSY. Eu evitei o sanitize, pelo menos por hora, porque talvez fosse mais confuso pra ele. Meu objetivo era apenas colocar o compilador sob estresse pra ver como/quando o problema seria detectado.

Sempre às ordens, patrão, e bom estudo.

Curioso não? ele encontrou o problema mas não classificou como erro. Apenas alertou pra inconsistência. Isso porque a padronização de C não diz o que deve ser feito nesses casos, devemos tratar apenas como um "undefined behavior". Olha, em termos de livro eu sempre recomendo a bíblia que talvez nem seja mais uma referência popular hoje em dia, chama-se "The C Programming Language (ISO C)". Escrito por um dos deuses da programação, Brian Kernighan e, ninguém mais ninguém menos, que Dennis Ritchie, o criador de C. O bom da linguagem C é ser pequena, concisa, fácil de aprender, além de extremamente poderosa, e que continua praticamente igual em mais de 40 anos. Então, apesar desse livro ter sido escrito em 1978, ainda é uma ótima referência. O link do Amazon vai em anexo abaixo. https://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628 PS: acho que você consegue uma copia em pdf por ai mas não podemos promover esse tipo de material aqui no fórum. Além do mais, muito mais gratificante é comprar a obra original.

Bom, então vemos um limite ali, ele vai quebrar em certo momento. Talvez pudéssemos aumentar a perspicácia do compilador aumentando o nível de otimização que ele faria no seu código durante a compilação. Pra fazer isso você pode usar as opções -O0, -O1, -O2 ou -O3. Provavelmente, ele sabe de antemão que o código pode funcionar sem grande perigo e então simplesmente compila. Mas se aumentarmos o nível de otimização ele talvez comece a reclamar. Tenta o seguinte: gcc -O3 test.c -o test.out E vejamos o que acontece.

Tenta o experimento de aumentar o tamanho do for até, digamos, 100 (mantenha o vetor com 60 elementos) e vejamos o que acontece. Vamos encontrar o limite pro problema ocorrer.

Bom, calma. Você pode utilizar essa opção nesse caso em particular, como um teste, mas não deve em hipótese alguma escrever em C confiando numa opção magica do compilador pra fazer o seu trabalho. Isso porque o seu código não vai ficar portável, ou seja, ele só poderia ser compilado por um compilador especifico. Então a recomendação oficial seria escrever o programa de acordo com a gramatica do C e, nesse caso, cuidando sempre de não acessar memoria fora do intervalo. Sim, por exemplo, supondo que o código fonte esteja num arquivo chamado main.c, seria algo como, gcc -fbounds-checking main.c -o main.out

Não, foi mal. Bom o erro evidente você já citou: for(i = 0; i < 60; i++) ao invés de de i <= 60. O compilador não faria checagem do intervalo em condições normais, então seria compilável. Qual o compilador? GNU gcc? dependendo da versão você pode usar a opção -fbounds-checking durante a compilação e então ele iria identificar um erro.

Na padronização da linguagem C, em inglês, usa-se o termo "undefined behavior", ou seja, comportamento imprevisível. O que ocorre ao tentar usar um elemento que esteja fora do intervalo não é determinado pelo C. Então tudo pode acontecer. Desde nada, ou retornar um zero, até dar "segmentation fault" caso você acesse um pedaço de memoria alheia, ou congelar a maquina, formatar o HD do vizinho etc. A lista de comportamentos imprevisíveis é longa (infinita, de fato ). Nunca, sob hipótese alguma, explore um comportamento imprevisível num projeto real.

Você precisa dizer ao compilador o que fazer quando der ao operador << dois objetos, um do tipo std::ostream (no caso, std::cout) e outro do tipo Pilha. Por exemplo, std::ostream &operator<<(std::ostream &out, const Pilha &p) { // determinar o comportamento de << aqui }

Sempre às ordens, patrão. Parece correto. Basta compilar e executar. Você escreve os valores de A e B na tela e checa se o resultado de maiorval é consistente. PS: Apenas escreva os valores de A e B na tela de maneira que possa distingui-los, , tipo: std::cout << "A[" << i << "] = " << A[i] << std::endl;

Basicamente, "rand" significa "random" em inglês e retorna valores aleatórios a cada chamada. Ou seja, em A[0] = rand() e A[1] = rand(), muito provavelmente, A[0] != A[1]. Mas algoritmos que geram números (pseudo) aleatórios precisam de um inicializador, em inglês usa-se o termo "seed" (semente). Essa é a função de srand, fornecer um inicializador, um número, do qual o algoritmo poderá criar outros números aleatórios. E sempre deve ser chamado, ou seja inicializado, antes do uso do algoritmo. Você é livre pra escolher um inicializador. O tempo, de time(NULL), é um parâmetro que funciona bem em casos simples. Caso, use por exemplo srand(3), então, com um inicializador constante, os mesmos números aleatórios serão criados a cada execução do programa. Dependendo da implementação, claro. Por isso chama-se gerador de números pseudo aleatórios.