Articles tagged 'data structure'

  • Rambling Trie 1.0.0 released!

    January 23, 2017

    It’s been a while since I last wrote anything about Rambling Trie (or anything at all really), but I wanted to take the time to talk about all the changes and performance improvements that I’ve made to the gem lately and that culminated in the release of version 1.0.0.

    The changes worth highlighting are:

    NEW: Ability to dump and load tries from disk

    It takes a relatively long time to load all the words from a large dictionary into a new trie in memory. This becomes especially annoying when you have to do this full process every time you restart your application, even though you know that the trie is going to remain constant over time.

    To sort this out, you can now use the Rambling::Trie.load and Rambling::Trie.dump methods! Like this...

    Continue Reading →

  • New homepage for Rambling Trie

    July 28, 2012


    This post was originally published in the Rambling Labs Blog on July 28, 2012.


    As done with the jQuery Rambling Slider previously on this week, and as I promised on that post as well, the Rambling Trie now has its own homepage on ramblinglabs.com! Here’s the link:

    Rambling Trie | A Ruby implementation of the Trie data structure

    It features installation and usage steps as well as a contributing page, and includes the badges from various cool GitHub services (more on that later). It also has a brand new logo, inspired on the trie data structure (and other tree data structures) concept.

    Go ahead and check it out!

    Still pending:

    • Examples page for jQuery Rambling Slider
    • Examples page for Rambling Trie
    • Examples page for Rambling Slider...

    Continue Reading →

  • Version 0.4.2 of the Rambling Trie has been released!

    July 28, 2012


    This post was originally published in the Rambling Labs Blog on July 28, 2012.


    The Rambling Trie has reached its 0.4.2 version. This one includes the before mentioned changes for the trie instance to behave as an Enumerable.

    This means that having this:

    trie = Rambling::Trie.create
    (%w(some words and other stuff)).each |word|
      trie << word
    end
    

    You can do something like this:

    trie.each do |word|
      puts "#{word} is included!"
    end
    

    As well as:

    trie.any? { |word| word.include? 'x' }
    trie.all? { |word| word.length > 0 }
    

    And any other method included in Ruby core’s Enumerable module. Isn’t that cool!?

    Enjoy!

  • Rambling Trie 0.4.1 is out!

    July 21, 2012


    This post was originally published in the Rambling Labs Blog on July 21, 2012.


    Version 0.4.1 of the Rambling Trie is here. It has some minor performance improvements over previous versions, changes in file/directoy structure, as well as a new API entry point, other API methods and more documentation.

    You can now instance a new trie like this:

    trie = Rambling::Trie.create
    

    DEPRECATION WARNING

    The old API entry point Rambling::Trie.new is now marked as deprecated and will be removed soon. Use the new Rambling::Trie.create method.


    Also, you can add words to the trie using <<:

    trie << 'word'
    

    And check if a word is contained in the trie with include?:

    trie.include? 'word'
    

    You can see more documentation available on the project’s...

    Continue Reading →

  • Rambling Trie 0.3.3 has been released!

    February 13, 2012


    This post was originally published in the Rambling Labs Blog on February 13, 2012.


    The new version of the rambling-trie gem is out! As I said on my previous post, the rambling-trie is an implementation of the Trie data structure in Ruby.

    Version 0.3.3 has several performance improvements, and I also added the code’s documentation via Yard. Also, since the previous version (0.3.2), the methods has_branch_for? and is_word? have been fixed for the compressed trie.

    For the uncompressed trie, the has_branch_for? and is_word? methods work very fast. The compressed trie’s is_word? method is as fast as it’s uncompressed counterpart, but the has_branch_for? is a bit slower.

    I’ve also added some benchmarking reports for each version of the...

    Continue Reading →

  • Rambling Trie: A custom Trie data structure implementation in Ruby

    February 10, 2012


    This post was originally published in the Rambling Labs Blog on February 10, 2012.


    We’re proud to announce that our first gem is here!

    It’s called rambling-trie, and it’s an implementation of the Trie data structure. A Trie is an ordered tree data structure, and it is great for managing dictionaries and for word searching and matching.

    Now, to install the rambling-trie, you can either install it manually by running:

    gem install rambling-trie
    

    Or, you can add this line to the Gemfile of your application:

    gem 'rambling-trie'
    

    To create a new Trie you can do this:

    require 'rambling-trie'
    
    trie = Rambling::Trie.new
    

    And to add a new word to the Trie, you can call this:

    trie.add_branch_from 'word'
    

    Or to automatically load words from a...

    Continue Reading →