priority_queue_cxx 0.3.2 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c2b5bbef541a1b74a11e959cda5b1b11020bda89
-  data.tar.gz: 15d62c6289e5d07cacafba804497305b6719c532
+SHA256:
+  metadata.gz: 9ba1b848409a000b5cb7ee56d1ae562eb7192aa7d705365a6f3b7a56729fbc89
+  data.tar.gz: 7a42739b6d89de0bce7e989938cfa352f8a32152cf0a43e377e584b22914374c
 SHA512:
-  metadata.gz: 7f14a5601f02ab38049968a222dd01d9403755984f0b91f6365b881cfe5af229173edf16290aa7568e15a87fd343205d965c9f8f2782cf096aed070cbd3ad934
-  data.tar.gz: 264b327c4dbc023d21a06868eebe55b76812d6f48b3a9797dd456aeb206766c936fd00ea1d1ae97ac3e58ae70a04a0b891b866ac14da513ae152f52b1ba3015f
+  metadata.gz: 8a7e866717d1e8c178f671bdb268180ac618d67a6e9489d027d28575179eab562866a87681ca1b539e6eddca2ef136e4494e7da3e58226a922f25ecde0ab8543
+  data.tar.gz: 1623288217123aac3da66d238c9178b21ff5aaa14421390c59d901d80ec2d861246972895b0d372fc97e9336f3a4636e8fa3242809e25342b8e77a726a331051

data/README.md

@@ -1,10 +1,12 @@
 # PriorityQueueCxx
 
-[![Gem Version](https://badge.fury.io/rb/fast_containers.png)](http://badge.fury.io/rb/fast_containers)
+[![Gem Version](https://badge.fury.io/rb/priority_queue_cxx.png)](http://badge.fury.io/rb/priority_queue_cxx)
+[![priority_queue_cxx API Documentation](https://www.omniref.com/ruby/gems/priority_queue_cxx.png)](https://www.omniref.com/ruby/gems/priority_queue_cxx)
 
-FastContainers provides a fast implementatin of priority queues for ruby. Speed is achieved by exposing  the c++ standard implementation through a light ruby wrapper. As a bigger project, the library may grow  a number of containers that are not in the standard ruby library and are presently only available as pure ruby libraries, but presently the library includes a single class named PriorityQueue. More containers will be added as necessity arises. Contributors and feature requests are most welcome.
 
-The library exposes a module named 'FastContainers' (to be required using ```require 'fc'```) which provides the PriorityQueue class.
+*PriorityQueueCxx* provides a fast implementation of priority queues for ruby. Speed is achieved by exposing  the c++ standard implementation through a light ruby wrapper. As a bigger project, the library may grow to provide a number of containers that are not in the standard ruby library and are presently only available as pure ruby libraries. Presently, however, the library includes a single class named PriorityQueue. More containers will be added as necessity arises. Contributors and feature requests are most welcome.
+
+The library exposes a module named ```FastContainers``` (to be required using ```require 'fc'```) which provides the PriorityQueue class.
 
 ## Installation
 
@@ -29,7 +31,7 @@ q.pop
 
 As far as I know, only one other library (the PriorityQueue gem) provides priority queues implemented as a C extension. This implies that the fc::PriorityQueue is a *lot* faster than most current alternatives and, as shown below, it compares favorably with the mentioned C extension as well.
 
-To get an idea about how fast it is, below we provide a comparison of the time needed to push and pop a large number of elements into a priority queue. Each experiment compares FastContainers with others priority queues implementations. Since timings varies greatly among different implementations, the number of push/pop performed is chosen so to make the experiments to run for (at most) few minutes.
+To get an idea about how fast it is, below I provide a comparison of the time needed to push and pop a large number of elements into a priority queue. Each experiment compares FastContainers with other priority queues implementations. Since timings varies greatly among different implementations, the number of push/pop performed is chosen so to make the experiments to run for (at most) few minutes.
 
 The following table summarizes the outputs, detailed results can be found in the next few sections. All libraries have been installed through the 'gem' command and executed using ruby v. 2.1.0.
 
@@ -42,7 +44,7 @@ The following table summarizes the outputs, detailed results can be found in the
 | algorithms        | 2584.6  |   29.6  |1307.1 |
 | priority_queue    | 1.4     |19134.6  |9568.0 |
 
-where: results are sorted according to "avg μs per op" (higher is better); μs stands for micro seconds; op stands for any operation (push or pop); the figures for priority_queue_cxx has been calculated with the results of experiments with PriorityQueue (the experiment with the highest number of operations).
+where: results are sorted according to "avg μs per op" (higher in the list is better); μs stands for micro seconds; op stands for any operation (push or pop); the figures for priority_queue_cxx has been calculated with the results of experiments with PriorityQueue (the experiment with the highest number of operations).
 
 
 ### Comparison with [algorithms (0.6.1)](http://rubygems.org/gems/algorithms) (50,000 push/pop)
@@ -205,7 +207,7 @@ As it usually happens, the answer is: it depends. The evidence reported above sh
 
 ## API
 
-Here it follows a transcription of the RDoc documentation for the library. I'm adding it here because I've having difficulties in instructing the 'gem' executable to generate the correct files on installation (everything works fine using rdoc from the command line though). Any suggestion about how to solve this problem is *very* welcome.
+Here it follows a transcription of the RDoc documentation for the library. I'm adding it here because I'm having difficulties in instructing the 'gem' executable to generate the correct files on installation (everything works fine using rdoc from the command line though). Any suggestion about how to solve this problem is *very* welcome.
 
 ### FastContainers::PriorityQueue
 
@@ -217,7 +219,7 @@ Create a new priority queue and returns it. queue_kind specifies whether to buil
 
 Example:
 
-```ruby 
+```ruby
   pq = FastContainers::PriorityQueue.new(:min)
 ```
 
@@ -291,4 +293,3 @@ The class Includes Enumerable, so that standard enumeration based methods (e.g.,
 ## Notes
 
 <sup id="ref1">1</sup> It is worth mentioning that, due to how priority queue are implemented by the C++ standard library, this implementation can't efficiently support priority changes. In any case, to support this feature would require important changes in the current API.<a href="#which-is-the-best-priority-queue-implementation-for-ruby" title="back reference">&#8617;</a>
-

data/ext/fast_containers/fc_pq.cpp

@@ -22,9 +22,9 @@
 #include <iostream>
 
 namespace fc_pq {
-  
+
   typedef std::pair<void*,double> PQElem;
- 
+
   class PairsComparator
   {
     bool reverse;
@@ -36,54 +36,54 @@ namespace fc_pq {
       else return (lhs.second<rhs.second);
     }
   };
-  
+
   // --------------------------------------
   // PQueue
   // --------------------------------------
-    
+
   typedef std::vector<PQElem> PQueueStorage;
   typedef unsigned int PQueueStorageVersion;
-  
-  typedef struct _PQueue { 
+
+  typedef struct _PQueue {
     PQueueStorage storage;
     PairsComparator comparator;
     PQueueStorageVersion version;
-    
+
     _PQueue(PQueueKind kind) : comparator(kind), version(0) { }
-  }* PQueue;  
+  }* PQueue;
 
   void destroy(PQueue q){
     delete q;
   }
-  
+
   PQueue create(PQueueKind kind) {
     return new _PQueue(kind);
   }
-  
+
   /* Getting the size of the container */
   unsigned int size(PQueue q) {
      return q->storage.size();
   }
-  
-  
+
+
   void push(PQueue q, void* value, double priority) {
     q->version++;
     q->storage.push_back(PQElem(value, priority));
     push_heap(q->storage.begin(), q->storage.end(), q->comparator);
   }
-  
+
   void* top(PQueue q) {
     return q->storage.at(0).first;
   }
-  
+
   double top_key(PQueue q) {
     return q->storage.at(0).second;
   }
-  
+
   double second_best_key(PQueue q) {
      if(q->storage.size()==2)
         return q->storage.at(1).second;
-     
+
      double key1 = q->storage.at(1).second;
      double key2 = q->storage.at(2).second;
      if( key1 > key2 ) {
@@ -92,67 +92,67 @@ namespace fc_pq {
         return key2;
      }
   }
-  
+
   void pop(PQueue q) {
     q->version++;
     pop_heap(q->storage.begin(), q->storage.end(), q->comparator);
     q->storage.pop_back();
   }
-  
+
   bool empty(PQueue q) {
     return q->storage.empty();
   }
-  
+
   // --------------------------------------
   // Iterator
   // --------------------------------------
-  
-  
+
+
   typedef struct _PQueueIterator {
     PQueueStorage::const_iterator iterator;
     PQueue pqueue;
     PQueueStorage* storage;
     PQueueStorageVersion version;
-    
-    _PQueueIterator(PQueue q) : iterator(q->storage.begin()), pqueue(q), storage(&q->storage), version(q->version) 
+
+    _PQueueIterator(PQueue q) : iterator(q->storage.begin()), pqueue(q), storage(&q->storage), version(q->version)
       { }
-    
-    void checkVersion() throw(PQueueException) {
+
+    void checkVersion() {
       if(version != pqueue->version) {
         throw PQueueException("FastContainers::PriorityQueue - a change in the priority queue invalidated the current iterator.");
       }
     }
   } PQueueImplIterator;
   #define QIT(it) ((PQueueImplIterator*)(it))
-  
+
   /* Returns a new iterator object */
   PQueueIterator iterator(PQueue q) {
     PQueueImplIterator* it = new PQueueImplIterator(q);
     return it;
   }
-  
+
   void iterator_dispose(PQueueIterator it) {
     delete it;
   }
-  
+
   /* Returns the value of the current element */
   void* iterator_get_value(PQueueIterator it) {
     return it->iterator->first;
   }
-  
+
   /* Returns the priority of the current  element */
   double iterator_get_key(PQueueIterator it) {
     return it->iterator->second;
   }
-  
+
   /* Moves on to the next element */
-  PQueueIterator iterator_next(PQueueIterator it) throw(PQueueException) {
+  PQueueIterator iterator_next(PQueueIterator it) {
     it->checkVersion();
     it->iterator++;
     return it;
   }
-  
+
   bool iterator_end(PQueueIterator it) {
     return it->iterator == it->storage->end();
   }
-}
+}

data/ext/fast_containers/fc_pq.h

@@ -22,64 +22,63 @@
 #define FC_QUEUE_H_KTY6FH1S
 
 #include <queue>
+#include <stdexcept>
 
 namespace fc_pq {
   class PQueueException : public std::runtime_error {
   public:
     PQueueException(const char* msg) : std::runtime_error(msg) {}
   };
-  
+
   typedef struct _PQueue* PQueue;
   typedef struct _PQueueIterator* PQueueIterator;
   typedef enum { MIN_QUEUE, MAX_QUEUE } PQueueKind;
-  
+
   /* Constructor. It defaults to construct a max queue. If true is passed
-  it construct a min queue.*/  
+  it construct a min queue.*/
   PQueue create(PQueueKind kind);
-  
+
   /* Destructor */
-  void destroy(PQueue q); 
-  
+  void destroy(PQueue q);
+
   /* Getting the size of the container */
   unsigned int size(PQueue q);
-  
+
   /* Adding elements */
   void push(PQueue q, void* value, double priority);
-  
+
   /* Inspecting the queue top (for values) */
   void* top(PQueue q);
-  
+
   /* Inspecting the queue top (for priorities) */
   double top_key(PQueue q);
-  
+
  /* Returns the priority of the next best element */
   double second_best_key(PQueue q);
-  
+
   /* Removing the queue top */
   void pop(PQueue q);
-  
+
   /* Returns true if the queue is empty */
   bool empty(PQueue q);
-  
+
   /* Returns a new iterator object */
   PQueueIterator iterator(PQueue q);
-  
+
   /* Dispose the iterator */
   void iterator_dispose(PQueueIterator it);
-  
+
   /* Returns the value of the current element */
   void* iterator_get_value(PQueueIterator it);
-  
+
   /* Returns the priority of the current  element */
   double iterator_get_key(PQueueIterator it);
-  
+
   /* Moves on to the next element */
-  PQueueIterator iterator_next(PQueueIterator it) throw(PQueueException);
-  
+  PQueueIterator iterator_next(PQueueIterator it);
+
   /* Return true if the iterator is already out of the container */
   bool iterator_end(PQueueIterator it);
 }
 
 #endif /* end of include guard: FC_QUEUE_H_KTY6FH1S */
-
-

data/lib/fc.rb

@@ -21,11 +21,11 @@
 require 'fast_containers'
 
 module FastContainers
-  VERSION = "0.3.2"
-  
+  VERSION = "0.3.4"
+
   class PriorityQueue
     include Enumerable
-    
+
     alias_method :next, :top
     alias_method :next_key, :top_key
   end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: priority_queue_cxx
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.5
 platform: ruby
 authors:
 - Roberto Esposito
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
 date: 2014-03-25 00:00:00.000000000 Z
@@ -24,7 +24,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
-description: A thin wrapper around C++ priority queues
+description: Fast priority queue implementation (c++ wrapper, see README.md for a
+  comparison with other libraries)
 email:
 - boborbt@gmail.com
 executables: []
@@ -45,11 +46,11 @@ files:
 - test/performance/test_fc_vs_pqueue.rb
 - test/performance/test_fc_vs_priority_queue.rb
 - test/test_fast_containers.rb
-homepage: https://github.com/boborbt/fast_containers
+homepage: https://github.com/boborbt/priority_queue_cxx
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--main"
 - README.md
@@ -66,10 +67,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.3.11
+signing_key:
 specification_version: 4
 summary: Fast (c++ wrapper) priority queue implementation for ruby.
 test_files: []
-has_rdoc: