everypolitician-daff 1.3.26

data/lib/lib/coopy/unit.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Unit 
+    
+    def initialize(l = -2,r = -2,p = -2)
+      @l = l
+      @r = r
+      @p = p
+    end
+    
+    attr_accessor :l
+    attr_accessor :r
+    attr_accessor :p
+    
+    def lp 
+      if @p == -2 
+        return @l
+      else 
+        return @p
+      end
+    end
+    
+    def to_s 
+      return _hx_str(::Coopy::Unit.describe(@p)) + "|" + _hx_str(::Coopy::Unit.describe(@l)) + ":" + _hx_str(::Coopy::Unit.describe(@r)) if @p >= -1
+      _hx_str(::Coopy::Unit.describe(@l)) + ":" + _hx_str(::Coopy::Unit.describe(@r))
+    end
+    
+    def from_string(txt)
+      txt += "]"
+      at = 0
+      begin
+        _g1 = 0
+        _g = txt.length
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          ch = (txt[i].ord rescue nil)
+          if ch >= 48 && ch <= 57 
+            at *= 10
+            at += ch - 48
+          elsif ch == 45 
+            at = -1
+          elsif ch == 124 
+            @p = at
+            at = 0
+          elsif ch == 58 
+            @l = at
+            at = 0
+          elsif ch == 93 
+            @r = at
+            return true
+          end
+        end
+      end
+      false
+    end
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    def base26(num)
+      alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+      return "-" if num < 0
+      out = ""
+      begin 
+        out = _hx_str(out) + _hx_str(alpha[num.remainder(26)])
+        num = (num / 26).floor - 1
+      end while(num >= 0)
+      out
+    end
+    
+    public
+    
+    def to_base26string 
+      return _hx_str(self.base26(@p)) + "|" + _hx_str(self.base26(@l)) + ":" + _hx_str(self.base26(@r)) if @p >= -1
+      _hx_str(self.base26(@l)) + ":" + _hx_str(self.base26(@r))
+    end
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    def Unit.describe(i)
+      if i >= 0 
+        return "" + _hx_str(i)
+      else 
+        return "-"
+      end
+    end
+    
+  haxe_me ["coopy", "Unit"]
+  end
+
+end

data/lib/lib/coopy/view.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class View 
+    def toString(d) puts "Abstract View.toString called" end
+    def equals(d1,d2) puts "Abstract View.equals called" end
+    def toDatum(str) puts "Abstract View.toDatum called" end
+    def makeHash() puts "Abstract View.makeHash called" end
+    def hashSet(h,str,d) puts "Abstract View.hashSet called" end
+    def isHash(h) puts "Abstract View.isHash called" end
+    def hashExists(h,str) puts "Abstract View.hashExists called" end
+    def hashGet(h,str) puts "Abstract View.hashGet called" end
+    def isTable(t) puts "Abstract View.isTable called" end
+    def getTable(t) puts "Abstract View.getTable called" end
+    def wrapTable(t) puts "Abstract View.wrapTable called" end
+  haxe_me ["coopy", "View"]
+  end
+
+end

data/lib/lib/coopy/viterbi.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Coopy
+  class Viterbi 
+    
+    def initialize
+      @k = @t = 0
+      self.reset
+      @cost = ::Coopy::SparseSheet.new
+      @src = ::Coopy::SparseSheet.new
+      @path = ::Coopy::SparseSheet.new
+    end
+    
+    protected
+    
+    attr_accessor :k
+    attr_accessor :t
+    attr_accessor :index
+    attr_accessor :mode
+    attr_accessor :path_valid
+    attr_accessor :best_cost
+    attr_accessor :cost
+    attr_accessor :src
+    attr_accessor :path
+    
+    public
+    
+    def reset 
+      @index = 0
+      @mode = 0
+      @path_valid = false
+      @best_cost = 0
+    end
+    
+    def set_size(states,sequence_length)
+      @k = states
+      @t = sequence_length
+      @cost.resize(@k,@t,0)
+      @src.resize(@k,@t,-1)
+      @path.resize(1,@t,-1)
+    end
+    
+    protected
+    
+    def assert_mode(_next)
+      @index+=1 if _next == 0 && @mode == 1
+      @mode = _next
+    end
+    
+    public
+    
+    def add_transition(s0,s1,c)
+      resize = false
+      if s0 >= @k 
+        @k = s0 + 1
+        resize = true
+      end
+      if s1 >= @k 
+        @k = s1 + 1
+        resize = true
+      end
+      if resize 
+        @cost.non_destructive_resize(@k,@t,0)
+        @src.non_destructive_resize(@k,@t,-1)
+        @path.non_destructive_resize(1,@t,-1)
+      end
+      @path_valid = false
+      self.assert_mode(1)
+      if @index >= @t 
+        @t = @index + 1
+        @cost.non_destructive_resize(@k,@t,0)
+        @src.non_destructive_resize(@k,@t,-1)
+        @path.non_destructive_resize(1,@t,-1)
+      end
+      sourced = false
+      if @index > 0 
+        c += @cost.get(s0,@index - 1)
+        sourced = @src.get(s0,@index - 1) != -1
+      else 
+        sourced = true
+      end
+      if sourced 
+        if c < @cost.get(s1,@index) || @src.get(s1,@index) == -1 
+          @cost.set(s1,@index,c)
+          @src.set(s1,@index,s0)
+        end
+      end
+    end
+    
+    def end_transitions 
+      @path_valid = false
+      self.assert_mode(0)
+    end
+    
+    def begin_transitions 
+      @path_valid = false
+      self.assert_mode(1)
+    end
+    
+    def calculate_path 
+      return if @path_valid
+      self.end_transitions
+      best = 0
+      bestj = -1
+      if @index <= 0 
+        @path_valid = true
+        return
+      end
+      begin
+        _g1 = 0
+        _g = @k
+        while(_g1 < _g) 
+          j = _g1
+          _g1+=1
+          if (@cost.get(j,@index - 1) < best || bestj == -1) && @src.get(j,@index - 1) != -1 
+            best = @cost.get(j,@index - 1)
+            bestj = j
+          end
+        end
+      end
+      @best_cost = best
+      begin
+        _g11 = 0
+        _g2 = @index
+        while(_g11 < _g2) 
+          j1 = _g11
+          _g11+=1
+          i = @index - 1 - j1
+          @path.set(0,i,bestj)
+          puts "Problem in Viterbi" if !(bestj != -1 && (bestj >= 0 && bestj < @k))
+          bestj = @src.get(bestj,i)
+        end
+      end
+      @path_valid = true
+    end
+    
+    def to_s 
+      self.calculate_path
+      txt = ""
+      begin
+        _g1 = 0
+        _g = @index
+        while(_g1 < _g) 
+          i = _g1
+          _g1+=1
+          if @path.get(0,i) == -1 
+            txt += "*"
+          else 
+            txt += @path.get(0,i)
+          end
+          txt += " " if @k >= 10
+        end
+      end
+      txt += " costs " + _hx_str(self.get_cost)
+      txt
+    end
+    
+    def length 
+      self.calculate_path if @index > 0
+      @index
+    end
+    
+    def get(i)
+      self.calculate_path
+      @path.get(0,i)
+    end
+    
+    def get_cost 
+      self.calculate_path
+      @best_cost
+    end
+    
+  haxe_me ["coopy", "Viterbi"]
+  end
+
+end

data/lib/lib/haxe/ds/int_map.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Haxe
+module Ds
+  class IntMap 
+    
+    def initialize
+    end
+    
+    def get(key)
+      self[key]
+    end
+    
+  haxe_me ["haxe", "ds", "IntMap"]
+  end
+
+end
+end

data/lib/lib/haxe/ds/string_map.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Haxe
+module Ds
+  class StringMap 
+    
+    def initialize
+    end
+    
+    def get(key)
+      self[key]
+    end
+    
+  haxe_me ["haxe", "ds", "StringMap"]
+  end
+
+end
+end

data/lib/lib/haxe/format/json_parser.rb

@@ -0,0 +1,265 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Haxe
+module Format
+  class JsonParser 
+    
+    def initialize(str)
+      @str = str
+      @pos = 0
+    end
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    attr_accessor :str
+    attr_accessor :pos
+    
+    def parse_rec 
+      while(true) 
+        c = nil
+        begin
+          index = @pos
+          @pos+=1
+          c = (@str[index] || 0).ord
+        end
+        case(c)
+        when 32,13,10,9
+        when 123
+          obj = { }
+          field = nil
+          comma = nil
+          while(true) 
+            c1 = nil
+            begin
+              index1 = @pos
+              @pos+=1
+              c1 = (@str[index1] || 0).ord
+            end
+            case(c1)
+            when 32,13,10,9
+            when 125
+              self.invalid_char if field != nil || comma == false
+              return obj
+            when 58
+              self.invalid_char if field == nil
+              begin
+                value = self.parse_rec
+                obj[field] = value
+              end
+              field = nil
+              comma = true
+            when 44
+              if comma 
+                comma = false
+              else 
+                self.invalid_char
+              end
+            when 34
+              self.invalid_char if comma
+              field = self.parse_string
+            else
+              self.invalid_char
+            end
+          end
+        when 91
+          arr = []
+          comma1 = nil
+          while(true) 
+            c2 = nil
+            begin
+              index2 = @pos
+              @pos+=1
+              c2 = (@str[index2] || 0).ord
+            end
+            case(c2)
+            when 32,13,10,9
+            when 93
+              self.invalid_char if comma1 == false
+              return arr
+            when 44
+              if comma1 
+                comma1 = false
+              else 
+                self.invalid_char
+              end
+            else
+              self.invalid_char if comma1
+              @pos-=1
+              arr.push(self.parse_rec)
+              comma1 = true
+            end
+          end
+        when 116
+          save = @pos
+          if lambda{|_this_| index3 = @pos
+          @pos+=1
+          _r = (@str[index3] || 0).ord}.call(self) != 114 || lambda{|_this_| index4 = @pos
+          @pos+=1
+          _r2 = (@str[index4] || 0).ord}.call(self) != 117 || lambda{|_this_| index5 = @pos
+          @pos+=1
+          _r3 = (@str[index5] || 0).ord}.call(self) != 101 
+            @pos = save
+            self.invalid_char
+          end
+          return true
+        when 102
+          save1 = @pos
+          if lambda{|_this_| index6 = @pos
+          @pos+=1
+          _r4 = (@str[index6] || 0).ord}.call(self) != 97 || lambda{|_this_| index7 = @pos
+          @pos+=1
+          _r5 = (@str[index7] || 0).ord}.call(self) != 108 || lambda{|_this_| index8 = @pos
+          @pos+=1
+          _r6 = (@str[index8] || 0).ord}.call(self) != 115 || lambda{|_this_| index9 = @pos
+          @pos+=1
+          _r7 = (@str[index9] || 0).ord}.call(self) != 101 
+            @pos = save1
+            self.invalid_char
+          end
+          return false
+        when 110
+          save2 = @pos
+          if lambda{|_this_| index10 = @pos
+          @pos+=1
+          _r8 = (@str[index10] || 0).ord}.call(self) != 117 || lambda{|_this_| index11 = @pos
+          @pos+=1
+          _r9 = (@str[index11] || 0).ord}.call(self) != 108 || lambda{|_this_| index12 = @pos
+          @pos+=1
+          _r10 = (@str[index12] || 0).ord}.call(self) != 108 
+            @pos = save2
+            self.invalid_char
+          end
+          return nil
+        when 34
+          return self.parse_string
+        when 48,49,50,51,52,53,54,55,56,57,45
+          c3 = c
+          start = @pos - 1
+          minus = c3 == 45
+          digit = !minus
+          zero = c3 == 48
+          point = false
+          e = false
+          pm = false
+          _end = false
+          while(true) 
+            begin
+              index13 = @pos
+              @pos+=1
+              c3 = (@str[index13] || 0).ord
+            end
+            case(c3)
+            when 48
+              self.invalid_number(start) if zero && !point
+              if minus 
+                minus = false
+                zero = true
+              end
+              digit = true
+            when 49,50,51,52,53,54,55,56,57
+              self.invalid_number(start) if zero && !point
+              minus = false if minus
+              digit = true
+              zero = false
+            when 46
+              self.invalid_number(start) if minus || point
+              digit = false
+              point = true
+            when 101,69
+              self.invalid_number(start) if minus || zero || e
+              digit = false
+              e = true
+            when 43,45
+              self.invalid_number(start) if !e || pm
+              digit = false
+              pm = true
+            else
+              self.invalid_number(start) if !digit
+              @pos-=1
+              _end = true
+            end
+            break if _end
+          end
+          f = nil
+          begin
+            x = @str[start,@pos - start]
+            f = x.to_f
+          end
+          i = f.to_i
+          if i == f 
+            return i
+          else 
+            return f
+          end
+        else
+          self.invalid_char
+        end
+      end
+    end
+    
+    def parse_string 
+      start = @pos
+      buf_b = ""
+      while(true) 
+        c = nil
+        begin
+          index = @pos
+          @pos+=1
+          c = (@str[index] || 0).ord
+        end
+        break if c == 34
+        if c == 92 
+          buf_b += @str[start,@pos - start - 1]
+          begin
+            index1 = @pos
+            @pos+=1
+            c = (@str[index1] || 0).ord
+          end
+          case(c)
+          when 114
+            buf_b += [13].pack("U")
+          when 110
+            buf_b += [10].pack("U")
+          when 116
+            buf_b += [9].pack("U")
+          when 98
+            buf_b += [8].pack("U")
+          when 102
+            buf_b += [12].pack("U")
+          when 47,92,34
+            buf_b += [c].pack("U")
+          when 117
+            uc = nil
+            begin
+              x = "0x" + _hx_str(@str[@pos,4])
+              uc = x.to_i
+            end
+            @pos += 4
+            buf_b += [uc].pack("U")
+          else
+            raise hx_raise("Invalid escape sequence \\" + _hx_str([c].pack("U")) + " at position " + _hx_str((@pos - 1)))
+          end
+          start = @pos
+        elsif c == 0 
+          raise hx_raise("Unclosed string")
+        end
+      end
+      buf_b += @str[start,@pos - start - 1]
+      buf_b
+    end
+    
+    def invalid_char 
+      @pos-=1
+      raise hx_raise("Invalid char " + _hx_str((@str[@pos] || 0).ord) + " at position " + _hx_str(@pos))
+    end
+    
+    def invalid_number(start)
+      raise hx_raise("Invalid number at position " + _hx_str(start) + ": " + _hx_str(@str[start,@pos - start]))
+    end
+    
+  haxe_me ["haxe", "format", "JsonParser"]
+  end
+
+end
+end