Somar numero complexos

[Brown. 1]

Quero fazer isso:

 

Implementar uma função soma de numeros complexos (a+bi) + (c+di) = (a+c)+(b+d)i e a função multiplica complexo (a+bi) x (c+di) = (ac - bd) + (ad + bc)i. Não se sabe quantos numeros complexos serão inseridos. A soma e a multiplicação deve ser realizada entre todos os numeros dados.

Entrada = arquivo com quantidade de complexos e em seguida os numeros aos pares.

Saida = arquivo com resultados

Fazer array dinamico da estrutura

typedef struct

{

Double real;

Double imaginario;

}complexo;

 

Minha duvida, vou fazer o calculo no final do codigo?

Se alguem puder analisar o codigo e dizer o que posso alterar.

 

Fiz assim:

 

#include<stdio.h>
#include<stdlib.h>
typedef struct 
{
        double real;
        double imaginario;
}complexo;
main()
{
      float *n,c;
      printf("quantos numeros?");
      scanf("%f", &c);
      n = (float *) malloc (c * sizeof(float));
      if(n == NULL)
      {
           printf("impossivel alocar espaco");
           exit(1);
      }
      printf("digite %f\n",c);
      for(i=0;i < c; i++)
      {
          scanf("%d", &n[i]);
      }
}
void numeros(char *arq1);
void numeros(char *arq2);
{
     FILE *arq3;
     FILE *arq4;
     int a;
     if((arq3 =fopen (arq1, "r"))== NUL)
     {
              system("pause");
              printf("erro ao abrir arquivo");
              exit(1);
     }
     
     if(arq4 = fopen(arq1, "w")) = NULL)
     {
            printf("erro ao abrir o arquivo");
            system("pause");
            exit(1);
     }
     printf("entre com o numero");
     scanf("%f",&a);
     while(a!= -999)
     {
               fprintf(arq4,"%f\n",a);
               printf("entre com um numero");
               scanf("%f",&a);
     }
     fclose(arq3);
     fclose(arq4);
     printf("gravado com sucesso %s", arq2);
}

[_Isis_ 202]

Não sei onde você está programando, mas evite ficar criando mensagens para exceções. A linguagem C possui um header que faz isso, errno.h. Segundo a página do manual:

 

Previously both POSIX and X/Open documents were more restrictive than the ISO C standard in that they required errno to be defined as an external variable, whereas the ISO C standard required

only that errno be defined as a modifiable lvalue with type int.

 

Deduzo que também faça parte do padrão ISO.

 

Também, é necessário explicitar o tipo da função main e retornar um inteiro. Teu compilador pode não reclamar, mas se por acaso alguém resolver compilar o programa com todos os warnings sendo tratados como erros, a omissão do 'int' e a falta do 'return 0' impede a compilação.

 

 

Não se sabe quantos numeros complexos serão inseridos.

 

Se não se sabe quantos números serão lidos a partir do arquivo de entrada, por que você pede a quantidade de números?

 

 

void numeros(char *arq1);

void numeros(char *arq2);

{

 

Desnecessário quando se está definindo a implementação da função no mesmo arquivo que está utilizando. Usar protótipo faz todo sentido quando se tem declaração e implementação separadas e "espalhadas".

Depois posto outro código.

 

[_Isis_ 202]

Tenta rodar esse.

 

#include <stdio.h>
#include <errno.h>
#include <stdlib.h>


typedef struct {
double _real;
double _imaginario;
} complexo;


typedef struct cmp{
complexo _cmplx;
} unidade_complexo;



complexo soma_complexo(unidade_complexo * lista, unsigned int qtde) {

double _soma_real = 0.0;
double _soma_complexo = 0.0;
int i = 0;
complexo res;

for(; i < qtde; i++) {
	_soma_real += lista[i]._cmplx._real;
	_soma_complexo += lista[i]._cmplx._imaginario;
}

res._real = _soma_real;
res._imaginario = _soma_complexo;

return res;
}



complexo mult_complexo(complexo a, unidade_complexo * lista, int idx_proximo, int qtde) {
complexo tmp;
tmp._real = a._real * lista[idx_proximo]._cmplx._real - a._imaginario * lista[idx_proximo]._cmplx._imaginario;
tmp._imaginario = a._real * lista[idx_proximo]._cmplx._imaginario + a._imaginario * lista[idx_proximo]._cmplx._real;
if(idx_proximo < qtde)
	return mult_complexo(tmp, lista, idx_proximo+1, qtde);
return tmp;
}




int main(int argc, char *argv[]) {

if (argc != 3) {
	puts("Número incorreto de parâmetros.");
	printf("USO: %s arquivo_entrada arquivo_saida\n", argv[0]);
	return 1;
}


unidade_complexo * lista = (unidade_complexo*)calloc(0, sizeof(unidade_complexo));

if(lista == NULL) {
	printf("%m\n");
	return errno;
}


FILE * entrada = fopen(argv[1], "r");

if (entrada == NULL) {
	printf("%m\n");
	return errno;
}


unsigned int qtde;
fscanf(entrada, "%d", &qtde);

unsigned int tamanho = 0;
double parte_real, parte_imaginaria;
while(!feof(entrada)) {

	fscanf(entrada, "%lf %lf", &parte_real, &parte_imaginaria);
	tamanho++;
	lista = (unidade_complexo *)realloc(lista, tamanho*sizeof(unidade_complexo));

	if(lista == NULL) {
	free(lista);
	printf("%m\n");
	return errno;
	}

	lista[tamanho-1]._cmplx._real = parte_real;
	lista[tamanho-1]._cmplx._imaginario = parte_imaginaria;

};

fclose(entrada);

complexo retorno_soma, retorno_mul;

if(tamanho > 1) {
	retorno_soma = soma_complexo(lista, qtde);
	retorno_mul = mult_complexo(lista[0]._cmplx, lista, 1, qtde);
} else {
	retorno_soma = lista[0]._cmplx;
	retorno_mul = lista[0]._cmplx;
}

free(lista);
lista = NULL;

FILE * arq_out = fopen(argv[2], "w+");
if(arq_out == NULL) {
	printf("%m\n");
	return errno;
}

fprintf(arq_out, "soma: %.2lf %+.2lfi \n multiplicacao: %.2lf %+.2lfi\n", retorno_soma._real, retorno_soma._imaginario, retorno_mul._real, retorno_mul._imaginario);
fclose(arq_out);
return 0;
}

[Brown. 1]

Numero incorreto de parametros.

[_Isis_ 202]

Se você prestar atenção no código e ler ele, vai saber porque você está executando errado. Escrevi o programa em 2 minutos, mas ele está lendo, calculando e escrevendo.