appswarm 0.0.1

data/lib/appswarm/routing/routetest.rb

@@ -0,0 +1,85 @@
+require 'routing.rb'
+
+
+ns=Nodes.new(100,2)
+ns.computeDistances
+
+
+baseNode=ns.nodes[0]
+
+
+gr=GlobalRouting.new(baseNode,ns)
+
+neighbor=baseNode.neighbors[0]
+lr=LocalRouting.new(neighbor,ns)
+
+newNeighbors=(lr.neighbors-baseNode.neighbors)
+puts "__"
+puts newNeighbors
+newNeighbor=newNeighbors[0]
+
+pos=lr.getNodePos(newNeighbor)
+
+
+tpos=gr.translateFromNeighborToLocal(pos,neighbor)
+#pp pos
+pp tpos
+
+exit
+
+
+localRouting=LocalRouting.new(baseNode,ns)
+neighbor=baseNode.neighbors[0]
+p=localRouting.getNodePos(neighbor)
+pp p
+rVec=localRouting.routeVector(p)
+pp rVec
+
+pp localRouting.routeVectorDirect(neighbor)
+
+exit
+
+neighborNodes=baseNode.neighborHood(2)
+
+puts "NEIGHBORS",neighborNodes.length
+
+assert{!neighborNodes.member?(baseNode)}
+m=ns.createMatrix(neighborNodes)
+mInv=Linalg::DMatrix[*m].pseudo_inverse
+
+
+base=PCA::Base.new(PCA::Input.new(m))
+
+base.reduce([base.dimension-2,8].min)
+
+pp base.dimension
+
+pp base.measureSingleError(ns.createDistances(neighborNodes,ns.nodes[50]))
+
+routingMatrix=ns.computeRoutingMatrix(baseNode,neighborNodes)
+
+neighborNodes.each{|n|
+  dVec=m[neighborNodes.index(n)]
+  pp dVec
+  pos=base.compress(dVec)
+  vpos=base.decompress(pos)
+  pp "---"
+  pp dVec,vpos
+  tmpRes=(mInv*(vpos.transpose))
+  res=routingMatrix*(mInv*(vpos.transpose))
+  pp "RES:",res
+  check=Linalg::DMatrix[[1]+[0]*(tmpRes.vsize-1)]
+  pp check
+  pp routingMatrix*check.transpose
+exit
+}
+
+  
+#pp base
+exit
+
+30.downto(1){|i|
+base.reduce(i)
+  pp i
+  pp base.measureErrors(m)
+}

data/lib/appswarm/routing/routing.rb

@@ -0,0 +1,326 @@
+#!/usr/bin/env ruby
+require 'pp'
+require 'pca.rb'
+
+MYMAX=1000000
+
+class Array
+  def shuffle
+    sort{rand*2-1}
+  end
+  
+  
+  def createPermutationFromOrder
+    a=(0...length).to_a
+    a.sort_by{|x|self[x]}
+  end
+end
+
+class Node
+  attr_reader :neighbors, :id
+  def initialize(id)
+    @id=id
+    @neighbors=[]
+    @distance={}
+  end
+  
+  def add(n)
+    @neighbors << n
+    @distance[n]=1 
+  end
+  
+  def short_to_s
+    "("+@id.to_s+")"
+  end
+  
+  def to_s
+#    "["+@id.to_s+":"+@neighbors.map{|n|n.short_to_s+"="+@distance[n].to_s}.join(",")+"]"
+    "["+@id.to_s+"]" #:"+@distance.keys.map{|n|n.short_to_s+"="+@distance[n].to_s}.join(",")+"]"
+  end
+  
+  def setDistance(n,d)
+    if @distance[n].nil? or @distance[n]>d
+      @distance[n]=d
+      true
+    else
+      false
+    end
+  end
+  def distance(n)
+    return 0 if n==self
+    return @distance[n] if @distance.key?(n)
+    MYMAX
+  end
+  
+  def neighborHood(len=3)
+    @distance.keys.select{|k|@distance[k]<=len}-[self]
+  end
+  
+  def ==(o)
+    @id==o.id
+  end
+end
+
+class Nodes
+  attr_reader :nodes
+  def initialize(n=10,connectivity=2)
+    puts "Setup network"
+    @nodes=[]
+    n.times{|i|@nodes << Node.new(i) }
+    connectUntilAllConnected(connectivity)
+  end
+  def connectUntilAllConnected(connectivity)
+    @nodes.each{|n|
+      some=(@nodes-[n]).shuffle
+      some[0...connectivity].each{|o|
+        o.add(n)
+        n.add(o)
+      }
+    }
+  end
+  
+  def computeDistances
+    puts "Compute distances..."
+    @nodes.each{|n|
+      cur=[]
+      cur+=n.neighbors
+      while cur.length>0
+        c=cur.shift
+        (c.neighbors-[n]).each{|x|
+          nd=n.distance(c)+1
+          if n.setDistance(x,nd)
+            cur<<x
+          end
+        }
+      end
+    }
+    puts "Ready"
+  end
+  
+  class Path
+    attr_reader :nodes
+    def initialize(from)
+      if from.is_a?(Array)
+        @nodes=from
+      else
+        @nodes=[from]
+      end
+    end
+    def <<(node)
+      @nodes << node
+    end
+    def value
+      a=(1..(@nodes.length-1)).to_a
+      
+      val=a.inject(0){|old,i|
+        a=@nodes[i-1]
+        b=@nodes[i]
+        old.to_i+a.distance(b).to_i
+      }
+      val
+    end
+    def initialize_copy(s)
+      #puts "S:",*s,s
+      #exit
+      @nodes=s.nodes.clone
+      #Path.new(@nodes.clone)
+    end
+    def last
+      @nodes[-1]
+    end
+    def to_s
+      "[#{@nodes.length} - #{value}]"
+    end
+  end
+  
+  def shortestPath(from,to)
+    paths=[Path.new(from)]
+    
+    loop do
+      currentPath=paths.shift
+      last=currentPath.last
+      return currentPath if last==to
+      last.neighbors.each{|n|
+        nPath=currentPath.clone
+        nPath << n
+        if nPath.value < MYMAX
+          paths << nPath
+        end
+        #puts currentPath,nPath
+        #exit
+      }
+      
+      paths.sort!{|a,b|a.value<=>b.value}
+      #puts paths,"--"
+#      puts paths.length
+    end
+    return nil
+  end
+  
+  
+  def createMatrix(nodes=nil)
+    nodes||=@nodes
+    x=nodes.map{|a|
+        nodes.map{|b|
+          weight(a.distance(b))
+      }
+    }
+  end
+    
+  def weight(i)
+    i
+    #1-Math::atan(i)/Math::PI
+  end
+  
+  def createDistances(fromArray,toNode)
+    fromArray.map{|a|
+      weight(a.distance(toNode))
+    }
+  end
+  
+  # R*v=P
+  # v is (0,..,0,1,0,...,0) vector having 1 at pos i
+  # P is the vector (over j) describing the probability for reaching node i over neighbor j
+  # example: to compute the probabilities to reach node 4, compute
+  #   R*(0,0,0,0,1,0,...)
+  # result may be (0.5,0,0.5) - this means that you can reach node 4 by either crossing neighbor 0 or 2
+  # (counting from 0) 
+  def computeRoutingMatrix(myNode,nodes=nil)
+    #nodes||=(@nodes-myNode)
+    nodes||=@nodes
+    #assert{ !nodes.member?(myNode) }
+    neighbors=myNode.neighbors
+    #puts "---",neighbors,"--"
+    i=[[0]*nodes.length]*neighbors.length
+    #nodes.each{|x|puts "#{x} #{myNode.distance(x)}"}
+    matrix=Linalg::DMatrix[* i]
+    nodes.each{|curNode|
+     # assert{curNode!=myNode}
+      curArr={}
+      neighbors.each{|neighbor|
+        
+        d=neighbor.distance(curNode)+myNode.distance(neighbor)
+        myd=myNode.distance(curNode)
+        if d<=myd
+          curArr[neighbor]=d
+        end
+      }
+      sum=curArr.values.inject(0){|a,b|a+b}
+      #assert{sum>0}
+      if sum>0
+        curArr.each{|k,v|
+        y,x=nodes.index(curNode),neighbors.index(k)
+          matrix[x,y]=v.to_f/sum
+        }
+     end
+    }
+    matrix
+  end
+end
+
+class LocalRouting
+  attr_reader :neighbors, :base
+  def initialize(baseNode,network,neighborDepth=2)
+    puts "init local routing for #{baseNode}"
+    @baseNode=baseNode
+    @network=network
+    @depth=neighborDepth
+    @neighbors=@baseNode.neighborHood(@depth)+[@baseNode]
+    
+    @distMatrix=@network.createMatrix(@neighbors)
+    @distMatrixInv=Linalg::DMatrix[*@distMatrix].pseudo_inverse
+    
+    @base=PCA::Base.new(PCA::Input.new(@distMatrix))
+      
+    @base.reduce([@base.dimension,8].min)
+    
+    @routing=@network.computeRoutingMatrix(@baseNode,@neighbors) #-[@baseNode])
+  end
+  
+  def getNodePos(neighbor)
+    assert{@neighbors.member?(neighbor)}
+    distVec=@distMatrix[@neighbors.index(neighbor)]
+    #pp distVec
+    @base.compress(distVec)
+  end
+  
+  def routeVector(nodePos)
+    #puts "ROUTEV",nodePos
+    r0=(@distMatrixInv*@base.decompress(nodePos).transpose)
+    #puts "r0",r0
+    #puts @routing
+    @routing*r0
+  end
+  
+  def getNode(i)
+    neighbors[i]
+  end
+  
+  def getRouteOrder(nodePos)
+    rv=routeVector(nodePos)
+    ns=@baseNode.neighbors
+    #puts "RV",rv,"neigbors:",ns
+    ns.sort{|a,b| rv[ns.index(b)]<=>rv[ns.index(a)]}
+  end
+  
+  def routeVectorDirect(neighbor)
+    id=@neighbors.index(neighbor)
+    @routing*Linalg::DMatrix[[0]*(id)+[1]+[0]*(@neighbors.length-id-1)].transpose
+  end
+  
+  def getDistancesForPos(toNodePos)
+    distVec=base.decompress(toNodePos).to_a[0]
+    nodes={}
+    0.upto(distVec.length-1){|i|
+      nodes[@neighbors[i]]=distVec[i]
+    }
+    nodes
+  end
+  
+  def computePosForDistances(distHash)
+    distVec=@neighbors.map{|n|distHash[n]}
+    @base.compress(distVec)
+  end
+  
+  def distance(from,to)
+    assert{[from,to]-@neighbors==[]}
+    from.distance(to)
+  end
+  
+end
+
+class GlobalRouting
+  def initialize(baseNode,network,neighborDepth=2)
+    @myRouting=LocalRouting.new(baseNode,network,neighborDepth)
+    @neighborRouting=(baseNode.neighbors+[baseNode]).map2hash{|n|LocalRouting.new(n,network)}
+  end
+  
+  def getNodePos(p)
+    @myRouting.getNodePos(p)
+  end
+  def getRouteOrder(nodePos)
+    @myRouting.getRouteOrder(nodePos)
+  end
+  
+  def translateFromNeighborToLocal(nodePos,neighbor)
+    rt=@neighborRouting[neighbor]
+    oldDistances=rt.getDistancesForPos(nodePos)
+    
+    # translateDistances
+    neighbors=@myRouting.neighbors
+    # collect distances, that are the same
+    newDistances=oldDistances.select{|k,v|
+      neighbors.member?(k)
+    }
+    # add missing distances
+    (neighbors-newDistances.keys).each{|n|
+      newDistances[n]=
+      newDistances.map_to_a{|k,v|
+        @myRouting.distance(n,k)+v
+      }.min
+    }
+    npos=@myRouting.computePosForDistances(newDistances)
+  end
+end
+
+

data/lib/appswarm/routing/spec/nods_spec.rb

@@ -0,0 +1,23 @@
+if false
+
+$: << File.expand_path("../..",__FILE__)
+require File.expand_path("../../routing.rb",__FILE__)
+
+describe "Nodes" do
+  it "should compute the shortest path" do
+    ns=Nodes.new(30)
+    ns.computeDistances
+    
+    
+    a=ns.nodes[0]
+    b=ns.nodes[1]
+    
+    p=ns.shortestPath(a,b)
+    puts a,b,p,p.nodes
+    
+    p.value.should == a.distance(b)
+    a.distance(b).should == b.distance(a)
+  end
+end#
+
+end

data/lib/appswarm/routing/spec/pca_spec.rb

@@ -0,0 +1,27 @@
+if false
+
+$: << File.expand_path("../..",__FILE__)
+
+require 'pca.rb'
+
+describe "PCA" do
+  it "should compress/decompress without failure if element is in training-set" do
+    i=PCA::Input.new
+    i<<[1,1,0]
+    i<<[0,1,1]
+    i<<[0,1,2]
+    i<<[9,1,1]
+    i<<[0,1,0]
+    
+    base=PCA::Base.new(i)
+    
+    ref=[1,1,0]
+    
+    c=base.compress(ref)
+    r=base.decompress(c)
+    
+    (r-Linalg::DMatrix[ref]).norm.should < 0.1
+  end
+end
+
+end