Behaviour of non-finite complex numbers.

[harrysarson]

I was looking into issue josdejong/mathjs#804 regarding the behaviour of negative numbers raised to infinite powers.

Support for non-finite complex numbers seems to be incomplete in complex.js and I was wondering if it was something that you are planning to support more comprehensively. For example:

• new Complex(-0.5).pow(Infinity) currently gives NaN which is inconsistant with the behaviour of Math.pow(-0.5, Infinity) which (correctly) gives 0.

Additionally I found a couple of bug which need fixing regardless of whether the library is extended to add proper support for complex numbers.

• new Complex(0).inverse() currently gives 0.
• new Complex(Infinity).equals(Infinity) currently returns false.

[infusion]

Oh, that are good findings! Thanks a lot for the ticket and notifying me about #804! I'll look into this. About the last point, it's a mere philosophical question if infinity should equal infinity, or more specifically is 1/0 == 2/0? JavaScript simply compares the infintiy bit, but other languages treat this case differently.

[harrysarson]

Yeah that's fair re the equality - an isFinite might be a better way to test for infinite numbers although !isFinite(z) && z.im === 0 && z.re > 0 is far more unwieldy than z.equal(Infinity).

Is full support for infinite values (eg in the pow function) worth increasing the size of the library?

[infusion]

Okay, I added a new branch "infinity": f06449f

I added a new symbol Complex.Infinity, which sets real and imaginary part to infinity. This symbol is returned for inv(0), div(z, 0) and if the angle for cos/sin in pow is becoming infinity (which originally forced the number to become nan).

The actual code changes don't change the size of the library dramatically, so I would say it's worthwhile to add the feature.

I would say we keep equal as it is, but think about adding isFinite (which is true <=> isFinite(re)&isFinite(im)).

[harrysarson]

isFinite sounds like a good solution.

I noticed that currently complex(0).div(0) === complex(0). This is in both the master and infinity branches.

Additionally currently complex(1).div(0) === complex(Infinity, 0) where as complex(0).inverse() === complex(Infinity, Infinity). I am not sure about the best behaviour for this as I feel that the division of two real numbers should be real but also that inverse(z) should be equivalent to 1/z.

Finally complex(0, Infinity).mul(1) === complex(NaN, Infinity) at the moment.

[infusion]

Hm, yep I thought the same way and I think a real infinity should stay real. However, wolframalpha decided (maybe for the same reason) to print complex infinity for any case, the complex and real: http://www.wolframalpha.com/input/?i=1%2F0

0/0 Should be fixed, right. NaN is an approproate value for that.

The different behavior of div and inverse must be fixed as well.

About the last one, the multiplication, it happens to become NaN since 0Infinity=NaN. I see your point that the multiplicative neutral element should return the same value after multiplication (which would be the case, if we treat 0Infinity as 0. I must have a look, if this can be generalized this way.)

[infusion]

Okay, there is an update in infinity branch.

• isFinite was added
• 0/0 is now complex infinity as well, even if it's not defined. Let's see if we can get along with complex infinity and not returning a "complex nan" at all - since I don't want to add a special check for this rare case.
• About imaginary infinity times one - I'm not sure if we should fix that (see last post).
• 1/0=complex inf is consistent with inv(0)=complex inf

[harrysarson]

• I am not a big fan of 0/0 === ComplexInfinity as that would be different from every other maths language and I don't think consistent with complex maths although I had a look at the wikipedia article and it all went over my head.

• I had a go at implementing full support for infinity in the mul function see my pr. I don't like how messy it is but I couldn't find anyway to handle non finite numbers apart from bashing every case.

• I also had look at the parse function and added support for infinite complex numbers in the {r, phi} form. I don't think Infinity + 5i makes any sense so unless the number is purely real or purely imaginary the parse function sets both the re and imaginary components to Infinity. This slightly reduces the number of cases I had to include in the mul function.

[harrysarson]

Hi

What is the purpose of these lines in the divide function?

return new Complex(
  (a !== 0) ? (a / 0) : Infinity, 
  (b !== 0) ? (b / 0) : Infinity);

If a is not zero then the expression evaluates to Infinity anyway.

https://github.com/infusion/Complex.js/blob/infinity/complex.js#L387-l388.

I believe that the whole of the if (0 === c) conditional could be removed.

[infusion]

The purpose is to keep the sign of each Infinity.

[harrysarson]

But as both the real and imaginary parts will be infinite the return value will get converted to complex infinity anyway.

I am also reasonably convinced that new Complex(0).div(0) should be ComplexNaN; I think its worth a special case.

[balagge]

Hi!
I would like to ask how this issue is progressing. I am interested in having complex infinity fixed in the library. After all this is a Complex library so I would assume it treats infinities mathematically correctly.
Most of the workings of complex infinity is on the wikipedia page https://en.wikipedia.org/wiki/Riemann_sphere
But I am also happy to summarize this here, if needed.

[harrysarson]

@balagge have a look at pull #12, I have had a go at making the required fixes but I don't have an intensive knowledge of the maths so if you could have a look through the changes that would be grand.

Otherwise we are waiting on @infusion

[balagge]

Unfortunately I currently (and for quite a while) do not have the time to understand the code and test it. What I can do is write down what I consider the mathematically correct behavior.

Below c, c1, c2, etc. denotes any complex infinity object, z, z1, z2, etc. denotes any Complex object other than a complex infinity (i.e. finite)

Construction and equality

0. complex infinities should be constructed by the Complex constructor if either the real part or the imaginary part is infinite (Infinity and -Infinity does not matter), or the radius is positive Infinity. So the following are all complex infinities:
   c = new Complex(Infinity, 1)
c = new Complex(0,Infinity)
c = new Complex({re:Infinity, im:-Infinity})
c = new Complex({arg:3, abs:Infinity} (however, abs:-Infinity is invalid. also, arg:Infinity and arg:-Infinity should be invalid)
1. Any c should be a Complex object different from any z, so
   z.equals(c) === false and
   c.equals(z) === false should always hold (note that c is any complex infinity object and z is any finite complex object).
2. Complex Infinities should be equal (even if two different object)., so
   c1.equals(c2) === true should hold for any (different) complex infinity objects.

Addition, subtraction, negation

3. Adding infinity to any finite complex should yield a complex infinity, so
   z.add(c1).equals(c2) === true , and
   c1.add(z).equals(c2) === true should always hold (note the usual usage of letters)
4. Adding complex infinities is not defined (UNLIKE real infinities), so
   c1.add(c2) should not have a value (NaN or something else? I do not know how exactly to represent undefined operations, but probably there is some way to do that already)
5. Negation returns the same complex infinity (UNLIKE real infinities), so
   c1.neg().equals(c2) === true should always hold
6. Subtraction is the same as adding the negated operand. Specifically
   z.sub(c1).equals(c2) === true,
   c1.sub(z).equals(c2) === true,
   c1.sub(c2) is invalid (not defined)
7. sign is not defined, so
   c.sign() should not have a value.

Real and imaginary part, argument and absolute value

8. real part is not defined. This may be a problem, but c.re should NOT have a definite value
9. imaginary part is not defined.
10. argument is not defined, so c.arg() should not have a value
11. absolute value is positive infinity, so c.abs() === Infinity should hold.

Multiplication

12. Anything (finite or infinite), except zero, multiplied by a complex infinity is a complex infinity, so
    z.mul(c1).equals(c2) === true, and c1.mul(z).equals(c2) === true unless z is zero.
    z.mul(c1) and c1.mul(z) is not defined if z is zero.
    c1.mul(c2).equals(c3) === true

Division

Division has multiple cases. both the dividend and the divisor must be examined and three cases separated: zero, non-zero (but finite), infinity. This yields 9 possible combinations (here I use more traditional notation and z', z1', z2', etc. mean nonzero, finite complex numbers)
13) 0 / 0 is not defined
14) 0 / z' is 0, as usual.
15) 0 / ∞ is also 0.
16) z' / 0 is ∞.
17) z1' / z2' is normal division of complexes.
18) z1' / ∞ is 0.
19) ∞ / 0 is not defined
20) ∞ / z' is ∞
21) ∞ / ∞ is not defined.

Multiplicative inverse

22. this follows from the division above, here I use 1/z notation instead of z.inverse(),
    1 / 0 is ∞
1 / z' is normal inverse of a complex
    1 / ∞ is 0.

This is the basic stuff, other functions require some more thinking but I will come back when I have some time