Sabe-se que um número complexo é escrito da forma
, onde
, sendo
a sua parte real e
a parte imaginária, ambas representadas por valores reais. Crie um Tipo Abstrato de Dados (TAD) que represente os números complexos com as seguintes funções:
(a) criar um número complexo
(b) destruir um número complexo
© soma de dois números complexos;
(d) subtração de dois números complexos;
(e) mutiplicação de dois números complexos;
(f) divisão de dois números complexos;
(a) criar um número complexo
(b) destruir um número complexo
© soma de dois números complexos;
(d) subtração de dois números complexos;
(e) mutiplicação de dois números complexos;
(f) divisão de dois números complexos;
Passo 1
O exercício pede criar um TAD para números complexos, fornecendo operações de criação, destruição, soma, subtração, multiplicação e divisão. O conteúdo envolve representar um número complexo z = x + i y e implementar suas operações básicas.
Passo 2
Para representar internamente um número complexo, usamos um registro (struct) com dois campos reais: um para a parte real e outro para a parte imaginária. Assim temos uma estrutura que armazena x = Re(z) e y = Im(z).
Passo 3
Para criar e destruir complexos, definimos: • criarComplexo(x,y): aloca dinamicamente uma struct, inicializa real = x e imag = y e retorna o ponteiro. • destruirComplexo©: libera a memória alocada para c.
Passo 4
Para soma e subtração, usamos as fórmulas conhecidas: • z₁ + z₂ = (x₁+x₂) + i(y₁+y₂) • z₁ - z₂ = (x₁−x₂) + i(y₁−y₂) Implementamos addComplexo e subComplexo que chamam criarComplexo com as partes calculadas.
Passo 5
Para multiplicação usamos a regra (x₁ + i y₁)(x₂ + i y₂) = (x₁ x₂ − y₁ y₂) + i(x₁ y₂ + y₁ x₂). A função mulComplexo calcula essas duas partes e retorna um novo complexo.
Passo 6
Para divisão, aplicamos a multiplicação pelo conjugado: z₁∕z₂ = [(x₁ x₂ + y₁ y₂) + i(y₁ x₂ − x₁ y₂)] / (x₂² + y₂²). A função divComplexo calcula o denominador d = x₂² + y₂² e depois as partes real e imaginária dividindo por d.
Passo 7
O TAD final em estilo C fica com o tipo Complex, as funções criar/destroy e as operações addComplexo, subComplexo, mulComplexo e divComplexo conforme abaixo.
Resposta
// Definição do TAD para números complexos em C
#include <stdlib.h>
#include <stdlib.h>
typedef struct Complex {
double real; // parte real
double imag; // parte imaginária
} Complex;
double real; // parte real
double imag; // parte imaginária
} Complex;
// (a) criar um número complexo
Complex* criarComplexo(double x, double y) {
Complex* c = (Complex*)malloc(sizeof(Complex));
if (c != NULL) {
c->real = x;
c->imag = y;
}
return c;
}
Complex* criarComplexo(double x, double y) {
Complex* c = (Complex*)malloc(sizeof(Complex));
if (c != NULL) {
c->real = x;
c->imag = y;
}
return c;
}
// (b) destruir um número complexo
void destruirComplexo(Complex* c) {
free©;
}
void destruirComplexo(Complex* c) {
free©;
}
// © soma de dois números complexos
Complex* addComplexo(const Complex* a, const Complex* b) {
return criarComplexo(a->real + b->real,
a->imag + b->imag);
}
Complex* addComplexo(const Complex* a, const Complex* b) {
return criarComplexo(a->real + b->real,
a->imag + b->imag);
}
// (d) subtração de dois números complexos
Complex* subComplexo(const Complex* a, const Complex* b) {
return criarComplexo(a->real - b->real,
a->imag - b->imag);
}
Complex* subComplexo(const Complex* a, const Complex* b) {
return criarComplexo(a->real - b->real,
a->imag - b->imag);
}
// (e) multiplicação de dois números complexos
Complex* mulComplexo(const Complex* a, const Complex* b) {
double real = a->real * b->real - a->imag * b->imag; // Re(z₁z₂) = x₁x₂ − y₁y₂
double imag = a->real * b->imag + a->imag * b->real; // Im(z₁z₂) = x₁y₂ + y₁x₂
return criarComplexo(real, imag);
}
Complex* mulComplexo(const Complex* a, const Complex* b) {
double real = a->real * b->real - a->imag * b->imag; // Re(z₁z₂) = x₁x₂ − y₁y₂
double imag = a->real * b->imag + a->imag * b->real; // Im(z₁z₂) = x₁y₂ + y₁x₂
return criarComplexo(real, imag);
}
// (f) divisão de dois números complexos
Complex* divComplexo(const Complex* a, const Complex* b) {
double denom = b->real * b->real + b->imag * b->imag; // d = x₂² + y₂²
double real = (a->real * b->real + a->imag * b->imag) / denom; // Re(z₁/z₂) = (x₁x₂ + y₁y₂)/d
double imag = (a->imag * b->real - a->real * b->imag) / denom; // Im(z₁/z₂) = (y₁x₂ − x₁y₂)/d
return criarComplexo(real, imag);
}
Complex* divComplexo(const Complex* a, const Complex* b) {
double denom = b->real * b->real + b->imag * b->imag; // d = x₂² + y₂²
double real = (a->real * b->real + a->imag * b->imag) / denom; // Re(z₁/z₂) = (x₁x₂ + y₁y₂)/d
double imag = (a->imag * b->real - a->real * b->imag) / denom; // Im(z₁/z₂) = (y₁x₂ − x₁y₂)/d
return criarComplexo(real, imag);
}