Complex enhancements

spec/std/complex_spec.cr

@@ -104,6 +104,10 @@ describe "Complex" do
   end
 
   describe "+" do
+    it "+ complex" do
+      (+Complex.new(-5.43, -27.12)).should eq(Complex.new(5.43, 27.12))
+    end
+
     it "complex + complex" do
       (Complex.new(2.2, 7) + Complex.new(10.1, 1.34)).should eq(Complex.new(12.3, 8.34))
     end

src/complex.cr

@@ -8,12 +8,15 @@
 #
 # Complex.new(1, 0)   # => 1.0 + 0.0i
 # Complex.new(5, -12) # => 5.0 - 12.0i
+#
+# 1.to_c # => 1.0 + 0.0i
+# 1.i    # => 0.0 + 1.0i
 # ```
 struct Complex
-  # Returns the real part of self.
+  # Returns the real part.
   getter real : Float64
 
-  # Returns the image part of self.
+  # Returns the imaginary part.
   getter imag : Float64
 
   def initialize(real : Number, imag : Number)
@@ -36,6 +39,48 @@ struct Complex
     false
   end
 
+  # Returns `self`.
+  def to_c
+    self
+  end
+
+  # Returns the value as a `Float64` if possible (the imaginary part should be exactly zero),
+  # raises otherwise.
+  def to_f64
+    unless @imag.zero?
+      raise Exception.new "Complex number with non-zero imaginary part can't be converted to real number"
+    end
+    @real
+  end
+
+  # Returns the value as a `Float32` if possible (the imaginary part should be exactly zero),
+  # raises otherwise.
+  def to_f32
+    to_f64.to_f32
+  end
+
+  # See `#to_f64`.
+  def to_f
+    to_f64
+  end
+
+  # Returns the value as an `Int64` if possible (the imaginary part should be exactly zero),
+  # raises otherwise.
+  def to_i64
+    to_f64.to_i64
+  end
+
+  # Returns the value as a `Int32` if possible (the imaginary part should be exactly zero),
+  # raises otherwise.
+  def to_i32
+    to_i64.to_i32
+  end
+
+  # See `#to_i32`.
+  def to_i
+    to_i32
+  end
+
   # Writes this complex object to an *io*.
   #
   # ```
@@ -83,12 +128,12 @@ struct Complex
     self / abs
   end
 
-  # Returns the phase of self.
+  # Returns the phase of `self`.
   def phase
     Math.atan2(@imag, @real)
   end
 
-  # Returns a tuple with the abs value and the phase.
+  # Returns a `Tuple` with the `abs` value and the `phase`.
   #
   # ```
   # Complex.new(42, 2).polar # => {42.047592083257278, 0.047583103276983396}
@@ -97,7 +142,7 @@ struct Complex
     {abs, phase}
   end
 
-  # Returns the conjugate of self.
+  # Returns the conjugate of `self`.
   #
   # ```
   # Complex.new(42, 2).conj  # => 42.0 - 2.0i
@@ -107,7 +152,7 @@ struct Complex
     Complex.new(@real, -@imag)
   end
 
-  # Returns the inverse of self.
+  # Returns the inverse of `self`.
   def inv
     conj / abs2
   end
@@ -130,14 +175,10 @@ struct Complex
            @imag.abs / Math.sqrt(2 * (r + @real))
          end
 
-    if @imag >= 0
-      Complex.new(re, im)
-    else
-      Complex.new(re, -im)
-    end
+    Complex.new(re, @imag >= 0 ? im : -im)
   end
 
-  # Calculates the exp of self.
+  # Calculates the exp of `self`.
   #
   # ```
   # Complex.new(4, 2).exp # => -22.720847417619233 + 49.645957334580565i
@@ -147,21 +188,26 @@ struct Complex
     Complex.new(r * Math.cos(@imag), r * Math.sin(@imag))
   end
 
-  # Calculates the log of self.
+  # Calculates the log of `self`.
   def log
     Complex.new(Math.log(abs), phase)
   end
 
-  # Calculates the log2 of self.
+  # Calculates the log2 of `self`.
   def log2
     log / Math::LOG2
   end
 
-  # Calculates the log10 of self.
+  # Calculates the log10 of `self`.
   def log10
     log / Math::LOG10
   end
 
+  # Returns absolute value of `self`.
+  def +
+    Complex.new(@real.abs, @imag.abs)
+  end
+
   # Adds the value of `self` to *other*.
   def +(other : Complex)
     Complex.new(@real + other.real, @imag + other.imag)
@@ -172,12 +218,12 @@ struct Complex
     Complex.new(@real + other, @imag)
   end
 
-  # Returns the opposite of self.
+  # Returns the opposite of `self`.
   def -
     Complex.new(-@real, -@imag)
   end
 
-  # Removes the value from *other* to self.
+  # Removes the value of *other* from `self`.
   def -(other : Complex)
     Complex.new(@real - other.real, @imag - other.imag)
   end