polly 0.0.4

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@polly --create

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in polly.gemspec
+gemspec
+gem 'pry'
+gem 'pry-nav'
+gem 'pry-stack_explorer'
+gem 'rake'
+gem 'rspec'
+gem 'rcov', '0.9.11'
+gem 'simplecov', :require => false, :group => :test
+gem 'metrical'

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Alex Skryl
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+## About
+
+Polly is a DSL for manipulating and evaluating symbolic expressions.
+
+## Features
+
+* Create calculations consisting of one or more s-expressions 
+* Evaluate full s-expressions or any constituent parts
+* Add custom function primitives for complex calculations
+* Print s-expression parse trees in prefix or infix notation
+* Perform data dependence analysis
+* Analyze runtime performance 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'polly'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install polly
+
+
+## Usage
+
+TODO: for now just check out spec/examples.rb
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,3 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "metric_fu"

data/TODO

@@ -0,0 +1,5 @@
+- test universal types
+- prevent setting variables to non ruby types
+- injecting custom math functions easily
+- test serialization for big calcs 
+- test direct var references and the self NOOP

data/lib/polly/calculation.rb

@@ -0,0 +1,46 @@
+class Polly::Calculation
+  extend Forwardable
+  include Polly::Common
+
+  attr_reader :env, :context
+  def_delegators :@env, :print, :to_s, :inspect, :pretty_inspect, :atomic_variables,
+                 :defined_variables, :undefined_variables
+
+  def_delegator :@env, :values, :result
+  def_delegator :@env, :values!, :result!
+
+  meta_eval { attr_accessor :verbose }
+
+  def initialize(env = {}, &block)
+    @env = Env.new(env)
+    @context = Context.new(@env)
+    @context.evaluate(block)
+  end
+
+  def evaluate(inputs = {}, &block)
+    inputs.each { |k,v| @context.var(k,v) }
+    @context.evaluate(block) if block
+    self
+  end
+
+  def method_missing(method, *args, &block)
+    method.match(/^(\w+)=?$/)
+    method_name = $1.to_sym
+    
+    if @env.keys.include?(method_name)
+      method == method_name ?  @env[method_name] : @context.var(method_name, args[0])
+    else super
+    end
+  end
+   
+  def verbose_toggle
+    Calculation.verbose = !Calculation.verbose
+  end
+
+# Rails compatible serialization
+
+  def dump; env.to_yaml end
+  def self.load(yml); new(YAML::load(yml)) if yml end
+  def self.dump(obj); obj.dump if obj end
+
+end

data/lib/polly/common.rb

@@ -0,0 +1,8 @@
+module Polly::Common
+  include Polly
+
+  BINARY_OPS = [:*, :/, :%, :+, :-, :**, :<<, :>>, :&, :|, :^, :>, :>=, :<, :<=, :<=>, :==, :===, :=~ ]
+  UNARY_OPS = [:-, :+, :!, :~]
+  UNDEFINED = [nil]
+
+end

data/lib/polly/context.rb

@@ -0,0 +1,49 @@
+class Polly::Context < BasicObject
+  include ::Polly::Common
+  include ::Kernel
+
+  def initialize(env)
+    @env = env
+    @env.clean.each { |name, expr| var_reader name.to_sym }
+  end
+
+  def evaluate(proc)
+    instance_eval(&proc) if proc
+  end
+
+  def var(name, val = nil, opts = {})
+    if @env[name]  
+      @env[name].replace(val) 
+    else
+      @env[name] = Sexpr.build(val, @env, name)
+    end
+
+    var_reader name
+  end
+
+  def Sexpr(val)
+    Polly::Sexpr.build(val, @env)
+  end
+
+  alias_method :const, :var
+  alias_method :eq, :var
+
+# magix
+
+  # convert method calls on self to s-expressions
+  # 
+  def method_missing(method, *args, &block)
+    Sexpr.build([method, *args], @env)
+  end
+
+  def self.const_missing(name)
+    ::Object.const_get(name)
+  end
+
+private
+
+  def var_reader(name)
+    define_singleton_method(name) { @env[name] }
+  end
+
+end

data/lib/polly/env.rb

@@ -0,0 +1,52 @@
+class Polly::Env < Hash
+  include Polly::Common
+
+  def initialize(env = {})
+    Math.singleton_methods.each do |m|
+      self[m.to_sym] = lambda { |*args| Math.send(m, *args) }
+    end
+
+    env.each { |name, expr| self[name] = Sexpr.build(expr, self) }
+  end
+
+  def clean
+    Env[self.select { |name, expr| expr.is_a?(Sexpr) }]
+  end
+
+  def values
+    clean.inject({}) { |h, (name, expr)| h[name] = expr.value; h }
+  end
+
+  def values!
+    clean.inject({}) { |h, (name, expr)| h[name] = expr.value!; h }
+  end
+
+  def atomic_variables
+    clean.select { |name, expr| expr.atomic? }.keys
+  end
+
+  def defined_variables
+    clean.select { |name, expr| expr.atomic? && expr.defined? }.keys
+  end
+
+  def undefined_variables
+    clean.select { |name, expr| expr.atomic? && !expr.defined? }.keys
+  end
+
+# printing  and conversion
+
+  def print(opts = {}); puts to_s(opts) end
+  def to_s(opts = {}); clean.map { |(k,v)| "#{k.inspect} => #{v.to_s(opts)}" }.join("\n") end
+  def to_yaml(*args); dump.to_yaml(*args) end
+
+  def ==(env)
+    env.is_a?(Hash) ? Hash[self.clean] == Hash[env.clean] : false
+  end
+
+private
+
+  def dump
+    clean.inject({}) { |h, (name, expr)| h[name] = expr.to_ary; h }
+  end
+
+end

data/lib/polly/extensions/array.rb

@@ -0,0 +1,4 @@
+class Array
+  def car; self.first end
+  def cdr; self.drop(1) end
+end

data/lib/polly/extensions/numeric.rb

@@ -0,0 +1,5 @@
+class Numeric
+  def percent
+    self/100.00
+  end
+end

data/lib/polly/extensions/object.rb

@@ -0,0 +1,15 @@
+class BasicObject
+
+  # this shit is meta
+  def metaclass; class << self; self; end; end
+  def meta_eval &blk; metaclass.instance_eval &blk; end
+
+end
+
+class Object
+
+  def to_sexpr
+    Polly::Sexpr.build(self)
+  end
+
+end

data/lib/polly/math.rb

@@ -0,0 +1,53 @@
+module Polly::Math
+
+class << self
+
+  def min(*args)
+    args.min
+  end
+
+  def max(*args)
+    args.max
+  end
+
+  def ceil(val, ceil)
+    (val.to_f / ceil.to_i).to_i * ceil.to_i 
+  end
+
+  def pv(i, length, pmt)
+     pmt.to_f / i * (1 - (1 + i) ** -length.to_f)
+  end
+
+  # Some binary operators are not methods but part of Ruby's syntax. Since
+  # there is no way to latch on to them, they'll have to be redefined.
+  
+  def br(test, exp1, exp2)
+    test ? exp1 : exp2
+  end
+
+  def and(val1, val2)
+    val1 && val2
+  end
+
+  def or(val1, val2)
+    val1 || val2
+  end
+
+  def not(val)
+    !val
+  end
+  alias_method :!, :not
+
+  def not_eq(val1, val2)
+    !(val1 == val2)
+  end
+  alias_method :!=, :not_eq
+
+  # NOOP
+  def self(obj)
+    obj
+  end
+
+end
+
+end

data/lib/polly/sexpr.rb

@@ -0,0 +1,176 @@
+class Polly::Sexpr
+  include Polly::Common
+  include Enumerable
+
+  # instance accessors
+  attr_reader :op, :args, :sexpr, :env
+  attr_accessor :name, :env, :dirty
+  protected :sexpr, :env=, :name=, :dirty=
+
+  # class accessors
+  meta_eval { protected :new }
+
+  def self.build(val, env = nil, name = nil)
+    val = \
+      case val
+      when Sexpr 
+        val
+      when Symbol 
+        env_val = env && env[val]
+        env_val.is_a?(Sexpr) ? env_val : Array(val)
+      when Array
+        if val.size > 1
+          val.cdr.map do |arg| 
+            arg.is_a?(Sexpr) ? arg : Sexpr.build(arg, env, name) 
+          end.unshift(val.car)
+        else
+          Sexpr.build(val.first, env, name)
+        end
+      when NilClass
+        UNDEFINED
+      else Array(val)
+      end
+
+    val.is_a?(Sexpr) ? Sexpr.update(val, env, name) : Sexpr.new(val, env, name)
+  end
+
+  # If an sexpr directly references another named sexpr then the named sexpr
+  # should be wrapped in a self call, which is a noop, in order to avoid
+  # having two references to the same sexpr.
+  #
+  def self.update(sexpr, env, name)
+    if name && sexpr.name && name != sexpr.name
+      Sexpr.build([:self, sexpr])
+    else
+      sexpr.send(:name=, name) unless sexpr.name
+      sexpr.send(:env=, env) unless sexpr.env
+      sexpr
+    end
+  end
+
+  def initialize(sexpr, env, name)
+    @sexpr = sexpr
+    @op = @sexpr[0]
+    @args = @sexpr.cdr
+    @name = name
+    @env = env || Env.new
+  end
+
+  # use cached values unless some part of expression tree is dirty
+  #
+  def value(env = @env)
+    @value = \
+      (clean? && @value) || 
+      (self.defined? ? (atomic? ? @sexpr.first : self.send(:eval)) : nil)
+    @dirty = false
+    @value
+  end
+
+  # force a recalc of all sub-expressions
+  #
+  def value!(env = @env) 
+    each { |a| a.dirty = true }
+    value(env)
+  end
+
+  def replace(val)
+    @dirty = true
+    @sexpr = self.class.build(val, @env).sexpr
+  end
+
+  def atomic?
+    @sexpr.size == 1
+  end
+
+  def defined?; !undefined? end
+  def undefined?; any? { |s| s.sexpr == UNDEFINED } end
+  def undefined_variables; select { |s| s.atomic? && s.undefined? && s.name }.map(&:name) end
+
+  def clean?; !dirty? end
+  def dirty?; any? { |s| s.dirty } end
+  def dirty_variables; select { |s| s.atomic? && s.dirty? && s.name }.map(&:name) end
+
+  def ==(val)
+    case val
+    when Sexpr, Array
+      val == @sexpr
+    else
+      val == self.value
+    end
+  end
+
+  def each(&block)
+    return to_enum unless block_given?
+
+    yield self
+    args.each { |s| s.each(&block) }
+  end
+
+# magix
+
+  # convert any method call to an s-expression
+  #
+  def method_missing(method, *args, &block)
+    Sexpr.build([method, self, *args], @env)
+  end
+
+# printing and conversion
+  
+  def print(opts = {}); puts to_s(opts) end
+  def inspect(opts = {}); @sexpr.inspect end
+  def to_s(opts = {}); print(_to_ary(opts)) end
+  def to_ary(opts = {}); _to_ary(opts) end
+
+protected
+
+  def _to_ary(opts = {})
+    if atomic?
+      Array(value)
+    else
+      args.map do |a| 
+        if a.atomic? || (!opts[:expand] && a.name)
+          Array(opts[:numeric] ? a.value : (a.name || a.value))
+        else 
+          a._to_ary(opts)
+        end
+      end.unshift(op)
+    end
+  end
+
+  def print(sexpr)
+    op, args = sexpr.car, sexpr.cdr
+
+    if args.empty?
+      op.inspect
+    elsif BINARY_OPS.include?(op)
+      "(#{print(args[0])} #{op} #{print(args[1])})" 
+    else
+      "#{op}(#{args.map {|a| print(a)}.join(', ')})" 
+    end
+  end
+
+private
+
+  # Wizard hats on ;)
+
+  def eval
+    atomic? ? value : apply
+  end
+
+  def apply
+    result = \
+      if @env[op].respond_to?(:call)
+        @env[op].call(*arg_values) 
+      else
+        arg_values[0].send(op, *arg_values.cdr)
+      end
+
+    puts " -> #{op}(#{arg_values.join(', ')}) = #{result}" if Calculation.verbose
+    result
+  end
+
+  def arg_values
+    args.map { |a| a.value }
+  end
+
+end

data/lib/polly/version.rb

@@ -0,0 +1,3 @@
+module Polly
+  VERSION = "0.0.4"
+end

data/lib/polly.rb

@@ -0,0 +1,13 @@
+require 'polly/version'
+require 'polly/extensions/object'
+require 'polly/extensions/array'
+require 'polly/extensions/numeric'
+
+module Polly; end
+
+require 'polly/common'
+require 'polly/env'
+require 'polly/context'
+require 'polly/sexpr'
+require 'polly/math'
+require 'polly/calculation'

data/polly.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'polly/version'
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Alex Skryl"]
+  gem.email         = ["rut216@gmail.com"]
+  gem.description   = %q{ A Polynomial Solver DSL }
+  gem.summary       = %q{ A Rails compatible polynomial solver with persistence }
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "polly"
+  gem.require_paths = ["lib"]
+  gem.version       = Polly::VERSION
+end

data/spec/calculation.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Polly::Calculation do
+
+  let(:calc_class) { Polly::Calculation }
+
+  before :each do
+    @calc = calc_class.new do
+      var :a, 1
+      var :b, 2
+      var :c, 3
+      var :d, a + b + c
+    end
+  end
+
+  it 'should be able to toggle calculation options' do
+    @calc.verbose_toggle
+    calc_class.verbose.should be_true
+    @calc.verbose_toggle
+    calc_class.verbose.should be_false
+  end
+
+  it 'should eval the initialization block inside the context' do
+    @calc.context.should_not respond_to(:e, :f, :g)
+    @calc.context.should respond_to(:a, :b, :c, :d)
+  end
+
+  it 'should get and set variables in the context' do
+    @calc.a.should == 1
+    @calc.a = 2
+    @calc.a.should == 2
+  end
+
+  it 'should respond to delegated methods' do
+    @calc.should respond_to(:atomic_variables)
+    @calc.should respond_to(:defined_variables)
+    @calc.should respond_to(:undefined_variables)
+    @calc.should respond_to(:evaluate)
+    @calc.should respond_to(:to_yaml)
+  end
+
+  it 'should initialize from a yaml dump' do
+    dump = calc_class.dump(@calc)
+    c = calc_class.load(dump)
+    c.context.should respond_to(:a, :b, :c, :d)
+    c.a.should == 1
+    c.b.should == 2
+    c.c.should == 3
+    c.d.should == 6
+  end
+
+end

data/spec/context.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Polly::Context do
+
+  let(:env_class) { Polly::Env }
+  let(:sexpr_class) { Polly::Sexpr }
+  let(:context_class) { Polly::Context }
+
+  before :each do
+    @c = context_class.new(env_class.new)
+    @c.instance_eval do
+      var :a
+      const :b, 2
+      const :c, 3
+
+      eq :calc, c * (a + b)
+      eq :complex, min(10, 15, max(10,20,30, a, b, c), calc)
+    end
+  end
+
+  it 'should define aliases for specifying variables' do
+    [:const, :var, :eq].all? { |m| @c.should respond_to(m) }
+  end
+
+  it 'should define a variable as an s-expression' do
+    [:d, :e, :f].all? { |m| @c.should_not respond_to(m) }
+    [:a, :b, :c, :calc, :complex].all? { |m| @c.should respond_to(m) }
+    [:a, :b, :c, :calc, :complex].all? { |m| @c.send(m).should be_a(sexpr_class) }
+    @c.a.should == nil
+    @c.b.should == 2
+    @c.c.should == 3
+    @c.calc.should == nil
+  end
+
+  it 'should re-define a variable' do
+    @c.var(:a, 1)
+    @c.var(:calc, 2)
+    @c.a.should == 1
+    @c.calc.should == 2
+  end
+
+  it 'should respond to any unknown method by converting it to an s-expression' do
+    @c.foo.should be_a(sexpr_class)
+    @c.bar.should be_a(sexpr_class)
+  end
+
+  it 'should cast a literal to an s-expression' do
+    @c.instance_eval { Sexpr(5) }.should be_a(sexpr_class)
+    @c.instance_eval { 5.to_sexpr }.should be_a(sexpr_class)
+  end
+
+  it 'should evaluate a calculation block before or after initialization' do
+    p = Proc.new do
+      eq :another, min(complex, calc) ** 2
+    end
+    @c.evaluate(p)
+
+    [:a, :b, :c, :calc, :complex, :another].all? { |m| @c.should respond_to(m) }
+    [:a, :b, :c, :calc, :complex, :another].all? { |m| @c.send(m).should be_a(sexpr_class) }
+    @c.another.should == nil
+    @c.var(:a, 1)
+    @c.another.should == 81
+  end
+
+end

data/spec/env.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Polly::Env do
+
+  let(:math_class) { Polly::Math }
+  let(:env_class) { Polly::Env }
+  let(:sexpr_class) { Polly::Sexpr }
+
+  before :each do
+    @env = env_class.new( 
+      cat: sexpr_class.build("meow"), 
+      dog: sexpr_class.build("gruff") 
+    )
+
+    @env[:foo] = sexpr_class.build(0)
+    @env[:bar] = sexpr_class.build(:a)
+    @env[:buz] = sexpr_class.build('a')
+    @env[:him] = sexpr_class.build(true)
+    @env[:her] = sexpr_class.build(false)
+    @env[:it] = sexpr_class.build([:*,1,2])
+    @env[:nil] = sexpr_class.build(nil)
+  end
+
+  it 'should include all functions included in the Math module' do
+    math_class.singleton_methods.all? { |m| @env[m] }.should == true
+  end
+
+  it 'should return only the s-expressions' do
+    @env.clean.should be_a(env_class)
+    @env.clean.size.should == 9
+    @env.clean.all? { |k,v| [:cat, :dog, :foo, :bar, :buz, :him, :her, :it, :nil].include?(k) }.should == true
+  end
+
+  it 'should return only the atomic s-expressions' do
+    @env.atomic_variables.size.should == 8
+    @env.atomic_variables.all? { |k,v| [:cat, :dog, :foo, :bar, :buz, :him, :her, :nil].include?(k) }.should == true
+  end
+
+  it 'should return only atomic, defined s-expressions' do
+    @env.defined_variables.size.should == 7
+    @env.defined_variables.all? { |k,v| [:cat, :dog, :foo, :bar, :buz, :him, :her].include?(k) }.should == true
+  end
+
+  it 'should return the names of the atomic, undefined s-expressions' do
+    @env.undefined_variables.size.should == 1
+    @env.undefined_variables.should include(:nil)
+  end
+
+  it 'should marshal to native yaml' do
+    e = env_class.new(YAML::load(@env.to_yaml))
+    @env.should == e
+  end
+
+  it 'should return a value set' do
+    r = { cat: 'meow', dog: 'gruff', foo: 0, bar: :a, buz: 'a', him: true, her: false, it: 2, nil: nil }
+    @env.values.should == r
+    @env.values!.should == r
+  end
+
+end

data/spec/examples.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Polly::Calculation do
+
+  before :each do
+    @calc = \
+      Polly::Calculation.new do
+        name :name
+        version 1
+
+        # constants
+        const :a, 150.percent
+        const :b, 5000
+        const :c, 12
+        const :d, 80.percent
+
+        # inputs
+        var :e
+        var :f
+        var :g
+        var :h
+        var :i, b
+      end
+
+      @calc.evaluate do
+        # eq can nest other equations or vars
+        eq :eq1, (e * f + g) / 3.0 - f + -e
+        eq :eq2, br(h.length > 4, eq1.to_i, e)
+        eq :eq3, max(ceil(pv(a.round(1), c, eq2), 50), e)
+        eq :eq4, eq3
+
+        eq :final, 100.to_sexpr + Sexpr(1000) + eq4 + b
+      end
+
+    @calc.h = "str"
+    @calc.e = 3000
+    @calc.f = 2
+    @calc.g = 10000
+  end
+
+  it 'should perform a complex calculation' do
+    @calc.final.should == 9100
+  end
+
+  it 'should perform a complex calculation' do
+    @calc.h = "string"
+    @calc.final.should == 9100
+  end
+
+  it 'should perform a complex calculation' do
+    @calc.e = 20000
+    @calc.final.should == 26100
+  end
+
+  it 'should convert the calculation to an array' do
+    @calc.final.to_ary.should == \
+      [:+, [:+, [:+, [100], [1000]], [:self, [:eq3]]], [:b]]
+    @calc.final.to_ary(numeric: true).should == \
+      [:+, [:+, [:+, [100], [1000]], [:self, [3000]]], [5000]]
+    @calc.final.to_ary(expand: true).should == \
+      [:+, [:+, [:+, [100], [1000]], [:self, [:max, [:ceil, [:pv, [:round, [:a], [1]], [:c], [:br, [:>, [:length, [:h]], [4]], [:to_i, [:+, [:-, [:/, [:+, [:*, [:e], [:f]], [:g]], [3.0]], [:f]], [:-@, [:e]]]], [:e]]], [50]], [:e]]]], [:b]]
+    @calc.final.to_ary(numeric: true, expand: true).should == \
+      [:+, [:+, [:+, [100], [1000]], [:self, [:max, [:ceil, [:pv, [:round, [1.5], [1]], [12], [:br, [:>, [:length, ["str"]], [4]], [:to_i, [:+, [:-, [:/, [:+, [:*, [3000], [2]], [10000]], [3.0]], [2]], [:-@, [3000]]]], [3000]]], [50]], [3000]]]], [5000]]
+  end
+
+  it 'should convert the calculation to a human readable string' do
+    @calc.final.to_s.should == \
+      "(((100 + 1000) + self(:eq3)) + :b)"
+    @calc.final.to_s(numeric: true).should == \
+      "(((100 + 1000) + self(3000)) + 5000)"
+    @calc.final.to_s(expand: true).should == \
+      "(((100 + 1000) + self(max(ceil(pv(round(:a, 1), :c, br((length(:h) > 4), to_i((((((:e * :f) + :g) / 3.0) - :f) + -@(:e))), :e)), 50), :e))) + :b)"
+    @calc.final.to_s(numeric: true, expand: true).should == \
+      "(((100 + 1000) + self(max(ceil(pv(round(1.5, 1), 12, br((length(\"str\") > 4), to_i((((((3000 * 2) + 10000) / 3.0) - 2) + -@(3000))), 3000)), 50), 3000))) + 5000)"
+  end
+
+end

data/spec/math.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+
+describe Polly::Math do
+  let(:math_class) { Polly::Math }
+
+  describe 'mathematical functions' do
+
+    it 'should perform a min function' do
+      nums = [34, 893, 12, 1234, 17]
+      math_class.min(0).should == 0
+      math_class.min(15,10).should == 10
+      math_class.min(*nums).should == 12
+    end
+
+    it 'should perform a max function' do
+      nums = [34, 893, 12, 1234, 17]
+      math_class.max(0).should == 0
+      math_class.max(15,10).should == 15
+      math_class.max(*nums).should == 1234
+    end
+
+    it 'should perform a ceiling function' do
+      math_class.ceil(153,10).should == 150
+      math_class.ceil(153,20).should == 140
+      math_class.ceil(153,30).should == 150
+      math_class.ceil(153,40).should == 120
+      math_class.ceil(153,50).should == 150
+      math_class.ceil(153,100).should == 100
+    end
+
+    it 'should perform a net present value function' do
+      math_class.pv(0.100, 12, 50).round(2).should == 340.68
+      math_class.pv(0.100, 12, 75).round(2).should == 511.03
+      math_class.pv(0.100, 12, 100).round(2).should == 681.37
+
+      math_class.pv(0.150, 1, 100).round(2).should == 86.96
+      math_class.pv(0.150, 6, 100).round(2).should == 378.45
+      math_class.pv(0.150, 12, 100).round(2).should == 542.06
+
+      math_class.pv(0.200, 12, 100).round(2).should == 443.92
+      math_class.pv(0.300, 12, 100).round(2).should == 319.03
+      math_class.pv(0.400, 12, 100).round(2).should == 245.59
+    end
+
+  end
+
+  describe 'ruby replacement functions' do
+
+    it 'should perform a branch function' do
+      math_class.br(true, 0, 1).should == 0
+      math_class.br(false, 0, 1).should == 1
+    end
+
+    it 'should perform an and function' do
+      math_class.and(true, true).should == true
+      math_class.and(true, false).should == false
+      math_class.and(false, true).should == false
+      math_class.and(false, false).should == false
+    end
+
+    it 'should perform an or function' do
+      math_class.or(true, true).should == true
+      math_class.or(true, false).should == true
+      math_class.or(false, true).should == true
+      math_class.or(false, false).should == false
+    end
+
+    it 'should perform a not function' do
+      math_class.not(true).should == false
+      math_class.not(false).should == true
+
+      math_class.!(true).should == false
+      math_class.!(false).should == true
+    end
+
+    it 'should perform a not equal function' do
+      math_class.not_eq(true, true).should == false
+      math_class.not_eq(true, false).should == true
+
+      math_class.!=(true, true).should == false
+      math_class.!=(true, false).should == true
+    end
+
+  end
+
+end

data/spec/sexpr.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Polly::Sexpr do
+  
+  let(:env_class) { Polly::Env }
+  let(:sexpr_class) { Polly::Sexpr }
+
+  before :each do
+    @env = env_class.new
+
+    @s = []
+    @s[0] = sexpr_class.build(nil, nil, 'a')
+    @s[1] = sexpr_class.build(0)
+    @s[2] = sexpr_class.build(:a)
+    @s[3] = sexpr_class.build('a')
+    @s[4] = sexpr_class.build(true)
+    @s[5] = sexpr_class.build(false)
+    @s[6] = sexpr_class.build([:+, 1, 2])
+    @s[7] = sexpr_class.build([:*, [:+, 1, 2], 3])
+    @s[8] = sexpr_class.build([:*, [:+, 1, 2], @s[0]])
+  end
+
+  it 'should recursively build an s-expression from a supported native type' do
+    @s.all? { |s| s.should be_a(sexpr_class) }
+  end
+
+  it 'should save the s-expressions name if provided' do
+    @s[0].name.should == 'a'
+  end
+
+  it 'should determine the operation and arguments of any s-expression' do
+    @s[0].op.should == nil 
+    @s[0].args.should be_empty
+    @s[6].op.should == :+
+    @s[6].args.should == [1,2]
+    @s[7].op.should == :*
+    @s[7].args.should == [@s[6], 3]
+    @s[8].op.should == :*
+    @s[8].args.should == [@s[6], @s[0]]
+  end
+
+  it 'should compare an s-expression to another s-expression, an array, or a value' do
+    sexpr = [:*, [:+, 1, 2], 3]
+    @s[7].should == sexpr_class.build(sexpr, @env)
+    @s[7].should == sexpr
+    @s[7].should == 9
+  end
+
+  it 'should evaluate a valid s-expression' do
+    @s[0].should == nil
+    @s[1].should == 0
+    @s[2].should == :a
+    @s[3].should == 'a'
+    @s[4].should == true
+    @s[5].should == false
+    @s[6].should == 3
+    @s[7].should == 9
+    @s[8].should == nil
+  end
+
+  it 'should replace an s-expression value in place' do
+    old_oid = @s[0].object_id
+    @s[0].replace(1)
+    @s[0].should == 1
+    @s[0].object_id.should == old_oid
+  end
+
+  it 'should be able to tell if an s-expression is atomic' do
+    @s.values_at(0,1,2,3,4,5).all? { |s| s.atomic?.should be_true }
+    @s.values_at(6,7,8).all? { |s| s.atomic?.should be_false }
+  end
+
+  it 'should be able to tell if an s-expression is defined' do
+    @s.values_at(1,2,3,4,5,6,7).all? { |s| s.defined?.should be_true }
+    @s.values_at(0,8).all? { |s| s.defined?.should be_false }
+    @s.values_at(0,8).all? { |s| s.undefined?.should be_true}
+    @s[0].undefined_variables.should == ['a']
+    @s[8].undefined_variables.should == ['a']
+  end
+
+  it 'should mark a modified s-expression as dirty' do
+    @s[0].replace(1)
+    @s[0].should be_dirty
+    @s[8].should be_dirty
+    @s[7].should be_clean
+    @s[7].should_not be_dirty
+    @s[0].dirty_variables.should == ['a']
+    @s[8].dirty_variables.should == ['a']
+  end
+
+  it 'should convert all method calls to an s-expression' do
+    (@s[1] + 5).should be_a(sexpr_class)
+    @s[1].foo.should be_a(sexpr_class)
+    @s[1].bar(1,2).should be_a(sexpr_class)
+
+    (@s[1] + 5).should == [:+, 0, 5]
+    @s[1].foo.should == [:foo, 0]
+    @s[1].bar(1,2).should == [:bar, 0, 1, 2]
+    @s[1].foo.bar(1,2).should == [:bar, [:foo, 0],  1, 2]
+  end
+
+  it 'should convert to an array' do
+    @s[6].to_ary.should == [:+, [1], [2]]
+    @s[7].to_ary.should == [:*, [:+, [1], [2]], [3]]
+  end
+
+  describe 'make sure caching internals are working' do
+
+    before :each do
+      @s[7].value
+    end
+
+    it 'should re-evaluate same s-expression using cache' do
+      @s[7].should_not_receive(:eval)
+      @s[7].value
+      @s[7].value
+    end
+
+    it 'should re-evaluate same s-expression and sub-expressions' do
+      @s[7].should_receive(:eval).twice
+      @s[7].value!
+      @s[7].value!
+    end
+
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'rubygems'
+require 'bundler/setup'
+Bundler.require(:default)
+
+require 'pry'
+require 'polly'
+ 
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: polly
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+  prerelease: 
+platform: ruby
+authors:
+- Alex Skryl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-29 00:00:00.000000000 Z
+dependencies: []
+description: ! ' A Polynomial Solver DSL '
+email:
+- rut216@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .irb_tempfile
+- .rspec
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- TODO
+- lib/polly.rb
+- lib/polly/calculation.rb
+- lib/polly/common.rb
+- lib/polly/context.rb
+- lib/polly/env.rb
+- lib/polly/extensions/array.rb
+- lib/polly/extensions/numeric.rb
+- lib/polly/extensions/object.rb
+- lib/polly/math.rb
+- lib/polly/sexpr.rb
+- lib/polly/version.rb
+- polly.gemspec
+- spec/calculation.rb
+- spec/context.rb
+- spec/env.rb
+- spec/examples.rb
+- spec/math.rb
+- spec/sexpr.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A Rails compatible polynomial solver with persistence
+test_files:
+- spec/calculation.rb
+- spec/context.rb
+- spec/env.rb
+- spec/examples.rb
+- spec/math.rb
+- spec/sexpr.rb
+- spec/spec_helper.rb
+has_rdoc: