Gecko [ beriskala.com ]

Name	Size	Permission	Date
enumerator	[ DIR ]	drwxr-xr-x	2026-05-05 23:08
io	[ DIR ]	drwxr-xr-x	2026-05-05 23:08
object_space	[ DIR ]	drwxr-xr-x	2026-05-05 23:08
rbs	[ DIR ]	drwxr-xr-x	2026-04-07 17:22
rubygems	[ DIR ]	drwxr-xr-x	2026-05-05 23:08
array.rbs	120.37 KB	-rw-r--r--	2026-04-07 17:22
basic_object.rbs	12.49 KB	-rw-r--r--	2026-04-07 17:22
binding.rbs	4.11 KB	-rw-r--r--	2026-04-07 17:22
builtin.rbs	7.27 KB	-rw-r--r--	2026-04-07 17:22
class.rbs	6.72 KB	-rw-r--r--	2026-04-07 17:22
comparable.rbs	5.63 KB	-rw-r--r--	2026-04-07 17:22
complex.rbs	16.03 KB	-rw-r--r--	2026-04-07 17:22
constants.rbs	1.89 KB	-rw-r--r--	2026-04-07 17:22
data.rbs	12.71 KB	-rw-r--r--	2026-04-07 17:22
dir.rbs	31.12 KB	-rw-r--r--	2026-04-07 17:22
encoding.rbs	46.68 KB	-rw-r--r--	2026-04-07 17:22
enumerable.rbs	82.84 KB	-rw-r--r--	2026-04-07 17:22
enumerator.rbs	19.19 KB	-rw-r--r--	2026-04-07 17:22
env.rbs	157 B	-rw-r--r--	2026-04-07 17:22
errno.rbs	10.41 KB	-rw-r--r--	2026-04-07 17:22
errors.rbs	18.86 KB	-rw-r--r--	2026-04-07 17:22
exception.rbs	8.64 KB	-rw-r--r--	2026-04-07 17:22
false_class.rbs	2.1 KB	-rw-r--r--	2026-04-07 17:22
fiber.rbs	19.03 KB	-rw-r--r--	2026-04-07 17:22
fiber_error.rbs	374 B	-rw-r--r--	2026-04-07 17:22
file.rbs	89.71 KB	-rw-r--r--	2026-04-07 17:22
file_test.rbs	10.2 KB	-rw-r--r--	2026-04-07 17:22
float.rbs	29.98 KB	-rw-r--r--	2026-04-07 17:22
gc.rbs	13.04 KB	-rw-r--r--	2026-04-07 17:22
global_variables.rbs	5.63 KB	-rw-r--r--	2026-04-07 17:22
hash.rbs	58.31 KB	-rw-r--r--	2026-04-07 17:22
integer.rbs	38.32 KB	-rw-r--r--	2026-04-07 17:22
io.rbs	110.6 KB	-rw-r--r--	2026-04-07 17:22
kernel.rbs	100.05 KB	-rw-r--r--	2026-04-07 17:22
marshal.rbs	7.07 KB	-rw-r--r--	2026-04-07 17:22
match_data.rbs	16.99 KB	-rw-r--r--	2026-04-07 17:22
math.rbs	20.4 KB	-rw-r--r--	2026-04-07 17:22
method.rbs	8.26 KB	-rw-r--r--	2026-04-07 17:22
module.rbs	52.79 KB	-rw-r--r--	2026-04-07 17:22
nil_class.rbs	3.84 KB	-rw-r--r--	2026-04-07 17:22
numeric.rbs	23.74 KB	-rw-r--r--	2026-04-07 17:22
object.rbs	5.04 KB	-rw-r--r--	2026-04-07 17:22
object_space.rbs	6.11 KB	-rw-r--r--	2026-04-07 17:22
proc.rbs	22.37 KB	-rw-r--r--	2026-04-07 17:22
process.rbs	74.04 KB	-rw-r--r--	2026-04-07 17:22
ractor.rbs	30.8 KB	-rw-r--r--	2026-04-07 17:22
random.rbs	7.85 KB	-rw-r--r--	2026-04-07 17:22
range.rbs	31.67 KB	-rw-r--r--	2026-04-07 17:22
rational.rbs	14.91 KB	-rw-r--r--	2026-04-07 17:22
rb_config.rbs	2.9 KB	-rw-r--r--	2026-04-07 17:22
refinement.rbs	1.42 KB	-rw-r--r--	2026-04-07 17:22
regexp.rbs	66.25 KB	-rw-r--r--	2026-04-07 17:22
ruby_vm.rbs	13 KB	-rw-r--r--	2026-04-07 17:22
set.rbs	19.23 KB	-rw-r--r--	2026-04-07 17:22
signal.rbs	3.59 KB	-rw-r--r--	2026-04-07 17:22
string.rbs	117.37 KB	-rw-r--r--	2026-04-07 17:22
string_io.rbs	15.47 KB	-rw-r--r--	2026-04-07 17:22
struct.rbs	22.71 KB	-rw-r--r--	2026-04-07 17:22
symbol.rbs	12.82 KB	-rw-r--r--	2026-04-07 17:22
thread.rbs	51.93 KB	-rw-r--r--	2026-04-07 17:22
thread_group.rbs	2.35 KB	-rw-r--r--	2026-04-07 17:22
time.rbs	55.6 KB	-rw-r--r--	2026-04-07 17:22
trace_point.rbs	12.71 KB	-rw-r--r--	2026-04-07 17:22
true_class.rbs	2.23 KB	-rw-r--r--	2026-04-07 17:22
unbound_method.rbs	9.99 KB	-rw-r--r--	2026-04-07 17:22
warning.rbs	2.42 KB	-rw-r--r--	2026-04-07 17:22

Rename

# 
# A Complex object houses a pair of values, given when the object is created as
# either *rectangular coordinates* or *polar coordinates*.
#
# ## Rectangular Coordinates
#
# The rectangular coordinates of a complex number are called the *real* and
# *imaginary* parts; see [Complex number
# definition](https://en.wikipedia.org/wiki/Complex_number#Definition).
#
# You can create a Complex object from rectangular coordinates with:
#
# *   A [complex literal](rdoc-ref:doc/syntax/literals.rdoc@Complex+Literals).
# *   Method Complex.rect.
# *   Method Kernel#Complex, either with numeric arguments or with certain
#     string arguments.
# *   Method String#to_c, for certain strings.
#
#
# Note that each of the stored parts may be a an instance one of the classes
# Complex, Float, Integer, or Rational; they may be retrieved:
#
# *   Separately, with methods Complex#real and Complex#imaginary.
# *   Together, with method Complex#rect.
#
#
# The corresponding (computed) polar values may be retrieved:
#
# *   Separately, with methods Complex#abs and Complex#arg.
# *   Together, with method Complex#polar.
#
#
# ## Polar Coordinates
#
# The polar coordinates of a complex number are called the *absolute* and
# *argument* parts; see [Complex polar
# plane](https://en.wikipedia.org/wiki/Complex_number#Polar_complex_plane).
#
# You can create a Complex object from polar coordinates with:
#
# *   Method Complex.polar.
# *   Method Kernel#Complex, with certain string arguments.
# *   Method String#to_c, for certain strings.
#
#
# Note that each of the stored parts may be a an instance one of the classes
# Complex, Float, Integer, or Rational; they may be retrieved:
#
# *   Separately, with methods Complex#abs and Complex#arg.
# *   Together, with method Complex#polar.
#
#
# The corresponding (computed) rectangular values may be retrieved:
#
# *   Separately, with methods Complex#real and Complex#imag.
# *   Together, with method Complex#rect.
#
class Complex < Numeric
  # 
  # Returns a new Complex object formed from the arguments, each of which must be
  # an instance of Numeric, or an instance of one of its subclasses: Complex,
  # Float, Integer, Rational; see [Polar
  # Coordinates](rdoc-ref:Complex@Polar+Coordinates):
  #
  #     Complex.polar(3)        # => (3+0i)
  #     Complex.polar(3, 2.0)   # => (-1.2484405096414273+2.727892280477045i)
  #     Complex.polar(-3, -2.0) # => (1.2484405096414273+2.727892280477045i)
  #
  def self.polar: (Numeric, ?Numeric) -> Complex

# 
  # Returns a new Complex object formed from the arguments, each of which must be
  # an instance of Numeric, or an instance of one of its subclasses: Complex,
  # Float, Integer, Rational; see [Rectangular
  # Coordinates](rdoc-ref:Complex@Rectangular+Coordinates):
  #
  #     Complex.rect(3)             # => (3+0i)
  #     Complex.rect(3, Math::PI)   # => (3+3.141592653589793i)
  #     Complex.rect(-3, -Math::PI) # => (-3-3.141592653589793i)
  #
  # Complex.rectangular is an alias for Complex.rect.
  #
  def self.rect: (Numeric, ?Numeric) -> Complex

public

# 
  # Performs multiplication.
  #
  #     Complex(2, 3)  * Complex(2, 3)   #=> (-5+12i)
  #     Complex(900)   * Complex(1)      #=> (900+0i)
  #     Complex(-2, 9) * Complex(-9, 2)  #=> (0-85i)
  #     Complex(9, 8)  * 4               #=> (36+32i)
  #     Complex(20, 9) * 9.8             #=> (196.0+88.2i)
  #
  def *: (Numeric) -> Complex

# 
  # Performs exponentiation.
  #
  #     Complex('i') ** 2              #=> (-1+0i)
  #     Complex(-8) ** Rational(1, 3)  #=> (1.0000000000000002+1.7320508075688772i)
  #
  def **: (Numeric) -> Complex

# 
  # Performs addition.
  #
  #     Complex(2, 3)  + Complex(2, 3)   #=> (4+6i)
  #     Complex(900)   + Complex(1)      #=> (901+0i)
  #     Complex(-2, 9) + Complex(-9, 2)  #=> (-11+11i)
  #     Complex(9, 8)  + 4               #=> (13+8i)
  #     Complex(20, 9) + 9.8             #=> (29.8+9i)
  #
  def +: (Numeric) -> Complex

def +@: () -> Complex

# 
  # Performs subtraction.
  #
  #     Complex(2, 3)  - Complex(2, 3)   #=> (0+0i)
  #     Complex(900)   - Complex(1)      #=> (899+0i)
  #     Complex(-2, 9) - Complex(-9, 2)  #=> (7+7i)
  #     Complex(9, 8)  - 4               #=> (5+8i)
  #     Complex(20, 9) - 9.8             #=> (10.2+9i)
  #
  def -: (Numeric) -> Complex

# 
  # Returns negation of the value.
  #
  #     -Complex(1, 2)  #=> (-1-2i)
  #
  def -@: () -> Complex

# 
  # Performs division.
  #
  #     Complex(2, 3)  / Complex(2, 3)   #=> ((1/1)+(0/1)*i)
  #     Complex(900)   / Complex(1)      #=> ((900/1)+(0/1)*i)
  #     Complex(-2, 9) / Complex(-9, 2)  #=> ((36/85)-(77/85)*i)
  #     Complex(9, 8)  / 4               #=> ((9/4)+(2/1)*i)
  #     Complex(20, 9) / 9.8             #=> (2.0408163265306123+0.9183673469387754i)
  #
  def /: (Numeric) -> Complex

def <: (Numeric) -> bot

def <=: (Numeric) -> bot

# 
  # If `cmp`'s imaginary part is zero, and `object` is also a real number (or a
  # Complex number where the imaginary part is zero), compare the real part of
  # `cmp` to object.  Otherwise, return nil.
  #
  #     Complex(2, 3)  <=> Complex(2, 3)   #=> nil
  #     Complex(2, 3)  <=> 1               #=> nil
  #     Complex(2)     <=> 1               #=> 1
  #     Complex(2)     <=> 2               #=> 0
  #     Complex(2)     <=> 3               #=> -1
  #
  def <=>: (untyped) -> Integer?

# 
  # Returns true if cmp equals object numerically.
  #
  #     Complex(2, 3)  == Complex(2, 3)   #=> true
  #     Complex(5)     == 5               #=> true
  #     Complex(0)     == 0.0             #=> true
  #     Complex('1/3') == 0.33            #=> false
  #     Complex('1/2') == '1/2'           #=> false
  #
  def ==: (untyped) -> bool

def >: (Numeric) -> bot

def >=: (Numeric) -> bot

# 
  # Returns the absolute part of its polar form.
  #
  #     Complex(-1).abs         #=> 1
  #     Complex(3.0, -4.0).abs  #=> 5.0
  #
  def abs: () -> Numeric

# 
  # Returns square of the absolute value.
  #
  #     Complex(-1).abs2         #=> 1
  #     Complex(3.0, -4.0).abs2  #=> 25.0
  #
  def abs2: () -> Numeric

# 
  # Returns the angle part of its polar form.
  #
  #     Complex.polar(3, Math::PI/2).arg  #=> 1.5707963267948966
  #
  def angle: () -> Float

# 
  # Returns the angle part of its polar form.
  #
  #     Complex.polar(3, Math::PI/2).arg  #=> 1.5707963267948966
  #
  alias arg angle

def ceil: (*untyped) -> bot

def coerce: (Numeric) -> [ Complex, Complex ]

# 
  # Returns the complex conjugate.
  #
  #     Complex(1, 2).conjugate  #=> (1-2i)
  #
  def conj: () -> Complex

# 
  # Returns the complex conjugate.
  #
  #     Complex(1, 2).conjugate  #=> (1-2i)
  #
  def conjugate: () -> Complex

# 
  # Returns the denominator (lcm of both denominator - real and imag).
  #
  # See numerator.
  #
  def denominator: () -> Integer

def div: (Numeric) -> bot

def divmod: (Numeric) -> bot

def dup: () -> self

def eql?: (untyped) -> bool

# 
  # Performs division as each part is a float, never returns a float.
  #
  #     Complex(11, 22).fdiv(3)  #=> (3.6666666666666665+7.333333333333333i)
  #
  def fdiv: (Numeric) -> Complex

# 
  # Returns `true` if `cmp`'s real and imaginary parts are both finite numbers,
  # otherwise returns `false`.
  #
  def finite?: () -> bool

def floor: (?Integer) -> bot

# 
  #
  def hash: () -> Integer

def i: () -> bot

# 
  # Returns the imaginary part.
  #
  #     Complex(7).imaginary      #=> 0
  #     Complex(9, -4).imaginary  #=> -4
  #
  def imag: () -> Numeric

# 
  # Returns the imaginary part.
  #
  #     Complex(7).imaginary      #=> 0
  #     Complex(9, -4).imaginary  #=> -4
  #
  def imaginary: () -> Numeric

# 
  # Returns `1` if `cmp`'s real or imaginary part is an infinite number, otherwise
  # returns `nil`.
  #
  #     For example:
  #
  #        (1+1i).infinite?                   #=> nil
  #        (Float::INFINITY + 1i).infinite?   #=> 1
  #
  def infinite?: () -> Integer?

# 
  # Returns the value as a string for inspection.
  #
  #     Complex(2).inspect                       #=> "(2+0i)"
  #     Complex('-8/6').inspect                  #=> "((-4/3)+0i)"
  #     Complex('1/2i').inspect                  #=> "(0+(1/2)*i)"
  #     Complex(0, Float::INFINITY).inspect      #=> "(0+Infinity*i)"
  #     Complex(Float::NAN, Float::NAN).inspect  #=> "(NaN+NaN*i)"
  #
  def inspect: () -> String

def integer?: () -> bool

# 
  # Returns the absolute part of its polar form.
  #
  #     Complex(-1).abs         #=> 1
  #     Complex(3.0, -4.0).abs  #=> 5.0
  #
  alias magnitude abs

def modulo: (Numeric) -> bot

def negative?: () -> bot

def nonzero?: () -> self?

# 
  # Returns the numerator.
  #
  #         1   2       3+4i  <-  numerator
  #         - + -i  ->  ----
  #         2   3        6    <-  denominator
  #
  #     c = Complex('1/2+2/3i')  #=> ((1/2)+(2/3)*i)
  #     n = c.numerator          #=> (3+4i)
  #     d = c.denominator        #=> 6
  #     n / d                    #=> ((1/2)+(2/3)*i)
  #     Complex(Rational(n.real, d), Rational(n.imag, d))
  #                              #=> ((1/2)+(2/3)*i)
  #
  # See denominator.
  #
  def numerator: () -> Complex

# 
  # Returns the angle part of its polar form.
  #
  #     Complex.polar(3, Math::PI/2).arg  #=> 1.5707963267948966
  #
  alias phase angle

# 
  # Returns an array; [cmp.abs, cmp.arg].
  #
  #     Complex(1, 2).polar  #=> [2.23606797749979, 1.1071487177940904]
  #
  def polar: () -> [ Numeric, Float ]

def positive?: () -> bot

# 
  # Returns the value as a rational if possible (the imaginary part should be
  # exactly zero).
  #
  #     Complex(1.0/3, 0).rationalize  #=> (1/3)
  #     Complex(1, 0.0).rationalize    # RangeError
  #     Complex(1, 2).rationalize      # RangeError
  #
  # See to_r.
  #
  def rationalize: (?Numeric eps) -> Rational

# 
  # Returns the real part.
  #
  #     Complex(7).real      #=> 7
  #     Complex(9, -4).real  #=> 9
  #
  def real: () -> Numeric

# 
  # Returns false, even if the complex number has no imaginary part.
  #
  def real?: () -> false

# 
  # Returns a new Complex object formed from the arguments, each of which must be
  # an instance of Numeric, or an instance of one of its subclasses: Complex,
  # Float, Integer, Rational; see [Rectangular
  # Coordinates](rdoc-ref:Complex@Rectangular+Coordinates):
  #
  #     Complex.rect(3)             # => (3+0i)
  #     Complex.rect(3, Math::PI)   # => (3+3.141592653589793i)
  #     Complex.rect(-3, -Math::PI) # => (-3-3.141592653589793i)
  #
  # Complex.rectangular is an alias for Complex.rect.
  #
  def rect: () -> [ Numeric, Numeric ]

# 
  # Returns an array; [cmp.real, cmp.imag].
  #
  #     Complex(1, 2).rectangular  #=> [1, 2]
  #
  alias rectangular rect

def reminder: (Numeric) -> bot

def round: (*untyped) -> bot

def step: (*untyped) ?{ (*untyped) -> untyped } -> bot

# 
  # Returns self.
  #
  #     Complex(2).to_c      #=> (2+0i)
  #     Complex(-8, 6).to_c  #=> (-8+6i)
  #
  def to_c: () -> Complex

# 
  # Returns the value as a float if possible (the imaginary part should be exactly
  # zero).
  #
  #     Complex(1, 0).to_f    #=> 1.0
  #     Complex(1, 0.0).to_f  # RangeError
  #     Complex(1, 2).to_f    # RangeError
  #
  def to_f: () -> Float

# 
  # Returns the value as an integer if possible (the imaginary part should be
  # exactly zero).
  #
  #     Complex(1, 0).to_i    #=> 1
  #     Complex(1, 0.0).to_i  # RangeError
  #     Complex(1, 2).to_i    # RangeError
  #
  def to_i: () -> Integer

alias to_int to_i

# 
  # Returns the value as a rational if possible (the imaginary part should be
  # exactly zero).
  #
  #     Complex(1, 0).to_r    #=> (1/1)
  #     Complex(1, 0.0).to_r  # RangeError
  #     Complex(1, 2).to_r    # RangeError
  #
  # See rationalize.
  #
  def to_r: () -> Rational

# 
  # Returns the value as a string.
  #
  #     Complex(2).to_s                       #=> "2+0i"
  #     Complex('-8/6').to_s                  #=> "-4/3+0i"
  #     Complex('1/2i').to_s                  #=> "0+1/2i"
  #     Complex(0, Float::INFINITY).to_s      #=> "0+Infinity*i"
  #     Complex(Float::NAN, Float::NAN).to_s  #=> "NaN+NaN*i"
  #
  def to_s: () -> String

def truncate: (?Integer) -> bot

def zero?: () -> bool
end

# 
# Equivalent to `Complex(0, 1)`:
#
#     Complex::I # => (0+1i)
#
Complex::I: Complex