struct Complex
Overview
A complex number is a number represented in the form a + bi. In this form, a and b are real numbers, and i is an imaginary number such as i² = -1. The a is the real part of the number, and the b is the imaginary part of the number.
NOTE  To use Complex, you must explicitly import it with require "complex"
require "complex"
Complex.new(1, 0)   # => 1.0 + 0.0.i
Complex.new(5, -12) # => 5.0 - 12.0.i
1.to_c # => 1.0 + 0.0.i
1.i    # => 0.0 + 1.0.iDefined in:
complex.crConstructors
- .additive_identity : self
- .multiplicative_identity : self
- .new(real : Number, imag : Number = 0)
- .new(c : Complex)
- 
        .zero : Complex
        
          Returns the number 0in complex form.
Instance Method Summary
- 
        #*(other : Complex) : Complex
        
          Multiplies selfby other.
- 
        #*(other : Number) : Complex
        
          Multiplies selfby other.
- 
        #+(other : Complex) : Complex
        
          Adds the value of selfto other.
- 
        #+(other : Number) : Complex
        
          Adds the value of selfto other.
- 
        #+ : Complex
        
          Returns self.
- 
        #-(other : Complex) : Complex
        
          Removes the value of other from self.
- 
        #-(other : Number) : Complex
        
          Removes the value of other from self.
- 
        #- : Complex
        
          Returns the opposite of self.
- 
        #/(other : Complex) : Complex
        
          Divides selfby other.
- 
        #/(other : Number) : Complex
        
          Divides selfby other.
- 
        #==(other : Complex)
        
          Determines whether selfequals other or not.
- 
        #==(other : Number)
        
          Determines whether selfequals other or not.
- 
        #==(other)
        
          Determines whether selfequals other or not.
- 
        #abs : Float64
        
          Returns the absolute value of this complex number in a number form, using the Pythagorean theorem. 
- 
        #abs2 : Float64
        
          Returns the square of absolute value in a number form. 
- #clone
- 
        #conj : Complex
        
          Returns the conjugate of self.
- #hash(hasher)
- 
        #imag : Float64
        
          Returns the imaginary part. 
- 
        #inspect(io : IO) : Nil
        
          Writes this complex object to an io, surrounded by parentheses. 
- 
        #inv : Complex
        
          Returns the inverse of self.
- 
        #phase : Float64
        
          Returns the phase of self.
- #polar : Tuple(Float64, Float64)
- 
        #real : Float64
        
          Returns the real part. 
- 
        #round(digits = 0) : Complex
        
          Rounds to the nearest digits. 
- 
        #sign : Complex
        
          Returns the complex sign of self.
- 
        #to_c
        
          Returns self.
- 
        #to_f
        
          See #to_f64.
- #to_f32(*args, **options)
- #to_f32(*args, **options, &)
- 
        #to_f64 : Float64
        
          Returns the value as a Float64if possible (the imaginary part should be exactly zero), raises otherwise.
- 
        #to_i
        
          See #to_i32.
- #to_i128(*args, **options)
- #to_i128(*args, **options, &)
- #to_i16(*args, **options)
- #to_i16(*args, **options, &)
- #to_i32(*args, **options)
- #to_i32(*args, **options, &)
- #to_i64(*args, **options)
- #to_i64(*args, **options, &)
- #to_i8(*args, **options)
- #to_i8(*args, **options, &)
- 
        #to_s(io : IO) : Nil
        
          Writes this complex object to an io. 
- #to_u128(*args, **options)
- #to_u128(*args, **options, &)
- #to_u16(*args, **options)
- #to_u16(*args, **options, &)
- #to_u32(*args, **options)
- #to_u32(*args, **options, &)
- #to_u64(*args, **options)
- #to_u64(*args, **options, &)
- #to_u8(*args, **options)
- #to_u8(*args, **options, &)
- 
        #zero? : Bool
        
          Returns trueif the complex number is zero.
Instance methods inherited from struct Struct
  
  
    
      ==(other) : Bool
    ==, 
    
  
    
      hash(hasher)
    hash, 
    
  
    
      inspect(io : IO) : Nil
    inspect, 
    
  
    
      pretty_print(pp) : Nil
    pretty_print, 
    
  
    
      to_s(io : IO) : Nil
    to_s
    
  
      
      
      
    
      
  Instance methods inherited from struct Value
  
  
    
      ==(other : JSON::Any)==(other : YAML::Any)
==(other) ==, dup dup
Instance methods inherited from class Object
  
  
    
      ! : Bool
    !, 
    
  
    
      !=(other)
    !=, 
    
  
    
      !~(other)
    !~, 
    
  
    
      ==(other)
    ==, 
    
  
    
      ===(other : JSON::Any)===(other : YAML::Any)
===(other) ===, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash hash, in?(collection : Object) : Bool
in?(*values : Object) : Bool in?, inspect(io : IO) : Nil
inspect : String inspect, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String to_json, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json, to_s(io : IO) : Nil
to_s : String to_s, to_yaml(io : IO) : Nil
to_yaml : String to_yaml, try(&) try, unsafe_as(type : T.class) forall T unsafe_as
Class methods inherited from class Object
  
  
    
      from_json(string_or_io, root : String)from_json(string_or_io) from_json, from_yaml(string_or_io : String | IO) from_yaml
Macros inherited from class Object
  
  
    
      class_getter(*names, &block)
    class_getter, 
    
  
    
      class_getter!(*names)
    class_getter!, 
    
  
    
      class_getter?(*names, &block)
    class_getter?, 
    
  
    
      class_property(*names, &block)
    class_property, 
    
  
    
      class_property!(*names)
    class_property!, 
    
  
    
      class_property?(*names, &block)
    class_property?, 
    
  
    
      class_setter(*names)
    class_setter, 
    
  
    
      def_clone
    def_clone, 
    
  
    
      def_equals(*fields)
    def_equals, 
    
  
    
      def_equals_and_hash(*fields)
    def_equals_and_hash, 
    
  
    
      def_hash(*fields)
    def_hash, 
    
  
    
      delegate(*methods, to object)
    delegate, 
    
  
    
      forward_missing_to(delegate)
    forward_missing_to, 
    
  
    
      getter(*names, &block)
    getter, 
    
  
    
      getter!(*names)
    getter!, 
    
  
    
      getter?(*names, &block)
    getter?, 
    
  
    
      property(*names, &block)
    property, 
    
  
    
      property!(*names)
    property!, 
    
  
    
      property?(*names, &block)
    property?, 
    
  
    
      setter(*names)
    setter
    
  
    
  Constructor Detail
Instance Method Detail
Returns the absolute value of this complex number in a number form, using the Pythagorean theorem.
require "complex"
Complex.new(42, 2).abs  # => 42.04759208325728
Complex.new(-42, 2).abs # => 42.04759208325728Returns the square of absolute value in a number form.
require "complex"
Complex.new(42, 2).abs2 # => 1768Returns the conjugate of self.
require "complex"
Complex.new(42, 2).conj  # => 42.0 - 2.0.i
Complex.new(42, -2).conj # => 42.0 + 2.0.iWrites this complex object to an io, surrounded by parentheses.
require "complex"
Complex.new(42, 2).inspect # => "(42.0 + 2.0i)"Returns a Tuple with the #abs value and the #phase.
require "complex"
Complex.new(42, 2).polar # => {42.047592083257278, 0.047583103276983396}Returns the complex sign of self.
If self is non-zero, the returned value has the same phase as self and
absolute value 1.0. If self is zero, returns self.
The returned value's real and imaginary components always have the same
signs as the respective components of self.
require "complex"
Complex.new(7, -24).sign        # => (0.28 - 0.96.i)
Complex.new(1.0 / 0.0, 24).sign # => (1.0 + 0.0.i)
Complex.new(-0.0, +0.0).sign    # => (-0.0 + 0.0.i)Returns the value as a Float64 if possible (the imaginary part should be exactly zero),
raises otherwise.
Writes this complex object to an io.
require "complex"
Complex.new(42, 2).to_s # => "42.0 + 2.0i"