linmeric 0.1.0

data/lib/linmeric/Error_print.rb

@@ -0,0 +1,66 @@
+#! /usr/bin/env ruby
+
+module PrintError
+  def self.print(message,expression,pos)
+    puts message
+    puts expression
+    puts " " * pos + "^"
+    #puts
+  end
+  
+  def self.default(token,expression)
+    message = "  Sintax Error: unexpected #{token.attribute} token '#{token.me}' found"
+    self.print(message,expression,token.position)
+  end
+  
+  def self.reduced(token,expression)
+    message = "  Sintax Error: unexpected #{token.attribute} '#{token.me}' found"
+    self.print(message,expression,token.position)
+  end
+  
+  def self.unknown(token,expression)
+    message = "  Sintax Error: unknown #{token.attribute} '#{token.me}' found"
+    self.print(message,expression,token.position)
+  end
+  
+  def self.missmatch(token,expression,expectation)
+    message = "  Sintax Error: expecting #{expectation} but #{token.attribute} token '#{token.me}' found"
+    self.print(message,expression,token.position)
+  end
+  
+  def self.missing(token,expression)
+    message = "  Sintax Error: missing argument for '#{token.me}' #{token.attribute}"
+    self.print(message,expression,token.position)
+  end
+  
+  def self.no_final_quotes(expression,position)
+    message = "  Sintax Error: missing quotes for block"
+    self.print(message,expression,position)
+  end
+  
+  def self.missing_general_string(position,expression)
+    message = "  Sintax Error: missing agument block"
+    self.print(message,expression,position)
+  end
+  
+  def self.numPoint_missing(position,expression)
+    message = "  Sintax Error: number of points is missing"
+    self.print(message,expression,position)
+  end
+  
+  def self.missing_expression_after_equal(pos,expression)
+    message = "  Sintax Error: missing expression after EQUAL operator"
+    self.print(message,expression,pos)
+  end
+  
+  def self.unexpected_token_in_solve(token,expression)
+    message = "  Sintax Error: unexpected #{token.attribute} token '#{token.me}' in 'solve:' args"
+    self.print(message,expression,token.position)
+  end
+  
+  def self.missing_integ_range(pos,expression)
+    message = "  Sintax Error: missing integration range for 'integ:' method"
+    self.print(message,expression,pos)
+  end
+  
+end

data/lib/linmeric/Function_class.rb

@@ -0,0 +1,249 @@
+#! /usr/bin/env ruby
+
+require_relative 'CnGal_new_classes.rb'
+require_relative 'Integrators.rb'
+
+class Function
+  def initialize(str)
+    @inp = str
+    @vars = []
+    @i = 0
+    @funct = convert(str)
+  end
+  
+  def ok? 
+    @funct == nil ? (return false) : (return true)
+  end
+  
+  def to_block(n = 0)
+    n = @vars.size if n == 0
+    return nil if not self.ok?
+    return nil if n < @vars.size
+    b_v = "|#{vars(n)}|" if @vars.size > 0
+    return "{ #{b_v} #{@funct} }"
+  end
+  
+  def vars(n = 0)
+    n = @vars.size if n == 0
+    return nil if not self.ok?
+    return nil if n < @vars.size 
+    var = @vars[0]
+    for i in 1...@vars.length do
+      var += ',' + @vars[i]
+    end
+    if n != @vars.size then
+      i = 0
+      ('a'..'z').each do |ch|
+        unless @vars.include? ch
+          i +=1
+          var += ',' + ch
+          break if i == (n - @vars.size)
+        end
+      end
+    end
+    return var
+  end
+  
+  def show()
+    puts @inp
+  end
+  
+  def integrate(r,n,m = 'simpson')
+    return nil unless self.ok?
+    block = self.to_block(1)
+    unless block == nil
+      m = (m - '"').downcase
+      case m
+        when "trapezes"
+          return eval("Integrators.trapezi(r.sx,r.dx,n)#{block}")
+        when "midpoint"
+          return eval("Integrators.simpson(r.sx,r.dx,n)#{block}")
+        when "simpson"
+          return eval("Integrators.simpson(r.sx,r.dx,n)#{block}")
+        when "rectl"
+          return eval("Integrators.rettsx(r.sx,r.dx,n)#{block}")
+        when "rectr"
+          return eval("Integrators.rettdx(r.sx,r.dx,n)#{block}")
+        when "boole"
+          return eval("Integrators.boole(r.sx,r.dx,n)#{block}")
+        else
+          puts "Argument Error: Invalid integration method"; #puts
+          return nil
+      end
+    end
+    puts "Argument Error: bad function for integration"; #puts
+    return nil
+  end
+  
+ private
+  
+  def tokenize(str)
+    tokens = Array.new
+    x = ''
+    str.each_char do |ch|
+      case ch
+        when /[\+\-\*\/\^\(\)]/
+          tokens.push ch
+        when /[a-zA-Z\0-9\.]/
+          x = tokens.pop if not '+-*/^()'.include? tokens[tokens.size - 1].to_s
+          tokens.push (x + ch)
+          x = ""
+        else
+          return nil
+      end
+    end
+    return tokens
+  end
+  
+  def convert(str)
+    return nil unless str.is_a? String
+    str = tokenize(str)
+    return nil if str == ""
+    return nil unless balanced_brackets? str
+    return translate(str)
+  end
+  
+  def balanced_brackets?(expr)
+    return nil unless expr.is_a? Array
+    brakets = 0
+    expr.each do |el|
+      case el
+        when '('
+          brakets += 1
+        when ')'
+          brakets -= 1
+      end
+    end
+    brakets == 0 ? (return true) : (return false)
+  end
+  
+  def translate(str,open_b = false)
+    return nil unless str.is_a? Array
+    funct = ""
+    state = 0
+    while @i < str.size
+      case state
+        when 0
+          case str[@i]
+            when /[\+\-]/
+              funct += str[@i]
+              state = 1
+            when /\p{Alpha}/
+              if Tool.f.include? str[@i] then
+                funct += "Math::#{str[@i]}"
+                state = 4 unless str[@i] == "PI"
+                state = 2 if str[@i] == "PI"
+              elsif str[@i].size == 1
+                ch = str[@i].downcase
+                funct += ch
+                @vars << ch unless @vars.include? ch
+                state = 2
+              else
+                return nil
+              end
+            when /[0-9]+/
+              if str[@i].integer? or str[@i].float? then
+                funct += str[@i]
+                state = 2
+              else
+                return nil
+              end
+            when "("
+              funct += "("
+              @i += 1
+              part = translate(str,true)
+              state = 2
+              if part != nil then
+                funct += part
+              else
+                return nil
+              end
+            else
+              return nil
+          end
+          
+        # state 1 expects or a variable (single char) or a number or a function or (
+        when 1
+          case str[@i]
+            when /\p{Alpha}/
+              if Tool.f.include? str[@i] then
+                funct += "Math::#{str[@i]}"
+                state = 4 unless str[@i] == "PI"
+                state = 2 if str[@i] == "PI"
+              elsif str[@i].size == 1
+                ch = str[@i].downcase
+                funct += ch
+                @vars << ch unless @vars.include? ch
+                state = 2
+              else
+                return nil
+              end
+            when /[0-9]+/ 
+              if str[@i].integer? or str[@i].float? then
+                funct += str[@i]
+                state = 2
+              else
+                return nil
+              end
+            when "("
+              funct += "("
+              state = 3
+            else
+              return nil
+              
+          end
+        
+        # state 2 expects an operator or )
+        when 2
+          if /[\+\-\*\/\^]{1}/ =~ str[@i] then
+            funct += str[@i] if str[@i] != "^"
+            funct += "**" if str[@i] == "^"
+            state = 1
+          elsif str[@i] == ")"
+            if open_b then
+              return funct + ")"
+            else
+              return nil
+            end
+          else
+            return nil
+          end
+       
+        # state 3 expects a sub_expression not beginnin with (
+        when 3
+          part = translate(str,true)
+          state = 2
+          if part != nil then
+            funct += part
+          else
+            return nil
+          end
+        
+        # state 4 expects a sub_expression beginning with (
+        when 4
+          if str[@i] == '(' then
+            @i += 1
+            part = translate(str,true)
+            state = 2
+            if part != nil then
+              funct += '(' + part
+            else
+              return nil
+            end
+          else
+            return nil
+          end
+          
+        else
+          return nil
+      end
+    @i += 1
+    end
+    return nil if state == 1
+    return funct
+  end
+  
+end
+
+
+

data/lib/linmeric/Integrators.rb

@@ -0,0 +1,76 @@
+#! /usr/bin/env ruby
+
+module Integrators
+   def self.trapezi(a,b,n)
+     #Implementazione
+       h=(b-a)/n.to_f
+       int_parz=0
+       for i in 0...n
+          #calcolo primo addendo =f(x_i)
+          f1=yield(a+i*h)  #chiama il blocco definito sotto
+          #calcolo secondo addendo = f(X_{i+1})
+          f2=yield(a+(i+1)*h)
+          #calcolo area trapezio
+          trap=0.5*h*(f1+f2)
+          int_parz+=trap
+       end
+       return int_parz
+   end
+   
+   def self.midpoint(a,b,n)
+     parz=0
+     h=(b-a)/n.to_f
+     for i in 0...n
+       f1 = yield(a+(i+0.5)*h)
+       parz+=f1
+     end
+     return h*parz
+   end
+   
+   def self.simpson(a,b,n)
+     hs=(b-a)/(n*2.0)
+     intSA =0
+     intSB =0
+     for i in 1..n-1
+       xa = a+ (2*i)*hs
+       intSA+=yield(xa)
+     end
+  
+     for i in 0..n-1
+       xb=a+ (2*i+1)*hs
+       intSB+=yield(xb)
+     end
+     fa=yield(a)
+     fb=yield(b)
+     intS=hs/3.0*(fa+fb+2*intSA+4*intSB)
+     return intS
+   end
+   
+   def self.rettsx(a,b,n)
+     h=(b-a)/n.to_f
+     area=0
+     for i in 0..n-1
+       area+=yield(a+(h*i))*h
+     end
+     return area
+   end
+   
+   def self.rettdx(a,b,n)
+     h=(b-a)/n.to_f
+     area=0
+     for i in 1..n
+       area+=yield(a+(h*i))*h
+     end
+     return area
+   end
+   
+   def self.boole(a,b,n)
+     h=(b-a)/(4*n.to_f)
+     parz=0
+     for i in 0..n-1
+       parz+=7*yield(a+(h*4*i)) +32*yield(a+(h*(4*i+1))) +12*yield(a+(h*(4*i+2))) +32*yield(a+(h*(4*i+3)))+7*yield(a+(h*(4*i+4)))
+     end
+     return (2*h)/45.0*parz
+   end
+  
+end

data/lib/linmeric/LU.rb

@@ -0,0 +1,84 @@
+#! /usr/bin/env ruby
+require_relative 'CnGal_Matrix_class'
+
+module LU
+  
+  # swapping two rows (pivoting)
+  def self.swap(mx,r1,r2)
+    for i in 0...mx.getCls do
+      mx[r1,i],mx[r2,i] = mx[r2,i],mx[r1,i] 
+    end
+    return mx
+  end
+  
+  def self.L()
+    return @L
+  end
+  
+  def self.U()
+    return @U
+  end
+  
+  def self.reset
+    @L = nil
+    @U = nil
+  end
+  
+  def self.factorize(mx,sol)
+    [mx,sol].each do |vec|
+      return nil unless vec.is_a? Matrix
+    end
+    sol = sol.tr if sol.getCls > 1
+    return nil unless sol.getCls == 1
+    return nil unless mx.is_squared?
+    return nil unless mx.getRws == sol.getRws
+    rows = mx.getRws
+    #sol.show;gets
+    for k in 0...rows do
+      column = mx[k...mx.getRws,k].export.map! { |val| val.abs}
+      max_index = column.index(column.max)
+      mx = self.swap(mx,k,k + max_index) unless k == max_index + k
+      sol = self.swap(sol,0,k + max_index) unless k == max_index + k
+      #mx.show;gets
+      for i in (k+1)...mx.getRws do
+        alpha = (mx[k,k] != 0) ? (mx[i,k] / mx[k,k].to_f) : 0
+        mx[i,k] = alpha
+        for j in (k+1)...mx.getCls do
+          mx[i,j] -= alpha * mx[k,j] 
+        end
+      end
+    end
+    #return mx
+    @L = Matrix.identity(mx.getRws) + Matrix.new(mx.getRws,mx.getCls){ |i,j| (i > j) ? mx[i,j] : 0} #
+    @U = Matrix.new(mx.getRws,mx.getCls){ |i,j| (i <= j) ? mx[i,j] : 0}
+    return solve(sol)
+  end
+  
+  def self.solve(sol)
+    z = Matrix.new(sol.getRws,1) {0}
+    x = Matrix.new(sol.getRws,1) {0}
+    for i in 0...sol.getRws do
+      z[i,0] = sol[i,0]
+      for j in 0...i do       
+        z[i,0] -= @L[i,j] * (z[j,0] || 1)
+      end
+    end
+
+    (sol.getRws - 1).downto(0) do |i|
+      x[i,0] = z[i,0]     
+      for j in i...sol.getRws
+        x[i,0] -= (@U[i,j+1] || 0) * (x[j+1,0] || 0)       
+      end
+      x[i,0] = x[i,0] / @U[i,i].to_f
+    end
+    return x
+  end
+  
+  
+end
+
+
+
+
+
+

data/lib/linmeric/Lexer.rb

@@ -0,0 +1,54 @@
+#! /usr/bin/env ruby
+
+require_relative 'CnGal_tools.rb'
+require_relative 'CnGal_new_classes.rb'
+require_relative 'Token.rb'
+
+class Lexer
+
+  def tokenize(expr)
+    token = []
+    temp = ""
+    ignore = false
+    pos = 0
+    i = 0
+    gen_exp = []
+    tokenizers = Tool.operators + [" ","(",")",":",'"',"~"]
+    while i < expr.size
+     # puts expr[i];gets
+      if  (tokenizers.include? expr[i]) then
+        temp += ':' if expr[i] == ':'
+        token << Token.new(temp, pos) unless temp == ""
+        temp = ""
+        token << Token.new(expr[i],i) unless " :".include? expr[i]
+        gen_exp = extract_gen_exp(expr[(i+1)...expr.size]) if expr[i] == '"'
+        token << Token.new(gen_exp[0],pos+1,"GENERAL_STRING") unless gen_exp == [] 
+        i += gen_exp[1] unless gen_exp == []
+        pos = i + ((gen_exp == []) ? 1 : 0)
+        token << Token.new('"',pos) && pos += 1 if gen_exp[2]
+        gen_exp = []
+      else
+        temp += expr[i]
+      end
+      i += 1
+    end 
+    token << Token.new(temp,pos) unless temp == ""
+    return token
+  end
+   
+ private
+ 
+  def extract_gen_exp(string)
+    i = 0
+    gen_exp = ""
+    while i < string.size and string[i] != '"'
+      gen_exp += string[i]
+      i += 1
+    end
+    quotes = (string[i] == '"') ? true : false
+    i += 1 if string[i] == '"'
+    return [gen_exp,i,quotes]
+  end
+  
+   
+end

data/lib/linmeric/Listener.rb

@@ -0,0 +1,191 @@
+#! /usr/bin/env ruby
+
+require 'io/console'
+require_relative 'CnGal_new_classes.rb'
+require_relative 'Archive.rb'
+require_relative 'CnGal_tools.rb'
+
+class Listener
+  CSI = "\e["
+  LETTERS = Tool.letters
+  NUMBERS = "0123456789"
+  SPECIAL_CHARS = "|!$%&/()=?'^~+-*<>-_,:;. " + '"'
+  CHARS = LETTERS + LETTERS.upcase + SPECIAL_CHARS + NUMBERS
+  
+  def initialize
+    @final_string = ""
+    @i = 0
+    @s = 0
+    @exit = false
+    @list = Archive.new
+  end
+  
+  def reset
+    @final_string = ""
+    @i = 0
+    @exit = false
+  end
+  
+  def read_char
+    STDIN.echo = false
+    STDIN.raw!
+
+    input = STDIN.getc.chr
+    if input == "\e" then
+      input << STDIN.read_nonblock(3) rescue nil
+      input << STDIN.read_nonblock(2) rescue nil
+    end
+  ensure
+    STDIN.echo = true
+    STDIN.cooked!
+
+    return input
+  end
+  
+  def show_single_key()
+    c = read_char
+    case c
+    
+      when "\t"
+        # "TAB"
+      
+      # "RETURN"
+      when "\r"
+        puts c
+        @exit = true
+      when "\n"
+        # "LINE FEED"
+      when "\e"
+        # "ESCAPE"
+    
+      # "UP ARROW"
+      when "\e[A"      	
+        temp = @list.previous
+        unless temp == ""
+          clear_line
+          @final_string = temp
+          @i = @final_string.size
+          print @final_string
+        end
+        
+      # "DOWN ARROW"    
+      when "\e[B" 
+          clear_line
+          @final_string = @list.next_
+          @i = @final_string.size
+          print @final_string
+
+      # "RIGHT ARROW"
+      when "\e[C"
+        @list.top
+        unless @i == @final_string.size
+          $stdout.write "#{CSI}1C"
+          @i += 1
+        end 
+      
+      # "LEFT ARROW"  
+      when "\e[D"
+        @list.top
+        unless @i == 0
+          $stdout.write "#{CSI}1D" 
+          @i -= 1
+        end
+     
+      # Delete char 
+      when "\177" 
+        @list.top
+        unless @i == 0
+          $stdout.write "#{CSI}1D"
+          for i in (@i)...@final_string.size do
+            $stdout.write "#{@final_string[i]}"
+          end
+          $stdout.write " "
+          @final_string = @final_string.remove(@i-1)
+          for i in (@i-2)...@final_string.size do
+            $stdout.write "#{CSI}1D"
+          end
+          @i -= 1
+        end
+
+      when "\004"
+        # "DELETE"
+      when "\e[3~"
+        # "ALTERNATE DELETE"
+      
+      # "Ctrl + C"
+      when "\u0003"        
+#        puts
+#        exit 0
+      when /^.$/
+        @list.top
+        if CHARS.include? c
+          if @i < @final_string.size then
+            last_i = @i + 2
+            @final_string.insert @i, c
+            clear_line
+            $stdout.write "#{@final_string}"
+            cursor_to(last_i)
+            @i = last_i - 1
+          else
+            print c
+            @final_string += c
+            @i += 1
+          end
+        elsif c == "\f" then
+          @i = 0
+          print "\e[H\e[2J"
+          print "Linmeric-main> "
+        end
+    end
+  end
+  
+  def gets()
+    show_single_key while(!@exit)
+    @list.store(@final_string)
+    return @final_string.clone
+  end
+  
+ private
+ 
+  def clear_line
+    if @i < @final_string.size
+      for i in @i...@final_string.size do
+        $stdout.write "#{CSI}1C"
+      end
+    end
+    @i = (@final_string == nil or @final_string == "") ? 0 : @final_string.size
+    for i in 0...@i do
+      $stdout.write "#{CSI}1D"
+      $stdout.write " "
+      $stdout.write "#{CSI}1D"
+    end
+    @i = 0
+  end
+  
+  def cursor_to(pos)
+    return nil if pos < 0
+    for i in pos..@final_string.size
+      $stdout.write "#{CSI}1D"
+    end
+  end
+  
+end
+
+
+
+########################################
+#                TESTS                 #
+########################################
+=begin
+listener = Listener.new
+while true
+print '> '
+listener.gets
+listener.reset
+end
+=end
+
+
+
+
+