rb_prob 0.0.1 → 0.0.2

data/examples/alarm.rb

@@ -90,7 +90,7 @@ def mk_joint_p(&blk)
             p_alarm(b, e).dep {|a|
                 p_john(a).dep { |j|
                     p_mary(a).dep {|m|
-                        mkState(if blk then blk.call([b,e,a,j,m])
+                        mk_const(if blk then blk.call([b,e,a,j,m])
                                 else [b,e,a,j,m] end)
                     }
                 }
@@ -122,7 +122,7 @@ def mk_joint_p2( tsts = {}, &blk )
                 condition(!tsts[:john] || tsts[:john] == j) {
                     p_mary(a).dep {|m|
                     condition(!tsts[:mary] || tsts[:mary] == m) {
-                        mkState(if blk then blk.call [b,e,a,j,m] else [b,e,a,j,m] end)
+                        mk_const(if blk then blk.call [b,e,a,j,m] else [b,e,a,j,m] end)
                     }}
                 }}
             }}
@@ -133,18 +133,18 @@ end
 # like mk_joint_p2, but using event_dep directly instead of mixing in
 # condition-statements
 def mk_joint_p3 (tsts = {}, &blk)
-    tst_b = ifJust tsts[:burglary]
-    tst_e = ifJust tsts[:earthquake]
-    tst_a = ifJust tsts[:alarm]
-    tst_j = ifJust tsts[:john]
-    tst_m = ifJust tsts[:mary]
+    tst_b = if_just tsts[:burglary]
+    tst_e = if_just tsts[:earthquake]
+    tst_a = if_just tsts[:alarm]
+    tst_j = if_just tsts[:john]
+    tst_m = if_just tsts[:mary]
 
     PBurglary.event_dep(tst_b) {|b|
         PEarthquake.event_dep(tst_e) {|e|
             p_alarm(b,e).event_dep(tst_a) {|a|
                 p_john(a).event_dep(tst_j) {|j|
                     p_mary(a).event_dep(tst_m) {|m|
-                        mkState(if blk then blk.call [b,e,a,j,m] else [b,e,a,j,m] end)
+                        mk_const(if blk then blk.call [b,e,a,j,m] else [b,e,a,j,m] end)
                     }
                 }
             }

data/examples/diagnosis.rb

@@ -52,36 +52,37 @@ end
 # P(T|I)
 # but combine states and save final distribution in constant
 PTest = PDisease.dep {|i|
-    pTest(i).dep {|t| mkState([i,t]) }
+    pTest(i).dep {|t| mk_const([i,t]) }
 }
 
 testpred = Proc.new {|disease, test| disease == :ILL}
 
-p PTest
+puts "joint probability:"
+puts PTest
 
 # using filter we find on PTest which is P(T|I) we find 
 # P( I | T = Positive )
-p "probability of I if test is Positive:"
-p PTest.filter{|disease, test| test == :Positive}
+puts "probability of I if test is Positive:"
+puts PTest.filter{|disease, test| test == :Positive}
 
 # using the testpred function and query we can find the probability of all
 # events testpred returns true for. In this case P( I = Ill | T = Positive)
-p "probability of being ill"
-p PTest.filter{|disease,test| test == :Positive}.query? &testpred
+puts "\nprobability of being ill"
+puts PTest.filter{|disease,test| test == :Positive}.query? &testpred
 
 # next find the most probable explanation if Test was Positive:
-p "most probable"
-p PTest.filter{|disease,test| test == :Positive}.most_probable
+puts "\nmost probable"
+puts PTest.filter{|disease,test| test == :Positive}.most_probable
 
 # alternatively using condition on the monadic computation directly
 # and normalizing the result needed multiplications and memory may be reduced:
 # event_dep is like 'dep {|var| condition(var == :Positive) { ... } }'
-p "another way of finding P(I|T=Positive)"
-p PDisease.dep {|i|
+puts "\nanother way of finding P(I|T=Positive)"
+puts PDisease.dep {|i|
     # event_dep will execute block only if
     # Test was :Positive and return 'nil' else
     pTest(i).event_dep(just :Positive) { 
-        mkState(i)
+        mk_const(i)
     }
   }.normalize
 

data/examples/drugtest.rb

@@ -11,14 +11,14 @@ def drugTest(puser = 0.001, p_posifuser = 0.99, p_posifclean = 0.01)
     choose(puser, :User, :Clean).dep { |user|
         choose(if user == :User then p_posifuser else p_posifclean end,
                :Pos, :Neg).dep { |test|
-            mkState([user, test])
+            mk_const([user, test])
         }
     }
 end
 
 def drugTest2
     drugTest.dep {|u,t|
-        if t == :Pos then mkState(u) else nil end
+        if t == :Pos then mk_const(u) else nil end
     }
 end
 
@@ -27,7 +27,7 @@ def drugTest3(puser = 0.001, p_posifuser = 0.99, p_posifclean = 0.01)
         choose(if user == :User then p_posifuser else p_posifclean end,
                :Pos, :Neg).dep { |test|
             condition(test == :Pos) {
-                mkState user
+                mk_const user
             }
         }
     }.normalize
@@ -35,10 +35,18 @@ end
 
 #p drugTest2
 
-p drugTest
-p drugTest.filter {|u,t| t == :Pos }
-p drugTest(0.5).filter {|u,t| t == :Pos}
+puts "test1"
+puts drugTest
 
-p drugTest3
-# p drugTest3(0.5)
+puts "\ntest2"
+puts drugTest.filter {|u,t| t == :Pos }
+
+puts "\ntest3"
+puts drugTest(0.5).filter {|u,t| t == :Pos}
+
+puts "\ntest4"
+puts drugTest3
+
+puts "\ntest5"
+puts drugTest3(0.5)
 

data/examples/spamplan.rb

@@ -121,7 +121,7 @@ module SpamDatabaseProbabilities
     # P(W|S) <- likelyhood
     
     def pMsgType # P(S)
-        enumDist types, @msgCounts
+        enum_dist types, @msgCounts
     end
 
     def pWord(word, type) # P(W == word | S == type)
@@ -134,7 +134,7 @@ module SpamDatabaseProbabilities
     def pHasWord(word, prior = pMsgType)    
         prior.dep {|t|
             pWord(word, t).event_dep(just true) {
-                mkState(t)
+                mk_const(t)
             }
         }.normalize
     end
@@ -282,14 +282,14 @@ class SpamClassifier
         f.call uniform(@knowledge.types)
     end
 
-    def score(f = nil, &blk)
-        pDistance( characteristic(f || blk), uniform(@knowledge.types))
+    def score(&blk)
+        characteristic(blk).distance uniform(@knowledge.types)
     end
 
     def buildClassifiers
         @knowledge.knownWords.each {|w,types|
             s = score {|prior| @knowledge.pHasWord(w,prior)}
-            probs = adjustMinimums(@knowledge.pHasWord(w, uniform(S)))
+            probs = @knowledge.pHasWord(w, uniform(S)).adjust_min
             yield w, s, probs
         }
     end

data/lib/prob.rb

@@ -2,19 +2,17 @@
 # The Probably module provides functions and a discrete Distribution class for
 # monadic functional probabilistic programming in ruby.
 
-puts 'loading rb_prob'
-
 module Probably
 
     # simple helper function running a given block with its first argument and
     # returns first argument
-    def block1(x, &blk)
-        blk.call(x)
-        x
+    def block1(value)
+        yield value
+        value
     end
 
     # given a block return a new Proc defined on range [0..1]
-    def mkShapeFunction
+    def mk_shape_fn
         proc { |x|
             if x < 0 || x > 1.0 then 0 else yield x end
         }
@@ -22,10 +20,10 @@ module Probably
 
     # creates a Proc computing a gaussian distribution
     # in range [0..1] given a mean and deviation
-    def normalDistShape(mean, dev)
+    def normal_dist(mean, dev)
         include Math
 
-        mkShapeFunction { |x|
+        mk_shape_fn { |x|
             u = (x - mean) / dev
             exp (-0.5 * u * u) / sqrt(2 * PI)
         }
@@ -36,23 +34,23 @@ module Probably
         include Enumerable
 
         protected
-        def initializeLists(data, shape)
+        def init_lsts(data, shape)
             @map = Hash.new(0)
             count = data.length
-            data.each_with_index { |val, i| 
-                @map[val] += shape.call( Float(i + 1) / count  )
+            data.each_with_index { |value, index| 
+                @map[value] += shape.call( Float(index + 1) / count  )
             }
         end
 
-        def initializeMap(m)
+        def init_map(map)
             @map = Hash.new(0)
-            m.each { |k,v| @map[k] = v }
-            self.normalizeProbabilities
+            map.each { |value, prob| @map[value] = prob }
+            self.normalize_probabilities
         end
 
-        def normalizeProbabilities
+        def normalize_probabilities
             sum = Float( @map.values.inject(:+) )
-            @map.keys.each { |k| @map[k] /= sum } if sum != 1.0
+            @map.keys.each { |value| @map[value] /= sum } if sum != 1.0
         end
 
         public
@@ -72,13 +70,13 @@ module Probably
                 when :MAP 
                     @map = data[0]
                 when :MAPCOPY
-                    initializeMap(data[0])
+                    init_map(data[0])
                 when :LISTS
-                    initializeLists(data[0], data[1])
+                    init_lsts(data[0], data[1])
                 else
                     raise "unable to create probability distribution"
             end
-            self.normalizeProbabilities
+            self.normalize_probabilities
         end
 
         # set of keys in distribution
@@ -92,7 +90,7 @@ module Probably
         # to compute normalization of bayes theorem
         def normalize
             if @map[nil] > 0.0
-                filter { |v| v != nil }
+                filter { |value| value != nil }
             else
                 @self
             end
@@ -115,30 +113,36 @@ module Probably
         # randomly pick a key-value with respect to its probability
         # in given distribution
         def pick
-            r = rand
+            tst = rand
             sum = 0
-            for k,p in @map
-                sum += p
-                return k,p if r < sum
+            @map.each do |value, prob|
+                sum += prob
+                return value,prob if tst < sum
             end
             return nil
         end
 
         def each
-            @map.each { |k, p| yield p, k }
+            @map.each { |value, prob| yield prob, value }
         end
 
         def map
             tmp = Hash.new(0)
-            for k,p in @map
-                tmp[yield(k)] += p
+            @map.each do |value, prob|
+                tmp[yield(value)] += prob
             end
             Distribution.new(:MAP, tmp)
         end
 
         def filter
-            Distribution.new :MAP, @map.reject { |k,v|
-                !(yield k)
+            Distribution.new :MAP, @map.reject { |value,prob|
+                !(yield value)
+            }
+        end
+
+        def reject
+            Distribution.new :MAP, @map.reject { |value, prob|
+                yield value
             }
         end
 
@@ -152,61 +156,65 @@ module Probably
         def join
             tmp = Hash.new(0)
 
-            for dist,p1 in @map
-                for p2, k in dist
-                    tmp[k] += p1 * p2 
+            @map.each do |dist, p1|
+                dist.each do |p2, value|
+                    tmp[value] += p1 * p2 
                 end
             end
             Distribution.new(:MAP, tmp)
         end
 
         def dep
-            m = Hash.new(0)
-            for k1,p1 in @map
-                tmp = yield k1
-                if tmp != nil
-                    for p2, k in tmp
-                        m[k] += p1 * p2
+            Distribution.new :MAP, block1(Hash.new(0)) {|m|
+                @map.each do |key, p1|
+                    tmp = yield key
+                    if tmp != nil
+                        tmp.each do |p2, value|
+                            m[value] += p1 * p2
+                        end
+                    else
+                        m[nil] += p1
                     end
                 end
-            end
-            Distribution.new(:MAP, m)
+                }
         end
 
         def event_dep(pred)
-            self.dep {|x|
-                if !pred.call x 
-                    mkState nil
+            self.dep {|value|
+                if !pred.call value 
+                    nil
                 else 
-                    yield x 
+                    yield value
                 end
             }
         end
 
         def mult(dist2)
             self.dep do |k|
-                if block_given? then dist2.map { |k2| yield(k, k2) }
-                else      dist2.map { |k2| [k, k2] }
+                if block_given? 
+                    dist2.map { |k2| yield(k, k2) }
+                else      
+                    dist2.map { |k2| [k, k2] }
                 end
             end
         end
 
-        def * (dist2)
-            self.mult dist2
+        def * (other)
+            self.mult other
         end
 
         # computes expectation given that keys in distribution
         # are numeric
         def expectation
-            @map.reduce(0) {|sum, (k,p)| sum + k.to_f * p }
+            @map.reduce(0) {|sum, (value, p)| sum + value.to_f * p }
         end
 
         # computes variance given that keys in distribution
         # are numeric
         def variance
             expected = self.expectation
-            @map.reduce(0) {|sum, (k,p)| 
-                tmp = (k.to_f - expectation)
+            @map.reduce(0) {|sum, (value,p)| 
+                tmp = (value.to_f - expectation)
                 sum + tmp * tmp * p 
             }
         end
@@ -218,110 +226,114 @@ module Probably
         end
 
         def to_s
-            @map.reduce("") { |str,(k,p)|
-                str + "#{k} : #{p * 100} %\n"
+            @map.reduce("") { |str,(value, prob)|
+                str + "#{value} : #{prob * 100} %\n"
             }
         end
+
+        def distance(other)
+            (self.keys | other.keys).reduce(0) {|sum, value|
+                tmp = self.probability(value) - other.probability(value)
+                sum + tmp * tmp
+            }
+        end
+
+        def adjust_min(new_min = 0.01)
+            tmp = Hash.new(0)
+            self.each do |prob, value|
+                tmp[value] = if prob > new_min then prob else new_min end
+            end
+            Distribution.new :MAP, tmp
+        end
     end
 
     # create uniformly distributed Distribution from array of values
     def uniform(data)
-        Distribution.new :LISTS, data, mkShapeFunction {|x| 1}
+        Distribution.new :LISTS, data, mk_shape_fn {|x| 1}
     end
 
     # creates linearly distributed Distribution from array of values
     def linear(data)
-        Distribution.new :LISTS, data, mkShapeFunction {|x| x }
+        Distribution.new :LISTS, data, mk_shape_fn {|x| x }
     end
 
     # creates exp(-x) distributed Distribution from array of values
-    def negExp(data)
-        Distribution.new :LISTS, data, mkShapeFunction {|x| Math.exp(-x) }
+    def nexp(data)
+        Distribution.new :LISTS, data, mk_shape_fn {|x| Math.exp(-x) }
     end
 
     # creates Distribution from array of values using a gaussian distribution
     def normal(data, mean = 0.5, dev = 0.5)
-        Distribution.new :LISTS, data, normalDistShape(mean, dev)
+        Distribution.new :LISTS, data, normal_dist(mean, dev)
     end
 
     # creates a distribution from first array holding the distribution
     # values and second one the corresponding probabilities (do be normalized)
     # - data: array of input values
     # - dist: array of probabilities
-    def enumDist(data, dist)
-        if data.length != dist.length
+    def enum_dist(data, dist)
+        dist_len = dist.length
+
+        if data.length != dist_len
             raise "data and distribution length must be equal"
         end
 
-        Distribution.new :LISTS, data, mkShapeFunction {|i| dist[i * dist.length - 1]}
+        Distribution.new :LISTS, data, mk_shape_fn {|i| 
+            dist[i * dist_len - 1]
+        }
     end
 
     # Creates a new probability distribution from given map:
     # m = { key1 => probability1, key2 => probability2, key3 => ... }
-    def mapDist(m)
+    def dist_from_map(m)
         Distribution.new :MAPCOPY, m
     end
 
-    def distWithShape(data, &blk)
-        Distribution.new :LISTS, data, mkShapeFunction(&blk)
+    def dist_with(data, &blk)
+        Distribution.new :LISTS, data, mk_shape_fn(&blk)
     end
 
-    def choose(p, elem1, elem2)
-        tmp = Hash.new(0)
-        tmp[elem1] = p
-        tmp[elem2] = 1 - p
-        Distribution.new :MAP, tmp
+    def choose(prob, value, other)
+        Distribution.new :MAP, block1(Hash.new(0)) { |tmp|
+            tmp[value] = prob
+            tmp[other] = 1 - prob
+        }
     end
 
-    def mkState(a)
-        tmp = Hash.new(0)
-        tmp[a] = 1
-        Distribution.new :MAP, tmp
+    def mk_const(value)
+        Distribution.new :MAP, block1(Hash.new(0)) { |tmp|
+            tmp[value] = 1
+        }
     end
 
-    def histogram(a)
-        block1(Hash.new(0)) do |r|
-            for x in a
-                r[x] += 1
+    def histogram(iter)
+        block1(Hash.new(0)) do |tmp|
+            iter.each do |value|
+                tmp[value] += 1
             end
         end
     end
 
-    def condition(b)
-        if b then yield else mkState nil end
+    def condition(bool)
+        if bool then yield else nil end
     end
 
     # events
-    def mkEvent(&f)
-        f
+    def mk_event(&fn)
+        fn
     end
 
-    def just(x)
-        mkEvent {|y| x == y}
+    def just(default)
+        mk_event {|value| default == value}
     end
 
-    def ifJust(x)
-        if x == nil then proc {|y| true }
-        else proc {|y| x == y } end
+    def if_just(default)
+        if default == nil then proc {|value| true }
+        else proc {|value| default == value } end
     end
 
-    def oneOf(*elems)
-        proc {|y| elems.include? y }
-    end
-
-    def pDistance(dist1, dist2)
-        (dist1.keys | dist2.keys).reduce(0) {|sum,k|
-            tmp = dist1.probability(k) - dist2.probability(k)
-            sum + tmp * tmp
-        }
-    end
-
-    def adjustMinimums(dist, newMin = 0.01)
-        tmp = Hash.new(0)
-        dist.each do |p,k|
-            tmp[k] = if p > newMin then p else newMin end
-        end
-        Distribution.new :MAP, tmp
+    def one_of(*elems)
+        proc {|value| elems.include? value }
     end
     
 end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: rb_prob
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Steffen Siering
@@ -9,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-21 00:00:00 +01:00
+date: 2010-03-24 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -42,18 +47,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: monadic probabilistic programming for ruby