mathviz 1.0.0

data/History.txt

@@ -0,0 +1,18 @@
+=== 1.0.0 2009-12-23
+
+* Rename from MatLat to MathViz
+* Default output file name
+* Add rdoc comments and examples
+* Package as gem
+* Included classes/modules under MathViz namespace
+
+=== 0.1.0 2009-12-18
+
+* Support unit tracking
+* Unary operators
+* Moved operator out of box
+
+=== 0.0.1 2009-02-12
+
+* Generate Graphs
+* Track values

data/Manifest.txt

@@ -0,0 +1,16 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+examples/E_mc2.png
+examples/E_mc2.rb
+examples/dc.rb
+examples/first.rb
+examples/mathviz.rb
+lib/mathviz.rb
+spec/measurable_spec.rb
+spec/measured_spec.rb
+spec/operation_spec.rb
+spec/spec_helper.rb
+spec/unit_spec.rb
+tasks/idocs.rake

data/README.rdoc

@@ -0,0 +1,51 @@
+-*- rdoc -*-
+
+= MathViz
+
+* http://github.com/JustinLove/mathviz
+
+== DESCRIPTION:
+
+Turn simple equations (a = b * c) into GraphViz dot files showing relationships, values, and units.
+
+== FEATURES/PROBLEMS:
+
+* Adds one method to Object and several to Numeric (some direct, some by Measurable and Unit.)  If you use units of measure, each unit will appear on Numeric via module Unit.
+* MathViz produces textual .dot files.  You will need a viewer which supports dot files directly, or Graphviz to convert them to images yourself.
+
+== SYNOPSIS:
+
+  require 'rubygems'
+  require 'mathviz'
+  
+  # No units are provided by default.
+  # You can also use 1.unit(:m).per.unit(:s) etc.
+  module MathViz::Units
+    new_units :m, :s, :kg, :lb, :joule
+  end
+  
+  MathViz.new {
+    # Alternate form: MathViz.new('optional_output_filename', binding_object)
+  
+    m = 140.lb * 0.45359237.kg.per.lb
+    c = 299_792_458.m.per.s
+    # capitalized values are constants in ruby, so we need the underscore
+    _E = (m * (c * c)) * 1.joule.per.kg.m.m.per.s.s
+  
+    binding # Don't forget to return the binding
+  }.dot # Required to produces the actual .dot file
+
+link:examples/E_mc2.png
+== REQUIREMENTS:
+
+* GraphvizR (aka graphviz_r)
+* Graphviz - http://www.graphviz.org/
+
+== INSTALL:
+
+* sudo gem install mathviz
+
+== LICENSE:
+
+Creative Commons Attribution-Share Alike 3.0 Unported Licence
+http://creativecommons.org/licenses/by-sa/3.0/

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/mathviz'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'mathviz' do
+  self.developer 'Justin Love', 'git@JustinLove.name'
+  self.rubyforge_name       = self.name # TODO this is default value
+  self.extra_deps         = [['GraphvizR','>= 0.5.1']]
+  self.extra_rdoc_files = ['README.rdoc']
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/examples/E_mc2.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'mathviz'
+
+# No units are provided by default.
+# You can also use 1.unit(:m).per.unit(:s) etc.
+module MathViz::Units
+  new_units :m, :s, :kg, :lb, :joule
+end
+
+MathViz.new {
+  # Alternate form: MathViz.new('optional_output_filename', binding_object)
+
+  m = 140.lb * 0.45359237.kg.per.lb
+  c = 299_792_458.m.per.s
+  # capitalized values are constants in ruby, so we need the underscore
+  _E = (m * (c * c)) * 1.joule.per.kg.m.m.per.s.s
+
+  binding # Don't forget to return the binding
+}.dot # Required to produces the actual .dot file

data/examples/dc.rb

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'mathviz'
+
+module MathViz::Units
+  new_units :ms, :s, :frame
+  new_units :rev, :xx
+  new_units :pixel, :timel
+end
+
+MathViz.new {
+  pi = const 3.14159
+  second = 1000.ms.per.s
+
+  scale = input 1
+  diameter = 172.pixel
+  count = 10.xx.per.rev
+  unit = 1.per.xx
+  resolution = 100.ms
+  timeMultiplier = const 1
+  time = input((Time.now.to_f * 1000).floor).ms
+  frameRate = input 1.frame.per.s
+
+  root_position = time / resolution
+  unit_position = root_position / unit
+  un_position = unit_position / count
+
+  timels = unit * count
+  ms_rev = resolution * timels
+  rev_s = const(1000.ms.per.s) / ms_rev
+  real_rev_s = rev_s * timeMultiplier
+  rev_timel = const(1) / timels
+  configPerimeter = diameter * pi
+  perimeter = configPerimeter * scale
+  rev_pixel = const(1.rev) / perimeter
+  tick = rev_timel.min((rev_pixel * 1.pixel).max(rev_s * 1.s))
+  threshold = tick * 2
+  real_ms_rev = ms_rev / timeMultiplier
+  delay = tick * real_ms_rev
+
+  step = second / frameRate
+  passed = step * (timeMultiplier * 1.frame)
+  #passed = delay * timeMultiplier
+  ms = time + passed
+
+  root_to = ms / resolution
+  unit_to = root_to / unit
+  un_to = unit_to / count
+
+  delta = un_to - un_position
+  big = delta > threshold
+  visible = delta > rev_pixel
+  animatable = real_rev_s < 0.01.rev.per.s
+  jump = big & animatable
+  superfast = real_rev_s > 1.5.rev.per.s
+
+  binding
+}.dot
+

data/examples/first.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'mathviz'
+
+MathViz.new('first') {
+  pi = const 3.14159
+
+  scale = input 1.0
+  size = const 172
+  count = const 60
+  unit = const 1
+  calcUnit = const 1000
+  timeMultiplier = const 1
+  time = input 859294
+  ms = time + 500
+
+  root_position = time / calcUnit
+  unit_position = root_position / unit
+  un_position = unit_position / count
+
+  root_to = ms / calcUnit
+  unit_to = root_to / unit
+  un_to = unit_to / count
+
+  relativeTime = count * unit * calcUnit
+  perimeter = size * scale * pi
+  pixel = const(1) / perimeter
+  tick = relativeTime * pixel
+  realTime = calcUnit.min(tick.max(1000))
+  delay = realTime / timeMultiplier
+  threashold = delay * 2
+  delta = un_to - un_position
+  timeDelta = relativeTime * delta
+  
+  binding
+}.dot

data/examples/mathviz.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'mathviz')

data/lib/mathviz.rb

@@ -0,0 +1,594 @@
+require 'rubygems'
+require 'graphviz_r'
+
+# Top level object.
+class MathViz
+  # RubyGem version
+  VERSION = '1.0.0'
+
+  # Something to return instead of dividing by zero, etc.
+  Infinity = 1.0/0
+
+  # * base name of the output file.  If omitted(falsy) it will use the top level program name.
+  # * Binding object, as if from 'binding'
+  # * A proc which returns a binding.
+  #
+  # If bind is passed, the proc will not be executed.  If bind is falsy, the proc will be executed and it's return value stored.
+  #
+  # The proc is evaluated in the context of the new MathViz instance, making #const and #input directly available
+  def initialize(name = nil, bind = nil, &proc)
+    @name = name || File.basename($PROGRAM_NAME, '.rb')
+    @env = bind || instance_eval(&proc)
+  end
+
+  # Convert a basic value (typically Numeric) into a MathViz::Term (MathViz::Constant)
+  def const(x)
+    MathViz::Constant.new(x)
+  end
+
+  # Convert a basic value (typically Numeric) into a MathViz::Term (MathViz::Input)
+  def input(x)
+    MathViz::Input.new(x)
+  end
+
+  # Save a Graphviz .dot file in the current directory, with name specified in the constructor.  Triggers most of the actual processsing.
+  def dot
+    MathViz::Term.name_terms!(@env)
+    #puts MathViz::Term.list_terms(@env).map {|t| t.long}
+    graph = GraphvizR.new @name
+    graph = MathViz::Term.list_terms(@env).inject(graph) {|g, t|
+      t.to_dot(g)
+      g
+    }
+
+    #puts graph.to_dot
+    graph.output(@name + '.dot', 'dot')
+  end
+end
+
+# Value objects that do the actual unit tracking.
+# 
+# Contains all the interesting power tracking and cancellation.
+class MathViz::Unit
+  # The interal representation.  Current implementation method is hash-of-powers; e.g. {:m => 2, :s => -1} represents m*m/s
+  attr_reader :unit
+
+  # * With a symbol, creates a simple unit.
+  # * With a hash-of-powers, it simply copies those values.
+  # * Otherwise, it becomes a dimensionless unit.
+  def initialize(h = nil)
+    @unit = Hash.new(0)
+    case h
+    when Hash; @unit.merge!(h); normalize!
+    when Symbol: @unit[h] = 1
+    end
+    @unit.freeze
+    freeze
+  end
+
+  # Implement a simple binary operation.  It verifies that the units match and returns the unit ERROR if not.
+  def binop(other)
+    if (unit != other.unit)
+      #p "#{to_s} !+- #{other.to_s}"
+      return MathViz::Unit.new(:ERROR)
+    end
+    return self
+  end
+
+  alias_method :+, :binop
+  alias_method :-, :binop
+  alias_method :<, :binop
+  alias_method :>, :binop
+  alias_method :==, :binop
+  alias_method :max, :binop
+  alias_method :min, :binop
+  alias_method :&, :binop
+  alias_method :|, :binop
+
+  def *(other)
+    x = @unit.dup
+    other.unit.each do |u,power|
+      x[u] += power
+    end
+    MathViz::Unit.new(x)
+  end
+
+  def /(other)
+    x = @unit.dup
+    other.unit.each do |u,power|
+      x[u] -= power
+    end
+    MathViz::Unit.new(x)
+  end
+
+  def numerator
+    unit.reject {|u,power| power < 0}
+  end
+
+  def denominator
+    unit.reject {|u,power| power > 0}
+  end
+
+  def to_s
+    n = stream(numerator)
+    d = stream(denominator)
+    return '' unless (n || d)
+    return "#{n||1}/#{d}" if d
+    return n
+  end
+
+  private
+
+  # Produce a string of multiplied terms
+  def stream(units)
+    x = units.map {|u,power| [u] * power.abs }.flatten.join('*')
+    if (x.empty?)
+      return nil
+    else
+      x
+    end
+  end
+
+  # Remove zero-powers
+  def normalize!
+    unit.reject! { |u,power| power == 0 }
+    self
+  end
+end
+
+# Common container for defined units.
+#
+# including MathViz::Units triggers extension by MathViz::Units::Class.  MathViz::Units includes MathViz::Units::Class itself, so all those methods are available.
+module MathViz::Units
+  # Provides the new_units class method to all classes with units
+  module Class
+    # Define new units (instance methods) on module MathViz::Units (where they will be picked up by everything including the module)
+    # Defined methods are essentialy aliases for #unit(name); see MathViz::Measurable / MathViz::Measured
+    def new_units(*units)
+      units.each do |u|
+        MathViz::Units.__send__ :define_method, u do
+          unit(u)
+        end
+      end
+    end
+
+    # extend MathViz::Units::Class
+    def included(host)
+      host.extend(MathViz::Units::Class)
+    end
+  end
+
+  extend MathViz::Units::Class
+end
+
+# Something (i.e. Numeric) which does not have MathViz::Units, but can be turned into something which does (i.e., MathViz::Constant)
+module MathViz::Measurable
+  include MathViz::Units
+
+  # return constant wrapping self with the specified units; see also MathViz::Units::Class#new_units
+  def unit(x)
+    MathViz::Constant.new(self).unit(x)
+  end
+
+  # return constant wrapping self with new units assigned to the denominator
+  def per
+    MathViz::Constant.new(self).per
+  end
+end
+
+# Something (i.e. MathViz::Term) which has MathViz::Units.
+module MathViz::Measured
+  include MathViz::Units
+
+  # Return a string representation of the units portion, with space if applicable
+  def with_units
+    u = units.to_s
+    if (u.empty?)
+      u
+    else
+      ' ' + u
+    end
+  end
+
+  # Add the named unit to our units and return self.  See also MathViz::Units::Class#new_units
+  def unit(x)
+    @unit ||= MathViz::Unit.new
+    @unit_sign ||= 1
+    if (@unit_sign > 0)
+      @unit *= MathViz::Unit.new(x)
+    else
+      @unit /= MathViz::Unit.new(x)
+    end
+    self
+  end
+
+  # Statefull toggle numerator/denominator of unit assignment; e.g. m/s = .m.per.s
+  def per
+    @unit_sign ||= 1
+    @unit_sign *= -1
+    self
+  end
+
+  # attr_reader
+  def units
+    @unit || MathViz::Unit.new
+  end
+end
+
+class Numeric
+  include MathViz::Measurable
+
+  # Provide in operator form
+  def max(b)
+    [self, b].max
+  end
+
+  # Provide in operator form
+  def min(b)
+    [self, b].min
+  end
+
+  # Dummy defintion for all numerics.  Normally only defined on things where it can possible return false.
+  def finite?
+    true
+  end
+end
+
+class Object
+  # Representation used for graphviz node names
+  def node
+    to_s
+  end
+end
+
+# Base class for graphable objects.  It also contain the operators, which return MathViz::Operation subclasses.
+class MathViz::Term
+  include MathViz::Measured
+
+  # Assign names to named MathViz::Terms, so the name can be effiently looked up from the MathViz::Term object.
+  def self.name_terms!(env)
+    eval("local_variables", env).each do |var|
+      value = eval(var, env)
+      if value.respond_to? :name=
+        value.name = var
+      end
+    end
+  end
+
+  # Return a list of all MathViz::Terms accessible from a binding
+  def self.list_terms(env)
+    eval("local_variables", env).map { |var|
+      value = eval(var, env)
+      if (value.kind_of?(MathViz::Term))
+        value
+      else
+        nil
+      end
+    }.compact
+  end
+
+  # Define op as a binary operator
+  def self.binop(op)
+    define_method(op) do |c|
+      MathViz::Operation::Binary.new(self, op, c)
+    end
+  end
+
+  # Define op as an unary operator
+  def self.unop(op)
+    define_method(op) do
+      MathViz::Operation::Unary.new(self, op)
+    end
+  end
+
+  # Graphviz node name; see MathViz::Term#name_terms!
+  attr_accessor :name
+
+  def to_s
+    @name || anon
+  end
+
+  # A string representation of the node's data, typically calculated value with units.
+  def data
+    f = to_f
+    if (f.kind_of?(TrueClass) || f.kind_of?(FalseClass))
+      f.to_s
+    elsif (!f.respond_to? :finite?)
+      f.to_s + with_units
+    elsif (!f.finite?)
+      MathViz::Infinity.to_s
+    elsif (f.floor == f)
+      f.to_i.to_s + with_units
+    else
+      f.to_s + with_units
+    end
+  end
+
+  def to_i
+    f = to_f
+    return MathViz::Infinity unless f.finite?
+    f.to_i
+  end
+
+  # Text label for graph nodes
+  def label
+    if (@name)
+      [data, node].join("\n")
+    else
+      data
+    end
+  end
+
+  # Graphviz node shape
+  def shape
+    :ellipse
+  end
+
+  # Graphviz node color
+  def color
+    :black
+  end
+
+  # Graphviz node line style
+  def style
+    if anonymous?
+      :dotted
+    elsif constant?
+      :solid
+    else
+      :dashed
+    end
+  end
+
+  # Extend Graphviz g with a representation of this object
+  def to_dot(g)
+    g[node] [:label => label, :shape => shape, :color => color, :style => style]
+  end
+
+  private
+  @@anon_master = 'A'
+
+  # Produces an unique name for #anonymous? nodes.  Results are memoized for each instance.
+  def anon
+    if (@anon)
+      @anon
+    else
+      @anon = @@anon_master
+      @@anon_master = @@anon_master.succ
+      #puts "#{self.object_id} anon #{@anon}"
+      @anon
+    end
+  end
+
+  def anonymous?
+    !@name
+  end
+
+  public
+
+  ##
+  unop :floor
+
+  ##
+  unop :ceil
+
+
+  ##
+  binop :+
+
+  ##
+  binop :-
+
+  ##
+  binop :*
+
+  ##
+  binop :/
+
+  ##
+  binop :max
+
+  ##
+  binop :min
+
+  ##
+  binop :>
+
+  ##
+  binop :<
+
+  ##
+  binop :<=
+
+  ##
+  binop :>=
+
+  ##
+  binop :&
+
+  ##
+  binop :|
+
+  ##
+  binop :==
+end
+
+# A simple number.
+#
+# Also identifies the number as true constant, which affects nodes display style, so that opportunities for constant-folding can be idenified.
+class MathViz::Constant < MathViz::Term
+  # wraps a primitive value
+  def initialize(a)
+    super()
+    @a = a
+  end
+
+  # Debugging method; string with both name and value
+  def long
+    n = @name && (@name + " = ")
+    "(#{n}#{to_f})"
+  end
+
+  # Forward to contained object
+  def to_f
+    @a.to_f
+  end
+
+  # Returns the units of the contained object (if any) or else it's own.
+  def units
+    if @a.respond_to? :units
+      @a.units
+    else
+      super
+    end
+  end
+
+  # Graphviz node shape
+  def shape
+    :plaintext
+  end
+
+  def constant?
+    true
+  end
+
+  # Forward to contained object
+  def finite?
+    @a.finite?
+  end
+end
+
+# A simple number.
+#
+# Derives most of it's behavior from MathViz::Constant, but also identifies the number as variable, which affects nodes display style, so that opportunities for constant-folding can be idenified.
+class MathViz::Input < MathViz::Constant
+  # Graphiviz node shape
+  def shape
+    :ellipse
+  end
+
+  # false
+  def constant?
+    false
+  end
+end
+
+# Base class for MathViz::Operation::Binary and MathViz::Operation::Unary
+class MathViz::Operation < MathViz::Term
+  # Turn the object into a MathViz::Term (MathViz::Constant) if isn't already a MathViz::Term.  This allows for operator parameters to be primitive values without needing MathViz#const, MathViz#input, or units.
+  def term(x)
+    if (x.kind_of?(MathViz::Term))
+      x
+    else
+      MathViz::Constant.new(x)
+    end
+  end
+
+  # Graphviz node shape
+  def shape
+    :box
+  end
+
+  # Default Graphviz node color.
+  def color
+    :red
+  end
+end
+
+# Display and processing for single-value operators
+class MathViz::Operation::Unary < MathViz::Operation
+  def initialize(a, op)
+    super()
+    @a = term(a)
+    @op = op
+  end
+
+  # Debugging method; return string of name and value.
+  def long
+    n = @name && (@name + " = ")
+    "(#{n}#{@a} #{@op} = #{to_f})"
+  end
+
+  # Extend Graphviz g with a representation of this object, and incoming connections
+  def to_dot(g)
+    super
+    (g[@a.node] >> g[node]) [:arrowhead => :normal, :headlabel => @op.to_s, :labeldistance => '2']
+    @a.to_dot(g) if (@a.respond_to?(:name) && @a.name.nil?)
+  end
+
+  # Apply the operator to create the derived value.
+  def to_f
+    return MathViz::Infinity unless @a.to_f.finite?
+    @a.to_f.__send__(@op)
+  end
+
+  # Forward to contained value
+  def units
+    @a.units
+  end
+
+  # Forward to contained value
+  def constant?
+    @a.constant?
+  end
+end
+
+# Display and processing for two-value operators
+class MathViz::Operation::Binary < MathViz::Operation
+  def initialize(a, op, b)
+    super()
+    @a = term(a)
+    @op = op
+    @b = term(b)
+  end
+
+  # Debugging method; returns string of names and values
+  def long
+    n = @name && (@name + " = ")
+    "(#{n}#{@a} #{@op} #{@b} = #{to_f})"
+  end
+
+  # Graphviz node shape; differentiates comparison operators
+  def shape
+    if ([:>, :<, :>=, :<=, :&, :|, :==].include? @op)
+      :ellipse
+    else
+      :box
+    end
+  end
+
+  # Graphviz node color; differentiates basic mathematical operators (+, -, *, /)
+  def color
+    case @op
+    when :+: :green;
+    when :-: :yellow;
+    when :*: :blue;
+    when :/: :cyan;
+    else :red;
+    end
+  end
+
+  # Extend Graphviz g with a representation of this object, and incoming connections
+  def to_dot(g)
+    super
+    (g[@a.node] >> g[node]) [:arrowhead => :normal, :headlabel => @op.to_s, :labeldistance => '2']
+    (g[@b.node] >> g[node]) [:arrowhead => :onormal]
+    @a.to_dot(g) if (@a.respond_to?(:name) && @a.name.nil?)
+    @b.to_dot(g) if (@b.respond_to?(:name) && @b.name.nil?)
+  end
+
+  # Apply the operator to create the derived value.
+  def to_f
+    @a.to_f.__send__(@op, @b.to_f)
+  end
+
+  # Apply the operator to create the derived units.
+  def units
+    @a.units.__send__(@op, @b.units)
+  end
+
+  # True only if both operands are #constant?
+  def constant?
+    @a.constant? && @b.constant?
+  end
+end

data/spec/measurable_spec.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+module MathViz::Units
+  new_units :s
+end
+
+describe MathViz::Measured do
+  it "works on numbers" do
+    1.s.data.should == "1 s"
+  end
+end

data/spec/measured_spec.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+class Subject
+  include MathViz::Measured
+
+  new_units :s
+
+  def to_s
+    "1"
+  end
+end
+
+describe MathViz::Measured do
+  before do
+    @subject = Subject.new.s
+  end
+
+  it "should be created" do
+    @subject.should_not be_nil
+  end
+
+  it "should have a unit in it's string" do
+    @subject.with_units.should == " s"
+  end
+
+  it "should not have extra space if no unit" do
+    Subject.new.with_units.should == ""
+  end
+
+  it "can have different units" do
+    Subject.new.unit(:x).with_units.should == " x"
+  end
+
+  it "should create denominators" do
+    Subject.new.per.s.with_units.should == " 1/s"
+  end
+
+  it "should have a shorthand for new units" do
+    Subject.new_units(:m, :h)
+    Subject.new.m.per.h.with_units.should == " m/h"
+  end
+end

data/spec/operation_spec.rb

@@ -0,0 +1,31 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+module MathViz::Units
+  new_units :s
+end
+
+describe MathViz::Operation do
+  describe MathViz::Operation::Unary do
+    it "can floor infinity" do
+      (MathViz::Constant.new(1.0/0).floor).data.should == "Infinity"
+    end
+
+    it "preserves units" do
+      (MathViz::Constant.new(1).s.floor).data.should == "1 s"
+    end
+  end
+
+  describe MathViz::Operation::Binary do
+    it "reports ints as ints" do
+      (MathViz::Constant.new(1) * 2).data.should == "2"
+    end
+
+    it "doesn't croak on divide by zero" do
+      (MathViz::Constant.new(220) / 0).data.should == "Infinity"
+    end
+
+    it "preserves units" do
+      (1.s * 2).data.should == "2 s"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'mathviz'

data/spec/unit_spec.rb

@@ -0,0 +1,189 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+shared_examples_for "common combinations" do
+  it "can be created" do
+    @unit.should_not be_nil
+  end
+
+  it "flags a mismatch" do
+    (@unit + MathViz::Unit.new(:x)).to_s.should == 'ERROR'
+  end
+
+  it "adds with same" do
+    (@unit + @unit).to_s.should == @unit.to_s
+  end
+
+  it "multiplies with nothing" do
+    (@unit * MathViz::Unit.new).to_s.should == @unit.to_s
+  end
+
+  it "divides with nothing" do
+    (@unit / MathViz::Unit.new).to_s.should == @unit.to_s
+  end
+
+  it "cancels on division" do
+    (@unit / @unit).should.to_s == ''
+  end
+end
+
+describe "MathViz::Unit" do
+  context "with no argument" do
+    before do
+      @unit = MathViz::Unit.new
+    end
+
+    it_should_behave_like "common combinations"
+
+    it "has a blank representation" do
+      @unit.to_s.should == ''
+    end
+
+    it "multiplies with numerator" do
+      (@unit * MathViz::Unit.new(:x)).to_s.should == 'x'
+    end
+
+    it "divides with numerator" do
+      (@unit / MathViz::Unit.new(:x)).to_s.should == '1/x'
+    end
+
+    it "multiplies with denominator" do
+      (@unit * MathViz::Unit.new(:x => -1)).to_s.should == '1/x'
+    end
+
+    it "divides with denominator" do
+      (@unit / MathViz::Unit.new(:x => -1)).to_s.should == 'x'
+    end
+  end
+
+  context "with a single argument" do
+    before do
+      @unit = MathViz::Unit.new(:s)
+    end
+
+    it_should_behave_like "common combinations"
+
+    it "has a simple representation" do
+      @unit.to_s.should == "s"
+    end
+  end
+
+  context "with a numerator argument" do
+    before do
+      @unit = MathViz::Unit.new(:s => 1)
+    end
+
+    it_should_behave_like "common combinations"
+
+    it "has a simple representation" do
+      @unit.to_s.should == "s"
+    end
+
+    it "multiplies with numerator" do
+      ['s*x', 'x*s'].should include((@unit * MathViz::Unit.new(:x)).to_s)
+    end
+
+    it "divides with numerator" do
+      (@unit / MathViz::Unit.new(:x)).to_s.should == 's/x'
+    end
+
+    it "multiplies with denominator" do
+      (@unit * MathViz::Unit.new(:x => -1)).to_s.should == 's/x'
+    end
+
+    it "divides with denominator" do
+      ['s*x', 'x*s'].should include((@unit / MathViz::Unit.new(:x => -1)).to_s)
+    end
+
+    it "cancels on multiplication" do
+      (@unit * MathViz::Unit.new(:s => -1)).to_s.should == ''
+    end
+  end
+
+  context "with a numerator squared argument" do
+    before do
+      @unit = MathViz::Unit.new(:s => 2)
+    end
+
+    it_should_behave_like "common combinations"
+
+    it "has a double representation" do
+      @unit.to_s.should == "s*s"
+    end
+
+    it "multiplies with numerator" do
+      ['s*s*x', 'x*s*s'].should include((@unit * MathViz::Unit.new(:x)).to_s)
+    end
+
+    it "divides with numerator" do
+      (@unit / MathViz::Unit.new(:x)).to_s.should == 's*s/x'
+    end
+
+    it "multiplies with denominator" do
+      (@unit * MathViz::Unit.new(:x => -1)).to_s.should == 's*s/x'
+    end
+
+    it "divides with denominator" do
+      ['s*s*x', 'x*s*s'].should include((@unit / MathViz::Unit.new(:x => -1)).to_s)
+    end
+
+    it "cancels on multiplication" do
+      (@unit * MathViz::Unit.new(:s => -1)).to_s.should == 's'
+    end
+
+    it "increases on multiplication" do
+      (@unit * MathViz::Unit.new(:s => 1)).to_s.should == 's*s*s'
+    end
+  end
+
+  context "with a denominator argument" do
+    before do
+      @unit = MathViz::Unit.new(:s => -1)
+    end
+
+    it_should_behave_like "common combinations"
+
+    it "has a 1 in the numerator position" do
+      @unit.to_s.should == "1/s"
+    end
+
+    it "multiplies with numerator" do
+      ['x/s'].should include((@unit * MathViz::Unit.new(:x)).to_s)
+    end
+
+    it "divides with numerator" do
+      ['1/s*x', '1/x*s'].should include((@unit / MathViz::Unit.new(:x)).to_s)
+    end
+
+    it "multiplies with denominator" do
+      ['1/s*x', '1/x*s'].should include((@unit * MathViz::Unit.new(:x => -1)).to_s)
+    end
+
+    it "divides with denominator" do
+      ['x/s'].should include((@unit / MathViz::Unit.new(:x => -1)).to_s)
+    end
+
+    it "cancels on multiplication" do
+      (@unit * MathViz::Unit.new(:s => 1)).to_s.should == ''
+    end
+  end
+
+  context "with a complex argument" do
+    before do
+      @unit = MathViz::Unit.new(:V => 1, :A => 1, :h => -1)
+    end
+
+    it_should_behave_like "common combinations"
+
+    it "has a complex representation" do
+      ["V*A/h", "A*V/h"].should include(@unit.to_s)
+    end
+
+    it "cancels on multiplication" do
+      ["V*A", "A*V"].should include((@unit * MathViz::Unit.new(:h)).to_s)
+    end
+
+    it "cancels on multiplication" do
+      ["V/h"].should include((@unit * MathViz::Unit.new(:A => -1)).to_s)
+    end
+  end
+end

data/tasks/idocs.rake

@@ -0,0 +1,4 @@
+task :idocs => [:redocs, 'README.rdoc', 'examples/E_mc2.png']  do |t|
+  mkdir 'doc/examples'
+  cp 'examples/E_mc2.png', 'doc/examples/'
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: mathviz
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Justin Love
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-25 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: GraphvizR
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.3
+    version: 
+description: Turn simple equations (a = b * c) into GraphViz dot files showing relationships, values, and units.
+email: 
+- git@JustinLove.name
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- examples/E_mc2.png
+- examples/E_mc2.rb
+- examples/dc.rb
+- examples/first.rb
+- examples/mathviz.rb
+- lib/mathviz.rb
+- spec/measurable_spec.rb
+- spec/measured_spec.rb
+- spec/operation_spec.rb
+- spec/spec_helper.rb
+- spec/unit_spec.rb
+- tasks/idocs.rake
+has_rdoc: true
+homepage: http://github.com/JustinLove/mathviz
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+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: mathviz
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Turn simple equations (a = b * c) into GraphViz dot files showing relationships, values, and units.
+test_files: []
+