SimplySoft.ComplexNumerics 2.0.1

Complex-Library

Complex-Library is .NET 5.0 based reusable library designed perform algebraic arithmetic on complex numeric. Any .NET 5.0 or above application can utilize the functionalities of Complex-Library by referring it in the project dependencies.

Prerequisites

Complex-Library requires .NET 5.0 (v5.#.#) or .NET 6.0 (v6.#.#).

Get Started

Add ComplexLibrary.dll assembly to project dependencies. Refer the content from the code by adding namespace using ComplexLibrary; at the top.

Implementation Overview

Following tables indicate the implementation structure of Complex-Library.

Fields

Properties

Enums

ComplexFormat enumeration defines the complex number format to be used in string notation.

PhaseMode enumeration defines the method of sign-convention when defining argument.

Constructors

Methods

Operators

Usage

Following section describe the general usage of ComplexLibrary to perform complex arithmetic operations.

Initialize New Complex number

To initialize a complex number z with cartesian coordinates such that z = 5 - 3i,

Complex z = new(5, -3);

To initialize a complex number z with polar coordinates such that radius is 2 and argument (angle) is 240° (the argument should be defined with radians as 4π/3 or -2π/3 based on sign-convention, instead of degrees),
Using -π < Arg(Z) ≤ π convention or PhaseMode.ArgPrimary

Complex z = new(2, -2 * Complex.Pi / 3, PhaseMode.ArgPrimary);

Using 0 ≤ arg(Z) < 2π convention or PhaseMode.ArgSecondary

Complex z = new(2, 4 * Complex.Pi / 3, PhaseMode.ArgSecondary);

The constructor throws ArgumentException exception when the argument parameter is out of the range specified by the phaseMode parameter.

Properties of Complex Number

Complex number object has four accessible properties such that the Real component, Imaginary component, Modulus and Argument values. These values can be read as follows.

Complex z = (2, -3);
double Re = z.Real;
double Im = z.Imaginary;
double Mod = z.Modulus;
double Arg = z.Argument;

Note that the Argument is represented according to the PhaseMode.ArgSecondary convention with range of 0 ≤ Argument < 2π.

Represent Complex Number

A complex number can be represented as a string using ToString() functions. This function has several overloads to support different notation formats and decimal precisions.

Complex z = new(2, -3);
Complex w = new(2, Complex.Pi / 3, PhaseMode.ArgPrimary);

string result1 = z.ToString(); // (2, -3)
string result2 = w.ToString(4); // (1, 1.7320)

To represent in cartesian notation,

string result = new Complex(2, -3).ToString(ComplexFormat.Cartesian); 
// Represent as 2 - 3i

To represent in polar notation,

string result = new Complex(2, Complex.Pi / 3, PhaseMode.ArgPrimary).ToString(ComplexFormat.Polar); 
// Represent as 2[Cos(1.0472) + i.Sin(1.0472)]

To represent in exponential notation,

string result = new Complex(2, Complex.Pi / 3, PhaseMode.ArgPrimary).ToString(ComplexFormat.Exponential); 
// Represent as 2e1.0472i

Complex Number Conversion

A complex number can be converted to a double-precison real number if there is no imaginary component. The function throws InvalidCastException exception when try to convert a complex number having a non-zero imaginary component.

Complex z = new(-5, 0);
Complex w = new(1, -1);
double value1 = z.ToReal();
double value2 = w.ToReal(); // This throws an exception

A double precision real number can be converted to equivalent complex number using following static function.

double k = 3;
Complex z = Complex.ToComplex(k);
string result = z.ToString(); // (3, 0)

Complex Conjugate

The conjugate pair of complex number z = x + iy is represented by ~z = x - iy. The conjugate of complex number z can be calculated as follows.

Complex z = new(2, 5);
Complex conjugate;
conjugate = z.Conjugate()
// Or
conjugate = ~z;

This operation will throw ComplexNotInitializedException exception when required complex parameters are null.

Complex Negation

Negation of complex number represents the negative version of itself. The negation of complex number z can be calculated as follows.

Complex z = new(5, -3);
Complex negate;
negate = z.Negate()
// Or
negate = -z;

This operation will throw ComplexNotInitializedException exception when required complex parameters are null.

Complex Reciprocal Division

The reciprocal of complex number represents the multiplicative inverse of itself. For a complex number z, the reciprocal is represented by 1/z. The reciprocal of complex number z can be calculated as follows.

Complex z = new(-2, 3);
Complex reciprocal = z.Reciprocal();

This operation will throw ComplexNotInitializedException exception when required complex parameters are null and DivideByZeroException exception if the modulus of the complex number is zero which causes the zero division.

Quadratic Complex Roots

To calculate roots of standard quadratic equation ax² + bx + c = 0,

Complex[] roots;

// Roots of x² - 5x + 6 = 0
roots = Complex.FindQuadraticRoots(1, -5, 6);
Console.WriteLine("{0} and {1}", roots[0], roots[1]);
// (3, 0) and (2, 0)

// Roots of x² - 2x + 1 = 0
roots = Complex.FindQuadraticRoots(1, -2, 1);
Console.WriteLine(roots[0]);
// (1, 0)

// Roots of x² - 2x + 5 = 0
roots = Complex.FindQuadraticRoots(1, -2, 5);
Console.WriteLine("{0} and {1}", roots[0], roots[1]);
// (1, 2) and (1, -2)

This operation will throw InvalidOperationException exception when parameter a is zero which correspond to the coefficient a of the quadratic equation.

Complex Operations

Complex object can perform following arithmetic operations.

Addition

To add two complex numbers x and y,

Complex x = new(1, 5);
Complex y = new(2, Complex.Pi / 3, PhaseMode.ArgPrimary);
Complex result = x + y;

To add double-precision real number n to the complex number z and then value 3,

double k = 2;
double result = z + k + 3;

Addition will throw ComplexNotInitializedException exception when required complex parameters are null.

Subtraction

To subtract complex numbers y from x,

Complex x = new(1, 5);
Complex y = new(2, Complex.Pi / 3, PhaseMode.ArgPrimary);
Complex result = x - y;

To substract double-precision real number n from the complex number z and then value 3,

double k = 2;
double result = z - k - 3;

Subtraction will throw ComplexNotInitializedException exception when required complex parameters are null.

Multiplication

To multiply complex numbers x by y,

Complex x = new(1, 5);
Complex y = new(2, Complex.Pi / 3, PhaseMode.ArgPrimary);
Complex result = x * y;

To multiply complex numbers x by a double-precision real number n,

Complex x = new(1, 5);
double n = 3;
Complex result = x * n;

Multiplication will throw ComplexNotInitializedException exception when required complex parameters are null.

Division

To divide complex numbers x by y,

Complex x = new(1, 5);
Complex y = new(2, Complex.Pi / 3, PhaseMode.ArgPrimary);
Complex result = x / y;

This will throws DivideByZeroException exception when the modulus of y is 0.

To multiply complex numbers x by a double-precision real number n,

Complex x = new(1, 5);
double n = 3;
Complex result = x / n;

This will throw DivideByZeroException exception when the value of n is 0. Division will throw ComplexNotInitializedException exception when required complex parameters are null.

Power or Exponent

To raise the complex numbers x to the power of integer real number e,

Complex x = new(1, 5);
int e = 4;
Complex result = x ^ e;

Power will throw ComplexNotInitializedException exception when required complex parameters are null.

Square Root

To calculate the square root of complex number x,

Complex x = new(1, 5);
Complex result = x.Sqrt();

Square root operation will throw ComplexNotInitializedException exception when required complex parameters are null.

Complex Comparison

Two complex numbers can be compared using following comparison methods.

Equality

To evaluate the equality of two complex numbers,

Complex w = new(1, 3);
bool result;

result = w.Reciprocal() == (~w / Math.Pow(w.Modulus, 2)); // True
// Or
result = w.Reciprocal().Equals(~w / Math.Pow(w.Modulus, 2)); // True

result = w == ~w; // False
// Or
result = w.Equals(~w); // False

Inequality

To evaluate the inequality of two complex numbers,

Complex w = new(1, 3);
bool result;

result = w != ~w; // True
// Or
result = !w.Equals(~w); // True