rdl 1.1.0 → 1.1.1.rc1

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

@@ -1,42 +1,131 @@
-class Complex
+class Complex < Numeric
   rdl_nowrap
 
-  type 'self.polar', '(%real abs, ?%real arg) -> Complex'
-  type 'self.rect', '(%real real, ?%real imag) -> Complex'
-  pre('self.rect') { |r, i| (not i) || (i.real?) }
-  rdl_alias 'self.rectangular', 'self.rect'
-  type :*, '(Numeric) -> Complex'
-  type :**, '(Numeric) -> Complex'
-  type :+, '(Numeric) -> Complex'
-  type :-, '(Numeric) -> Complex'
+  type :*, '(Integer) -> Complex' 
+  type :*, '(Float) -> Complex'
+  pre(:*) { |x| if x.infinite?||x.nan? then !self.imaginary.is_a?(BigDecimal)&&!self.real.is_a?(BigDecimal) else true end}
+  type :*, '(Rational) -> Complex'
+  type :*, '(BigDecimal) -> Complex'
+  pre(:*) {if x.real.is_a?(Float) then !x.real.infinite? && !x.real.nan? elsif x.imaginary.is_a?(Float) then !x.imaginary.infinite? && !x.imaginary.nan? else true end}
+  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}
+
+  type :**, '(Integer) -> Complex'
+  type :**, '(Float) -> Complex'
+  type :**, '(Rational) -> Complex'
+  type :**, '(BigDecimal) -> Complex'
+  pre(:**) { |x| x!=BigDecimal::INFINITY && !x.nan? && 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}
+
+  type :+, '(Integer) -> Complex' 
+  type :+, '(Float) -> Complex'
+  pre(:+) { |x| if x.infinite?||x.nan? then !self.real.is_a?(BigDecimal) else true end}
+  type :+, '(Rational) -> Complex'
+  type :+, '(BigDecimal) -> Complex'
+  pre(:+) {if x.real.is_a?(Float) then !x.real.infinite? && !x.real.nan? else true end}
+  type :+, '(Complex) -> Complex'
+  pre(:+) { |x| if (x.real.is_a?(BigDecimal) && self.real.is_a?(Float)) then !(self.real.infinite?||self.real.nan?) elsif x.real.is_a?(Float)&&self.real.is_a?(BigDecimal) then !(x.real.infinite?||x.real.nan?) elsif (x.imaginary.is_a?(BigDecimal) && self.imaginary.is_a?(Float)) then !(self.imaginary.infinite?||self.imaginary.nan?) elsif x.imaginary.is_a?(Float)&&self.imaginary.is_a?(BigDecimal) then !(x.imaginary.infinite?||x.imaginary.nan?) else true end}
+  
+  type :-, '(Integer) -> Complex' 
+  type :-, '(Float) -> Complex'
+  pre(:-) { |x| if x.infinite?||x.nan? then !self.real.is_a?(BigDecimal) else true end}
+  type :-, '(Rational) -> Complex'
+  type :-, '(BigDecimal) -> Complex'
+  pre(:-) {if x.real.is_a?(Float) then !x.real.infinite? && !x.real.nan? else true end}
+  type :-, '(Complex) -> Complex'
+  pre(:-) { |x| if (x.real.is_a?(BigDecimal) && self.real.is_a?(Float)) then !(self.real.infinite?||self.real.nan?) elsif x.real.is_a?(Float)&&self.real.is_a?(BigDecimal) then !(x.real.infinite?||x.real.nan?) elsif (x.imaginary.is_a?(BigDecimal) && self.imaginary.is_a?(Float)) then !(self.imaginary.infinite?||self.imaginary.nan?) elsif x.imaginary.is_a?(Float)&&self.imaginary.is_a?(BigDecimal) then !(x.imaginary.infinite?||x.imaginary.nan?) else true end}
+
   type :-, '() -> Complex'
-  type :/, '(Numeric) -> Complex'
-  type :==, '(%any object) -> %bool'
-  type :abs, '() -> %real'
-  post(:abs) { |r| r >= 0 }
-  type :abs2, '() -> %real'
-  post(:abs2) { |r| r >= 0 }
+
+  type :/, '(Integer) -> Complex'
+  pre(:/) { |x| x!=0}
+  type :/, '(Float) -> Complex'
+  pre(:/) { |x| x!=0 && if x.infinte?||x.nan? then !self.real.is_a?(BigDecimal) && !self.imaginary.is_a?(BigDecimal) else true end}
+  type :/, '(Rational) -> Complex'
+  pre(:/) { |x| x!=0}
+  type :/, '(BigDecimal) -> Complex'
+  pre(:/) { |x| x!=0 && if self.real.is_a?(Float) then !self.real.infinite? && !self.real.nan? else true end && if self.imaginary.is_a?(Float) then !self.imaginary.infinite? && !self.imaginary.nan? else true end}
+  type :/, '(Complex) -> Complex'
+  pre(:/) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal) || self.real.is_a?(BigDecimal) || self.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) && if self.real.is_a?(Float) then !self.real.infinite? && !self.real.nan? else true end && if self.imaginary.is_a?(Float) then !self.imaginary.infinite? && !self.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:==, '(Object) -> %bool'
+
+  type :abs, '() -> Numeric'
+  post(:abs) { |r,x| r >= 0 }
+
+  type :abs2, '() -> Numeric'
+  post(:abs2) { |r,x| r >= 0 }
+
   type :angle, '() -> Float'
+
   type :arg, '() -> Float'
+
   type :conj, '() -> Complex'
-  rdl_alias :conjugate, :conj
+  type :conjugate, '() -> Complex'
+
   type :denominator, '() -> Integer'
+
+  type :equal?, '(Object) -> %bool'
+  type :eql?, '(Object) -> %bool'
+
   type :fdiv, '(Numeric) -> Complex'
+  pre(:fdiv) { |x| if (self.real.is_a?(Float) && (self.real.infinite? || self.real.nan?))||(self.imaginary.is_a?(Float) && (self.imaginary.infinite? || self.imaginary.nan?)) then !x.is_a?(BigDecimal) && (if x.is_a?(Complex) then !x.real.is_a?(BigDecimal) && !x.imaginary.is_a?(BigDecimal) else true end) else true end}
+
+  type :hash, '() -> Integer'
+  
   type :imag, '() -> %real'
-  rdl_alias :imaginary, :imag
+  type :imaginary, '() -> %real'
+
   type :inspect, '() -> String'
+
   type :magnitude, '() -> %real'
-  type :numerator, '() -> Numeric'
+
+  type :numerator, '() -> Complex'
+
   type :phase, '() -> Float'
-  type :polar, '() -> [%real, %real]'
-  rdl_alias :quo, :/
-  type :rationalize, '(?Numeric eps) -> Rational'
+
+  type :polar, '() -> [%real, %real]' 
+
+
+  type :quo, '(Integer) -> Complex'
+  pre(:quo) { |x| x!=0}
+  type :quo, '(Float) -> Complex'
+  pre(:quo) { |x| x!=0 && if self.real.is_a?(BigDecimal)||self.imaginary.is_a?(BigDecimal) then !x.infinite? && !x.nan? else true end}
+  type :quo, '(Rational) -> Complex'
+  pre(:quo) { |x| x!=0}
+  type :quo, '(BigDecimal) -> BigDecimal'
+  pre(:quo) { |x| x!=0 && if self.real.is_a?(Float) then !self.real.infinite?&&!self.real.nan? else true end && if self.imaginary.is_a?(Float) then !self.imaginary.infinite? && !self.imaginary.nan? else true end}
+  type :quo, '(Complex) -> Complex'
+  pre(:quo) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal) || self.real.is_a?(BigDecimal) || self.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) && if self.real.is_a?(Float) then !self.real.infinite? && !self.real.nan? else true end && if self.imaginary.is_a?(Float) then !self.imaginary.infinite? && !self.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'
+  pre(:rationalize) { self.imaginary==0 && if self.real.is_a?(Float)||self.real.is_a?(BigDecimal) then !self.real.infinite? && !self.real.nan? else true end}
+
+  type :rationalize, '(Numeric) -> Rational'
+  pre(:rationalize) { |x| self.imaginary==0 && if self.real.is_a?(Float)||self.real.is_a?(Rational) then (if x.is_a?(Float)||x.is_a?(BigDecimal) then !x.infinite? && !x.nan? else true end) else true end && if self.real.is_a?(Float)||self.real.is_a?(BigDecimal) then !self.real.infinite? && !self.real.nan? else true end}
+
   type :real, '() -> %real'
+
   type :real?, '() -> FalseClass'
+
   type :rect, '() -> [%real, %real]'
-  type :to_c, '() -> self'
+  type :rectangular, '() -> [%real, %real]'
+
+  type :to_c, '() -> Complex'
+
   type :to_f, '() -> Float'
+  pre(:to_f) { self.imaginary==0}
+
   type :to_i, '() -> Integer'
+  pre(:to_i) { self.imaginary==0 && if self.real.is_a?(Float)||self.real.is_a?(BigDecimal) then !self.real.infinite? && !self.real.nan? else true end}
+
   type :to_r, '() -> Rational'
+  pre(:to_r) { self.imaginary==0 && if self.real.is_a?(Float)||self.real.is_a?(BigDecimal) then !self.real.infinite? && !self.real.nan? else true end}
+
   type :to_s, '() -> String'
+
+  type :zero?, '() -> %bool'
+
+  type :coerce, '(Numeric) -> [Complex, Complex]'
 end

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

@@ -1,45 +1,252 @@
-class Fixnum
+class Fixnum < Integer
   rdl_nowrap
 
-  type :%, '(Numeric other) -> Numeric'
-  post(:%) { |r, _| r.real? }
-  type :&, '(Integer) -> Integer'
-  type :*, '(Numeric) -> Numeric'
-  type :**, '(Numeric) -> Numeric'
-  type :+, '(Numeric) -> Numeric'
-  type :-, '(Numeric) -> Numeric'
-  type :-, '() -> Numeric'
-  type :/, '(Numeric) -> Numeric'
-  type :<, '(Numeric) -> %bool'
-  pre(:<) { |x| x.real? }
-  type :<<, '(Fixnum count) -> Integer'
-  type :<=, '(Numeric) -> %bool'
-  pre(:<=) { |x| x.real? }
-  type :<=>, '(Numeric) -> -1 or 0 or 1 or nil'
-  type :==, '(%any) -> %bool'
-  type :>, '(Numeric) -> %bool'
-  pre(:>) { |x| x.real? }
-  type :>=, '(Numeric) -> %bool'
-  pre(:>=) { |x| x.real? }
-  type :>>, '(Fixnum count) -> Integer'
-  type :[], '(Fixnum) -> 0 or 1'
+  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 :*, '(Integer) -> Integer'
+  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 :-, '() -> Fixnum'
+
+  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' #must be below a certain amount, not exactly sure what amount
+
+  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 :~, '() -> Integer'
+
+  type :~, '() -> Fixnum'
+
   type :abs, '() -> Integer'
+  post(:abs) { |r,x| r >= 0 }
+
   type :bit_length, '() -> Fixnum'
-  type :div, '(Numeric) -> Integer'
-  type :divmod, '(Numeric) -> [Numeric, Numeric]'
+  post(:bit_length) { |r,x| r >= 0 }
+
+  type :div, '(Fixnum) -> Integer'
+  pre(:div) { |x| x!=0}
+  type :div, '(Bignum) -> Fixnum'
+  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, '(Numeric) -> Float'
-  rdl_alias :inspect, :to_s
+
+  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, '() -> Integer'
-  rdl_alias :modulo, :%
+  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, '() -> Fixnum'
-  rdl_alias :succ, :next
+
+  type :succ, '() -> Integer'
+
   type :to_f, '() -> Float'
-  type :to_s, '(?Fixnum base) -> String'
+
   type :zero?, '() -> %bool'
+
+  type :ceil, '() -> Integer'
+
+  type :denominator, '() -> Fixnum'
+  post(:denominator) { |r,x| r == 1 }
+
+  type :floor, '() -> Integer' 
+  type :numerator, '() -> Fixnum'
+
+  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, '() -> Fixnum'
+
+  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, '() -> Integer'
+  post(:abs2) { |r,x| r >= 0 }
+
+  type :conj, '() -> Fixnum'
+  type :conjugate, '() -> Fixnum'
+
+  type :imag, '() -> Fixnum'
+  post(:imag) { |r,x| r == 0 }
+  type :imaginary, '() -> Fixnum'
+  post(:imaginary) { |r,x| r == 0 }
+
+  type :real, '() -> Fixnum'
+
+  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, '(Numeric) -> [%real, %real]'
+  pre(:coerce) { |x| if x.is_a?(Complex) then x.imaginary==0 else true end}
 end

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

@@ -1,54 +1,236 @@
-class Float
+class Float < Numeric
   rdl_nowrap
 
-  type :%, '(Numeric other) -> Numeric'
-  type :*, '(Numeric other) -> Numeric'
-  type :**, '(Numeric other) -> Numeric'
-  type :+, '(Numeric other) -> Numeric'
-  type :-, '(Numeric other) -> Numeric'
+  type :%, '(Integer) -> Float'
+  pre(:%) { |x| x!=0}
+  type :%, '(Float) -> Float'
+  pre(:%) { |x| x!=0}
+  type :%, '(Rational) -> Float'
+  pre(:%) { |x| x!=0}
+  type :%, '(BigDecimal) -> BigDecimal'
+  pre(:%) { |x| x!=0 && self !=Float::INFINITY && !self.nan?}
+
+  type :*, '(Integer) -> Float'
+  type :*, '(Float) -> Float'
+  type :*, '(Rational) -> Float'
+  type :*, '(BigDecimal) -> BigDecimal'
+  pre(:*) { self!=Float::INFINITY && !(self.nan?)}
+  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) && self!=Float::INFINITY && !(self.nan?) else true end} #can't have a complex with part BigDecimal, other part infinity/NAN
+
+  type :**, '(Integer) -> Float'
+  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(:**) { |x| x.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) && self!=Float::INFINITY && !(self.nan?) else true end}
+
+  type :+, '(Integer) -> Float'
+  type :+, '(Float) -> Float'
+  type :+, '(Rational) -> Float'
+  type :+, '(BigDecimal) -> BigDecimal'
+  pre(:+) { self!=Float::INFINITY && !(self.nan?)}
+  type :+, '(Complex) -> Complex'
+  pre(:+) { |x| if x.real.is_a?(BigDecimal) then self!=Float::INFINITY && !(self.nan?) else true end}
+
+  type :-, '(Integer) -> Float'
+  type :-, '(Float) -> Float'
+  type :-, '(Rational) -> Float'
+  type :-, '(BigDecimal) -> BigDecimal'
+  pre(:-) { self!=Float::INFINITY && !(self.nan?)}
+  type :-, '(Complex) -> Complex'
+  pre(:-) { |x| if x.real.is_a?(BigDecimal) then self!=Float::INFINITY && !(self.nan?) else true end}
+
   type :-, '() -> Float'
-  type :/, '(Numeric other) -> Float'
-  type :<, '(Numeric) -> %bool'
-  pre(:<) { |x| x.real? }
-  type :<=, '(Numeric) -> %bool'
-  pre(:<=) { |x| x.real? }
-  type :<=>, '(Numeric) -> -1 or 0 or 1 or nil'
-  pre(:<=>) { |x| x.real? }
-  type :==, '(%any) -> %bool'
-  type :>, '(Numeric) -> %bool'
-  pre(:>) { |x| x.real? }
-  type :>=, '(Numeric) -> %bool'
-  pre(:>=) { |x| x.real? }
+
+  type :/, '(Integer) -> Float'
+  pre(:/) { |x| x!=0}
+  type :/, '(Float) -> Float'
+  pre(:/) { |x| x!=0}
+  type :/, '(Rational) -> Float'
+  pre(:/) { |x| x!=0}
+  type :/, '(BigDecimal) -> BigDecimal'
+  pre(:/) { |x| x!=0 && self!=Float::INFINITY && !self.nan?}
+  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) && self!=Float::INFINITY && !(self.nan?) 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'
+  pre(:<) { !self.nan? && self!=Float::INFINITY}
+
+  type :<=, '(Integer) -> %bool'
+  type :<=, '(Float) -> %bool'
+  type :<=, '(Rational) -> %bool'
+  type :<=, '(BigDecimal) -> %bool'
+  pre(:<=) { !self.nan? && self!=Float::INFINITY}
+
+  type :<=>, '(Integer) -> Object'
+  post(:<=>) { |x| x == -1 || x==0 || x==1}
+  type :<=>, '(Float) -> Object'
+  post(:<=>) { |x| x == -1 || x==0 || x==1}
+  type :<=>, '(Rational) -> Object'
+  post(:<=>) { |x| x == -1 || x==0 || x==1}
+  type :<=>, '(BigDecimal) -> Object'
+  pre(:<=>) { !self.nan? && self!=Float::INFINITY}
+  post(:<=>) { |x| x == -1 || x==0 || x==1}
+
+  type :==, '(Object) -> %bool'
+  pre(:==) { |x| if (x.is_a?(BigDecimal)) then (!self.nan? && self!=Float::INFINITY) else true end}
+
+  type :===, '(Object) -> %bool'
+  pre(:===) { |x| if (x.is_a?(BigDecimal)) then (!self.nan? && self!=Float::INFINITY) else true end}
+
+  type :>, '(Integer) -> %bool'
+  type :>, '(Float) -> %bool'
+  type :>, '(Rational) -> %bool'
+  type :>, '(BigDecimal) -> %bool'
+  pre(:>) { !self.nan? && self!=Float::INFINITY}
+
+  type :>=, '(Integer) -> %bool'
+  type :>=, '(Float) -> %bool'
+  type :>=, '(Rational) -> %bool'
+  type :>=, '(BigDecimal) -> %bool'
+  pre(:>=) { !self.nan? && self!=Float::INFINITY}
+
   type :abs, '() -> Float'
-  type :angle, '() -> 0 or ${Math::PI}'
-  type :arg, '() -> 0 or ${Math::PI}'
+  post(:abs) { |x| x >= 0 }
+
+  type :abs2, '() -> Float'
+  post(:abs2) { |x| x >= 0 }
+
+  type :div, '(Fixnum) -> Integer'
+  pre(:div) { |x| x!=0 && self!=Float::INFINITY && !self.nan?}
+  type :div, '(Bignum) -> Integer'
+  pre(:div) { |x| x!=0 && self!=Float::INFINITY && !self.nan?}
+  type :div, '(Float) -> Integer'
+  pre(:div) { |x| x!=0 && self!=Float::INFINITY && !self.nan?}
+  type :div, '(Rational) -> Integer'
+  pre(:div) { |x| x!=0 && self!=Float::INFINITY && !self.nan?}
+  type :div, '(BigDecimal) -> Integer'
+  pre(:div) { |x| x!=0 && !x.nan? && self!=Float::INFINITY && !self.nan?}
+
+  type :divmod, '(%real) -> [%real, %real]'
+  pre(:divmod) { |x| x!=0 && if x.is_a?(Float) then !x.nan? else true end && self!=Float::INFINITY && !self.nan?}
+
+  type :angle, '() -> Numeric'
+  post(:angle) { |r,x| r == 0 || r == Math::PI || r == Float::NAN}
+
+  type :arg, '() -> Numeric'
+  post(:arg) { |r,x| r == 0 || r == Math::PI || r == Float::NAN}
+
   type :ceil, '() -> Integer'
-  type :coerce, '(Numeric) -> [Float, Float]'
+  pre(:ceil) { self!=Float::INFINITY && !self.nan?}
+
+  type :coerce, '(%real) -> [Float, Float]'
+
   type :denominator, '() -> Integer'
-  post(:denominator) { |r, _| r > 0 }
-  type :divmod, '(Numeric) -> [Numeric, Numeric]'
-  type :equl?, '(%any) -> %bool'
-  type :fdiv, '(Numeric) -> Float'
+  post(:denominator) { |r,x| r > 0 }
+
+  type :equal?, '(Object) -> %bool'
+
+  type :eql?, '(Object) -> %bool' 
+
+  type :fdiv, '(Integer) -> Float'
+  type :fdiv, '(Float) -> Float'
+  type :fdiv, '(Rational) -> Float'
+  type :fdiv, '(BigDecimal) -> BigDecimal'
+  pre(:fdiv) { self!=Float::INFINITY && !self.nan?}
+  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) && self!=Float::INFINITY && !(self.nan?) 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(:ceil) { self!=Float::INFINITY && !self.nan?}
+
   type :hash, '() -> Integer'
-  type :infinite?, '() -> -1 or 1 or nil'
-  rdl_alias :inspect, :to_s
+
+  type :infinite?, '() -> Object'
+  post(:infinite?) { |r,x| r == -1 || r == 1 || r == nil }
+
+  type :to_s, '() -> String'
+  type :inspect, '() -> String'
+
   type :magnitude, '() -> Float'
-  rdl_alias :modulo, :%
+  post(:magnitude) { |r,x| r>=0 }
+
+  type :modulo, '(Integer) -> Float'
+  pre(:modulo) { |x| x!=0}
+  type :modulo, '(Float) -> Float'
+  pre(:modulo) { |x| x!=0}
+  type :modulo, '(Rational) -> Float'
+  pre(:modulo) { |x| x!=0}
+  type :modulo, '(BigDecimal) -> BigDecimal'
+  pre(:modulo) { |x| x!=0 && self!=Float::INFINITY && !self.nan?}
+
   type :nan?, '() -> %bool'
+
   type :next_float, '() -> Float'
+
   type :numerator, '() -> Integer'
-  type :phase, '() -> 0 or ${Math::PI}'
+
+  type :phase, '() -> Numeric'
+  post(:phase) { |r,x| r == 0 || r == Math::PI || r == Float::NAN}
+
   type :prev_float, '() -> Float'
-  rdl_alias :quo, :/
-  type :rationalize, '(Float eps) -> Rational'
-  type :round, '(?Fixnum ndigits) -> Integer or Float'
-  type :to_f, '() -> self'
+
+  type :quo, '(Integer) -> Float'
+  pre(:quo) { |x| x!=0}
+  type :quo, '(Float) -> Float'
+  pre(:quo) { |x| x!=0}
+  type :quo, '(Rational) -> Float'
+  pre(:quo) { |x| x!=0}
+  type :quo, '(BigDecimal) -> BigDecimal'
+  pre(:quo) { |x| x!=0 && self!=Float::INFINITY && !self.nan?}
+  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) && self!=Float::INFINITY && !(self.nan?) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
+
+  type :rationalize, '() -> Rational'
+  pre(:rationalize) { self!=Float::INFINITY && !self.nan?}
+
+  type :rationalize, '(Numeric) -> Rational'
+  pre(:rationalize) { |x| if x.is_a?(Float) then x!=Float::INFINITY && !x.nan? else true end}
+
+  type :round, '() -> Integer'
+  pre(:round) { self!=Float::INFINITY && !self.nan?}
+
+  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_f, '() -> Float'
+
   type :to_i, '() -> Integer'
-  rdl_alias :to_int, :to_i
+  pre(:to_i) { self!=Float::INFINITY && !self.nan?}
+
+  type :to_int, '() -> Integer'
+  pre(:to_int) { self!=Float::INFINITY && !self.nan?}
+
   type :to_r, '() -> Rational'
-  type :to_s, '() -> String'
+  pre(:to_r) { self!=Float::INFINITY && !self.nan?}
+
   type :truncate, '() -> Integer'
+
   type :zero?, '() -> %bool'
+
+  type :conj, '() -> Float'
+  type :conjugate, '() -> Float'
+
+  type :imag, '() -> Fixnum'
+  post(:imag) { |r,x| r == 0 }
+  type :imaginary, '() -> Fixnum'
+  post(:imaginary) { |r,x| r == 0 }
+
+  type :real, '() -> Float'
+
+  type :real?, '() -> TrueClass'
+
+  type :to_c, '() -> Complex'
+  post(:to_c) { |r,x| r.imaginary == 0 }
+
+  type :coerce, '(Numeric) -> [Float, Float]'
+  pre(:coerce) { |x| if x.is_a?(Complex) then x.imaginary==0 else true end}
 end