ComplexosLib.murilao 1.0.0

Complexos

Struct imutável representando números complexos. Inclui funcionalidades algébricas básicas, além de conversões.

Propósito

Feito para uma avaliação de matemática, visando ser integrado em uma aplicação gráfica para encontrar raízes de números complexos arbitrários. Portanto, bibliotecas externas não foram utilizadas, dependendo somente de funcionalidade nativa disponível pela System.Math. Esse pacote NÃO deve ser utilizado para aplicações profissionais, e especialmente onde precisão for necessária.

Uso

O construtor da struct está disponível, e recebe dois argumentos, representando seu valor real e seu valor imaginário. Ambos são armazenados como pontos flutuantes de dupla precisão (double), para maior compatibilidade com os métodos de Sytem.Math.

Números complexos também podem ser declarados através de uma tupla.

Complex number = new Complex(4, 5);
Complex tupleNumber = (4, 5);

A sobrecarga do método ToString() permite exibição legível e inspirada em notação matemática.

Complex number = new Complex(4, 5);
Complex tupleNumber = (4, 5);

Console.WriteLine(number); // 4 + 5i

Forma polar

A forma polar de um número complexo está disponível pela propriedade .Polar, que retorna uma tupla (abs double, arg double), de primeiro elemento igual ao módulo e segundo igual ao argumento, em radianos.

A propriedade .Abs retorna o módulo do complexo, e .Arg retorna o argumento do complexo, em radianos. A conversão de radianos para graus pode ser feita com arg * Math.PI / 180, ou, alternativamente, o argumento em graus é retornado pela propriedade .ArgDegree.

Complex numero = (2, -2);

Console.WriteLine(numero.Abs); // 2.8282
Console.WriteLine(numero.Arg); // 5.4978
Console.WriteLine(numero.ArgDegree); // 315

var polar = numero.Polar;
polar.arg;
polar.abs;

A conversão de forma polar para complexo pode ser feita através do método estático .FromPolar(polar), com duas assinaturas.

Complex number = (3, 4);

var polar = number.Polar;

var fromPolar = Complex.FromPolar(polar); // Igual a `number`
var fromPolar2 = Complex.FromPolar(4, Math.PI * 2 / 3); // Módulo 4, argumento 60º

Aritmética

Todos os operadores aritméticos estão implementados, além de potenciação e radiciação, através das fórmulas de De Moivre.

Complex firstNumber = (4, 5);
Complex secondNumber = (1, 2);

Console.WriteLine(firstNumber + secondNumber); // 5 + 7i
Console.WriteLine(firstNumber - secondNumber); // 3 + 3i
Console.WriteLine(firstNumber * secondNumber); // -6 + 13i
Console.WriteLine(firstNumber / secondNumber); // 2.8 - 0.6i

Potenciação

Pode ser realizada através do método .Pow(n), que eleva o complexo a n, retornando um único novo complexo. A potenciação é calculada pela primeira fórmula de De Moivre, onde a potência do complexo z pode ser descrita como um complexo w cuja forma polar tem módulo igual ao módulo de z elevado a n e argumento igual ao produto do argumento de z por n.

z = a + bi w = z^3

w = |z|^3 * (sen(arg(z) * 3) + icos(arg(z) * 3))

Complex number = (4, 2);
Complex power = number.Pow(3); // Equivalente a (4 + 2i)^3

Console.WriteLine(power); // 16 + 88i

Radiciação

Ao calcular a raiz N de um número complexo, obtém-se N complexos que, elevados a N, resultam no complexo original. Portanto, o método .Root(n) retorna um IEnumerable<Complex>, um gerador que produz as raízes apenas quando iterado, atráves das fórmulas de De Moivre.

O argumento de todas as raízes é calculado como a N raíz do argumento original, enquanto o argumento consiste em vetores de ângulo θ entre si, onde θ é igual a 2π/N.

Resulta-se, portanto, numa circunferência contendo N pontos.

Complex number = (4, 9);

foreach (var root in number.Root(3)) {
    Console.WriteLine(root); // exibe as três raízes cúbicas de 4 + 9i
}

Há também uma propriedade Sqrt, levemente otimizada em relação ao método genérico .Root(n), para raízes quadradas.

Complex number = (4, 9);

foreach (var root in number.Sqrt) { // Equivalente a number.Root(2)
    Console.WriteLine(root); // exibe as duas raízes quadradas de 4 + 9i
}