exalted_math 0.1.3 → 0.2.0

data/.gitignore

@@ -1,2 +0,0 @@
-pkg
-doc

data/lib/exalted_math/ast.rb

@@ -1,226 +0,0 @@
-#!/usr/bin/ruby
-# Jonathan D. Stott <jonathan.stott@gmail.com>
-module Exalted
-  # Provides a simple AST for Exalted Maths
-  class Ast < Array
-    class UnknownNodeError < ArgumentError
-      def initialize(type)
-        @message = "Unknown node type '#{type}'"
-        puts @message
-      end
-    end
-
-    def initialize(*args)
-      super(args)
-    end
-
-    # Is this AST constant?
-    #
-    # If an AST only has constant child nodes, it is constant.
-    # This allows some simplification.
-    #
-    # @return [Boolean] is the AST constant
-    def constant?
-      case self[0]
-      when 'mul', 'div', 'add', 'sub'
-        self[1].constant? and self[2].constant?
-      when 'num'
-        true
-      when 'stat', 'spec'
-        false
-      when 'max', 'min'
-        self[2].all? { |ast| ast.constant? }
-      else
-        raise UnknownNodeError, self[0]
-      end
-    end
-
-    # Is the given AST constant?
-    #
-    # If an AST only has constant child nodes, it is constant.
-    # This allows some simplification.
-    #
-    # @param ast [Ast] An Ast
-    #
-    # @return [Boolean] is the AST constant
-    def self.constant?(ast)
-      ast.constant?
-    end
-
-    # Is the given AST valid?
-    #
-    # Does the context provide all the values the AST is looking for?
-    #
-    # @param ast [Ast] The Ast to test
-    # @param valid_values [Array] Array of valid values, the keys of the context
-    # @param errors [Array] Optional array of errors
-    #
-    # @return [Boolean] True if valid, false if not.
-    def self.valid?(ast, valid_values, errors=[])
-      case ast[0]
-      when 'mul', 'div', 'add', 'sub'
-        valid?(ast[1], valid_values, errors) and valid?(ast[2], valid_values, errors)
-      when 'num'
-        true
-      when 'stat', 'spec'
-        if valid_values.include? ast[1]
-          true
-        else
-          errors << "Unknown #{ast[0]} '#{ast[1]}'"
-          false
-        end
-      when 'max', 'min'
-        ast[2].map { |ast| valid?(ast, valid_values, errors) }.all?
-      else
-        raise UnknownNodeError, ast[0]
-      end
-    end
-
-    # Calculate the value of the AST for the given context
-    #
-    # This method recursively walks the AST, calculating the final value
-    #
-    # @param ast [Ast] The AST to compute
-    # @param context [#[]] Context used to evaluate the AST
-    #
-    # @return [Integer] The value of the AST
-    def self.value(ast, context={})
-      case ast[0]
-      when 'mul'
-        value(ast[1], context) * value(ast[2], context)
-      when 'div'
-        value(ast[1], context) / value(ast[2], context)
-      when 'add'
-        value(ast[1], context) + value(ast[2], context)
-      when 'sub'
-        value(ast[1], context) - value(ast[2], context)
-      when 'num'
-        ast[1]
-      when 'stat', 'spec'
-        context[ast[1]]
-      when 'max'
-        tmp = ast[2].map { |ast| value(ast, context) }.sort[-ast[1], ast[1]]
-        (tmp.size == 1) ? tmp.first : tmp.inject(0) { |fin, val| fin += val }
-      when 'min'
-        tmp = ast[2].map { |ast| value(ast, context) }.sort[0, ast[1]]
-        (tmp.size == 1) ? tmp.first : tmp.inject(0) { |fin, val| fin += val }
-      else
-        raise UnknownNodeError, self[0]
-      end
-    end
-
-    # Simplify the AST
-    #
-    # This recusively walks the AST, replacing any constant subtrees with their
-    # value.
-    #
-    # @param ast [Ast] The AST to simplify
-    # @return [Ast] The simplified AST
-    def self.simplify(ast)
-      if ast.constant?
-        new('num', value(ast))
-      else
-        case ast[0]
-        when 'add', 'sub', 'mul', 'div'
-           new(ast[0], simplify(ast[1]), simplify(ast[2]))
-        else
-          ast
-        end
-      end
-    end
-
-    # Create a new num node
-    #
-    # @param value [Integer] The value of the new node
-    #
-    # @return [Ast] A num Ast Node
-    def self.num(value)
-      new('num', value)
-    end
-
-    # Create a new stat node
-    #
-    # @param value [String] The value of the new node
-    #
-    # @return [Ast] A stat Ast Node
-    def self.stat(value)
-      new('stat', value)
-    end
-
-    # Create a new spec node
-    #
-    # @param value [String] The value of the new node
-    #
-    # @return [Ast] A spec Ast Node
-    def self.spec(value)
-      new('spec', value)
-    end
-
-    # Create a new add node
-    #
-    # @param left [Ast] The left node of the add
-    # @param right [Ast] The right node of the add
-    # @return [Ast] An add Ast Node
-    def self.add(left, right)
-      new('add', left, right)
-    end
-
-    # Create a new sub node
-    #
-    # @param left [Ast] The left node of the sub
-    # @param right [Ast] The right node of the sub
-    # @return [Ast] An sub Ast Node
-    def self.sub(left, right)
-      new('sub', left, right)
-    end
-
-    # Create a new mul node
-    #
-    # @param left [Ast] The left node of the mul
-    # @param right [Ast] The right node of the mul
-    # @return [Ast] An mul Ast Node
-    def self.mul(left, right)
-      new('mul', left, right)
-    end
-
-    # Create a new div node
-    #
-    # @param left [Ast] The left node of the div
-    # @param right [Ast] The right node of the div
-    # @return [Ast] An div Ast Node
-    def self.div(left, right)
-      new('div', left, right)
-    end
-
-    # Create a new min node
-    #
-    # @param count [Integer] Number of values to sum for the min
-    # @param list  [Array]  Array of ASTs to calculate the min from
-    # @return [Ast] A min Ast Node
-    def self.min(count, list)
-      new('min', count, list)
-    end
-
-    # Create a new max node
-    #
-    # @param count [Integer] Number of values to sum for the max
-    # @param list  [Array]  Array of ASTs to calculate the max from
-    # @return [Ast] A max Ast Node
-    def self.max(count, list)
-      new('max', count, list)
-    end
-
-    def self.from_array(array)
-      case array[0]
-      when 'mul', 'div', 'add', 'sub'
-        new(array[0], from_array(array[1]), from_array(array[2])  )
-      when 'num', 'stat', 'spec'
-        new(array[0], array[1])
-      when 'max', 'min'
-        new(array[0], array[1], array[2].map! { |ast| new(ast) } )
-      else
-        raise UnknownNodeError, self[0]
-      end
-    end
-  end
-end

data/spec/ast_spec.rb

@@ -1,207 +0,0 @@
-#!/usr/bin/ruby
-# Jonathan D. Stott <jonathan.stott@gmail.com>
-require 'spec_helper'
-require 'exalted_math/ast'
-
-include Exalted
-
-
-describe "Exalted::Ast" do
-  before do
-    @three    = Exalted::Ast.new('num', 3 )
-    @seven    = Exalted::Ast.new('num', 7 )
-    @foo      = Exalted::Ast.new('stat', 'foo')
-    @bar      = Exalted::Ast.new('spec', 'bar')
-    @invalid  = Exalted::Ast.new('stat', 'invalid')
-    @add      = Exalted::Ast.new('add', @three, @seven)
-    @sub      = Exalted::Ast.new('sub', @three, @seven)
-    @mul      = Exalted::Ast.new('mul', @three, @seven)
-    @div      = Exalted::Ast.new('div', @seven, @three)
-    @add_foo  = Exalted::Ast.new('add', @three, @foo)
-    @sub_foo  = Exalted::Ast.new('sub', @three, @foo)
-    @mul_foo  = Exalted::Ast.new('mul', @three, @foo)
-    @div_foo  = Exalted::Ast.new('div', @three, @foo)
-    @nested   = Exalted::Ast.new('mul', @add, @sub_foo)
-    @min      = Exalted::Ast.new('min', 1, [@three, @seven] )
-    @max      = Exalted::Ast.new('max', 1, [@three, @seven] )
-    @context  = { 'foo' => 3, 'bar' => 4 }
-  end
-
-  it ".num makes a number" do
-    @three.should == Ast.num(3)
-  end
-
-  it ".stat makes a stat" do
-    @foo.should == Ast.stat('foo')
-  end
-
-  it ".spec makes a spec" do
-    @bar.should == Ast.spec('bar')
-  end
-
-  it ".add makes an add" do
-    @add.should == Ast.add(@three, @seven)
-  end
-
-  it ".sub makes an sub" do
-    @sub.should == Ast.sub(@three, @seven)
-  end
-
-  it ".mul makes an mul" do
-    @mul.should == Ast.mul(@three, @seven)
-  end
-
-  it ".div makes an div" do
-    @div.should == Ast.div(@seven, @three)
-  end
-
-  it ".min makes a min" do
-    @min.should == Ast.min(1, [@three, @seven])
-  end
-
-  it ".max makes a max" do
-    @max.should == Ast.max(1, [@three, @seven])
-  end
-
-  it "a number is constant" do
-    @three.should.be.constant
-  end
-
-  it "a stat is not constant" do
-    @foo.should.not.be.constant
-  end
-
-  it "an add of two constants is constant" do
-    @add.should.be.constant
-  end
-  it "an sub of two constants is constant" do
-    @sub.should.be.constant
-  end
-  it "an mul of two constants is constant" do
-    @mul.should.be.constant
-  end
-  it "an div of two constants is constant" do
-    @div.should.be.constant
-  end
-  it "a min of constants is constant" do
-    @min.should.be.constant
-  end
-  it "a max of constants is constant" do
-    @max.should.be.constant
-  end
-
-  it "an add of constant and not constant is not constant" do
-    @add_foo.should.not.be.constant
-  end
-  it "an sub of constant and not constant is not constant" do
-    @sub_foo.should.not.be.constant
-  end
-  it "an mul of constant and not constant is not constant" do
-    @mul_foo.should.not.be.constant
-  end
-  it "an div of constant and not constant is not constant" do
-    @div_foo.should.not.be.constant
-  end
-
-  it "A number is valid" do
-    Exalted::Ast.valid?(@three, @context.keys).should.be.true
-  end
-
-  it "A stat is valid if it is in the array of valid keys" do
-    Exalted::Ast.valid?(@foo, @context.keys).should.be.true
-  end
-
-  it "A stat is not valid if it is not in the array of valid keys" do
-    Exalted::Ast.valid?(@invalid, @context.keys).should.not.be.true
-  end
-
-  it "An add is valid if both its keys are valid" do
-    Exalted::Ast.valid?(@add, @context.keys).should.be.true
-  end
-  it "An sub is valid if both its keys are valid" do
-    Exalted::Ast.valid?(@sub, @context.keys).should.be.true
-  end
-  it "An mul is valid if both its keys are valid" do
-    Exalted::Ast.valid?(@mul, @context.keys).should.be.true
-  end
-  it "An div is valid if both its keys are valid" do
-    Exalted::Ast.valid?(@div, @context.keys).should.be.true
-  end
-  it "An add is invalid if one key is invalid" do
-    @add = Exalted::Ast.new('add', @three, @invalid)
-    Exalted::Ast.valid?(@add, @context.keys).should.not.be.true
-  end
-  it "An sub is invalid if one key is invalid" do
-    @sub = Exalted::Ast.new('sub', @three, @invalid)
-    Exalted::Ast.valid?(@sub, @context.keys).should.not.be.true
-  end
-  it "An mul is invalid if one key is invalid" do
-    @mul = Exalted::Ast.new('mul', @three, @invalid)
-    Exalted::Ast.valid?(@mul, @context.keys).should.not.be.true
-  end
-  it "An div is invalid if one key is invalid" do
-    @div = Exalted::Ast.new('div', @three, @invalid)
-    Exalted::Ast.valid?(@div, @context.keys).should.not.be.true
-  end
-
-  it "the value of a number is the number" do
-    Exalted::Ast.value(@three, @context).should == 3
-    Exalted::Ast.value(@seven, @context).should == 7
-  end
-
-  it "the value of a stat is looked up in the context" do
-    Exalted::Ast.value(@foo, @context).should == @context['foo']
-    Exalted::Ast.value(@bar, @context).should == @context['bar']
-  end
-
-  it "the value of an add is the sum of the two children" do
-     Exalted::Ast.value(@add, @context).should == 10
-  end
-
-  it "the value of an sub is first child minus the second" do
-    Exalted::Ast.value(@sub, @context).should == -4
-  end
-
-  it "the value of an mul is the two children multiplied together" do
-    Exalted::Ast.value(@mul, @context).should == 21
-  end
-
-  it "the value of a div is the first child divided by the second" do
-    Exalted::Ast.value(@div, @context).should == 2
-  end
-
-  it "the value of a min is the mininum value" do
-    Exalted::Ast.value(@min, @context).should == 3
-  end
-  it "the value of a max is the maxinum value" do
-    Exalted::Ast.value(@max, @context).should == 7
-  end
-
-  it "it walks the whole tree to compute a value" do
-     Exalted::Ast.value(@nested, @context).should == 0
-  end
-
-  it "has sane equality behaviour" do
-    @three.should == Exalted::Ast.new('num', 3)
-  end
-
-  it "can simplify a constant add" do
-    Exalted::Ast.simplify(@add).should == Exalted::Ast.new('num', 10)
-  end
-
-  it "A number is simple" do
-    Exalted::Ast.simplify(@three).should == Exalted::Ast.new('num', 3)
-  end
-
-  it "A stat is simple" do
-    Exalted::Ast.simplify(@foo).should == Exalted::Ast.new('stat', 'foo')
-  end
-
-  it "A non-constant add isn't simplified" do
-    Exalted::Ast.simplify(@add_foo).should == Exalted::Ast.new('add', @three, @foo)
-  end
-  it "A constant branches are simplified" do
-    Exalted::Ast.simplify(@nested).should == Exalted::Ast.new('mul', Exalted::Ast.new('num', 10), @sub_foo)
-  end
-end
-