rdl 2.0.1 → 2.1.0

data/extras/type_tests/|.rb

@@ -1,159 +0,0 @@
-#!/usr/bin/env ruby
-
- require 'bigdecimal'
- require 'rdl'
- require 'rdl_types'
-
-MAX_FIXNUM = 2**(0.size*8-2)-1 #Largest fixnum. -2 since 1 bit used for sign, 1 bit used as int marker.
-MIN_FIXNUM = -(2**(0.size*8-2)) #Smallest fixnum.
-
- def test()
-	x = gen_number(0.5,0.5,0,0,0,0,0,0)
-	type_one = x.class.to_s
-	y = gen_number(0.5,0.5,0,0,0,0,0,0)
-	type_two = y.class.to_s
-	#puts "Arg1= #{x} and type = #{type_one}"
-	#puts "Arg2= #{y} and type = #{type_two}"
-	operation_type = query(type_one+'#|',y)
-	expected_type = operation_type[operation_type.index('->')+3..-1]
-	w = x|y
-	#puts "here"
-	test_result = w.is_a?(Object.const_get(expected_type))
-	if !test_result
-		puts "Arg1= #{x} (type: #{type_one})"
-		puts "Arg2= #{y} (type: #{type_two})"
-		puts "Res= #{w}"
-		puts "Expected type: #{expected_type}"
-		puts "Received type: #{w.class}"
-	end
-	#puts test_result
- 	return test_result
- end
-
-def gen_fixnum()
-	return Random.rand(MIN_FIXNUM..MAX_FIXNUM)
-end
-
-def gen_bignum()
-	r = Random.rand()
-	if r<0.5
-		return Random.rand(MAX_FIXNUM+1..MAX_FIXNUM*1000)
-	else
-		return -1*Random.rand(MAX_FIXNUM+1..MAX_FIXNUM*1000)
-	end
-end
-
-def gen_float()
-	r = Random.rand()
-	if r<0.5
-		return Float::MAX*Random.rand
-	else
-		return -1*Float::MAX*Random.rand
-	end
-end
-
-def gen_bigdec()
-	r = Random.rand()
-	if r<0.33
-		return BigDecimal.new(gen_fixnum())
-	elsif r<0.66
-		return BigDecimal.new(gen_bignum())
-	else
-		return BigDecimal.new(gen_float(),0)
-	end
-end
-
-def gen_complex()
-	x = gen_number(0.2,0.2,0.1,0.05,0.05,0.3,0,0.1)
-	#puts x
-	y = gen_number(0.2,0.2,0.1,0.05,0.05,0.3,0,0.1)
-	#puts y
-	return Complex(x,y)
-end
-
-def gen_rational()
-	x = gen_fixnum()
-	y = gen_fixnum()
-	return Rational(x,y)
-end
-	
-
-def gen_number(probFixnum,probBignum,probBigDec,probInf,probNAN,probFloat,probComplex,probRational)
-	r = Random.rand()
-	if r<probFixnum then
-		#Fixnum type
-		x = gen_fixnum()
-	elsif r<(probFixnum+probBignum)
-		x = gen_bignum()
-	elsif r<(probFixnum+probBignum+probBigDec)
-		#BigDecimal type
-		x = gen_bigdec()
-	elsif r<(probFixnum+probBignum+probBigDec+probInf)
-		x=Float::INFINITY
-	elsif r<(probFixnum+probBignum+probBigDec+probInf+probNAN)
-		x=Float::NAN
-	elsif r<(probFixnum+probBignum+probBigDec+probInf+probNAN+probFloat)
-		#Random Float type
-		x = gen_float()
-        elsif r<(probFixnum+probBignum+probBigDec+probInf+probNAN+probFloat+probComplex)
-		x= gen_complex()
-	elsif (probFixnum+probBignum+probBigDec+probInf+probNAN+probFloat+probComplex+probRational)
-		x = gen_rational()
-	end
-	return x
-end
-
- def rounds(x)
-	counter = 0
-	for i in 0..x
-		b= test()
-		if (!b) then
-			counter=counter+1
-		end
-	
-	end
-	return counter
- end	
-
-def query(q,y)
-    $__rdl_contract_switch.off {
-      if q =~ /^(\w+(#|\.))?(\w+(!|\?|=)?|!|~|\+|\*\*|-|\*|\/|%|<<|>>|&|\||\^|<|<=|=>|>|==|===|!=|=~|!~|<=>|\[\]|\[\]=)$/
-        klass = nil
-        klass_pref = nil
-        meth = nil
-        if q =~ /(.+)#(.+)/
-          klass = $1
-          klass_pref = "#{klass}#"
-          meth = $2.to_sym
-        elsif q =~ /(.+)\.(.+)/
-          klass_pref = "#{$1}."
-          klass = RDL::Util.add_singleton_marker($1)
-          meth = $2.to_sym
-        else
-          klass = self.class.to_s
-          klass_pref = "#{klass}#"
-          meth = q.to_sym
-        end
-        if RDL::Wrap.has_contracts?(klass, meth, :type)
-          typs = RDL::Wrap.get_contracts(klass, meth, :type)
-          typs.each { |t|
-            #puts "#{klass_pref}#{meth}: #{t}"
-	    t_string = "#{t}"
-	    t_string =~ /\((\w*)\)(.+)/
-	
-	    #puts y
-	    if y.is_a?(Object.const_get($1))
-		return t_string
-	    end
-	    #return "#{t}" 
-          }
-          nil
-        else
-          #puts "No type for #{klass_pref}#{meth}"
-        end
-      else
-        #puts "Not implemented"
-      end
-    }
-  end
-

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

@@ -1,15 +0,0 @@
-if defined? BigDecimal
-  type_alias '%real', 'Fixnum or Bignum or Float or Rational or BigDecimal'
-  type_alias '%numeric', 'Fixnum or Bignum or Float or Rational or BigDecimal or Complex'
-else
-  type_alias '%real', 'Fixnum or Bignum or Float or Rational'
-  type_alias '%numeric', 'Fixnum or Bignum or Float or Rational'
-end
-type_alias '%string', '[to_str: () -> String]'
-type_alias '%integer', 'Fixnum or Bignum'
-if defined? Pathname
-  type_alias '%path', '%string or Pathname'
-else
-  type_alias '%path', '%string'
-end
-type_alias '%open_args', '{external_encoding: ?String, internal_encoding: ?String, encoding: ?String, textmode: ?%any, binmode: ?%any, autoclose: ?%any, mode: ?String}'

data/lib/types/core-ruby-2.x/abbrev.rb

@@ -1,5 +0,0 @@
-module Abbrev
-  rdl_nowrap
-
-  type 'self.abbrev', '(Array<String>) -> Hash<String,String>'
-end

data/lib/types/core-ruby-2.x/array.rb

@@ -1,137 +0,0 @@
-class Array
-  rdl_nowrap
-
-  type_params [:t], :all?
-
-  type :<<, '(t) -> Array<t>'
-  type :[], '(Range<%integer>) -> Array<t>'
-  type :[], '(%integer or Float) -> t'
-  type :[], '(%integer, %integer) -> Array<t>'
-  type :&, '(Array<u>) -> Array<t>'
-  type :*, '(%integer) -> Array<t>'
-  type :*, '(String) -> String'
-  type :+, '(Enumerable<u>) -> Array<u or t>'
-  type :-, '(Array<u>) -> Array<u or t>'
-  type :slice, '(Range<%integer>) -> Array<t>'
-  type :slice, '(%integer) -> t'
-  type :slice, '(%integer, %integer) -> Array<t>'
-  type :[]=, '(%integer, t) -> t'
-  type :[]=, '(%integer, %integer, t) -> t'
-  #type :[]=, '(%integer, %integer, Array<t>) -> Array<t>'
-  #type :[]=, '(Range, Array<t>) -> Array<t>'
-  type :[]=, '(Range<%integer>, t) -> t'
-  type :assoc, '(t) -> Array<t>'
-  type :at, '(%integer) -> t'
-  type :clear, '() -> Array<t>'
-  type :map, '() {(t) -> u} -> Array<u>'
-  type :map, '() -> Enumerator<t>'
-  type :map!, '() {(t) -> u} -> Array<u>'
-  type :map!, '() -> Enumerator<t>'
-  type :collect, '() { (t) -> u } -> Array<u>'
-  type :collect, '() -> Enumerator<t>'
-  type :combination, '(%integer) { (Array<t>) -> %any } -> Array<t>'
-  type :combination, '(%integer) -> Enumerator<t>'
-  type :push, '(?t) -> Array<t>'
-  type :compact, '() -> Array<t>'
-  type :compact!, '() -> Array<t>'
-  type :concat, '(Array<t>) -> Array<t>'
-  type :count, '() -> %integer'
-  type :count, '(t) -> %integer'
-  type :count, '() { (t) -> %bool } -> %integer'
-  type :cycle, '(?%integer) { (t) -> %any } -> %any'
-  type :cycle, '(?%integer) -> Enumerator<t>'
-  type :delete, '(u) -> t'
-  type :delete, '(u) { () -> v } -> t or v'
-  type :delete_at, '(%integer) -> Array<t>'
-  type :delete_if, '() { (t) -> %bool } -> Array<t>'
-  type :delete_if, '() -> Enumerator<t>'
-  type :drop, '(%integer) -> Array<t>'
-  type :drop_while, '() { (t) -> %bool } -> Array<t>'
-  type :drop_while, '() -> Enumerator<t>'
-  type :each, '() -> Enumerator<t>'
-  type :each, '() { (t) -> %any } -> Array<t>'
-  type :each_index, '() { (%integer) -> %any } -> Array<t>'
-  type :each_index, '() -> Enumerator<t>'
-  type :empty?, '() -> %bool'
-  type :fetch, '(%integer) -> t'
-  type :fetch, '(%integer, u) -> u'
-  type :fetch, '(%integer) { (%integer) -> u } -> t or u'
-  type :fill, '(t) -> Array<t>'
-  type :fill, '(t, %integer, ?%integer) -> Array<t>'
-  type :fill, '(t, Range<%integer>) -> Array<t>'
-  type :fill, '() { (%integer) -> t } -> Array<t>'
-  type :fill, '(%integer, ?%integer) { (%integer) -> t } -> Array<t>'
-  type :fill, '(Range<%integer>) { (%integer) -> t } -> Array<t>'
-  type :flatten, '() -> Array<%any>' # Can't give a more precise type
-  type :index, '(u) -> %integer'
-  type :index, '() { (t) -> %bool } -> %integer'
-  type :index, '() -> Enumerator<t>'
-  type :first, '() -> t'
-  type :first, '(%integer) -> Array<t>'
-  type :include?, '(u) -> %bool'
-  type :insert, '(%integer, *t) -> Array<t>'
-  type :inspect, '() -> String'
-  type :join, '(?String) -> String'
-  type :keep_if, '() { (t) -> %bool } -> Array<t>'
-  type :last, '() -> t'
-  type :last, '(%integer) -> Array<t>'
-  type :member, '(u) -> %bool'
-  type :length, '() -> Fixnum'
-  type :permutation, '(?%integer) -> Enumerator<t>'
-  type :permutation, '(?%integer) { (Array<t>) -> %any } -> Array<t>'
-  type :pop, '(%integer) -> Array<t>'
-  type :pop, '() -> t'
-  type :product, '(*Array<u>) -> Array<Array<t or u>>'
-  type :rassoc, '(u) -> t'
-  type :reject, '() { (t) -> %bool } -> Array<t>'
-  type :reject, '() -> Enumerator<t>'
-  type :reject!, '() { (t) -> %bool } -> Array<t>'
-  type :reject!, '() -> Enumerator<t>'
-  type :repeated_combination, '(%integer) { (Array<t>) -> %any } -> Array<t>'
-  type :repeated_combination, '(%integer) -> Enumerator<t>'
-  type :repeated_permutation, '(%integer) { (Array<t>) -> %any } -> Array<t>'
-  type :repeated_permutation, '(%integer) -> Enumerator<t>'
-  type :reverse, '() -> Array<t>'
-  type :reverse!, '() -> Array<t>'
-  type :reverse_each, '() { (t) -> %any } -> Array<t>'
-  type :reverse_each, '() -> Enumerator<t>'
-  type :rindex, '(u) -> t'
-  type :rindex, '() { (t) -> %bool } -> %integer'
-  type :rindex, '() -> Enumerator<t>'
-  type :rotate, '(?%integer) -> Array<t>'
-  type :rotate!, '(?%integer) -> Array<t>'
-  type :sample, '() -> t'
-  type :sample, '(%integer) -> Array<t>'
-  type :select, '() { (t) -> %bool } -> Array<t>'
-  type :select, '() -> Enumerator<t>'
-  type :select!, '() { (t) -> %bool } -> Array<t>'
-  type :select!, '() -> Enumerator<t>'
-  type :shift, '() -> t'
-  type :shift, '(%integer) -> Array<t>'
-  type :shuffle, '() -> Array<t>'
-  type :shuffle!, '() -> Array<t>'
-  rdl_alias :size, :length
-  rdl_alias :slice, :[]
-  type :slice!, '(Range<%integer>) -> Array<t>'
-  type :slice!, '(%integer, %integer) -> Array<t>'
-  type :slice!, '(%integer or Float) -> t'
-  type :sort, '() -> Array<t>'
-  type :sort, '() { (t,t) -> %integer } -> Array<t>'
-  type :sort!, '() -> Array<t>'
-  type :sort!, '() { (t,t) -> %integer } -> Array<t>'
-  type :sort_by!, '() { (t) -> u } -> Array<t>'
-  type :sort_by!, '() -> Enumerator<t>'
-  type :take, '(%integer) -> Array<t>'
-  type :take_while, '() { (t) ->%bool } -> Array<t>'
-  type :take_while, '() -> Enumerator<t>'
-  type :to_a, '() -> Array<t>'
-  type :to_ary, '() -> Array<t>'
-  rdl_alias :to_s, :inspect
-  type :transpose, '() -> Array<t>'
-  type :uniq, '() -> Array<t>'
-  type :uniq!, '() -> Array<t>'
-  type :unshift, '(*t) -> Array<t>'
-  type :values_at, '(*Range<%integer> or %integer) -> Array<t>'
-  type :zip, '(*Array<u>) -> Array<Array<t or u>>'
-  type :|, '(Array<u>) -> Array<t or u>'
-end

data/lib/types/core-ruby-2.x/base64.rb

@@ -1,10 +0,0 @@
-module Base64
-  rdl_nowrap
-
-  type 'self.decode64', '(String) -> String'
-  type 'self.encode64', '(String) -> String'
-  type 'self.strict_decode64', '(String) -> String'
-  type 'self.strict_encode64', '(String) -> String'
-  type 'self.urlsafe_decode64', '(String) -> String'
-  type 'self.urlsafe_encode64', '(String) -> String'
-end

data/lib/types/core-ruby-2.x/basic_object.rb

@@ -1,14 +0,0 @@
-class BasicObject
-  rdl_nowrap
-  
-  type :==, '(%any other) -> %bool'
-  type :equal?, '(%any other) -> %bool'
-  type :!, '() -> %bool'
-  type :!=, '(%any other) -> %bool'
-  type :instance_eval, '(String, ?String filename, ?Fixnum lineno) -> %any'
-  type :instance_eval, '() { () -> %any } -> %any'
-  type :instance_exec, '(*%any args) { (*%any) -> %any } -> %any'
-  type :__send__, '(Symbol, *%any) -> %any obj'
-  rdl_alias :__id__, :object_id
-  type :object_id, '() -> Fixnum'
-end

data/lib/types/core-ruby-2.x/benchmark.rb

@@ -1,11 +0,0 @@
-module Benchmark
-  rdl_nowrap
-
-  type 'self.benchmark', '(String, ?Fixnum, ?String, *String) -> Array<Benchmark::Tms>'
-  type 'self.bm', '(?Fixnum, *String) { (Benchmark::Process) -> nil} -> Array<Benchmark::Tms>'
-  #type 'self.benchmark', '(Caption: String, Label_Width: ?Fixnum, Format: ?String, Labels: *String) -> Benchmark::Tms'
-  #type 'self.bm', '(Label_Width: ?Fixnum, Labels: *String) { (Benchmark::Process) -> nil} -> Array<Benchmark::Tms>'
-  type 'self.bmbm', '(?Fixnum label_width) { (Benchmark::Process) -> nil} -> Array<Benchmark::Tms>'
-  type 'self.measure', '(?String label) -> Benchmark::Tms'
-  type 'self.realtime', '() {(*%any) -> %any} -> Fixnum'
-end

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

@@ -1,224 +0,0 @@
-class BigDecimal < Numeric
-  rdl_nowrap
-
-  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 x {{ !x.infinite? && !x.nan? }}) -> BigDecimal'
-  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 x {{ !x.infinite? && !x.nan? }}) -> BigDecimal'
-  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 x {{ !x.infinite? && !x.nan? }}) -> BigDecimal'
-  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 x {{ x!=0 }}) -> BigDecimal'
-  type :/, '(Float x {{ x!=0 && !x.infinite? && !x.nan? }}) -> BigDecimal'
-  type :/, '(Rational x {{ x!=0 }}) -> BigDecimal'
-  type :/, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
-  type :/, '(Complex x {{ x!=0 }}) -> Complex'
-  pre(:/) { |x| 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 x {{ !x.nan? && !x.infinite? }}) -> %bool'
-  type :<, '(Rational) -> %bool'
-  type :<, '(BigDecimal) -> %bool'
-
-  type :<=, '(%integer) -> %bool'
-  type :<=, '(Float x {{ !x.nan? && !x.infinite }}) -> %bool'
-  type :<=, '(Rational) -> %bool'
-  type :<=, '(BigDecimal) -> %bool'
-
-  type :>, '(%integer) -> %bool'
-  type :>, '(Float x {{ !x.nan? && !x.infinite? }}) -> %bool'
-  type :>, '(Rational) -> %bool'
-  type :>, '(BigDecimal) -> %bool'
-
-  type :>=, '(%integer) -> %bool'
-  type :>=, '(Float x {{ !x.nan? && !x.infinite? }}) -> %bool'
-  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 r {{ r>=0 }}'
-
-  type :abs2, '() -> BigDecimal r {{ 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 x {{ x!=0 && !self.infinite? && !self.nan? }}) -> %integer'
-  type :div, '(Bignum x {{ x!=0 && !self.infinite? && !self.nan? }}) -> %integer'
-  type :div, '(Float x {{ x!=0 && !self.infinite? && !self.nan? && !x.infinite? && !x.nan? }}) -> %integer'
-  type :div, '(Rational x {{ x!=0 && !self.infinite? && !self.nan? }}) -> %integer'
-  type :div, '(BigDecimal x {{ x!=0 && !self.infinite? && !self.nan? && !x.infinite? && !x.nan? }}) -> %integer'
-
-  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 r {{ r==0 }}'
-  type :imaginary, '() -> Fixnum r {{ r==0 }}'
-
-  type :infinite?, '() -> %bool'
-
-  type :to_s, '() -> String'
-  type :inspect, '() -> String'
-
-  type :magnitude, '() -> BigDecimal r {{ 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 x {{ x!=0 }}) -> BigDecimal'
-  type :quo, '(Float x {{ x!=0 && !x.infinite? && !x.nan?}}) -> BigDecimal'
-  type :quo, '(Rational x {{ x!=0 }}) -> BigDecimal'
-  type :quo, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
-  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?, '() -> true'
-
-  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 r {{ r.imaginary == 0 }}'
-  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