BOAST 0.9995 → 0.9996

data/lib/BOAST/Case.rb

@@ -1,8 +1,6 @@
 module BOAST
 
-  class Case < BOAST::ControlStructure
-    include BOAST::Inspectable
-    extend BOAST::Functor
+  class Case < ControlStructure
 
     attr_reader :expression
     attr_reader :constants_list
@@ -44,10 +42,10 @@ module BOAST
     }
 
     @@strings = {
-      BOAST::C => @@c_strings,
-      BOAST::CL => @@c_strings,
-      BOAST::CUDA => @@c_strings,
-      BOAST::FORTRAN => @@f_strings
+      C => @@c_strings,
+      CL => @@c_strings,
+      CUDA => @@c_strings,
+      FORTRAN => @@f_strings
     }
 
     eval token_string_generator( * %w{switch expr})
@@ -60,49 +58,49 @@ module BOAST
       s = ""
       if block_number then
         if block_number != 0 then
-          s += BOAST::indent + break_string + "\n" if break_string
-          BOAST::decrement_indent_level
+          s += indent + break_string + "\n" if break_string
+          decrement_indent_level
         end
-        s += BOAST::indent
+        s += indent
         if @constants_list[block_number] and @constants_list[block_number].size > 0 then
           s += case_string(@constants_list[block_number])
         else
           s += default_string
         end
       else
-        s += BOAST::indent
+        s += indent
         s += switch_string(@expression)
       end
-      BOAST::increment_indent_level
+      increment_indent_level
       return s
     end
 
     def open
-      BOAST::get_output.puts self.to_s
+      output.puts to_s
       return self
     end
 
-    def print(*args)
-      self.open
+    def pr(*args)
+      open
       if @blocks.size > 0 then
         @blocks.each_index { |indx|
-          s = self.to_s(indx)
-          BOAST::get_output.puts s
+          s = to_s(indx)
+          output.puts s
           @blocks[indx].call(*args)
         }
-        self.close
+        close
       end
       return self
     end
 
     def close
       s = ""
-      s += BOAST::indent + break_string + "\n" if break_string
-      BOAST::decrement_indent_level      
-      s += BOAST::indent
+      s += indent + break_string + "\n" if break_string
+      decrement_indent_level      
+      s += indent
       s += end_string
-      BOAST::decrement_indent_level      
-      BOAST::get_output.puts s
+      decrement_indent_level      
+      output.puts s
       return self
     end
 

data/lib/BOAST/ControlStructure.rb

@@ -1,13 +1,21 @@
 module BOAST
 
   class ControlStructure
+    include PrivateStateAccessor
+    include Inspectable
+
+    def self.inherited(child)
+      child.extend Functor
+    end
+
     def self.token_string_generator(name, *args)
        s = <<EOF
     def #{name}_string(#{args.join(",")})
-      return eval @@strings[BOAST::get_lang][:#{name}] 
+      return eval @@strings[get_lang][:#{name}] 
     end
 EOF
     end
+
   end
 
 end

data/lib/BOAST/DataTypes.rb

@@ -1,11 +1,21 @@
 module BOAST
 
-  class Sizet
-    extend BOAST::VarFunctor
+  class DataType
+
+    include PrivateStateAccessor
+
+    def self.inherited(child)
+      child.extend( VarFunctor)
+    end
+
+  end
+
+  class Sizet < DataType
 
     attr_reader :signed
     attr_reader :size
     attr_reader :vector_length
+
     def initialize(hash={})
       if hash[:signed] != nil then
         @signed = hash[:signed]
@@ -19,7 +29,7 @@ module BOAST
     end
 
     def copy(options={})
-      hash = self.to_hash
+      hash = to_hash
       options.each { |k,v|
         hash[k] = v
       }
@@ -27,17 +37,21 @@ module BOAST
     end
 
     def decl
-      return "integer(kind=#{BOAST::get_default_int_size})" if BOAST::get_lang == FORTRAN
+      return "integer(kind=#{get_default_int_size})" if lang == FORTRAN
       if not @signed then
-        return "size_t" if [C, CL, CUDA].include?( BOAST::get_lang )
+        return "size_t" if [C, CL, CUDA].include?( lang )
       else
-        return "ptrdiff_t" if [C, CL, CUDA].include?( BOAST::get_lang )
+        return "ptrdiff_t" if [C, CL, CUDA].include?( lang )
       end
     end
+
+    def signed?
+      return !!signed
+    end
+
   end
  
-  class Real
-    extend BOAST::VarFunctor
+  class Real < DataType
 
     attr_reader :size
     attr_reader :signed
@@ -47,7 +61,7 @@ module BOAST
     attr_reader :setters
 
     def ==(t)
-      return true if t.class == self.class and t.size == self.size and t.vector_length == self.vector_length
+      return true if t.class == self.class and t.size == size and t.vector_length == vector_length
       return false
     end
 
@@ -55,7 +69,7 @@ module BOAST
       if hash[:size] then
         @size = hash[:size]
       else
-        @size = BOAST::get_default_real_size
+        @size = get_default_real_size
       end
 #      @getters = {}
 #      @setters = {}
@@ -72,6 +86,10 @@ module BOAST
       @signed = true
     end
 
+    def signed?
+      return !!signed
+    end
+
     def to_hash
       return { :size => @size, :vector_length => @vector_length }
     end
@@ -85,30 +103,29 @@ module BOAST
     end
 
     def decl
-      return "real(kind=#{@size})" if BOAST::get_lang == FORTRAN
-      if [C, CL, CUDA].include?( BOAST::get_lang ) and @vector_length == 1 then
+      return "real(kind=#{@size})" if lang == FORTRAN
+      if [C, CL, CUDA].include?( lang ) and @vector_length == 1 then
         return "float" if @size == 4
         return "double" if @size == 8
-      elsif BOAST::get_lang == C and @vector_length > 1 then
-        if BOAST::get_architecture == BOAST::X86 then
+      elsif lang == C and @vector_length > 1 then
+        if get_architecture == X86 then
           return "__m#{@total_size*8}" if @size == 4
           return "__m#{@total_size*8}d" if @size == 8
-        elsif BOAST::get_architecture == BOAST::ARM then
+        elsif get_architecture == ARM then
           raise "Unsupported data type in NEON: double!" if @size == 8
           raise "Unsupported vector length in NEON: #{@total_size} (#{@size} x 8 x #{@vector_length})!" if @total_size * 8 != 64 or @total_size * 8 != 128
           return "float#{@size*8}x#{@vector_length}_t"
         else
           raise "Unsupported architecture!"
         end
-      elsif [CL, CUDA].include?( BOAST::get_lang ) and @vector_length > 1 then
+      elsif [CL, CUDA].include?( lang ) and @vector_length > 1 then
         return "float#{@vector_length}" if @size == 4
         return "double#{@vector_length}" if @size == 8
       end
     end
   end
 
-  class Int
-    extend BOAST::VarFunctor
+  class Int < DataType
 
     attr_reader :size
     attr_reader :signed
@@ -116,7 +133,7 @@ module BOAST
     attr_reader :total_size
 
     def ==(t)
-      return true if t.class == self.class and t.signed == self.signed and t.size == self.size and t.vector_length == self.vector_length
+      return true if t.class == self.class and t.signed == signed and t.size == size and t.vector_length == vector_length
       return false
     end
 
@@ -124,12 +141,12 @@ module BOAST
       if hash[:size] then
         @size = hash[:size]
       else
-        @size = BOAST::get_default_int_size
+        @size = get_default_int_size
       end
       if hash[:signed] != nil then
         @signed = hash[:signed]
       else
-        @signed = BOAST::get_default_int_signed
+        @signed = get_default_int_signed
       end
 #      @getters = {}
 #      @setters = {}
@@ -150,7 +167,7 @@ module BOAST
     end
 
     def copy(options={})
-      hash = self.to_hash
+      hash = to_hash
       options.each { |k,v|
         hash[k] = v
       }
@@ -158,27 +175,27 @@ module BOAST
     end
 
     def signed?
-      return @signed
+      return !!@signed
     end
 
     def decl
-      return "integer(kind=#{@size})" if BOAST::get_lang == FORTRAN
-      if BOAST::get_lang == C then
+      return "integer(kind=#{@size})" if lang == FORTRAN
+      if lang == C then
         if @vector_length == 1 then
           s = ""
           s += "u" if not @signed
           return s+"int#{8*@size}_t"
         elsif @vector_length > 1 then
-          if BOAST::get_architecture == BOAST::X86 then
+          if get_architecture == X86 then
             return "__m#{@total_size*8}#{@total_size*8>64 ? "i" : ""}"
-          elsif BOAST::get_architecture == BOAST::ARM then
+          elsif get_architecture == ARM then
             raise "Unsupported vector length in NEON: #{@total_size*8} (#{@size} x 8 x #{@vector_length})!" if @total_size * 8 != 64 and @total_size * 8 != 128
             return "#{ @signed ? "" : "u"}int#{@size*8}x#{@vector_length}_t"
           else
             raise "Unsupported architecture!"
           end
         end
-      elsif BOAST::get_lang == CL then
+      elsif lang == CL then
         #char="cl_"
         char=""
         char += "u" if not @signed
@@ -198,7 +215,7 @@ module BOAST
           char += "#{@vector_length}"
         end
         return char
-      elsif BOAST::get_lang == CUDA then
+      elsif lang == CUDA then
         if @vector_length > 1 then
           char=""
           char += "u" if not @signed
@@ -227,8 +244,7 @@ module BOAST
     end
   end
 
-  class CStruct
-    extend BOAST::VarFunctor
+  class CStruct < DataType
 
     attr_reader :name, :members, :members_array
 
@@ -244,61 +260,62 @@ module BOAST
     end
 
     def decl_c
-      return "struct #{@name}" if [C, CL, CUDA].include?( BOAST::get_lang )
+      return "struct #{@name}" if [C, CL, CUDA].include?( lang )
     end
 
     def decl_fortran
-      return "TYPE(#{@name})" if BOAST::get_lang == FORTRAN
+      return "TYPE(#{@name})" if lang == FORTRAN
     end
 
     def decl
-      return self.decl_c if [C, CL, CUDA].include?( BOAST::get_lang )
-      return self.decl_fortran if BOAST::get_lang == FORTRAN
+      return decl_c if [C, CL, CUDA].include?( lang )
+      return decl_fortran if lang == FORTRAN
     end
 
     def finalize
        s = ""
-       s += ";" if [C, CL, CUDA].include?( BOAST::get_lang )
+       s += ";" if [C, CL, CUDA].include?( lang )
        s+="\n"
        return s
     end
 
     def define
-      return define_c if [C, CL, CUDA].include?( BOAST::get_lang )
-      return define_fortran if BOAST::get_lang == FORTRAN
+      return define_c if [C, CL, CUDA].include?( lang )
+      return define_fortran if lang == FORTRAN
     end
 
     def define_c
-      s = BOAST::indent
-      s += self.decl_c + " {"
-      BOAST::get_output.puts s
+      s = indent
+      s += decl_c + " {"
+      output.puts s
       @members_array.each { |value|
          value.decl
       }
-      s = BOAST::indent
+      s = indent
       s += "}"
-      s += self.finalize
-      BOAST::get_output.print s
+      s += finalize
+      output.print s
       return self
     end
     
     def define_fortran
-      s = BOAST::indent
+      s = indent
       s += "TYPE :: #{@name}\n"
-      BOAST::get_output.puts s
+      output.puts s
       @members_array.each { |value|
          value.decl
       }
-      s = BOAST::indent
+      s = indent
       s += "END TYPE #{@name}"
-      s += self.finalize
-      BOAST::get_output.print s
+      s += finalize
+      output.print s
       return self
     end
 
   end
 
-  class CustomType
+  class CustomType < DataType
+
     attr_reader :size, :name, :vector_length
     def initialize(hash={})
       @name = hash[:type_name]
@@ -308,9 +325,11 @@ module BOAST
       @vector_length = 1 if @vector_length.nil?
       @total_size = @vector_length*@size
     end
+
     def decl
-      return "#{@name}" if [C, CL, CUDA].include?( BOAST::get_lang )
+      return "#{@name}" if [C, CL, CUDA].include?( lang )
     end
+
   end
 
 end

data/lib/BOAST/Expression.rb

@@ -1,13 +1,17 @@
 module BOAST
 
-  def self.Return(value)
+  module_function
+
+  def Return(value)
     return Expression("return",nil, value)
   end
 
   class Expression
-    include BOAST::Arithmetic
-    include BOAST::Inspectable
-    extend BOAST::Functor
+    include PrivateStateAccessor
+    include Arithmetic
+    include Inspectable
+    extend Functor
+    include TypeTransition
 
     attr_reader :operator
     attr_reader :operand1
@@ -18,7 +22,7 @@ module BOAST
       @operand2 = operand2
     end
 
-    def Expression.to_s_base(op1, op2, oper, return_type = nil)
+    def to_s_base(op1, op2, oper, return_type = nil)
       return oper.to_s(op1, op2, return_type) if not oper.kind_of?(String)
       s = ""
       if op1 then
@@ -27,7 +31,7 @@ module BOAST
         s += ")" if (oper == "*" or oper == "/") 
       end        
       s += " " unless oper == "++" or oper == "."
-      s += oper unless ( oper == "&" and BOAST::get_lang == BOAST::FORTRAN )
+      s += oper unless ( oper == "&" and lang == FORTRAN )
       s += " " unless oper == "." or oper == "&" or ( oper == "*" and op1.nil? )
       if op2 then
         s += "(" if (oper == "*" or oper == "/" or oper == "-") 
@@ -43,14 +47,14 @@ module BOAST
       op2 = nil
       op2 = @operand2.to_var if @operand2.respond_to?(:to_var)
       if op1 and op2 then
-        r_t, oper = BOAST::transition(op1, op2, @operator)
-        res_exp = BOAST::Expression::to_s_base(op1, op2, oper, r_t)
+        r_t, oper = transition(op1, op2, @operator)
+        res_exp = to_s_base(op1, op2, oper, r_t)
         return r_t.copy(res_exp, :const => nil, :constant => nil, :direction => nil, :dir => nil)
       elsif op2
-        res_exp = BOAST::Expression::to_s_base(@operand1, op2, @operator)
+        res_exp = to_s_base(@operand1, op2, @operator)
         return op2.copy(res_exp, :const => nil, :constant => nil, :direction => nil, :dir => nil)
       elsif op1
-        res_exp = BOAST::Expression::to_s_base(op1, @operand2, @operator)
+        res_exp = to_s_base(op1, @operand2, @operator)
         return op1.copy(res_exp, :const => nil, :constant => nil, :direction => nil, :dir => nil)
       else
         STDERR.puts "#{@operand1} #{@operand2}"
@@ -65,7 +69,7 @@ module BOAST
       op2 = @operand2.to_var if @operand2.respond_to?(:to_var)
       r_t = nil
       if op1 and op2 then
-        r_t, oper = BOAST::transition(op1, op2, @operator)
+        r_t, oper = transition(op1, op2, @operator)
       else
         oper = @operator
       end
@@ -73,17 +77,18 @@ module BOAST
       op1 = @operand1 if op1.nil?
       op2 = @operand2 if op2.nil?
 
-      return BOAST::Expression::to_s_base(op1, op2, oper, r_t)
+      return to_s_base(op1, op2, oper, r_t)
     end
 
-    def print
+    def pr
       s=""
-      s += BOAST::indent
-      s += self.to_s
-      s += ";" if [C, CL, CUDA].include?( BOAST::get_lang ) 
-      BOAST::get_output.puts s
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang ) 
+      output.puts s
       return self
     end
+
   end
 
 end

data/lib/BOAST/For.rb

@@ -1,8 +1,6 @@
 module BOAST
 
   class For < ControlStructure
-    include BOAST::Inspectable
-    extend BOAST::Functor
 
     attr_reader :iterator
     attr_reader :begin
@@ -14,11 +12,27 @@ module BOAST
       @begin = b
       @end = e
       @step = s
+      @operator = "<="
       @block = block
+      begin
+        push_env( :replace_constants => true )
+        if @step.kind_of?(Variable) then
+          step = @step.constant
+        elsif @step.kind_of?(Expression) then
+          step = eval "#{@step}"
+        else
+          step = @step.to_i
+        end
+        @operator = ">=" if step < 0
+      rescue
+        STDERR.puts "Warning could not determine sign of step (#{@step}) assuming positive" if [C, CL, CUDA].include?( lang ) and debug?
+      ensure
+        pop_env( :replace_constants )
+      end
     end
 
     @@c_strings = {
-      :for => '"for (#{i} = #{b}; #{i} <= #{e}; #{i} += #{s}) {"',
+      :for => '"for (#{i} = #{b}; #{i} #{o} #{e}; #{i} += #{s}) {"',
       :end => '"}"'
     }
 
@@ -28,23 +42,23 @@ module BOAST
     }
 
     @@strings = {
-      BOAST::C => @@c_strings,
-      BOAST::CL => @@c_strings,
-      BOAST::CUDA => @@c_strings,
-      BOAST::FORTRAN => @@f_strings
+      C => @@c_strings,
+      CL => @@c_strings,
+      CUDA => @@c_strings,
+      FORTRAN => @@f_strings
     }
 
-    eval token_string_generator( * %w{for i b e s})
+    eval token_string_generator( * %w{for i b e s o})
     eval token_string_generator( * %w{end})
 
     def to_s
-      s = for_string(@iterator, @begin, @end, @step)
+      s = for_string(@iterator, @begin, @end, @step, @operator)
       return s
     end
 
     def unroll(*args)
       raise "Block not given!" if not @block
-      BOAST::push_env( :replace_constants => true )
+      push_env( :replace_constants => true )
       begin
         if @begin.kind_of?(Variable) then
           start = @begin.constant
@@ -70,11 +84,11 @@ module BOAST
         raise "Invalid bounds (not constants)!" if not ( start and e and step )
       rescue Exception => ex
         if not ( start and e and step ) then
-          BOAST::pop_env( :replace_constants )
-          return self.print(*args) if not ( start and e and step )
+          pop_env( :replace_constants )
+          return pr(*args) if not ( start and e and step )
         end
       end
-      BOAST::pop_env( :replace_constants )
+      pop_env( :replace_constants )
       range = start..e
       @iterator.force_replace_constant = true
       range.step(step) { |i|
@@ -87,28 +101,28 @@ module BOAST
 
     def open
       s=""
-      s += BOAST::indent
-      s += self.to_s
-      BOAST::get_output.puts s
-      BOAST::increment_indent_level      
+      s += indent
+      s += to_s
+      output.puts s
+      increment_indent_level      
       return self
     end 
 
-    def print(*args)
-      self.open
+    def pr(*args)
+      open
       if @block then
         @block.call(*args)
-        self.close
+        close
       end
       return self
     end
 
     def close
-      BOAST::decrement_indent_level      
+      decrement_indent_level      
       s = ""
-      s += BOAST::indent
+      s += indent
       s += end_string
-      BOAST::get_output.puts s
+      output.puts s
       return self
     end
 

data/lib/BOAST/FuncCall.rb

@@ -1,9 +1,10 @@
 module BOAST
 
   class FuncCall
-    include BOAST::Arithmetic
-    include BOAST::Inspectable
-    extend BOAST::Functor
+    include PrivateStateAccessor
+    include Arithmetic
+    include Inspectable
+    extend Functor
 
     @return_type
     @options
@@ -35,8 +36,8 @@ module BOAST
     end
       
     def to_s
-      return self.to_s_fortran if BOAST::get_lang == FORTRAN
-      return self.to_s_c if [C, CL, CUDA].include?( BOAST::get_lang )
+      return to_s_fortran if lang == FORTRAN
+      return to_s_c if [C, CL, CUDA].include?( lang )
     end
 
     def to_s_fortran
@@ -51,12 +52,12 @@ module BOAST
       s += "#{func_name}(#{@args.join(", ")})"
     end
 
-    def print
+    def pr
       s=""
-      s += BOAST::indent
-      s += self.to_s
-      s += ";" if [C, CL, CUDA].include?( BOAST::get_lang )
-      BOAST::get_output.puts s
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang )
+      output.puts s
       return self
     end
   end