BOAST 0.995 → 0.996

data/lib/BOAST/FuncCall.rb

@@ -0,0 +1,66 @@
+module BOAST
+
+  class FuncCall
+    include BOAST::Arithmetic
+
+    @return_type
+    @options
+    def self.parens(*args,&block)
+      return self::new(*args,&block)
+    end
+
+    attr_reader :func_name
+    attr_reader :args
+    attr_accessor :prefix
+
+    def initialize(func_name, *args)
+      @func_name = func_name
+      if args.last.kind_of?(Hash) then
+        @options = args.last
+        @args = args[0..-2]
+      else
+        @args = args
+      end
+      @return_type = @options[:returns] if @options
+    end
+
+    def to_var
+      if @return_type then
+        if @return_type.kind_of?(Variable)
+          return @return_type.copy("#{self}")
+        else
+          return Variable::new("#{self}", @return_type)
+        end
+      end
+      return nil
+    end
+      
+    def to_s
+      self.to_str
+    end
+
+    def to_str
+      return self.to_str_fortran if BOAST::get_lang == FORTRAN
+      return self.to_str_c if [C, CL, CUDA].include?( BOAST::get_lang )
+    end
+    def to_str_fortran
+      s = ""
+      s += @prefix if @prefix
+      s += "#{func_name}(#{@args.join(", ")})"
+    end
+    def to_str_c
+      s = ""
+      s += @prefix if @prefix
+      s += "#{func_name}(#{@args.join(", ")})"
+    end
+    def print(final=true)
+      s=""
+      s += " "*BOAST::get_indent_level if final
+      s += self.to_str
+      s += ";" if final and [C, CL, CUDA].include?( BOAST::get_lang )
+      BOAST::get_output.puts s if final
+      return s
+    end
+  end
+
+end

data/lib/BOAST/If.rb

@@ -0,0 +1,109 @@
+module BOAST
+
+  class If
+    def self.parens(*args,&block)
+      return self::new(*args,&block)
+    end
+
+    attr_reader :conditions
+    def initialize(*conditions, &block)
+      @conditions = []
+      @blocks = []
+      if conditions.size == 0 then
+        raise "Illegal if construct!"
+      elsif conditions.size == 1 then
+        @conditions.push(conditions[0])
+        @blocks.push(block)
+      elsif conditions.size.even? then
+        (0..conditions.size-1).step(2) { |i|
+          @conditions[i/2] = conditions[i]
+          @blocks[i/2] = conditions[i+1]
+        }
+      else
+        (0..conditions.size-2).step(2) { |i|
+          @conditions[i/2] = conditions[i]
+          @blocks[i/2] = conditions[i+1]
+        }
+        @blocks.push(conditions.last)
+      end
+    end
+    def to_s(*args)
+      self.to_str(*args)
+    end
+    def to_str(condition, first= true)
+      return self.to_str_fortran(condition, first) if BOAST::get_lang == FORTRAN
+      return self.to_str_c(condition, first) if [C, CL, CUDA].include?( BOAST::get_lang )
+    end
+    def to_str_fortran(condition, first)
+      s = ""
+      if first then
+        s += "if ( #{condition} ) then"
+      else
+        if condition then
+          s += "else if ( #{condition} ) then"
+        else
+          s += "else"
+        end
+      end
+      return s
+    end
+    def to_str_c(condition, first)
+      s = ""
+      if first then
+        s += "if(#{condition}){"
+      else
+        if condition then
+          s += "} else if(#{condition}){"
+        else
+          s += "} else {"
+        end
+      end
+      return s
+    end
+    def print(*args)
+      s=""
+      s += " "*BOAST::get_indent_level
+      s += self.to_str(@conditions.first)
+      BOAST::increment_indent_level      
+      BOAST::get_output.puts s
+      if @blocks.size > 0 then
+        if @blocks[0] then
+          @blocks[0].call(*args)
+        end
+        @blocks[1..-1].each_index { |indx|
+          BOAST::decrement_indent_level      
+          s=""
+          s += " "*BOAST::get_indent_level 
+          s += self.to_str(@conditions[1..-1][indx],false)
+          BOAST::increment_indent_level
+          BOAST::get_output.puts s
+          @blocks[1..-1][indx].call(*args)
+        }
+        self.close
+      end
+      return self
+    end
+    def close(final=true)
+      return self.close_fortran(final) if BOAST::get_lang == FORTRAN
+      return self.close_c(final) if [C, CL, CUDA].include?( BOAST::get_lang )
+    end
+    def close_c(final=true)
+      s = ""
+      BOAST::decrement_indent_level      
+      s += " "*BOAST::get_indent_level if final
+      s += "}"
+      BOAST::get_output.puts s if final
+      return s
+    end
+    def close_fortran(final=true)
+      s = ""
+      BOAST::decrement_indent_level      
+      s += " "*BOAST::get_indent_level if final
+      s += "end if"
+      BOAST::get_output.puts s if final
+      return s
+    end
+
+  end
+
+end 

data/lib/BOAST/Index.rb

@@ -0,0 +1,123 @@
+module BOAST
+  class Index < Expression
+    attr_reader :source
+    attr_reader :indexes
+    def initialize(source, indexes)
+      @source = source
+      @indexes = indexes
+    end
+
+    def to_var
+      var = @source.copy("#{self}", :const => nil, :constant => nil, :dim => nil, :dimension => nil, :direction => nil, :dir => nil)
+      return var
+    end
+
+    def to_s
+      self.to_str
+    end
+    def to_str
+      return self.to_str_fortran if BOAST::get_lang == FORTRAN
+      return self.to_str_c if [C, CL, CUDA].include?( BOAST::get_lang )
+    end
+    def to_str_fortran
+      s = ""
+      s += "#{@source}(#{@indexes.join(", ")})"
+      return s
+    end
+    def to_str_texture
+      raise "Unsupported language #{BOAST::get_lang} for texture!" if not [CL, CUDA].include?( BOAST::get_lang )
+      raise "Write is unsupported for textures!" if not ( @source.constant or @source.direction == :in )
+      dim_number = 1
+      if @source.dimension then
+        dim_number == @source.dimension.size
+      end
+      raise "Unsupported number of dimension: #{dim_number}!" if dim_number > 3
+      s = ""
+      if BOAST::get_lang == CL then
+        s += "as_#{@source.type.decl}("
+        s += "read_imageui(#{@source}, #{@source.sampler}, "
+        if dim_number == 1 then
+          s += "int2(#{@indexes[0]},0)"
+        else
+          if dim_number == 2 then
+            s += "int2("
+          else
+            s += "int3("
+          end
+          s += "#{@indexes.join(", ")})"
+        end
+        s += ")"
+        if @source.type.size == 4 then
+          s += ".x"
+        elsif @source.type.size == 8 then
+          s += ".xy"
+        end
+        s += ")"
+      else
+        s += "tex#{dim_number}Dfetch(#{@source},"
+        if dim_number == 1 then
+          s += "#{@indexes[0]}"
+        else
+          if dim_number == 2 then
+            s += "int2("
+          else
+            s += "int3("
+          end
+          s += "#{@indexes.join(", ")})"
+        end
+        s += ")"
+      end
+      return s
+    end
+    def to_str_c
+      return to_str_texture if @source.texture
+      dim = @source.dimension.first
+      if dim.val2 then
+        start = dim.val1
+      else
+        start = BOAST::get_array_start
+      end
+      sub = "#{@indexes.first} - (#{start})"
+      i=1
+      ss = ""
+      @source.dimension[0..-2].each{ |d|
+        if d.size then
+          ss += " * (#{d.size})"
+        elsif d.val2 then
+          ss += " * (#{d.val2} - (#{d.val1}) + 1)"
+        else
+          raise "Unkwown dimension size!"
+        end
+        dim = @source.dimension[i]
+        if dim.val2 then
+          start = dim.val1
+        else
+          start = BOAST::get_array_start
+        end
+        sub += " + (#{@indexes[i]} - (#{start}))"+ss
+        i+=1
+      }
+      if BOAST::get_replace_constants then
+        begin
+#         puts sub
+         indx = eval(sub)
+         indx = indx.to_i
+#         puts indx
+         return "#{@source.constant[indx]}"
+        rescue Exception => e
+        end
+      end
+      s = "#{@source}[" + sub + "]"
+      return s
+    end
+    def print(final=true)
+      s=""
+      s += " "*BOAST::get_indent_level if final
+      s += self.to_str
+      s += ";" if final and [C, CL, CUDA].include?( BOAST::get_lang )
+      BOAST::get_output.puts s if final
+      return s
+    end
+  end
+
+end

data/lib/BOAST/Operators.rb

@@ -5,7 +5,7 @@ module BOAST
       case BOAST::get_architecture
       when X86
         case type
-        when Int
+        when BOAST::Int
           size = "#{type.size*8}"
           name = ""
           if type.total_size*8 > 64
@@ -22,7 +22,7 @@ module BOAST
             name += "u"
           end
           return name += size
-        when Real
+        when BOAST::Real
           case type.size
           when 4
             return "ps" if type.vector_length > 1
@@ -34,13 +34,13 @@ module BOAST
         else
           raise "Undefined vector type!"
         end
-      when ARM
+      when BOAST::ARM
         case type
-        when Int
+        when BOAST::Int
           name = "#{ type.signed ? "s" : "u" }"
           name += "#{ type.size * 8}"
           return name
-        when Real
+        when BOAST::Real
           return "f#{type.size*8}"
         else
           raise "Undefined vector type!"
@@ -52,7 +52,7 @@ module BOAST
 
     def Operator.convert(arg, type)
       case BOAST::get_architecture
-      when X86
+      when BOAST::X86
         s1 = arg.type.total_size*8
         s2 = type.total_size*8
         n1 = get_vector_name(arg.type)
@@ -64,14 +64,14 @@ module BOAST
         elsif [s1, s2].max <= 512 then
           return "_mm512_cvt#{n1}_#{n2}( #{arg} )"
         end
-      when ARM
+      when BOAST::ARM
         if type.class != arg.type.class then
           if type.size == arg.type.size then
             s = type.total_size*8
             n1 = get_vector_name(arg.type)
             n2 = get_vector_name(type)
             return "vcvt#{ s == 128 ? "q" : "" }_#{n2}_#{n1}( #{arg} )"
-          elsif type.class == Real then
+          elsif type.class == BOAST::Real then
             intr = convert(arg, arg.type.copy(:size=>type.size))
             return convert(arg.copy(intr, :size => type.size ), type)
           else
@@ -80,9 +80,9 @@ module BOAST
             t2 = type.copy(:size => arg.type.size)
             n2 = get_vector_name( t2 )
             intr = "vcvt#{ s == 128 ? "q" : "" }_#{n2}_#{n1}( #{arg} )"
-            return convert(Variable::from_type(intr, t2), type)
+            return convert(BOAST::Variable::from_type(intr, t2), type)
           end
-        elsif type.class != Real then
+        elsif type.class != BOAST::Real then
           n = get_vector_name(arg.type)
           if type.size == arg.type.size then
             if type.signed == arg.type.signed then
@@ -106,17 +106,17 @@ module BOAST
     end
   end
 
-  class BasicBinaryOperator < Operator
+  class BasicBinaryOperator < BOAST::Operator
 
     def BasicBinaryOperator.to_s(arg1, arg2, return_type)
       #puts "#{arg1.class} * #{arg2.class} : #{arg1} * #{arg2}"
-      if BOAST::get_lang == C and (arg1.class == Variable and arg2.class == Variable) and (arg1.type.vector_length > 1 or arg2.type.vector_length > 1) then
+      if BOAST::get_lang == BOAST::C and (arg1.class == BOAST::Variable and arg2.class == BOAST::Variable) and (arg1.type.vector_length > 1 or arg2.type.vector_length > 1) then
         raise "Vectors have different length: #{arg1} #{arg1.type.vector_length}, #{arg2} #{arg2.type.vector_length}" if arg1.type.vector_length != arg2.type.vector_length
         #puts "#{arg1.type.signed} #{arg2.type.signed} #{return_type.type.signed}"
 	return_name = get_vector_name(return_type.type)
         size = return_type.type.total_size * 8
         case BOAST::get_architecture
-        when X86
+        when BOAST::X86
           if arg1.type != return_type.type
             a1 = convert(arg1, return_type.type)
           else
@@ -133,7 +133,7 @@ module BOAST
           end
           intr_name += "_#{intr_name_X86}_#{return_name}"
           return "#{intr_name}( #{a1}, #{a2} )"
-        when ARM
+        when BOAST::ARM
           if arg1.type.class != return_type.type.class then
             a1 = convert(arg1, return_type.type)
           else
@@ -157,11 +157,11 @@ module BOAST
     end
   end
 
-  class Set < Operator
+  class Set < BOAST::Operator
 
     def Set.to_s(arg1, arg2, return_type)
-      if BOAST::get_lang == C then
-        if arg1.class == Variable and arg1.type.vector_length > 1 then
+      if BOAST::get_lang == BOAST::C then
+        if arg1.class == BOAST::Variable and arg1.type.vector_length > 1 then
           if arg1.type == arg2.type then
             return basic_usage(arg1, arg2)
           elsif arg1.type.vector_length == arg2.type.vector_length then
@@ -169,18 +169,18 @@ module BOAST
           elsif arg2.type.vector_length == 1 then
             size = arg1.type.total_size*8
             case BOAST::get_architecture
-            when ARM
+            when BOAST::ARM
               intr_name = "vmov"
               intr_name += "q" if size == 128
               intr_name += "_n_#{get_vector_name(arg1.type)}"
-            when X86
-              return "(#{arg1} = _m_from_int64( #{a2} ))" if arg1.type.class == Int and arg1.type.size == 8 and size == 64
+            when BOAST::X86
+              return "(#{arg1} = _m_from_int64( #{a2} ))" if arg1.type.class == BOAST::Int and arg1.type.size == 8 and size == 64
               intr_name = "_mm"
               if size > 128 then
                 intr_name += "#{size}"
               end
               intr_name += "_set1_#{get_vector_name(arg1.type).gsub("u","")}"
-              intr_name += "x" if arg1.type.class == Int and arg1.type.size == 8
+              intr_name += "x" if arg1.type.class == BOAST::Int and arg1.type.size == 8
             else
               raise "Unsupported architecture!"
             end
@@ -201,21 +201,21 @@ module BOAST
     end
   end
 
-  class Different < Operator
+  class Different < BOAST::Operator
     def Different.to_s(arg1, arg2, return_type)
       return basic_usage(arg1, arg2)
     end
 
     def Different.basic_usage(arg1, arg2)
-      return "#{arg1} /= #{arg2}" if BOAST::get_lang == FORTRAN
+      return "#{arg1} /= #{arg2}" if BOAST::get_lang == BOAST::FORTRAN
       return "#{arg1} != #{arg2}"
     end
   end
 
-  class Affectation < Operator
+  class Affectation < BOAST::Operator
     def Affectation.to_s(arg1, arg2, return_type)
-      if BOAST::get_lang == C then
-        if arg1.class == Variable and arg1.type.vector_length > 1 then
+      if BOAST::get_lang == BOAST::C then
+        if arg1.class == BOAST::Variable and arg1.type.vector_length > 1 then
           #puts "#{arg1.type.vector_length} #{arg2.type.vector_length}"
           if arg1.type == arg2.type then
             return basic_usage(arg1, arg2)
@@ -230,12 +230,12 @@ module BOAST
               a2 = a2[1..-1]
             end
             case BOAST::get_architecture
-            when ARM
+            when BOAST::ARM
               intr_name = "vldl"
               intr_name += "q" if size == 128
               intr_name += "_#{get_vector_name(arg1.type)}"
-            when X86
-              if arg1.type.class == Int and size == 64 then
+            when BOAST::X86
+              if arg1.type.class == BOAST::Int and size == 64 then
                 return "#{arg1} = _m_from_int64( *((int64_t * ) #{a2} ) )"
               end
               intr_name = "_mm"
@@ -243,7 +243,7 @@ module BOAST
                 intr_name += "#{size}"
               end
               intr_name += "_load_"
-              if arg1.type.class == Int then
+              if arg1.type.class == BOAST::Int then
                 intr_name += "si#{size}"
               else
                 intr_name += "#{get_vector_name(arg1.type)}"
@@ -255,7 +255,7 @@ module BOAST
           else
             raise "Unknown convertion between vectors of different length!"
           end
-        elsif arg2.class == Variable and arg2.type.vector_length > 1 then
+        elsif arg2.class == BOAST::Variable and arg2.type.vector_length > 1 then
           size = arg2.type.total_size*8
           a1 = "#{arg1}"
           if a1[0] != "*" then
@@ -264,12 +264,12 @@ module BOAST
             a1 = a1[1..-1]
           end
           case BOAST::get_architecture
-          when ARM
+          when BOAST::ARM
             intr_name = "vstl"
             intr_name += "q" if size == 128
             intr_name += "_#{get_vector_name(arg2.type)}"
-          when X86
-            if arg2.type.class == Int and size == 64 then
+          when BOAST::X86
+            if arg2.type.class == BOAST::Int and size == 64 then
               return " *((int64_t * ) #{a1}) = _m_to_int64( #{arg2} )"
             end
             intr_name = "_mm"
@@ -277,7 +277,7 @@ module BOAST
               intr_name += "#{size}"
             end
             intr_name += "_store_"
-            if arg2.type.class == Int then
+            if arg2.type.class == BOAST::Int then
               intr_name += "si#{size}"
             else
               intr_name += "#{get_vector_name(arg2.type)}"
@@ -299,7 +299,7 @@ module BOAST
     end
   end
 
-  class Multiplication < BasicBinaryOperator
+  class Multiplication < BOAST::BasicBinaryOperator
     class << self
 
       def symbol
@@ -321,7 +321,7 @@ module BOAST
     end
   end
 
-  class Addition < BasicBinaryOperator
+  class Addition < BOAST::BasicBinaryOperator
     class << self
 
       def symbol
@@ -343,7 +343,7 @@ module BOAST
     end
   end
 
-  class Substraction < BasicBinaryOperator
+  class Substraction < BOAST::BasicBinaryOperator
     class << self
 
       def symbol
@@ -365,7 +365,7 @@ module BOAST
     end
   end
 
-  class Division < BasicBinaryOperator
+  class Division < BOAST::BasicBinaryOperator
     class << self
 
       def symbol
@@ -387,16 +387,54 @@ module BOAST
     end
   end
 
-  class Minus < Operator
+  class Minus < BOAST::Operator
     def Minus.to_s(arg1, arg2, return_type)
       return " -(#{arg2})"
     end
   end
 
-  class Not < Operator
+  class Not < BOAST::Operator
     def Not.to_s(arg1, arg2, return_type)
       return " ! #{arg2}"
     end
   end
 
+  class Ternary
+    include BOAST::Arithmetic
+
+    def self.parens(*args,&block)
+      return self::new(*args,&block)
+    end
+
+    attr_reader :operand1
+    attr_reader :operand2
+    attr_reader :operand3
+    
+    def initialize(x,y,z)
+      @operand1 = x
+      @operand2 = y
+      @operand3 = z
+    end
+
+    def to_s
+      self.to_str
+    end
+
+    def to_str
+      raise "Ternary operator unsupported in FORTRAN!" if BOAST::get_lang == BOAST::FORTRAN
+      return self.to_str_c if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
+    end
+    def to_str_c
+      s = ""
+      s += "(#{@operand1} ? #{@operand2} : #{@operand3})"
+    end
+    def print(final=true)
+      s=""
+      s += " "*BOAST::get_indent_level if final
+      s += self.to_str
+      s += ";" if final and [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
+      BOAST::get_output.puts s if final
+      return s
+    end
+  end
 end

data/lib/BOAST/Pragma.rb

@@ -0,0 +1,41 @@
+module BOAST
+
+  class Pragma
+    def self.parens(*args,&block)
+      return self::new(*args,&block)
+    end
+
+    attr_reader :name
+    attr_reader :options
+
+    def initialize(name, options)
+      @name = name
+      @options = options
+    end
+
+    def to_s
+      self.to_str
+    end
+
+    def to_str
+      s = ""
+      if BOAST::get_lang == FORTRAN then
+        s += "$!"
+      else
+        s += "#pragma"
+      end
+      @options.each{ |opt|
+        s += " #{opt}"
+      }
+      return s
+    end
+
+    def print(final = true)
+      s=""
+      s += self.to_str
+      BOAST::get_output.puts s if final
+      return s
+    end
+  end
+
+end