Trees, Heaps, Timers, Error fitting, etc

Using this package, you can do powerful pattern recognition easily from your shell command line using a simple suite of tools. Applications include music cateogrization, text classification, handwritten digit recognition, and evolutionary tree reconstruction. The technique is based on a very general theoretical notion of Kolmogorov Complexity, and so is undoubtedly applicable to many as yet unknown disciplines. See the webpage for research papers explaining the math behind these techniques.

ParseTree is a C extension (using RubyInline) that extracts the parse tree for an entire class or a specific method and returns it as a s-expression (aka sexp) using ruby's arrays, strings, symbols, and integers. As an example: def conditional1(arg1) if arg1 == 0 then return 1 end return 0 end becomes: [:defn, :conditional1, [:scope, [:block, [:args, :arg1], [:if, [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]], [:return, [:lit, 1]], nil], [:return, [:lit, 0]]]]]

A screen + vim IDE setup for editing a Rails tree

Provides a generic tree data structure with ability to store keyed node elements in the tree. The implementation mixes in the Enumerable module.

RubyTree is a Ruby implementation of the generic tree data structure. It provides simple APIs to store named nodes, and to access, modify, and traverse the tree. The data model is node-centric, where nodes in the tree are the primary structural elements. It supports all common tree-traversal methods (pre-order, post-order, and breadth first). RubyTree mixes in the Enumerable and Comparable modules and behaves like a standard Ruby collection (iteration, comparison, etc.). RubyTree also includes a binary tree implementation, which provides in-order node traversal besides the other methods. RubyTree can import from and export to JSON, and supports Ruby’s object marshaling.

Rockit is a potent parser generator and gives you AST's (Abstract Syntax Tree's) which you can pattern match and pretty-print. Rockit does not distinghuish between lexing and parsing so the generated parsers are scanner-/lexer-less. The vision is to extend Rockit with more advanced compiler-related abilities including back-ends and code generation. However, currently the focus is on parsing and AST-related tasks such as transformation.

This module implements ordered n-ary branching tree structures. It includes support for breadth- and depth- first iteration, and serialization to and from a bracketed tree string.

Treemap visualization in ruby

This is a Ruby library for building trees representing HTML structure.

This is the original commit of the rtags source code as written by Keiju ISHITSUKA as part of the irb project. Now irb has moved into the main Ruby source tree rtags has become an independent project

ID3-based implementation of the M.L. Decision Tree algorithm

A Parsing Expression Grammar (PEG) Parser generator DSL for Ruby

== FEATURES/PROBLEMS: Chirp is a DSL for manipulating file systems. In the same way that rake is aimed at making system buildig easy, chirp is designed to make doing things to entire file systems easy. Chirp is still very much in development and you should be very careful with it: since chirp does operate on whole directory trees, it is capable of doing a lot of damage. == SYNOPSIS: FIX (code sample of usage)

CommandSet is a user interface framework. Its focus is a DSL for defining commands, much like Rake or RSpec. A default readline based terminal interpreter (complete with context sensitive tab completion, and the amenities of readline: history editing, etc) is included. It could very well be adapted to interact with CGI or a GUI - both are planned. CommandSet has a lot of very nice features. First is the domain-specific language for defining commands and sets of commands. Those sets can further be neatly composed into larger interfaces, so that useful or standard commands can be resued. Optional application modes, much like Cisco's IOS, with a little bit more flexibility. Arguments have their own sub-language, that allows them to provide interface hints (like tab completion) as well as input validation. On the output side of things, CommandSet has a very flexible output capturing mechanism, which generates a tree of data as it's generated, even capturing writes to multiple places at once (even from multiple threads) and keeping everything straight. Methods that normally write to stdout are interposed and fed into the tree, so you can hack in existing scripts with minimal adjustment. The final output can be presented to the user in a number of formats, including contextual coloring and indentation, or even progress hashes. XML is also provided, although it needs some work. Templates are on the way. While you're developing your application, you might find the record and playback utilities useful. cmdset-record will start up with your defaults for your command set, and spit out an interaction script. Then you can replay the script against the live set with cmdset-playback. Great for ad hoc testing, usability surveys and general demos.

A plugin for DataMapper that allows model objects to be a part of a heirarchal tree structure. Based on the acts_as_tree plugin for ActiveRecord.

== DESCRIPTION: Charlie is a library for genetic algorithms (GA) and genetic programming (GP). == FEATURES: - Quickly develop GAs by combining several parts (genotype, selection, crossover, mutation) provided by the library. - Sensible defaults are provided with any genotype, so often you only need to define a fitness function. - Easily replace any of the parts by your own code. - Test different strategies in GA, and generate reports comparing them. Example report: http://charlie.rubyforge.org/example_report.html == INSTALL: * sudo gem install charlie == EXAMPLES: This example solves a TSP problem (also quiz #142): N=5 CITIES = (0...N).map{|i| (0...N).map{|j| [i,j] } }.inject{|a,b|a+b} class TSP < PermutationGenotype(CITIES.size) def fitness d=0 (genes + [genes[0]]).each_cons(2){|a,b| a,b=CITIES[a],CITIES[b] d += Math.sqrt( (a[0]-b[0])**2 + (a[1]-b[1])**2 ) } -d # lower distance -> higher fitness. end use EdgeRecombinationCrossover, InversionMutator end Population.new(TSP,20).evolve_on_console(50) This example finds a polynomial which approximates cos(x) class Cos < TreeGenotype([proc{3*rand-1.5},:x], [:-@], [:+,:*,:-]) def fitness -[0,0.33,0.66,1].map{|x| (eval_genes(:x=>x) - Math.cos(x)).abs }.max end use TournamentSelection(4) end Population.new(Cos).evolve_on_console(500)

A RBTree is a sorted associative collection that is implemented with a Red-Black Tree. It maps keys to values like a Hash, but maintains its elements in ascending key order. The interface is the almost identical to that of Hash.

CQL Parser, with serialization from cql node tree to cql, xcql, and solr query

An ActsAs mixin implementing a set of trees (nested set) for ActiveRecord