signed_multiset 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c668c57c3959d0bfcb01c8100df51adc41b5608
-  data.tar.gz: 5058d5b5a8cfa2b2e39bd7e51ab7856617603fcd
+  metadata.gz: f89a246862b71b53eeb8ee2f38eadfab7a4b90cf
+  data.tar.gz: 30777e6a599eb97385961f21593de03ecd8b0347
 SHA512:
-  metadata.gz: 3f7b5820fcab890277e36e6159ce932a2814d7f6da029b94de16a317736b73e5673edd65eb177829cd2b4b7da94e4211cdc3210dc2142c9f39c440152f81eaf9
-  data.tar.gz: 3610e8eef2ece21ea1ab03a1de1ff2974d8065cad62e0a3449c1f61e22baa366a7d05ce8f1a93e9bbe7ad2e243a1ae339fff8296e8075718aab037f1f7f82b25
+  metadata.gz: 000bb39cfbed2233c77e35c9d4062a052648fbc1764fba9a892dc4f3c2327ee36dbafae8650be4f934f3ebc60b32ffd8c0cbf2dff432789aaaeb8e8bff458f81
+  data.tar.gz: c9dbf1ca92a7c8dc9905eb119180c7636a61a72e6499176ca95cf7c420bf5d99c3e19130345b341ddaa3f00096ece528699eea76c91fdd267f27a64f771d79ef

data/HISTORY.md

@@ -1,3 +1,8 @@
+# 0.2.0
+- Remove the SignedMultiset folder namespace.
+- Replace SignedMultiset[] with SignedMultiset()
+- SignedMultiset() and SignedMultiset.new() both take arrays, hashes, or argument lists as arguments.
+
 # 0.1.0
 - Fix return values when setting mutliplicity.
 

data/README.md

@@ -7,7 +7,7 @@
 
 Signed Multiset is a Ruby implementation of a Multiset that allows negative membership.
 
-You can think of it as a Multiset or Bag that allows for negative counts. It feels like a Ruby Hash or Array, but with some differences:
+You can think of it as a Multiset or Bag that allows for negative counts. It's functionality is very similar to Sorted Sets available in Redis (albeit without the storage functionality). It feels like a Ruby Hash or Array, but with some differences:
 
 - A key (any ruby object) can be added to or removed from the SignedMultiset any number of times. The number of times it is included in the multiset (positive or negative) is referred to as it's multiplicity.
 
@@ -65,7 +65,7 @@ set.cardinality
 set.size
 # => 3
 
-other_set = SignedMultiset[:a, :c, :d, :d]
+other_set = SignedMultiset(:a, :c, :d, :d)
 # => <SignedMultiset a: 1, c: 1, d: 2>
 
 set + other_set
@@ -75,7 +75,7 @@ set & other_set
 # => <SignedMultiset c: 1, d: -3>
 
 set | other_set
-=> <SignedMultiset b: 2, c: 3, d: 2, a: 1>
+# => <SignedMultiset b: 2, c: 3, d: 2, a: 1>
 ```
 
 ## Contributing

data/lib/signed_multiset.rb

@@ -1,2 +1,206 @@
-require "signed_multiset/version"
-require "signed_multiset/signed_multiset"
+class SignedMultiset
+  VERSION = "0.2.0"
+
+  include Enumerable
+  include Comparable
+
+  # Create a new SignedMultiset instance.
+  #
+  # @param object [Enumerable, nil] An array of keys, or key-muliplicity pairs.
+  def initialize(*args)
+    obj = args.count == 1 ? args.first : args
+    if obj.respond_to?(:each)
+      obj.each { |k, v| increment(k, v || 1) }
+    else
+      self << obj
+    end
+  end
+
+  # Get the non-zero key-multiplicity pairs.
+  #
+  # @return [Hash]
+  def multiplicities
+    entries.reject{|k,v| v == 0}
+  end
+
+  # Iterate over the multiplicity collection.
+  #
+  # @return [Enumerator]
+  def each(*args, &block)
+    if block_given?
+      multiplicities.each { |k,v| yield(k,v) }
+    else
+      multiplicities.each(args)
+    end
+  end
+
+  # Get the multiplicity for a key.
+  #
+  # @param key [Object] The key to get the multiplicity of
+  # @return [Integer, nil] The multiplicity for the key, or nil if the key is
+  #   not present, or has a zero multiplicity
+  def [](key)
+    multiplicities[key]
+  end
+
+  # Set the multiplicity for a key.
+  #
+  # @param key [Object] The key to set the multiplicity of
+  # @param multiplicity [Integer] The desired multiplicity
+  # @return [Integer] The multiplicity for the key
+  def []=(key, multiplicity)
+    entries[key] = multiplicity
+    self[key]
+  end
+
+  # Increment the multiplicity for a key.
+  #
+  # @param key (see #[]=)
+  # @param value [Integer] The desired increment value, positive or negative
+  # @return (see #[]=)
+  def increment(key, value)
+    entries[key] ||= 0
+    entries[key] += value
+    self[key]
+  end
+
+  # Increment multiplicity by 1 for a key. This method is chainable.
+  #
+  # @param key [Object] The key to increment the multiplicity of
+  # @return [self]
+  def <<(key)
+    increment(key, 1)
+    self
+  end
+
+  # Remove key completely from the set, similar to [key]=0
+  #
+  # @param key [Object] The key to remove
+  # @return [Integer] The multiplicity of the item removed.
+  def delete(key)
+    entries.delete(key)
+  end
+
+  # Creates a new instance of equal to current instance
+  # @return [SignedMultiset]
+  def dup
+    self.class.new(multiplicities)
+  end
+
+  # Combine self with another SignedMultiset via addition to create a merged instance.
+  #
+  # @param other [SignedMultiset]
+  # @return [SignedMultiset]
+  def +(other)
+    other.multiplicities.reduce(self.dup) do |m, (k, v)|
+      m.increment(k,v); m
+    end
+  end
+
+  # Combine self with another SignedMultiset via subtraction to create a merged instance.
+  #
+  # @param other (see #+)
+  # @return (see #+)
+  def -(other)
+    other.multiplicities.reduce(self.dup) do |m, (k, v)|
+      m.increment(k,-v); m
+    end
+  end
+
+  # Combine self with another SignedMultiset via union to create a merged instance.
+  #
+  # @param other (see #+)
+  # @return (see #+)
+  def |(other)
+    (keys | other.keys).reduce(self.class.new) do |m, k|
+      m.increment(k, [self[k] || 0, other[k] || 0].max); m
+    end
+  end
+
+  # Combine self with another SignedMultiset via intersection to create a merged instance.
+  #
+  # @param other (see #+)
+  # @return (see #+)
+  def &(other)
+    (keys & other.keys).reduce(self.class.new) do |m, k|
+      m.increment(k, [self[k], other[k]].min); m
+    end
+  end
+
+  # Get the list of keys for self.
+  #
+  # @return [Array]
+  def keys
+    multiplicities.keys
+  end
+
+  # Get the multiplicity values for self.
+  #
+  # @return [Array]
+  def values
+    multiplicities.values
+  end
+
+  # Get the cardinality (sum of multiplicities) for self.
+  #
+  # @return [Integer]
+  def cardinality
+    values.inject(&:+)
+  end
+  alias_method :sum, :cardinality
+
+  # Get the count of unique keys in the SignedMultiset.
+  #
+  # @return [Integer]
+  def size
+    keys.size
+  end
+  alias_method :length, :size
+
+  # Compare self with another SignedMultiset
+  #
+  # @param other (see #+)
+  # @return [-1,0,1]
+  def <=>(other)
+    if [:multiplicities, :cardinality, :size].all? { |m| other.respond_to?(m) }
+      if multiplicities == other.multiplicities
+        0
+      elsif cardinality != other.cardinality
+        cardinality <=> other.cardinality
+      elsif size != other.size
+        size <=> other.size
+      else
+        multiplicities <=> other.multiplicities
+      end
+    end
+  end
+
+  def to_hash
+    multiplicities.dup
+  end
+
+  def to_a
+    multiplicities.to_a
+  end
+
+  def to_s
+    multiplicities.map{ |k,m| "#{k}: #{m}"}.join(', ')
+  end
+
+  def inspect
+    "<#{self.class} #{to_s}>"
+  end
+
+  private
+
+  # Get the key-multiplicity pairs (even those with zero multiplicities).
+  #
+  # @return [Hash]
+  def entries
+    @entries ||= {}
+  end
+end
+
+def SignedMultiset(input)
+  SignedMultiset.new(input)
+end

data/signed_multiset.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'signed_multiset/version'
+require 'signed_multiset'
 
 Gem::Specification.new do |spec|
   spec.name          = "signed_multiset"
@@ -9,17 +9,15 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Josh Lewis"]
   spec.email         = ["josh.w.lewis@gmail.com"]
   spec.description   = %q{Multisets with negative membership}
-  spec.summary       = %q{Signed Multiset is a Ruby implementation of a Multiset that allows negative membership. You can think of it as a Multiset or Bag that allows for negative counts. It feels like a Ruby Hash or Array, but with some differences.}
+  spec.summary       = %q{You can think of it as a Multiset or Bag that allows for negative counts. It's functionality is very similar to Sorted Sets available in Redis (albeit without the storage functionality). It feels like a Ruby Hash or Array, but with some differences.}
   spec.homepage      = "http://github.com/joshwlewis/signed_multiset"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.test_files    = spec.files.grep(%r{^(test)/})
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest"
-
-end
+end

data/test/{signed_multiset/signed_multiset_test.rb → signed_multiset_test.rb}

@@ -1,4 +1,7 @@
-require 'test_helper'
+require 'signed_multiset'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/pride'
 
 describe SignedMultiset do
   subject { SignedMultiset.new(foo: 4, bar: 2, baz: 0) }
@@ -20,11 +23,8 @@ describe SignedMultiset do
       set = SignedMultiset.new(subject)
       set.keys.must_equal([:foo, :bar])
     end
-  end
-
-  describe "::[]" do
-    it "must create a new set" do
-      set = SignedMultiset[:a, :b, :b, :c]
+    it "must accept additional arguments" do
+      set = SignedMultiset.new(:a, :b, :c)
       set.keys.must_equal([:a, :b, :c])
     end
   end
@@ -187,8 +187,8 @@ describe SignedMultiset do
   end
 
   describe "#<=>" do
-    let(:small) { SignedMultiset[:foo, :bar] }
-    let(:large) { SignedMultiset[:foo, :bar, :baz, :foo, :bar, :qux, :foo, :bar] }
+    let(:small) { SignedMultiset.new([:foo, :bar]) }
+    let(:large) { SignedMultiset.new([:foo, :bar, :baz, :foo, :bar, :qux, :foo, :bar]) }
     let(:equal) { subject.dup }
 
     it "should return 1 when compared to a smaller set" do
@@ -201,4 +201,11 @@ describe SignedMultiset do
       (subject <=> equal).must_equal(0)
     end
   end
+end
+
+describe "::SignedMultiset()" do
+  it "must create a new set" do
+    set = SignedMultiset([:a, :b, :b, :c])
+    set.keys.must_equal([:a, :b, :c])
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: signed_multiset
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Josh Lewis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-11 00:00:00.000000000 Z
+date: 2013-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,11 +68,8 @@ files:
 - README.md
 - Rakefile
 - lib/signed_multiset.rb
-- lib/signed_multiset/signed_multiset.rb
-- lib/signed_multiset/version.rb
 - signed_multiset.gemspec
-- test/signed_multiset/signed_multiset_test.rb
-- test/test_helper.rb
+- test/signed_multiset_test.rb
 homepage: http://github.com/joshwlewis/signed_multiset
 licenses:
 - MIT
@@ -96,10 +93,9 @@ rubyforge_project:
 rubygems_version: 2.0.2
 signing_key: 
 specification_version: 4
-summary: Signed Multiset is a Ruby implementation of a Multiset that allows negative
-  membership. You can think of it as a Multiset or Bag that allows for negative counts.
-  It feels like a Ruby Hash or Array, but with some differences.
+summary: You can think of it as a Multiset or Bag that allows for negative counts.
+  It's functionality is very similar to Sorted Sets available in Redis (albeit without
+  the storage functionality). It feels like a Ruby Hash or Array, but with some differences.
 test_files:
-- test/signed_multiset/signed_multiset_test.rb
-- test/test_helper.rb
+- test/signed_multiset_test.rb
 has_rdoc: 

data/lib/signed_multiset/signed_multiset.rb

@@ -1,206 +0,0 @@
-class SignedMultiset
-
-  include Enumerable
-  include Comparable
-
-  # Create a new instance with a list of objects.
-  #
-  # @param *list [Object] A list of objects to add to the set
-  def self.[](*list)
-    new(list)
-  end
-
-  # Create a new SignedMultiset instance.
-  #
-  # @param object [Enumerable, nil] An array of keys, or key-muliplicity pairs.
-  def initialize(object=nil)
-    if object.is_a?(Enumerable)
-      object.each { |k, v| increment(k, v || 1) }
-    end
-  end
-
-  # Get the non-zero key-multiplicity pairs.
-  #
-  # @return [Hash]
-  def multiplicities
-    entries.reject{|k,v| v == 0}
-  end
-
-  # Iterate over the multiplicity collection.
-  #
-  # @return [Enumerator]
-  def each(*args, &block)
-    if block_given?
-      multiplicities.each { |k,v| yield(k,v) }
-    else
-      multiplicities.each(args)
-    end
-  end
-
-  # Get the multiplicity for a key.
-  #
-  # @param key [Object] The key to get the multiplicity of
-  # @return [Integer, nil] The multiplicity for the key, or nil if the key is
-  #   not present, or has a zero multiplicity
-  def [](key)
-    multiplicities[key]
-  end
-
-  # Set the multiplicity for a key.
-  #
-  # @param key [Object] The key to set the multiplicity of
-  # @param multiplicity [Integer] The desired multiplicity
-  # @return [Integer] The multiplicity for the key
-  def []=(key, multiplicity)
-    entries[key] = multiplicity
-    self[key]
-  end
-
-  # Increment the multiplicity for a key.
-  #
-  # @param key (see #[]=)
-  # @param value [Integer] The desired increment value, positive or negative
-  # @return (see #[]=)
-  def increment(key, value)
-    entries[key] ||= 0
-    entries[key] += value
-    self[key]
-  end
-
-  # Increment multiplicity by 1 for a key. This method is chainable.
-  #
-  # @param key [Object] The key to increment the multiplicity of
-  # @return [self]
-  def <<(key)
-    increment(key, 1)
-    self
-  end
-
-  # Remove key completely from the set, similar to [key]=0
-  #
-  # @param key [Object] The key to remove
-  # @return [Integer] The multiplicity of the item removed.
-  def delete(key)
-    entries.delete(key)
-  end
-
-  # Creates a new instance of equal to current instance
-  # @return [SignedMultiset]
-  def dup
-    self.class.new(multiplicities)
-  end
-
-  # Combine self with another SignedMultiset via addition to create a merged instance.
-  #
-  # @param other [SignedMultiset]
-  # @return [SignedMultiset]
-  def +(other)
-    other.multiplicities.reduce(self.dup) do |m, (k, v)|
-      m.increment(k,v); m
-    end
-  end
-
-  # Combine self with another SignedMultiset via subtraction to create a merged instance.
-  #
-  # @param other (see #+)
-  # @return (see #+)
-  def -(other)
-    other.multiplicities.reduce(self.dup) do |m, (k, v)|
-      m.increment(k,-v); m
-    end
-  end
-
-  # Combine self with another SignedMultiset via union to create a merged instance.
-  #
-  # @param other (see #+)
-  # @return (see #+)
-  def |(other)
-    (keys | other.keys).reduce(self.class.new) do |m, k|
-      m.increment(k, [self[k] || 0, other[k] || 0].max); m
-    end
-  end
-
-  # Combine self with another SignedMultiset via intersection to create a merged instance.
-  #
-  # @param other (see #+)
-  # @return (see #+)
-  def &(other)
-    (keys & other.keys).reduce(self.class.new) do |m, k|
-      m.increment(k, [self[k], other[k]].min); m
-    end
-  end
-
-  # Get the list of keys for self.
-  #
-  # @return [Array]
-  def keys
-    multiplicities.keys
-  end
-
-  # Get the multiplicity values for self.
-  #
-  # @return [Array]
-  def values
-    multiplicities.values
-  end
-
-  # Get the cardinality (sum of multiplicities) for self.
-  #
-  # @return [Integer]
-  def cardinality
-    values.inject(&:+)
-  end
-  alias_method :sum, :cardinality
-
-  # Get the count of unique keys in the SignedMultiset.
-  #
-  # @return [Integer]
-  def size
-    keys.size
-  end
-  alias_method :length, :size
-
-  # Compare self with another SignedMultiset
-  #
-  # @param other (see #+)
-  # @return [-1,0,1]
-  def <=>(other)
-    if [:multiplicities, :cardinality, :size].all? { |m| other.respond_to?(m) }
-      if multiplicities == other.multiplicities
-        0
-      elsif cardinality != other.cardinality
-        cardinality <=> other.cardinality
-      elsif size != other.size
-        size <=> other.size
-      else
-        multiplicities <=> other.multiplicities
-      end
-    end
-  end
-
-  def to_hash
-    multiplicities.dup
-  end
-
-  def to_a
-    multiplicities.to_a
-  end
-
-  def to_s
-    multiplicities.map{ |k,m| "#{k}: #{m}"}.join(', ')
-  end
-
-  def inspect
-    "<#{self.class} #{to_s}>"
-  end
-
-  private
-
-  # Get the key-multiplicity pairs (even those with zero multiplicities).
-  #
-  # @return [Hash]
-  def entries
-    @entries ||= {}
-  end
-
-end

data/lib/signed_multiset/version.rb

@@ -1,3 +0,0 @@
-class SignedMultiset
-  VERSION = "0.1.0"
-end

data/test/test_helper.rb

@@ -1,4 +0,0 @@
-require 'signed_multiset'
-require 'minitest/spec'
-require 'minitest/autorun'
-require 'minitest/pride'