Complex and Rational Numbers

Julia includes predefined types for both complex and rational numbers, and supports all the standard Mathematical Operations and Elementary Functions on them. Conversion and Promotion are defined so that operations on any combination of predefined numeric types, whether primitive or composite, behave as expected.

Complex Numbers

The global constant im is bound to the complex number i, representing the principal square root of -1. (Using mathematicians’ i or engineers’ j for this global constant was rejected since they are such popular index variable names.) Since Julia allows numeric literals to be juxtaposed with identifiers as coefficients, this binding suffices to provide convenient syntax for complex numbers, similar to the traditional mathematical notation:

  1. julia> 1+2im
  2. 1 + 2im

You can perform all the standard arithmetic operations with complex numbers:

  1. julia> (1 + 2im)*(2 - 3im)
  2. 8 + 1im
  4. julia> (1 + 2im)/(1 - 2im)
  5. -0.6 + 0.8im
  7. julia> (1 + 2im) + (1 - 2im)
  8. 2 + 0im
  10. julia> (-3 + 2im) - (5 - 1im)
  11. -8 + 3im
  13. julia> (-1 + 2im)^2
  14. -3 - 4im
  16. julia> (-1 + 2im)^2.5
  17. 2.729624464784009 - 6.9606644595719im
  19. julia> (-1 + 2im)^(1 + 1im)
  20. -0.27910381075826657 + 0.08708053414102428im
  22. julia> 3(2 - 5im)
  23. 6 - 15im
  25. julia> 3(2 - 5im)^2
  26. -63 - 60im
  28. julia> 3(2 - 5im)^-1.0
  29. 0.20689655172413793 + 0.5172413793103449im

The promotion mechanism ensures that combinations of operands of different types just work:

  1. julia> 2(1 - 1im)
  2. 2 - 2im
  4. julia> (2 + 3im) - 1
  5. 1 + 3im
  7. julia> (1 + 2im) + 0.5
  8. 1.5 + 2.0im
  10. julia> (2 + 3im) - 0.5im
  11. 2.0 + 2.5im
  13. julia> 0.75(1 + 2im)
  14. 0.75 + 1.5im
  16. julia> (2 + 3im) / 2
  17. 1.0 + 1.5im
  19. julia> (1 - 3im) / (2 + 2im)
  20. -0.5 - 1.0im
  22. julia> 2im^2
  23. -2 + 0im
  25. julia> 1 + 3/4im
  26. 1.0 - 0.75im

Note that 3/4im == 3/(4*im) == -(3/4*im), since a literal coefficient binds more tightly than division.

Standard functions to manipulate complex values are provided:

  1. julia> z = 1 + 2im
  2. 1 + 2im
  4. julia> real(1 + 2im) # real part of z
  5. 1
  7. julia> imag(1 + 2im) # imaginary part of z
  8. 2
  10. julia> conj(1 + 2im) # complex conjugate of z
  11. 1 - 2im
  13. julia> abs(1 + 2im) # absolute value of z
  14. 2.23606797749979
  16. julia> abs2(1 + 2im) # squared absolute value
  17. 5
  19. julia> angle(1 + 2im) # phase angle in radians
  20. 1.1071487177940904

As usual, the absolute value (abs) of a complex number is its distance from zero. abs2 gives the square of the absolute value, and is of particular use for complex numbers since it avoids taking a square root. angle returns the phase angle in radians (also known as the argument or arg function). The full gamut of other Elementary Functions is also defined for complex numbers:

  1. julia> sqrt(1im)
  2. 0.7071067811865476 + 0.7071067811865475im
  4. julia> sqrt(1 + 2im)
  5. 1.272019649514069 + 0.7861513777574233im
  7. julia> cos(1 + 2im)
  8. 2.0327230070196656 - 3.0518977991517997im
  10. julia> exp(1 + 2im)
  11. -1.1312043837568135 + 2.4717266720048188im
  13. julia> sinh(1 + 2im)
  14. -0.4890562590412937 + 1.4031192506220405im

Note that mathematical functions typically return real values when applied to real numbers and complex values when applied to complex numbers. For example, sqrt behaves differently when applied to -1 versus -1 + 0im even though -1 == -1 + 0im:

  1. julia> sqrt(-1)
  2. ERROR: DomainError with -1.0:
  3. sqrt was called with a negative real argument but will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
  4. Stacktrace:
  5. [...]
  7. julia> sqrt(-1 + 0im)
  8. 0.0 + 1.0im

The literal numeric coefficient notation does not work when constructing a complex number from variables. Instead, the multiplication must be explicitly written out:

  1. julia> a = 1; b = 2; a + b*im
  2. 1 + 2im

However, this is not recommended. Instead, use the more efficient complex function to construct a complex value directly from its real and imaginary parts:

  1. julia> a = 1; b = 2; complex(a, b)
  2. 1 + 2im

This construction avoids the multiplication and addition operations.

Inf and NaN propagate through complex numbers in the real and imaginary parts of a complex number as described in the Special floating-point values section:

  1. julia> 1 + Inf*im
  2. 1.0 + Inf*im
  4. julia> 1 + NaN*im
  5. 1.0 + NaN*im

Rational Numbers

Julia has a rational number type to represent exact ratios of integers. Rationals are constructed using the // operator:

  1. julia> 2//3
  2. 2//3

If the numerator and denominator of a rational have common factors, they are reduced to lowest terms such that the denominator is non-negative:

  1. julia> 6//9
  2. 2//3
  4. julia> -4//8
  5. -1//2
  7. julia> 5//-15
  8. -1//3
  10. julia> -4//-12
  11. 1//3

This normalized form for a ratio of integers is unique, so equality of rational values can be tested by checking for equality of the numerator and denominator. The standardized numerator and denominator of a rational value can be extracted using the numerator and denominator functions:

  1. julia> numerator(2//3)
  2. 2
  4. julia> denominator(2//3)
  5. 3

Direct comparison of the numerator and denominator is generally not necessary, since the standard arithmetic and comparison operations are defined for rational values:

  1. julia> 2//3 == 6//9
  2. true
  4. julia> 2//3 == 9//27
  5. false
  7. julia> 3//7 < 1//2
  8. true
  10. julia> 3//4 > 2//3
  11. true
  13. julia> 2//4 + 1//6
  14. 2//3
  16. julia> 5//12 - 1//4
  17. 1//6
  19. julia> 5//8 * 3//12
  20. 5//32
  22. julia> 6//5 / 10//7
  23. 21//25

Rationals can easily be converted to floating-point numbers:

  1. julia> float(3//4)
  2. 0.75

Conversion from rational to floating-point respects the following identity for any integral values of a and b, with the exception of the two cases b == 0 and a == 0 && b < 0:

  1. julia> a = 1; b = 2;
  3. julia> isequal(float(a//b), a/b)
  4. true

Constructing infinite rational values is acceptable:

  1. julia> 5//0
  2. 1//0
  4. julia> x = -3//0
  5. -1//0
  7. julia> typeof(x)
  8. Rational{Int64}

Trying to construct a NaN rational value, however, is invalid:

  1. julia> 0//0
  2. ERROR: ArgumentError: invalid rational: zero(Int64)//zero(Int64)
  3. Stacktrace:
  4. [...]

As usual, the promotion system makes interactions with other numeric types effortless:

  1. julia> 3//5 + 1
  2. 8//5
  4. julia> 3//5 - 0.5
  5. 0.09999999999999998
  7. julia> 2//7 * (1 + 2im)
  8. 2//7 + 4//7*im
  10. julia> 2//7 * (1.5 + 2im)
  11. 0.42857142857142855 + 0.5714285714285714im
  13. julia> 3//2 / (1 + 2im)
  14. 3//10 - 3//5*im
  16. julia> 1//2 + 2im
  17. 1//2 + 2//1*im
  19. julia> 1 + 2//3im
  20. 1//1 - 2//3*im
  22. julia> 0.5 == 1//2
  23. true
  25. julia> 0.33 == 1//3
  26. false
  28. julia> 0.33 < 1//3
  29. true
  31. julia> 1//3 - 0.33
  32. 0.0033333333333332993