rdl 1.1.0 → 1.1.1.rc1

data/extras/type_tests/type tests

@@ -0,0 +1 @@
+this directory contains random testing for numeric subclass method types

data/extras/type_tests/zero?.rb

@@ -0,0 +1,155 @@
+#!/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.2,0.2,0.1,0.05,0.05,0.2,0.1,0.1)
+	type_one = x.class.to_s
+	#puts "Arg1= #{x} and type = #{type_one}"
+	#puts "Arg2= #{y} and type = #{type_two}"
+	operation_type = query(type_one+'#zero?',nil)
+	expected_type = operation_type[operation_type.index('->')+3..-1]
+	w = x.zero?
+	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*)\)(.+)/
+	    if $1==""
+		return t_string
+	    end
+	    #return "#{t}" 
+          }
+          
+        else
+          #puts "No type for #{klass_pref}#{meth}"
+        end
+      else
+        #puts "Not implemented"
+      end
+    }
+  end
+

data/extras/type_tests/|.rb

@@ -0,0 +1,159 @@
+#!/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/rdl/contracts/and.rb

@@ -26,4 +26,4 @@ module RDL::Contract
       a.join(' && ')
     end
   end
-end
+end

data/lib/rdl/contracts/flat.rb

@@ -12,7 +12,7 @@ module RDL::Contract
         if (@pred &&
             ((@pred.arity < 0) ? (@pred.arity.abs - 1) <= v.size : @pred.arity == v.size)) then
           unless blk ? slf.instance_exec(*v, blk, &@pred) : slf.instance_exec(*v, &@pred) # TODO: Fix blk
-#          unless blk ? pred.call(*v, &blk) : pred.call(*v) 
+#          unless blk ? pred.call(*v, &blk) : pred.call(*v)
             raise ContractError,
                   "#{v.inspect} does not satisfy #{self.to_s}"
           end
@@ -28,4 +28,4 @@ module RDL::Contract
       @desc
     end
   end
-end
+end

data/lib/rdl/contracts/proc.rb

@@ -7,6 +7,7 @@ module RDL::Contract
       @post_cond = post_cond
     end
 
+
     def wrap(slf, &blk)
       Proc.new {|*v, &other_blk|
         @pre_cond.check(slf, *v, &other_blk)
@@ -21,4 +22,4 @@ module RDL::Contract
       "(#{@pre_cond}) -> (#{@post_cond})"
     end
   end
-end
+end

data/lib/rdl/types/.#lexer.rex

@@ -0,0 +1 @@
+milod@ubuntu.47783:1458260004

data/lib/rdl/types/dependent_arg.rb

@@ -0,0 +1,47 @@
+require_relative 'type'
+
+module RDL::Type
+  class DependentArgType < Type
+    attr_reader :name
+    attr_reader :type
+    attr_reader :predicate
+
+# Note: Named argument types aren't hashconsed.
+
+    def initialize(name, type, predicate)
+      @name = name
+      @type = type
+      /\{\{(.+)\}\}/ =~ predicate
+      @predicate = $1
+      raise RuntimeError, "Attempt to create annotated type with non-type" unless type.is_a? Type
+      raise RuntimeError, "Attempt to create doubly annotated type" if (type.is_a? AnnotatedArgType)||(type.is_a? DependentArgType)
+      super()
+    end
+
+    def to_s
+      "#{@type.to_s} #{@name} {{#{@predicate}}}"
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other) # :nodoc:
+      return (other.instance_of? DependentArgType) && (other.name == @name) && (other.type == @type)
+    end
+
+    # doesn't have a match method - queries shouldn't have annotations in them
+
+    def hash # :nodoc:
+      return (57 + @name.hash) * @type.hash
+    end
+
+    def member?(obj, *args)
+      @type.member?(obj, *args)
+    end
+
+    def instantiate(inst)
+      return DependentArgType.new(@name, @type.instantiate(inst),@predicate)
+    end
+  end
+end

data/lib/rdl/types/finitehash.rb

@@ -14,8 +14,8 @@ module RDL::Type
     end
 
     def self.new(elts)
-      t = @@cache[elts]
-      return t if t
+      ct = @@cache[elts]
+      return ct if ct
       t = FiniteHashType.__new__(elts)
       return (@@cache[elts] = t) # assignment evaluates to t
     end
@@ -73,8 +73,8 @@ module RDL::Type
       }
 
       # Check that any remaining types are optional
-      rest.each_pair { |k, t|
-        return false unless t.instance_of? OptionalType
+      rest.each_pair { |k, vt|
+        return false unless vt.instance_of? OptionalType
       }
     end
 
@@ -83,7 +83,7 @@ module RDL::Type
     end
 
     def hash
-      h = 229 * @elts.hash
+      229 * @elts.hash
     end
   end
 end

data/lib/rdl/types/generic.rb

@@ -48,7 +48,7 @@ module RDL::Type
     end
 
     def <=(other)
-      formals, variance, check = $__rdl_type_params[base.name]
+      formals, variance, _ = $__rdl_type_params[base.name]
       # do check here to avoid hiding errors if generic type written
       # with wrong number of parameters but never checked against
       # instantiated instances
@@ -88,7 +88,7 @@ module RDL::Type
 
     def member?(obj, *args)
       raise "No type parameters defined for #{base.name}" unless $__rdl_type_params[base.name]
-      formals = $__rdl_type_params[base.name][0]
+#      formals = $__rdl_type_params[base.name][0]
       t = RDL::Util.rdl_type obj
       return t <= self if t
       return false unless base.member?(obj, *args)
@@ -100,7 +100,7 @@ module RDL::Type
     end
 
     def hash
-      h = (61 + @base.hash) * @params.hash
+      (61 + @base.hash) * @params.hash
     end
   end
 end