Complex Number Classes

The CenterSpace NMath framework contains two classes to represent complex numbers at two different levels of precision. Additionally, classes are included for supporting vectors and matrices of complex numbers which are integrated into NMath’s extensive linear algebra classes.

 
FloatComplex
DoubleComplex
FloatComplexVector
DoubleComplexVector
FloatComplexMatrix
DoubleComplexMatrix

Each class supports a natural set of overloaded operations that include testing for equality, and inequality, along with addition, subtraction, multiplication, and division where appropriate. Here’s a simple example are some basic uses cases with these classes.

DoubleComplex dc1 = new DoubleComplex(1, 1);
DoubleComplex dc2 = new DoubleComplex(2, 2);
 
DoubleComplex dc_add = dc1 - dc2;
DoubleComplex dc_div = dc1 / dc2;
DoubleComplex dc_sin = NMathFunctions.Sin(dc1);
 
DoubleComplexVector dcv1 = new DoubleComplexVector([(1,3.3) (2,3) (3,5)];
DoubleComplexVector dcv2 = new DoubleComplexVector([(1,1) (-2,3) (3,-5.7)];
 
DoubleComplexVector dcv = dcv1 + dcv2;
DoubleComplex dcv_dot = NMathFunctions.Dot(dcv1, dcv2);

Basic Supporting Functions

The NMath numerical framework contains a static class called NMathFunctions that provides fast implementations of dozens of common functions for all of the basic NMath types, including all of the complex types. Frequently, new NMath user’s often wish they had discovered this class sooner than they did.

Below is a brief summary of the functions available in the NMathFunction class that operate on complex types. These functions span the range from basic operations such as Abs, to a variety to vector helper functions such as the Dot product, to more advanced functions such as computing the determinate of a matrix, or solving a set of linear equations. Using these functions will help you create correct, efficient, and more compact code.

• Abs, AbsSum, Sum
• Exp, Expm, Log, Pow, Sqrt, Arg
• Imag, Real, Conj
• ConjDot, OuterProduct, Dot
• Transpose, ConjTranspose, TransposeProduct, ConjTransposeProduct
• Cos, Cosh, Sin, Sinh, Tan, Tanh
• SumOfSquares, Variance
• MaxAbsIndex, MinAbsIndex, Median, Mean
• ConditionNumber, Determinant, Inverse, Solve

Summary

The CenterSpace framework for computation on the .NET platform seamless integrates complex types. While most of our customers are leveraging more sophisticated classes in NMath, a complete set of complex types with a surrounding framework is a key component to getting the job done quickly and accurately.

-Paul

The post Complex numbers in .NET with NMath appeared first on CenterSpace.

I’m working on the primitives (NMathCoreShared.dll) and have found a rather odd ‘quirk’ with complex division by zero:

DoubleComplex aa = new DoubleComplex(0.0, 0.0);
DoubleComplex bb = new DoubleComplex(5.2, -9.1);
DoubleComplex cc = new DoubleComplex();

cc = bb/aa;
Console.WriteLine(cc);  // (NaN,NaN)

double g = -5.0 / 0.0;
Console.WriteLine(g);   // -Infinity

On my machine (Athlon FX), I get the value NaN back when I’m pretty sure it should be ‘Inf’?

The code implementing complex division in the NMath complex number class does not check to see if the divisor is zero. It just applies the formula for complex division in terms of the operands’ real and imaginary parts:

\frac{a + bi}{c + di} = \frac{ac + bd}{c^2 + d^2} + i\frac{bc - ad}{c^2 + d^2}     (1)

As you can see, when c = d = 0 both the real and imaginary components of the quotient take the form 0/0. Now the IEEE standard says that for real numbers a/0, a not equal to 0, should yield +∞ or -∞ where the sign depends on whether a > 0 or a < 0 and 0/0 should yield NaN (Not a Number). So a direct application of the formulas for division of complex number, without “special casing” the zero denominator case, will yield a result of (NaN, NaN).

One might be tempted to say “OK, that’s the end of that. (NaN, NaN) is obviously the correct behavior”. However, this does not set very well with intuition. If I have a fixed complex number w which is divided by another variable complex number z, it seems that as z gets smaller and smaller, the quotient should get bigger and bigger. There is a slight technicality here–there really is no notion of bigger and smaller for the complex number. That is, there is no ordering of the complex numbers that is consistent with its algebraic structure. In particular there is no notion of negative and positive complex numbers, so the concept of positive and negative infinity are not well defined. Let’s take a look at some theoretical stuff in the hopes it will help to guide our thinking.

Let’s start with something more familiar. What does it mean to divide a real number by zero? From a purely algebraic sense if a and b are two real numbers then the number a ÷ b is the solution to the equation b * x = a. When b = 0 this equation has no solution and so the quotient is not defined (unless we extend the real numbers to include infinity and define algebraic operations that include infinity, but let’s not go there now as it isn’t really germane to our conversation). Where does infinity come in? Well, one can also look at the question from an analysis point of view, where one deals in functions and limits. With this perspective, given a real number a one defines a division function f_a(x) = a ÷ x. This function is well defined for all x not equal to 0. But, analysis deals also with limits, and one would naturally ask what happens when x gets close to 0. The answer is as x → 0, f_a → ∞. Formally, this means the following: Given any real number M>0, there exists a corresponding real number δ > 0 such that |fa | > M whenever |x| < δ. Now, we can apply this definition to complex numbers since we have a notion of absolute value for complex numbers: if z = a + ib is a complex number, then the modulus of z, |z|, is defined as

|z|=\sqrt{a^2 + b^2}

That is it’s the euclidean distance from the point z = (a,b) to the origin in the complex plane. From this it is clear that as a complex number tends to zero, so must its real and imaginary parts. So as the denominator in equation (1) above tends to zero, so do its real and imaginary parts c and d. The fact that c and d are squared in the denominator of the real and imaginary parts of the quotient means that they will tend to zero faster than the their corresponding numerators and hence, using a L’Hôpital’s Rule based argument, or a straight δ, M based argument, we can see that both the real and imaginary parts of the quotient tend to infinity as the denominator tends towards zero. Whether it is positive or negative infinity is another question.

But enough theoretical talk. Let’s look at something concrete. Unlike C#, the standard C++ library includes a complex number class. What do they do when dividing by zero? Here’s the result I get with Microsoft’s C++ complex class:

Microsoft Visual C++ 15.0

(1,1)/(0,0) = (1.#QNAN,1.#QNAN)
(0,0)/(0,0) = (1.#QNAN,1.#QNAN)
1/0 = 1.#INF
0/0 = -1.#IND

Hmm. They seem to just apply the formulas and get 0/0 for the real and imaginary parts. How about the GNU C++ compiler?

g++ 4.3.2

(1,1)/(0,0) = (inf,inf)
(0,0)/(0,0) = (nan,nan)
1/0 = inf
0/0 = nan

Interesting. They return infinite real and imaginary parts. What’s more interesting is that the two compilers do not agree. And just for fun, here’s the result with the complex class included in Microsoft’s F# compiler:

F#

(1,1)/(0,0) = NaNr+NaNi
(0,0)/(0,0) = NaNr+NaNi
1/0 = Infinity
0/0 = NaN

No surprise here. At least Microsoft is consistent.

What does the GNU compiler do about positive and negative infinity in its results?

(1,1)/(0,0) = (inf,inf)
(-1,-1)/(0,0) = (-inf,-inf)
(1,-1)/(0,0) = (inf,-inf)
(-1,1)/(0,0) = (-inf,inf)

Apparently, they have adopted the convention that the sign of infinity in the real and imaginary parts of the quotient is the same as the signs of the real and imaginary parts of the numerator, respectively.

So, what should NMath do? On the one hand .NET is a Microsofty kind of thing, so maybe we should be consistent with their C++ implementation. On the other hand g++ is a widely distributed compiler and they seem to take the moral high road here. What would you do?

Steve

The post Complex division by zero appeared first on CenterSpace.