rdl 1.1.0 → 1.1.1.rc1

data/test/test_types.rb

@@ -165,6 +165,7 @@ class TestTypes < Minitest::Test
     toptionalA = OptionalType.new tA
     tvarargA = VarargType.new tA
     tannotatedA = AnnotatedArgType.new("arg", tA)
+    tdependentA = DependentArgType.new("arg", tA, "{{ arg > 10 }}")
     tunionAB = UnionType.new(tA, tB)
     tinterAB = IntersectionType.new(tA, tB)
     tsyma = SingletonType.new(:a)
@@ -200,6 +201,7 @@ class TestTypes < Minitest::Test
     assert_equal toptionalA, toptionalA.instantiate(inst)
     assert_equal tvarargA, tvarargA.instantiate(inst)
     assert_equal tannotatedA, tannotatedA.instantiate(inst)
+    assert_equal tdependentA, tdependentA.instantiate(inst)
     assert_equal tunionAB, tunionAB.instantiate(inst)
     assert_equal tinterAB, tinterAB.instantiate(inst)
     assert_equal tsyma, tsyma.instantiate(inst)

data/types/ruby-2.x/_aliases.rb

@@ -1,4 +1,4 @@
-type_alias '%real', 'Integer or Float or Rational'
+type_alias '%real', 'Integer or Float or Rational or BigDecimal'
 type_alias '%string', '[to_str: () -> String]'
 type_alias '%path', '%string or Pathname'
-type_alias '%open_args', '{external_encoding: ?String, internal_encoding: ?String, encoding: ?String, textmode: ?%any, binmode: ?%any, autoclose: ?%any, mode: ?String}'
+type_alias '%open_args', '{external_encoding: ?String, internal_encoding: ?String, encoding: ?String, textmode: ?%any, binmode: ?%any, autoclose: ?%any, mode: ?String}'

data/types/ruby-2.x/bigdecimal.rb

@@ -1,15 +1,249 @@
-class BigDecimal
+class BigDecimal < Numeric
   rdl_nowrap
 
-  #type 'self._load', '()'
-  type 'self.double_fig', '() -> Fixnum'
-  type 'self.limit', '(Fixnum) -> Fixnum'
-  type 'self.mode', '(Fixnum mode, ?(%bool or Symbol) value) -> Fixnum'
-  #type 'self.new', '(Integer or Float or Rational or BigDecimal or String, Fixnum) -> BigDecimal'
-  type 'self.save_exception_mode', '() { (*%any) -> %any } -> %any'
-  type 'self.save_limit', '() { (*%any) -> %any } -> %any'
-  type 'self.save_rounding_mode', '() { (*%any) -> %any } -> %any'
-  type 'self.ver', '() -> String'
-
-  # TODO
+  type :%, '(Numeric) -> BigDecimal'
+  pre(:%) { |x| x!=0&&(if x.is_a?(Float) then x!=Float::INFINITY && !x.nan? else true end)}
+
+  type :+, '(Integer) -> BigDecimal'
+  type :+, '(Float) -> BigDecimal'
+  pre(:+) { |x| x!=Float::INFINITY && !(x.nan?)}
+  type :+, '(Rational) -> BigDecimal'
+  type :+, '(BigDecimal) -> BigDecimal'
+  type :+, '(Complex) -> Complex'
+  pre(:+) { |x| if x.real.is_a?(Float) then x.real!=Float::INFINITY && !(x.real.nan?) else true end}
+
+  type :-, '(Integer) -> BigDecimal'
+  type :-, '(Float) -> BigDecimal'
+  pre(:-) { |x| x!=Float::INFINITY && !(x.nan?)}
+  type :-, '(Rational) -> BigDecimal'
+  type :-, '(BigDecimal) -> BigDecimal'
+  type :-, '(Complex) -> Complex'
+  pre(:-) { |x| if x.real.is_a?(Float) then x.real!=Float::INFINITY && !(x.real.nan?) else true end}
+
+  type :-, '() -> BigDecimal'
+
+  type :*, '(Integer) -> BigDecimal'
+  type :*, '(Float) -> BigDecimal'
+  pre(:*) { |x| x!=Float::INFINITY && !(x.nan?)}
+  type :*, '(Rational) -> BigDecimal'
+  type :*, '(BigDecimal) -> BigDecimal'
+  type :*, '(Complex) -> Complex'
+  pre(:*) { |x| if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end}
+
+  type :**, '(Integer) -> BigDecimal'
+  type :**, '(Float) -> BigDecimal'
+  pre(:**) { |x| x!=Float::INFINITY && !x.nan? && if(self<0) then x<=-1||x>=0 else true end}
+  type :**, '(Rational) -> BigDecimal'
+  pre(:**) { |x| if(self<0) then x<=-1||x>=0 else true end}
+  type :**, '(BigDecimal) -> BigDecimal'
+  pre(:**) { |x| x!=BigDecimal::INFINITY && if(self<0) then x<=-1||x>=0 else true end}
+
+  type :/, '(Integer) -> BigDecimal'
+  pre(:/) { |x| x!=0}
+  type :/, '(Float) -> BigDecimal'
+  pre(:/) { |x| x!=0 && x!=Float::INFINITY && !(x.nan?)}
+  type :/, '(Rational) -> BigDecimal'
+  pre(:/) { |x| x!=0}
+  type :/, '(BigDecimal) -> BigDecimal'
+  pre(:/) { |x| x!=0}
+  type :/, '(Complex) -> Complex'
+  pre(:/) { |x| x!=0 && if x.real.is_a?(Float) then x.real!=Float::INFINITY && !(x.real.nan?) else true end && if x.imaginary.is_a?(Float) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end && if (x.real.is_a?(Rational)) then !x.imaginary.nan? else true end}
+
+  type :<, '(Integer) -> %bool'
+  type :<, '(Float) -> %bool'
+  pre(:<) { |x| !x.nan? && x!=Float::INFINITY}
+  type :<, '(Rational) -> %bool'
+  type :<, '(BigDecimal) -> %bool'
+
+  type :<=, '(Integer) -> %bool'
+  type :<=, '(Float) -> %bool'
+  pre(:<=) { |x| !x.nan? && x!=Float::INFINITY}
+  type :<=, '(Rational) -> %bool'
+  type :<=, '(BigDecimal) -> %bool'
+
+  type :>, '(Integer) -> %bool'
+  type :>, '(Float) -> %bool'
+  pre(:>) { |x| !x.nan? && x!=Float::INFINITY}
+  type :>, '(Rational) -> %bool'
+  type :>, '(BigDecimal) -> %bool'
+
+  type :>=, '(Integer) -> %bool'
+  type :>=, '(Float) -> %bool'
+  pre(:>=) { |x| !x.nan? && x!=Float::INFINITY}
+  type :>=, '(Rational) -> %bool'
+  type :>=, '(BigDecimal) -> %bool'
+
+  type :==, '(Object) -> %bool'
+  pre(:==) { |x| if (x.is_a?(Float)) then (!x.nan? && x!=Float::INFINITY) else true end}
+
+  type :===, '(Object) -> %bool'
+  pre(:===) { |x| if (x.is_a?(Float)) then (!x.nan? && x!=Float::INFINITY) else true end}
+
+  type :<=>, '(Integer) -> Object'
+  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+  type :<=>, '(Float) -> Object'
+  pre(:<=>) { |x| !x.nan? && x!=Float::INFINITY}
+  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+  type :<=>, '(Rational) -> Object'
+  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+  type :<=>, '(BigDecimal) -> Object'
+  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+
+  type :abs, '() -> BigDecimal'
+  post(:abs) { |r,x| r >= 0 }
+
+  type :abs2, '() -> BigDecimal'
+  post(:abs2) { |r,x| r >= 0 }
+
+  type :angle, '() -> Numeric'
+  post(:angle) { |r,x| r == 0 || r == Math::PI}
+
+  type :arg, '() -> Numeric'
+  post(:arg) { |r,x| r == 0 || r == Math::PI}
+
+  type :ceil, '() -> Integer'
+  pre(:ceil) { !self.ininite? && !self.nan?}
+
+  type :conj, '() -> BigDecimal'
+  type :conjugate, '() -> BigDecimal'
+
+  type :denominator, '() -> Integer'
+  pre(:denominator) { !self.ininite? && !self.nan?}
+  post(:denominator) { |r,x| r>0}
+
+  type :div, '(Fixnum) -> Integer'
+  pre(:div) { |x| x!=0 && !self.infinite? && !self.nan?}
+  type :div, '(Bignum) -> Integer'
+  pre(:div) { |x| x!=0 && !self.infinite? && !self.nan?}
+  type :div, '(Float) -> Integer'
+  pre(:div) { |x| x!=0 && !x.nan? && x!=Float::INFINITY && !self.infinite? && !self.nan?}
+  type :div, '(Rational) -> Integer'
+  pre(:div) { |x| x!=0 && !self.infinite? && !self.nan?}
+  type :div, '(BigDecimal) -> Integer'
+  pre(:div) { |x| x!=0 && !x.nan? && !self.infinite? && !self.nan?}
+
+  type :divmod, '(%real) -> [%real, %real]'
+  pre(:divmod) { |x| x!=0 && if x.is_a?(Float) then !x.nan? && x!=Float::INFINITY else true end}
+
+  type :equal?, '(Object) -> %bool'
+  type :eql?, '(Object) -> %bool'
+
+  type :fdiv, '(Integer) -> Float'
+  type :fdiv, '(Float) -> Float'
+  type :fdiv, '(Rational) -> Float'
+  type :fdiv, '(BigDecimal) -> BigDecimal'
+  type :fdiv, '(Complex) -> Complex'
+  pre(:fdiv) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
+
+  type :finite?, '() -> %bool'
+
+  type :floor, '() -> Integer'
+  pre(:floor) { !self.infinite? && !self.nan?}
+
+  type :hash, '() -> Integer'
+
+  type :imag, '() -> Fixnum'
+  post(:imag) { |r,x| r == 0 }
+  type :imaginary, '() -> Fixnum'
+  post(:imaginary) { |r,x| r == 0 }
+
+  type :infinite?, '() -> %bool'
+
+  type :to_s, '() -> String'
+  type :inspect, '() -> String'
+
+  type :magnitude, '() -> BigDecimal'
+  post(:magnitude) { |r,x| r>0}
+
+  type :modulo, '(Numeric) -> BigDecimal'
+  pre(:modulo) { |x| x!=0&&(if x.is_a?(Float) then x!=Float::INFINITY && !x.nan? else true end)}
+
+  type :nan?, '() -> %bool'
+
+  type :numerator, '() -> Integer'
+  pre(:numerator) { !self.infinite? && !self.nan?}
+
+  type :phase, '() -> Numeric'
+
+  type :quo, '(Integer) -> BigDecimal'
+  pre(:quo) { |x| x!=0}
+  type :quo, '(Float) -> BigDecimal'
+  pre(:quo) { |x| x!=0 && x!=Float::INFINITY && !x.nan?}
+  type :quo, '(Rational) -> BigDecimal'
+  pre(:quo) { |x| x!=0}
+  type :quo, '(BigDecimal) -> BigDecimal'
+  pre(:quo) { |x| x!=0}
+  type :quo, '(Complex) -> Complex'
+  pre(:quo) { |x| x!=0 && if x.real.is_a?(Float) then x.real!=Float::INFINITY && !(x.real.nan?) else true end && if x.imaginary.is_a?(Float) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end && if (x.real.is_a?(Rational)) then !x.imaginary.nan? else true end}
+
+  type :real, '() -> BigDecimal'
+
+  type :real?, '() -> TrueClass'
+
+  type :round, '() -> Integer' 
+  pre(:round) { !self.infinite? && !self.nan?}
+
+  type :round, '(Fixnum) -> BigDecimal' #Also, x must be in range [-2**31, 2**31].
+
+  type :to_f, '() -> Float'
+  pre(:to_f) { self<=Float::MAX}
+
+  type :to_i, '() -> Integer' 
+  pre(:to_i) { !self.infinite? && !self.nan?}
+  type :to_int, '() -> Integer'
+  pre(:to_int) { !self.infinite? && !self.nan?}
+
+  type :to_r, '() -> Rational'
+  pre(:to_r) { !self.infinite? && !self.nan?}
+
+  type :to_c, '() -> Complex'
+  post(:to_c) { |r,x| r.imaginary == 0 }
+
+  type :truncate, '() -> Integer'
+
+  type :truncate, '(Fixnum) -> Rational' #Also, x must be in range [-2**31, 2**31].
+
+  type :zero?, '() -> %bool'
+
+  type :precs, '() -> [Integer, Integer]'
+
+  type :split, '() -> [Fixnum, String, Integer, Integer]'
+
+  type :remainder, '(%real) -> BigDecimal'
+  pre(:remainder) { |x| if x.is_a?(Float) then !x.infinite? && !x.nan? else true end}
+
+  type :fix, '() -> BigDecimal'
+
+  type :frac, '() -> BigDecimal'
+
+  type :power, '(Integer) -> BigDecimal'
+  type :power, '(Float) -> BigDecimal'
+  pre(:power) { |x| x!=Float::INFINITY && !x.nan? && if(self<0) then x<=-1||x>=0 else true end}
+  type :power, '(Rational) -> BigDecimal'
+  pre(:power) { |x| if(self<0) then x<=-1||x>=0 else true end}
+  type :power, '(BigDecimal) -> BigDecimal'
+  pre(:power) { |x| x!=BigDecimal::INFINITY && if(self<0) then x<=-1||x>=0 else true end}
+
+  type :nonzero?, '() -> Object'
+
+  type :exponent, '() -> Integer'
+
+  type :sign, '() -> Fixnum'
+
+  type :_dump, '() -> String'
+
+  type :sqrt, '(Fixnum) -> BigDecimal'
+  pre(:sqrt) { self>=0}
+
+  type :add, '(%real, Fixnum) -> BigDecimal'
+  pre(:add) { |x,y| if x.is_a?(Float) then !x.infinite? && !x.nan? else true end}
+  
+  type :sub, '(%real, Fixnum) -> BigDecimal'
+  pre(:sub) { |x,y| if x.is_a?(Float) then !x.infinite? && !x.nan? else true end}
+
+  type :mult, '(%real, Fixnum) -> BigDecimal'
+  pre(:mult) { |x,y| if x.is_a?(Float) then !x.infinite? && !x.nan? else true end}
+  
+  type :coerce, '(%real) -> [BigDecimal, BigDecimal]'
+  pre(:coerce) { |x| if x.is_a?(Float) then !x.nan? && !x.finite? else true end}
 end

data/types/ruby-2.x/bignum.rb

@@ -0,0 +1,253 @@
+class Bignum < Integer
+  rdl_nowrap
+
+  type :%, '(Fixnum) -> Fixnum'
+  pre(:%) { |x| x!=0}
+  type :%, '(Bignum) -> Integer'
+  pre(:%) { |x| x!=0}
+  type :%, '(Float) -> Float'
+  pre(:%) { |x| x!=0}
+  type :%, '(Rational) -> Rational'
+  pre(:%) { |x| x!=0}
+  type :%, '(BigDecimal) -> BigDecimal'
+  pre(:%) { |x| x!=0}
+
+  type :&, '(Integer) -> Fixnum'
+
+  type :*, '(Fixnum) -> Integer'
+  type :*, '(Bignum) -> Bignum'
+  type :*, '(Float) -> Float'
+  type :*, '(Rational) -> Rational'
+  type :*, '(BigDecimal) -> BigDecimal'
+  type :*, '(Complex) -> Complex'
+  pre(:*) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end} #can't have a complex with part BigDecimal, other part infinity/NAN
+
+  type :**, '(Integer) -> Numeric'
+  type :**, '(Float) -> Numeric'
+  type :**, '(Rational) -> Numeric'
+  type :**, '(BigDecimal) -> BigDecimal'
+  pre(:**) { |x| x!=BigDecimal::INFINITY && if self<0 then x<=-1||x>=0 else true end}
+  post(:**) { |r,x| r.real?}
+  type :**, '(Complex) -> Complex'
+  pre(:**) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end}
+
+  type :+, '(Integer) -> Integer'
+  type :+, '(Float) -> Float'
+  type :+, '(Rational) -> Rational'
+  type :+, '(BigDecimal) -> BigDecimal'
+  type :+, '(Complex) -> Complex'
+
+  type :-, '(Integer) -> Integer'
+  type :-, '(Float) -> Float'
+  type :-, '(Rational) -> Rational'
+  type :-, '(BigDecimal) -> BigDecimal'
+  type :-, '(Complex) -> Complex'
+
+  type :-, '() -> Integer'
+
+  type :/, '(Integer) -> Integer'
+  pre(:/) { |x| x!=0}
+  type :/, '(Float) -> Float'
+  pre(:/) { |x| x!=0}
+  type :/, '(Rational) -> Rational'
+  pre(:/) { |x| x!=0}
+  type :/, '(BigDecimal) -> BigDecimal'
+  pre(:/) { |x| x!=0}
+  type :/, '(Complex) -> Complex'
+  pre(:/) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
+
+  type :<, '(Integer) -> %bool'
+  type :<, '(Float) -> %bool'
+  type :<, '(Rational) -> %bool'
+  type :<, '(BigDecimal) -> %bool'
+
+  type :<<, '(Fixnum) -> Integer'
+
+  type :<=, '(Integer) -> %bool'
+  type :<=, '(Float) -> %bool'
+  type :<=, '(Rational) -> %bool'
+  type :<=, '(BigDecimal) -> %bool'
+
+  type :<=>, '(Integer) -> Object'
+  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+  type :<=>, '(Float) -> Object'
+  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+  type :<=>, '(Rational) -> Object'
+  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+  type :<=>, '(BigDecimal) -> Object'
+  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+
+  type :==, '(Object) -> %bool'
+
+  type :===, '(Object) -> %bool'
+
+  type :>, '(Integer) -> %bool'
+  type :>, '(Float) -> %bool'
+  type :>, '(Rational) -> %bool'
+  type :>, '(BigDecimal) -> %bool'
+
+  type :>=, '(Integer) -> %bool'
+  type :>=, '(Float) -> %bool'
+  type :>=, '(Rational) -> %bool'
+  type :>=, '(BigDecimal) -> %bool'
+
+  type :>>, '(Integer) -> Integer'
+  post(:>>) { |r,x| r >= 0 }
+
+  type :[], '(Integer) -> Fixnum'
+  post(:[]) { |r,x| r == 0 || r==1}
+  type :[], '(Rational) -> Fixnum'
+  post(:[]) { |r,x| r == 0 || r==1}
+  type :[], '(Float) -> Fixnum'
+  pre(:[]) { |x| x!=Float::INFINITY && !x.nan? }
+  post(:[]) { |r,x| r == 0 || r==1}
+  type :[], '(BigDecimal) -> Fixnum'
+  pre(:[]) { |x| x!=BigDecimal::INFINITY && !x.nan? }
+  post(:[]) { |r,x| r == 0 || r==1}
+
+  type :^, '(Integer) -> Integer'
+
+  type :|, '(Integer) -> Integer'
+
+  type :~, '() -> Bignum'
+
+  type :abs, '() -> Bignum'
+  post(:abs) { |r,x| r >= 0 }
+
+  type :bit_length, '() -> Integer'
+  post(:bit_length) { |r,x| r >= 0 }
+
+  type :div, '(Fixnum) -> Integer'
+  pre(:div) { |x| x!=0}
+  type :div, '(Bignum) -> Integer'
+  pre(:div) { |x| x!=0}
+  type :div, '(Float) -> Integer'
+  pre(:div) { |x| x!=0 && !x.nan?}
+  type :div, '(Rational) -> Integer'
+  pre(:div) { |x| x!=0}
+  type :div, '(BigDecimal) -> Integer'
+  pre(:div) { |x| x!=0 && !x.nan?}
+
+  type :divmod, '(%real) -> [%real, %real]'
+  pre(:divmod) { |x| x!=0 && if x.is_a?(Float) then !x.nan? else true end}
+
+  type :even?, '() -> %bool'
+
+  type :fdiv, '(Integer) -> Float'
+  type :fdiv, '(Float) -> Float'
+  type :fdiv, '(Rational) -> Float'
+  type :fdiv, '(BigDecimal) -> BigDecimal'
+  type :fdiv, '(Complex) -> Complex'
+  pre(:fdiv) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
+
+  type :to_s, '() -> String'
+  type :inspect, '() -> String'
+
+  type :magnitude, '() -> Bignum'
+  post(:magnitude) { |r,x| r >= 0 }
+
+  type :modulo, '(Fixnum) -> Fixnum'
+  pre(:modulo) { |x| x!=0}
+  type :modulo, '(Bignum) -> Integer'
+  pre(:modulo) { |x| x!=0}
+  type :modulo, '(Float) -> Float'
+  pre(:modulo) { |x| x!=0}
+  type :modulo, '(Rational) -> Rational'
+  pre(:modulo) { |x| x!=0}
+  type :modulo, '(BigDecimal) -> BigDecimal'
+  pre(:modulo) { |x| x!=0}
+
+  type :next, '() -> Integer'
+
+  type :odd?, '() -> %bool'
+
+  type :size, '() -> Integer'
+
+  type :succ, '() -> Integer'
+
+  type :to_f, '() -> Float'
+
+  type :zero?, '() -> %bool'
+
+  type :ceil, '() -> Integer'
+
+  type :denominator, '() -> Fixnum'
+  post(:denominator) { |r,x| r == 1 }
+
+  type :floor, '() -> Integer'
+
+  type :numerator, '() -> Bignum'
+
+  type :quo, '(Integer) -> Rational'
+  pre(:quo) { |x| x!=0}
+  type :quo, '(Float) -> Float'
+  pre(:quo) { |x| x!=0}
+  type :quo, '(Rational) -> Rational'
+  pre(:quo) { |x| x!=0}
+  type :quo, '(BigDecimal) -> BigDecimal'
+  pre(:quo) { |x| x!=0}
+  type :quo, '(Complex) -> Complex'
+  pre(:quo) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
+
+  type :rationalize, '() -> Rational' 
+
+  type :rationalize, '(Numeric) -> Rational'
+
+  type :round, '() -> Integer'
+
+  type :round, '(Numeric) -> Numeric'
+  pre(:round) { |x| x!=0 && if x.is_a?(Complex) then x.imaginary==0 && (if x.real.is_a?(Float)||x.real.is_a?(BigDecimal) then !x.real.infinite? && !x.real.nan? else true end) elsif x.is_a?(Float) then x!=Float::INFINITY && !x.nan? elsif x.is_a?(BigDecimal) then x!=BigDecimal::INFINITY && !x.nan? else true end} #Also, x must be in range [-2**31, 2**31].
+
+  type :to_i, '() -> Bignum'
+
+  type :to_r, '() -> Rational'
+
+  type :truncate, '() -> Integer'
+
+  type :angle, '() -> Numeric'
+  post(:angle) { |r,x| r == 0 || r == Math::PI}
+
+  type :arg, '() -> Numeric'
+  post(:arg) { |r,x| r == 0 || r == Math::PI}
+
+  type :equal?, '(Object) -> %bool' 
+  type :eql?, '(Object) -> %bool'
+
+  type :hash, '() -> Integer'
+
+  type :phase, '() -> Numeric'
+
+  type :abs2, '() -> Bignum'
+  post(:abs2) { |r,x| r >= 0 }
+
+  type :conj, '() -> Bignum'
+  type :conjugate, '() -> Bignum'
+
+  type :imag, '() -> Fixnum'
+  post(:imag) { |r,x| r == 0 }
+  type :imaginary, '() -> Fixnum'
+  post(:imaginary) { |r,x| r == 0 }
+
+  type :real, '() -> Bignum'
+
+  type :real?, '() -> TrueClass'
+
+  type :to_c, '() -> Complex'
+  post(:to_c) { |r,x| r.imaginary == 0 }
+
+  type :remainder, '(Fixnum) -> Fixnum'
+  pre(:remainder) { |x| x!=0}
+  post(:remainder) { |r,x| r>0}
+  type :remainder, '(Bignum) -> Fixnum'
+  pre(:remainder) { |x| x!=0}
+  post(:remainder) { |r,x| r>0}
+  type :remainder, '(Float) -> Float'
+  pre(:remainder) { |x| x!=0}
+  type :remainder, '(Rational) -> Rational'
+  pre(:remainder) { |x| x!=0}
+  post(:remainder) { |r,x| r>0}
+  type :remainder, '(BigDecimal) -> BigDecimal'
+  pre(:remainder) { |x| x!=0}
+
+  type :coerce, '(Integer) -> [Integer, Integer]'
+end