chatchart 1.0.0

data/LICENSE

@@ -0,0 +1,3 @@
+this code is licensed under the "don't be a retarded asshole" license.
+if i don't like how you use this software i can tell you to fuck off
+and you can't use it, otherwise you can use it.

data/README

@@ -0,0 +1,37 @@
+ChatChart - ASCII Graph Layout & Drawing
+
+This is a package of various crappy ruby code which generally
+revolves around ASCII drawing, graph layout, and physics simulation
+
+Copyright(c) 2009 by Christopher Abad
+
+EMAIL: aempirei@gmail.com
+AIM: ambientempire
+IRC: aempirei on irc.freenode.net
+
+http://blog.twentygoto10.com/
+http://www.twentygoto10.com/
+http://www.the-mathclub.net/
+
+this code is licensed under the "don't be a retarded asshole" license.
+if i don't like how you use this software i can tell you t
+
+== RUNME ==
+
+check out the demos in the ./demos directory
+
+demo-automatic.rb - a simple automatic graph layout sample driver
+demo-animated.rb  - an animated automatic graph layout driver using somewhat of
+                    a molecular physics model
+demo-physics.rb   - gravity/mass physics demo
+demo-simple.rb    - simple random graph layout and ascii drawing driver
+
+== USEME ==
+
+chatchart.rb        - ASCII drawing module
+point.rb            - 2D point class
+particle.rb         - particle class
+
+== HOWTO ==
+
+read the samples for now. but i promise i will include more information soon.

data/demos/demo-animated.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/ruby
+#
+# autograph.rb - Animated Autographer Sample
+#
+# this will do some animated automatic graph layout.
+# make sure your terminal is the right size.
+# i think the drawing window is set to 70x30
+#
+# Copyright(c) 2009 by Christopher Abad
+# aempirei@gmail.com
+# http://www.twentygoto10.com/
+#
+# this code is licensed under the "don't be a retarded asshole" license.
+# if i don't like how you use this software i can tell you to fuck off
+# and you can't use it, otherwise you can use it.
+#
+# == Usage ==
+#
+# autograph.rb [OPTIONS]
+#
+# -h, --help:
+#    show help
+#
+# -1, --taxicab:
+#    draw using taxicab topology
+#
+# -2, --hockey:
+#    draw using hockey-stick topology
+#
+
+require 'rubygems'
+require 'chatchart'
+require 'getoptlong'
+require 'rdoc/usage'
+
+g = ChatChart::Graph.new << [
+       :course - :name0  ,
+       :course - :code   ,
+       :course - :'C-I'  ,
+       :course - :'S-C'  ,
+    :institute - :name1  ,
+    :institute - :'S-I'  ,
+    :institute - :'C-I'  ,
+      :student - :grade  ,
+      :student - :name2  ,
+      :student - :number ,
+      :student - :'S-C'  ,
+      :student - :'S-I'  ,
+      :a - :b,
+      :a - :c,
+      :a - :d,
+      :b - :q,
+      :b - :w,
+      :b - :e,
+]
+
+opts = GetoptLong.new(
+    [ '--help'   , '-h', GetoptLong::NO_ARGUMENT ],
+    [ '--hockey' , '-2', GetoptLong::NO_ARGUMENT ],
+    [ '--taxicab', '-1', GetoptLong::NO_ARGUMENT ]
+)
+
+linestyle = ChatChart::L1Line
+
+opts.each do |opt,arg|
+    case opt
+        when '--hockey'
+            linestyle = ChatChart::HLine
+        when '--taxicab'
+            linestyle = ChatChart::L1Line
+        when '--help'
+            RDoc::usage
+    end
+end
+
+COLS = 70
+ROWS = 30
+
+HOME = "\033[H"
+BOLD = "\033[1m"
+NORM = "\033[0m"
+CLRSCR = "\033[2J"
+
+CURSOR_ON = "\033[?25h"
+CURSOR_OFF = "\033[?25l"
+
+WINDOW = [ ChatChart::P[0,0], ChatChart::P[COLS,ROWS] ]
+
+Kernel::at_exit { puts CURSOR_ON + "\033[50;1H" + NORM }
+
+Kernel::trap('INT') { |signo| exit }
+
+puts CURSOR_OFF + CLRSCR
+
+# loop do
+
+ChatChart::RandomLayout[ g, COLS, ROWS ]
+
+C_SZ = 50
+es = []
+ses = 0
+
+loop do
+    ChatChart::SmartLayout[ g, 1 ]
+    es << g.energy
+    if es.length >= C_SZ
+        es = es[-C_SZ,C_SZ]
+        pses = ses
+        ses = es[-C_SZ,C_SZ].inject(0.0) { |sum,e| sum += e }.to_f / C_SZ
+        de = ses - pses
+    else
+        ses = 0
+        de = 0
+    end
+
+    c = g.to_canvas(linestyle) << ChatChart::Title[ "delta-energy: %+.3f" % [ de ], proc { |p| p.r }, 1, 1 ]
+    puts HOME + c.window(*WINDOW)
+end

data/demos/demo-automatic.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/ruby
+#
+# autograph-simple.rb - Simple AutoGrapher Sample Driver
+#
+# Copyright(c) 2009 by Christopher Abad
+# aempirei@gmail.com
+# http://www.twentygoto10.com/
+#
+# this code is licensed under the "don't be a retarded asshole" license.
+# if i don't like how you use this software i can tell you to fuck off
+# and you can't use it, otherwise you can use it.
+#
+
+require 'rubygems'
+require 'chatchart'
+
+g = ChatChart::Graph.new << [
+       :course - :name0  ,
+       :course - :code   ,
+       :course - :'C-I'  ,
+       :course - :'S-C'  ,
+    :institute - :name1  ,
+    :institute - :'S-I'  ,
+    :institute - :'C-I'  ,
+      :student - :grade  ,
+      :student - :name2  ,
+      :student - :number ,
+      :student - :'S-C'  ,
+      :student - :'S-I'  ,
+      :a - :b,
+      :a - :c,
+      :a - :d,
+      :b - :q,
+      :b - :w,
+      :b - :e,
+]
+
+puts "be patient, this is ruby code..."
+ChatChart::SmartLayout[ g ] 
+puts g.to_canvas(ChatChart::L1Line)

data/demos/demo-physics.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/ruby
+#
+# fizzix.rb - Physics Test Code
+#
+# Copyright(c) 2009 by Christopher Abad
+# aempirei@gmail.com
+# http://www.twentygoto10.com/
+#
+# this code is licensed under the "don't be a retarded asshole" license.
+# if i don't like how you use this software i can tell you to fuck off
+# and you can't use it, otherwise you can use it.
+#
+
+require 'rubygems'
+require 'chatchart'
+require 'particle'
+
+include ChatChart
+
+COLS = 100
+ROWS = 30
+P_SZ = 10
+
+HOME = "\033[H"
+BOLD = "\033[1m"
+NORM = "\033[0m"
+
+CURSOR_ON = "\033[?25h"
+CURSOR_OFF = "\033[?25l"
+
+WINDOW = [ P[0,0], P[COLS,ROWS] ]
+
+ps = []
+
+P_SZ.times { ps << GParticle.new(P.random(COLS, ROWS).vector) }
+
+c = Canvas.new
+
+Kernel::at_exit { puts CURSOR_ON + "\033[50;1H" + NORM }
+Kernel::trap('INT') { |signo| exit }
+
+puts CURSOR_OFF + BOLD
+
+loop do
+    ps.each { |p| c << Dot[' ', p.p.quantize] }
+    # calculate the instantaneous acceleration
+    ps.each { |p| p.a = p.n_body_acceleration(ps.reject { |q| q.object_id == p.object_id }) }
+    # update the velocities
+    ps.each { |p| p.v += p.a * GParticle::DT ; p.v *= GParticle::Z }
+    # project new positions
+    ps.each { |p| p.p += p.v * GParticle::DT }
+    ps.each { |p| c << Dot['@', p.p.quantize] }
+    puts HOME + c.window(*WINDOW)
+end

data/demos/demo-simple.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/ruby
+#
+# sample.rb - ChatChart Sample Driver
+#
+# Copyright(c) 2009 by Christopher Abad
+# aempirei@gmail.com
+# http://www.twentygoto10.com/
+#
+# this code is licensed under the "don't be a retarded asshole" license.
+# if i don't like how you use this software i can tell you to fuck off
+# and you can't use it, otherwise you can use it.
+#
+
+require 'rubygems'
+require 'chatchart'
+
+COLS = 60
+ROWS = 14
+
+g = ChatChart::Graph.new << [
+       :course - :name0  ,
+       :course - :code   ,
+       :course - :'C-I'  ,
+       :course - :'S-C'  ,
+    :institute - :name1  ,
+    :institute - :'S-I'  ,
+    :institute - :'C-I'  ,
+      :student - :grade  ,
+      :student - :name2  ,
+      :student - :number ,
+      :student - :'S-C'  ,
+      :student - :'S-I'  ,
+]
+
+ChatChart::RandomLayout[ g, COLS, ROWS ]
+
+print g.to_canvas << ChatChart::Title[ 'SHIT FOR BRAINS'.reverse, proc { |p| p.l.d }, -2, 0 ]

data/lib/chatchart.rb

@@ -0,0 +1,518 @@
+#
+# ChatChart
+# chatchart.rb - ASCII Graphs
+#
+# use this to create an ascii graph described using a simple array of
+# vertex adjacencies. just check out the sample driver (sample.rb)
+#
+# Copyright(c) 2009 by Christopher Abad
+# aempirei@gmail.com
+# http://www.twentygoto10.com/
+#
+# this code is licensed under the "don't be a retarded asshole" license.
+# if i don't like how you use this software i can tell you to fuck off
+# and you can't use it, otherwise you can use it.
+#
+
+require 'point'
+require 'particle'
+
+class Symbol
+    def <=>(b)
+        self.to_s <=> b.to_s
+    end
+    def -(b)
+        ChatChart::Edge[self,b]
+    end
+end
+
+class Circuit
+    def self.[](p)
+        edges = []
+        p.split(//).each_cons(2) { |a,b| edges << a.to_sym - b.to_sym }
+        edges
+    end
+end
+
+module ChatChart
+
+# a canvas is the primary drawing space
+
+class Canvas < Hash
+    def [](p)
+        raise 'non-point' unless p.is_a? P
+        super(p)
+    end
+
+    def <<(g)
+        case g
+            when Proc
+                g.call(self)
+            else
+                raise 'non-curve-proc' unless g < Curve
+        end
+        self
+    end
+
+    def []=(p,v)
+        raise 'non-point' unless p.is_a? P
+        raise 'non-char' unless v.is_a?(String) and v.length == 1
+        super(p,v)
+    end
+
+    def bounds
+        xs = keys.map { |p| p.x }.sort
+        ys = keys.map { |p| p.y }.sort
+
+        return [ P[xs.first,ys.first], P[xs.last,ys.last] ]
+    end
+
+    def window(ul,lr)
+        str = ''
+        ul = ul.quantize
+        lr = lr.quantize
+        ((ul.y)..(lr.y)).each do |y|
+            ((ul.x)..(lr.x)).each do |x|
+                p = P[x,y]
+                if has_key?(p)
+                    str << self[p]
+                else
+                    str << ' '
+                end
+            end
+            str << "\n"
+        end
+        return str
+    end
+
+    def to_s
+        window *bounds
+    end
+end
+
+# the curve is a general path through the canvas space, which consists of some geometric description
+# and the [] operator which returns a proc that accepts a single canvas parameter which is then drawn to
+
+class Curve
+    def self.[](*geometry)
+        proc { |canvas| self.draw(canvas, *geometry) }
+    end
+    def self.draw(canvas, *geometry)
+        raise 'undefined method'
+    end
+    def self.get_point(*geometry)
+        case geometry.first
+            when P
+                geometry.first
+            when Integer
+                P[geometry.first, geometry.last]
+            else
+                raise 'invalid-geometry'
+        end
+    end
+    def self.get_points(*geometry)
+        return [] if geometry.empty?
+        case geometry.first
+            when P
+                [ geometry.shift.dup ] + get_points(*geometry)
+            when Integer
+                [ P[geometry.shift, geometry.shift] ] + get_points(*geometry)
+            else
+                raise 'invalid-geometry'
+        end
+    end
+    def self.get_interval(*geometry)
+        points = get_points(*geometry)
+        points.first .. points.last
+    end
+end
+
+# titles are just an instance of a general curve, where there is
+# some geometry describing their origin and a block describing
+# their differential motion
+
+class Title < Curve
+    def self.[](title, blk, *geometry)
+        proc { |canvas| self.draw(canvas, title, *geometry, &blk) }
+    end
+
+    def self.draw(canvas, title, *geometry, &blk)
+        p = get_point(*geometry).quantize
+        title.to_s.split(//).each do |ch|
+            canvas[p] = ch
+            p = blk.call(p)
+        end
+    end
+end
+
+class Dot < Curve
+    def self.[](dot, *geometry)
+        proc { |canvas| self.draw(canvas, dot, *geometry) }
+    end
+
+    def self.draw(canvas, dot, *geometry)
+        p = get_point(*geometry)
+        canvas[p] = dot
+    end
+end
+
+# lines are just an instance of a general curve, where there is some geometry describing their path
+
+class Line < Curve
+    def self.[](*geometry)
+        proc { |canvas| self.draw(canvas, *geometry) }
+    end
+end
+
+# L1-norm (taxicab norm) lines are drawn up/down then left/right from origin (a) to destination (b)
+
+class L1Line < Line
+    def self.draw(canvas, *geometry)
+
+        a,b = get_points(*geometry)
+        a.quantize!
+        b.quantize!
+        c = a % b
+
+        y1,y2 = [a.y,c.y].sort
+
+        (y1..y2).each do |y|
+            p = P[c.x,y]
+            next if p == c
+            canvas[p] = '|'
+        end
+
+        x1,x2 = [b.x,c.x].sort
+
+        (x1..x2).each do |x|
+            p = P[x,c.y]
+            next if p == c
+            canvas[p] = '-'
+        end
+
+        canvas[c] = '+'
+        canvas[a] = 'o'
+        canvas[b] = 'o'
+    end
+end
+
+# a hockey line is somewhere between an L1-norm and L2-norm topology where the topology
+# is constructed from 0, 45, and 90 degree edges with unit projections onto x and y and
+# where length of a vector v is calculated as follows:
+# v = <dx,dy>
+# dz = min(dx,dy)
+# dw = |dx-dy|
+# |v| = |<dz,dz>|+dw
+
+class HLine < Line
+    def self.draw(canvas, *geometry)
+
+        a,b = get_points(*geometry)
+        a.quantize!
+        b.quantize!
+
+        v = b-a
+
+        amstep = (v.proj(P::J).unit + v.proj(P::I).unit)
+        amstep.quantize!
+        am = amstep * v.norm(:min)
+        am.quantize!
+
+        mb = v-am
+        mbstep = mb.unit.quantize
+
+        pos = a
+
+        while pos != a + am
+            pos += amstep
+            canvas[pos] = (amstep.monic == P[1,1]) ? '\\' : '/'
+        end
+
+        while pos != b
+            pos += mbstep
+            canvas[pos] = (mbstep.x == 0.0) ? '|' : '-'
+        end
+
+        canvas[a + am] = '+'
+        canvas[a] = 'o'
+        canvas[b] = 'o'
+    end
+end
+
+class WiggleLine < Line
+end
+
+class Edge
+    attr_accessor :from
+    attr_accessor :to
+
+    def self.[](a,b)
+        new(a,b)
+    end
+
+    def initialize(a,b)
+        raise 'invalid-edge' unless a.is_a? Symbol and b.is_a? Symbol
+        @from,@to = [a,b].sort
+    end
+
+    def name
+        "#{from} -- #{to}".to_sym
+    end
+
+    def to_a
+        [from,to]
+    end
+
+    def hash
+        to_a.hash
+    end
+    
+    def neighbor(v)
+        v == to ? from : to
+    end
+
+    # check for edge endpoint inclusion of a vertex (or by name of vertex)
+    def ===(v)
+        case v
+            when Array
+                v.inject(false) { |acc,w| acc ||= (self === w) }
+            when Vertex
+                self === v.name
+            when Symbol
+                @from == v or @to == v
+            else
+                raise 'invalid-comparison'
+        end
+    end
+    # compare two edges (undirected)
+    def ==(e)
+        raise 'invalid-comparison' unless e.is_a? Edge
+        from == e.from and to == e.to
+    end
+end
+
+class Vertex
+    attr_reader :p
+    attr_reader :name
+    def initialize(name)
+        raise 'non-symbol' unless name.is_a? Symbol
+        @p = Particle[]
+        @name = name
+    end
+    def initialize_copy(orig)
+        @p = @p.dup
+    end
+    def hash
+        @name.hash
+    end
+    # compare vertices, which allows for comparison against symbols, which is the vertex name type
+    def ===(v)
+        case v
+            when Array
+                v.inject(false) { |acc,w| acc ||= (self === w) }
+            when Symbol
+                self.name == v
+            when Vertex
+                self == v
+            else
+                raise 'invalid-comparison'
+        end
+    end
+    def ==(v)
+        raise 'invalid-comparison' unless v.is_a? Vertex
+        self.name == v.name
+    end
+end
+
+# graphs are collections of vertices and edges without layout information
+
+class Graph
+    attr_reader :e      # edges
+    attr_reader :v      # vertices
+    attr_accessor :root # root node name
+    def initialize(root=nil)
+        @e = {}
+        @v = {}
+        @root = case root
+            when Symbol
+                root
+            when Vertex
+                root.name
+            when NilClass
+                # do nothing
+            else
+                raise 'invalid-root-node'
+        end
+        self << root if root
+    end
+    def initialize_copy(orig)
+        @e = @e.dup
+        @v = @v.dup
+    end
+    def <<(elem)
+        case elem
+        when Graph
+            self << elem.v.values << elem.e.values
+        when Array
+            elem.each { |q| self << q }
+        when Edge
+            @e[elem.name] = elem.dup
+            self << elem.from unless @v[elem.from]
+            self << elem.to unless @v[elem.to]
+        when Vertex
+            @v[elem.name] = elem.dup
+        when Symbol
+            self << Vertex.new(elem)
+        when NilClass
+            # do nothing
+        else
+            raise 'non-graph-element'
+        end
+        self
+    end
+    def to_s
+        v_str = @v.keys.map { |s| "\t#{s};\n" }.join 
+        e_str = @e.keys.map { |s| "\t#{s};\n" }.join 
+        "#{self.class.name.downcase} g {\n#{e_str}#{v_str}};\n"
+    end
+    def to_canvas(linestyle = L1Line)
+        canvas = Canvas.new
+        @e.values.each { |e| canvas << linestyle[ @v[e.from].p.p, @v[e.to].p.p ] }
+        @v.values.each { |v| canvas << Title[ v.name, proc { |p| p.r }, v.p.p ] }
+        canvas
+    end
+
+    def find_edges(*vs)
+        @e.values.select { |e| e === vs }
+    end
+
+    def neighborhood(v)
+        find_edges(v).map { |e| @v[e.neighbor(v)] }
+    end
+
+    def [](*vs)
+        Graph.new(vs.first) << find_edges(*vs)
+    end
+
+    def degree(v)
+        find_edges(v).length
+    end
+
+    def pop(*vs)
+        # pop assumes vertices come in as their name, not a full vertex object
+        k1hood = self[*vs]                      # get k-1 N
+        vs.each { |v| @v.delete v }             # delete k-1 N vertices
+        k1hood.e.keys.each { |e| @e.delete e }  # delete k-1 N edges
+        k1hood                                  # return k-1 N
+    end
+
+    def span(plan)
+
+        remaining = dup
+        popped = remaining.pop plan.get_root(remaining)
+        tree = Graph.new << popped.root
+
+        until remaining.v.empty?
+            border = self[*tree.v.keys][*remaining.v.keys]  # find edges on the border between the tree and the remaining graph
+            edge = plan.get_edge(border)                    # choose one edge and new node to add to the tree
+            tree << edge                                    # add to the tree
+            remaining.pop(edge.from, edge.to)               # remove k-1 N from remaining graph
+        end
+
+        tree
+    end
+
+    def energy
+        @v.values.inject(0.0) { |sum,v| sum += (v.p.v * v.p.m).norm }
+    end
+end
+
+# edge/node selection plan for things like spanning trees
+class Plan
+end
+
+class FirstPlan < Plan
+    def self.get_edge(graph)
+        graph.e.values.first
+    end
+    def self.get_root(graph)
+        graph.v.keys.first
+    end
+end
+
+# layouts take graphs and output canvases, when then can be printed or whatever
+
+class Layout
+    def self.[](*as)
+        self.layout(*as)
+        self
+    end
+    def self.layout(*as)
+        raise 'undefined method'
+    end
+end
+
+# random layout places vertices at random and then connects them via L1-norm edges
+
+class RandomLayout < Layout
+    def self.layout(g,width,height)
+        g.v.values.each { |v| v.p.p.randomize!(width,height) }
+        self
+    end
+end
+
+class SmartLayout < Layout
+
+    CW_SZ = 200 # convolution window size
+
+    def self.layout(g,iter=nil)
+
+        RandomLayout[g, 40, 24] if iter.nil?
+
+        es = []
+        ps = g.v.values.map { |v| v.p }
+        ses = 0 
+
+        while iter.nil? or (iter -= 1) >= 0;
+
+            # update the gravity field
+            ps.each { |p| p.a = p.n_body_acceleration(ps.reject { |q| q.object_id == p.object_id }) }
+
+            # update the bond field
+            g.v.keys.each do |v|
+                p = g.v[v].p
+                qs = g.neighborhood v
+                p.b = p.n_body_bond(qs.map { |q| q.p })
+            end
+
+            # update the velocities
+            ps.each do |p|
+                p.v *= Particle::Z
+                p.v += p.a * Particle::DT
+                p.v += p.b * Particle::DT
+            end
+
+            # project new positions
+            ps.each { |p| p.p += p.v * Particle::DT }
+
+            # check system energy delta or iteration count
+
+            es << g.energy
+
+            if es.length >= CW_SZ
+                es = es[-CW_SZ,CW_SZ]
+                pses = ses
+                ses = es[-CW_SZ,CW_SZ].inject(0.0) { |sum,e| sum += e }.to_f / CW_SZ
+                de = ses - pses
+                break if de.abs < 0.005
+            else
+                ses = 1000
+                de = 1000
+            end
+        end
+
+        self
+    end
+end
+
+end # module ChatChart

data/lib/particle.rb

@@ -0,0 +1,93 @@
+#
+# particle.rb - Physics Particle Code
+#
+# Copyright(c) 2009 by Christopher Abad
+# aempirei@gmail.com
+# http://www.twentygoto10.com/
+#
+# this code is licensed under the "don't be a retarded asshole" license.
+# if i don't like how you use this software i can tell you to fuck off
+# and you can't use it, otherwise you can use it.
+#
+
+require 'point'
+
+module ChatChart
+class Particle
+
+    DT = 0.50        # time delta
+    G = -20.0        # universal constant of gravity
+    M = 300.0         # electron charge bond constant
+    Z = 0.90         # friction
+    D = 8.00         # bond distance
+
+    EPSILON = 0.03
+    NORMMIN = 0.002
+
+    attr_accessor :p # position
+    attr_accessor :m # mass
+    attr_accessor :v # velocity
+    attr_accessor :a # acceleration
+    attr_accessor :b # bond
+
+    def hash
+        object_id.hash
+    end
+
+    def self.[](*ns)
+        self.new P[*ns].vector
+    end
+
+    def initialize(p=P[0.0,0.0])
+        @m = 1.0
+        @v = P[0.0,0.0]
+        @p = p
+    end
+
+    def acceleration(p)
+        force(p) / @m
+    end
+
+    # electron bond attraction
+    def bond(p)
+        v = p.p - self.p
+        return P.zero if v == P.zero
+        return P.zero if v.aspect.norm < D - EPSILON
+        v0 = v.aspect.norm + D
+        v.unit * M / (v0 * v0)
+    end        
+
+    def n_body_acceleration(ps)
+        v = ps.inject(P[].vector) { |acc,p| acc += acceleration p }
+        v.aspect.norm < NORMMIN ? P.zero : v
+    end
+
+    def n_body_bond(ps)
+        v = ps.inject(P[].vector) { |acc,p| acc += bond p }
+        v.aspect.norm < NORMMIN ? P.zero : v
+    end
+
+    # monopole short acting repulsive nuclear force
+    def force(p)
+        v = p.p - self.p
+        return P.zero if v == P.zero
+        return P.zero if v.aspect.norm > D + EPSILON
+        v0 = v.aspect.norm + D
+        v.unit * G * @m * p.m / (v0 * v0)
+    end
+end
+
+class GParticle < Particle
+    DT = 0.5         # time delta
+    G = 50.0         # universal constant of gravity
+    Z = 0.98         # friction
+    D = 3.00         # bond distance
+    # monopole short acting repulsive nuclear force
+    def force(p)
+        v = p.p - self.p
+        return P.zero if v == P.zero
+        v0 = v.aspect.norm + D
+        v.unit * G * @m * p.m / (v0 * v0)
+    end
+end
+end

data/lib/point.rb

@@ -0,0 +1,167 @@
+#
+# Point
+# point.rb - Simple 2-D Point
+#
+# Copyright(c) 2009 by Christopher Abad
+# aempirei@gmail.com
+# http://www.twentygoto10.com/
+#
+# this code is licensed under the "don't be a retarded asshole" license.
+# if i don't like how you use this software i can tell you to fuck off
+# and you can't use it, otherwise you can use it.
+#
+
+module ChatChart
+class P
+    attr_accessor :x
+    attr_accessor :y
+
+    def initialize(*ns)
+        @x = ns[-2] || 0
+        @y = ns[-1] || 0
+    end
+
+    def self.[](*ns)
+        new *ns
+    end
+
+    I = P[1,0]
+    J = P[0,1]
+
+    def self.zero
+        return P[]
+    end
+
+    def randomize!(width,height)
+        @x = rand width
+        @y = rand height
+        self
+    end
+
+    def self.random(width,height)
+        new.randomize! width, height 
+    end
+
+    def quantize!
+        self << self.quantize
+    end
+
+    def quantize
+        P[@x.round.to_i, @y.round.to_i]
+    end
+
+    def vector
+        P[@x.to_f,@y.to_f]
+    end
+
+    def to_s
+        "(%05.1f,%05.1f)" % [@x,@y]
+    end
+
+    def to_a
+        [@x,@y]
+    end
+
+    def eql?(p)
+        p.is_a?(P) and (@x == p.x) and (@y == p.y)
+    end
+
+    def hash
+        [@x,@y].hash
+    end
+
+    def <=>(p)
+        (@x * @x + @y * @y) <=> (p.x * p.x + p.y * p.y)
+    end
+
+    # vector addition
+    def +(p)
+        P[@x + p.x, @y + p.y]
+    end
+
+    # both scalar product and dot product
+    def *(v)
+        case v
+            when P
+                (@x * v.x + @y * v.y)
+            else
+                P[@x * v, @y * v]
+        end            
+    end
+
+    def /(v)
+        self * (1.0 / v.to_f)
+    end
+
+    def unit
+        return P.zero if self == P.zero
+        self / norm
+    end
+
+    def comp(b)
+        norm * cos(b)
+    end
+
+    def monic
+        self.vector / @x
+    end
+
+    def proj(b)
+        b.unit * (self * b.unit)
+    end
+
+    def cos(b)
+        unit * b.unit
+    end
+
+    S2 = Math::sqrt(2.0)
+
+    def aspect(k=1.3)
+        P[@x, @y * k]
+    end
+
+    def norm(v=2)
+        case v
+            when 1
+                (@x.abs + @y.abs).to_f
+            when 2
+                Math::hypot @x, @y
+            when Numeric
+                (@x.abs ** v + @y.abs ** v) ** (1.0 / v)
+            when :ascii
+                aspect.norm
+            when :min
+                [@x.abs,@y.abs].min
+            when :max
+                [@x.abs,@y.abs].max
+            when :h
+                norm(:min) * (S2 - 1) + norm(:max)
+            else
+                1.0
+        end
+    end
+
+    def <<(p)
+        @x = p.x
+        @y = p.y
+        self
+    end
+
+    def u! ; self << self.u ; end
+    def d! ; self << self.d ; end
+    def l! ; self << self.l ; end
+    def r! ; self << self.r ; end
+
+    def u ; P[@x,@y-1] ; end
+    def d ; P[@x,@y+1] ; end
+    def l ; P[@x-1,@y] ; end
+    def r ; P[@x+1,@y] ; end
+
+    def ==(p) ; eql?(p)    ; end
+    def %(p)  ; P[@x,p.y]  ; end
+    def -@    ; P[-@x,-@y] ; end
+    def +@    ; self       ; end
+    def ~@    ; P[@y,@x]   ; end
+    def -(p)  ; self + -p  ; end
+end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: chatchart
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Christopher Abad
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-22 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: This is a package of various crappy ruby code which generally revolves around ASCII drawing and graph layout.
+email: aempirei@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- demos/demo-animated.rb
+- demos/demo-simple.rb
+- demos/demo-physics.rb
+- demos/demo-automatic.rb
+- lib/chatchart.rb
+- lib/particle.rb
+- lib/point.rb
+- README
+- LICENSE
+has_rdoc: true
+homepage: http://www.twentygoto10.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: ASCII drawing and graph layout
+test_files: []
+