evaluator 0.1.5 → 0.1.6

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - ruby-head
+  - jruby
+  - rbx-18mode
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+gemspec
+

data/README.markdown

@@ -27,7 +27,7 @@ it as follows:
     6241509647120.42 MeV
 
 The calculator loads a few natural constants at startup (calc.startup). For unit support
-my minad-units library is used. Units are denoted in brackets e.g. [meter], [kV] etc
+my unit gem is used. Units are denoted in brackets e.g. [meter], [kV] etc
 
 Authors
 -------

data/Rakefile

@@ -1,9 +1,6 @@
-require 'hoe'
+task :default => :test
 
-$:.unshift 'lib'
-require 'evaluator'
-
-Hoe.new 'evaluator', Evaluator::VERSION do |evaluator|
-  evaluator.developer 'Daniel Mendler', 'mail@daniel-mendler.de'
+desc 'Run tests with bacon'
+task :test => FileList['test/*_test.rb'] do |t|
+  sh "bacon -q -Ilib:test #{t.prerequisites.join(' ')}"
 end
-

data/bin/evaluator

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'evaluator'
+require 'readline'
+
+def process(line, vars, quiet = false)
+  exit if line == 'exit' || line == 'quit'
+  if line =~ /^(\w+)\s*:=?\s*(.*)$/
+    vars[$1] = Evaluator($2, vars)
+  else
+    Evaluator(line, vars)
+  end
+rescue Exception => ex
+  quiet ? nil : ex.message
+end
+
+vars = {}
+File.read(File.expand_path(File.join(File.dirname(__FILE__), '..', 'evaluator.constants'))).split("\n").each { |line| process(line, vars, true) }
+
+loop do
+  line = Readline::readline('> ')
+  if !line
+    puts
+    break
+  end
+  Readline::HISTORY.push(line)
+  puts process(line, vars)
+end

data/evaluator.constants

@@ -0,0 +1,18 @@
+SpeedOfLight:          2.99792458e8 [m/s]
+ElementaryCharge:      1.602176487e-19 [C]
+ElectronMass:          9.10938215e-31 [kg]
+ProtonMass:            1.67262158e-27 [kg]
+NeutronMass:           1.67492716e-27 [kg]
+AvogadroConstant:      6.02214179e+23 [1/mole]
+BoltzmannConstant:     1.3806504e-23 [J/K]
+PlanckConstant:        6.62606896e-34 [J s]
+ReducedPlanckConstant: PlanckConstant / (2 * pi)
+GravitationConstant:   6.67428e-11 [m^3 / (kg * s^2)]
+GasConstant:           AvogadroConstant * BoltzmannConstant
+BohrRadius:            5.2917720859e−11 [m]
+BohrMagneton:          9.27400915e-24 [J/T]
+VacuumPermeability:    4 * pi * 1e-7 [N/A]
+VacuumPermittivity:    1 / (VacuumPermeability * SpeedOfLight^2)
+FineStructureConstant: ElementaryCharge^2 / (4 * pi * VacuumPermittivity * ReducedPlanckConstant * SpeedOfLight)
+RydbergConstant:       10973731.568527 [1/m]
+FluxQuantum:           PlanckConstant / (2 * ElementaryCharge)

data/evaluator.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/lib/evaluator'
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name              = 'evaluator'
+  s.version           = Evaluator::VERSION
+  s.date              = Date.today.to_s
+  s.authors           = ['Daniel Mendler']
+  s.email             = ['mail@daniel-mendler.de']
+  s.summary           = 'Mathematical expression evaluator'
+  s.description       = 'Mathematical expression evaluator for infix notation'
+  s.homepage          = 'http://github.com/minad/evaluator'
+  s.rubyforge_project = s.name
+
+  s.files         = `git ls-files`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = %w(lib)
+
+  s.add_development_dependency('bacon')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('unit')
+end

data/lib/evaluator.rb

@@ -1,6 +1,11 @@
-require 'complex'
+if RUBY_VERSION < '1.9'
+  require 'complex'
+else
+  require 'cmath'
+end
+
 begin
-  require 'units'
+  require 'unit'
 rescue LoadError
 end
 
@@ -8,7 +13,7 @@ module Evaluator
   def self.infix(priority, unary = nil, &block) [false, priority, lambda(&block), unary] end
   def self.prefix(&block) [true, 1e5, lambda(&block)] end
 
-  VERSION = '0.1.5'
+  VERSION = '0.1.6'
   OPERATOR = {
     'in'       => infix(0) do |a,b|
       raise(RuntimeError, 'Unit support not available') if !a.respond_to? :in
@@ -112,7 +117,7 @@ module Evaluator
   HEX    = /^0[xX][\dA-Fa-f]+$/
   OCT    = /^0[0-7]+$/
   DEC    = /^\d+$/
-  SYMBOL = /^[a-zA-Z_][\w_]*$/
+  SYMBOL = /^[a-zA-Z_]\w*$/
   UNIT   = /^\[[^\]]+\]$/
   VALUE_TOKENS = [UNIT, STRING, REAL, HEX, OCT, DEC, SYMBOL].map {|x| x.source[1..-2] }
   OPERATOR_TOKENS = OPERATOR.keys.flatten.sort { |a,b| b.length <=> a.length}.map { |x| Regexp.quote(x) }
@@ -153,8 +158,8 @@ module Evaluator
       else
         val = case tok
               when UNIT
-                if tok.respond_to? :to_unit
-                  tok[1..-2].to_unit
+                if Object.const_defined?(:Unit)
+                  Unit(tok[1..-2])
                 else
                   raise(RuntimeError, 'Unit support not available')
                 end

data/test/evaluator_test.rb

@@ -0,0 +1,179 @@
+require 'evaluator'
+
+class Bacon::Context
+  def e(*args)
+    Evaluator(*args)
+  end
+end
+
+describe Evaluator do
+  it 'should parse binary operators' do
+    e('42 || false').should.equal 42
+    e('false || nil || true').should.equal true
+    e('42 or false').should.equal 42
+    e('false or nil or true').should.equal true
+
+    e('true && 42').should.equal 42
+    e('nil && 1').should.equal nil
+    e('true and 42').should.equal 42
+    e('nil and 1').should.equal nil
+
+    e('1+1==2').should.equal true
+    e("'abc' == 'a'+'b'+'c'").should.equal true
+
+    e('1+1 != 3').should.equal true
+    e("'xxx' != 'a'+'b'+'c'").should.equal true
+
+    e('1<=1').should.equal true
+    e('1<=2').should.equal true
+    e('1>=1').should.equal true
+    e('2>=1').should.equal true
+    e('1<1').should.equal false
+    e('1<2').should.equal true
+    e('1>1').should.equal false
+    e('2>1').should.equal true
+
+    e('1+2').should.equal 3
+    e('"x"+"yz"').should.equal 'xyz'
+    e("'a'+string 1+'b'").should.equal 'a1b'
+    e("'a'+string(1)+'b'").should.equal 'a1b'
+
+    e('5-2').should.equal 3
+    e('3-4').should.equal -1
+
+    e('3*4').should.equal 12
+    e('"ab"*3').should.equal 'ababab'
+
+    e('12/4').should.equal 3
+
+    e('103. div 10.').should.equal 10
+
+    e('7 mod 4').should.equal 3
+    e('7 % 4').should.equal 3
+
+    e('2 ** 10').should.equal 1024
+
+    e('2 << 2').should.equal 8
+    e('256 >> 3').should.equal 32
+
+    e('6 & 2').should.equal 2
+    e('1 | 2 | 4').should.equal 7
+    e('9 ^ 8').should.equal 1
+  end
+
+  it 'should parse unary operators' do
+    e('-1').should.equal -1
+    e('-(1+1)').should.equal -2
+    e('---42').should.equal -42
+    e('----42').should.equal 42
+    e('3*-3').should.equal -9
+    e('3*+3').should.equal 9
+  end
+
+  it 'should respect precendence' do
+    e('1+3*5').should.equal 16
+    e('3*5+1').should.equal 16
+    e('3*5+2**3').should.equal 23
+  end
+
+  it 'should parse constants' do
+    e('PI').should.equal Math::PI
+    e('E').should.equal Math::E
+    e('I').should.equal Complex::I
+    e('trUe').should.equal true
+    e('fAlSe').should.equal false
+    e('niL').should.equal nil
+  end
+
+  it 'should parse numeric functions' do
+    e('gcd(26, 39)').should.equal 13
+    e('lcm(26, 39)').should.equal 78
+    e('cos 42').should.equal Math.cos(42)
+    e('sin 42').should.equal Math.sin(42)
+    e('cos 42').should.equal Math.cos(42)
+    e('tan 42').should.equal Math.tan(42)
+    e('sinh 42').should.equal Math.sinh(42)
+    e('cosh 42').should.equal Math.cosh(42)
+    e('tanh 42').should.equal Math.tanh(42)
+    e('asin .5').should.equal Math.asin(0.5)
+    e('acos .5').should.equal Math.acos(0.5)
+    e('atan .5').should.equal Math.atan(0.5)
+    e('asinh .5').should.equal Math.asinh(0.5)
+    e('atanh .5').should.equal Math.atanh(0.5)
+    e('sqrt 42 + 1').should.equal Math.sqrt(42) + 1
+    e('log 42 + 3').should.equal Math.log(42) + 3
+    e('ln 42 + 3').should.equal Math.log(42) + 3
+    e('log10 42 + 3').should.equal Math.log10(42) + 3
+    e('log2 42 + 3').should.equal Math.log(42)/Math.log(2) + 3
+    e('3 * exp 42').should.equal 3 * Math.exp(42)
+    e('erf 2').should.equal Math.erf(2)
+    e('erfc 2').should.equal Math.erfc(2)
+    e('floor 42.3').should.equal 42
+    e('ceil 41.6').should.equal 42
+    e('float("3.5")').should.equal 3.5
+    e('string(3.5)').should.equal "3.5"
+    e('int("3.5")').should.equal 3
+    e('int(3.6)').should.equal 3
+    srand(42); x = rand; srand(42)
+    e('rand').should.equal x
+    e('conj(1+2*i)').should.equal Complex(1,-2)
+    e('Im(1+2*i)').should.equal 2
+    e('Re(1+2*i)').should.equal 1
+    e('round(3.4)').should.equal 3
+    e('round(3.5)').should.equal 4
+    e('abs -6').should.equal 6
+    e('plus 3').should.equal 3
+    e('minus 3').should.equal -3
+    e('!3').should.equal false
+    e('~3').should.equal ~3
+  end
+
+  it 'should parse string_functions' do
+    e('substr("abcde", 1, 3)').should.equal 'bcd'
+    e('len("abcd")').should.equal 4
+    e('strip "  abc "').should.equal 'abc'
+    e('reverse "abc"').should.equal 'cba'
+    e('index("abcdefg", "cde")').should.equal 2
+    e('rindex("abcdefgcdef", "cde")').should.equal 7
+  end
+
+  it 'should parse variables' do
+    e('a+b*c', :a => 2, :b => 3, :c => 4).should.equal 14
+    e('a+b*C', 'A' => 2, 'b' => 3, :c => 4).should.equal 14
+    e('alpha+beta*GAMMA', 'ALPHA' => 2, 'bEtA' => 3, 'gamma' => 4).should.equal 14
+  end
+
+  it 'should parse errors' do
+    lambda { e('(((((((((((((3+3))') }.should.raise SyntaxError
+    lambda { e('1+2)') }.should.raise SyntaxError
+    lambda { e('1+2+3+') }.should.raise SyntaxError
+    lambda { e('1 + floor') }.should.raise SyntaxError
+    lambda { e('42*a+3') }.should.raise NameError
+    lambda { e('abc10') }.should.raise NameError
+    lambda { e('abc10d') }.should.raise NameError
+  end
+
+  it 'should parse numbers' do
+    e('0xABCDEF123').should.equal 0xABCDEF123
+    e('01234').should.equal 01234
+    e('234 ').should.equal 234
+    e('.123').should.equal 0.123
+    e('0.123').should.equal 0.123
+    e('123.').should.equal 123.0
+    e('123e-42').should.equal 123e-42
+    e('.123e-42').should.equal 0.123e-42
+    e('2.123e-42').should.equal 2.123e-42
+  end
+
+  it 'should parse strings' do
+    e('"abc\'a"').should.equal "abc'a"
+    e('"abc\"a"').should.equal 'abc"a'
+    e("'abc\"a'").should.equal 'abc"a'
+    e("'abc\\'a'").should.equal "abc'a"
+  end
+
+  it 'should support units' do
+    e('1 [km] in [m]').should.equal Unit('1000 m')
+    e('3 [m] / 2 [s]').should.equal Unit('3 m / 2 s')
+  end
+end

metadata

@@ -1,68 +1,88 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: evaluator
-version: !ruby/object:Gem::Version 
-  version: 0.1.5
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Daniel Mendler
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2009-04-13 00:00:00 +02:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: hoe
+date: 2012-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bacon
+  requirement: &18032920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.8.3
-    version: 
-description: 
-email: 
+  prerelease: false
+  version_requirements: *18032920
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &18031680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *18031680
+- !ruby/object:Gem::Dependency
+  name: unit
+  requirement: &18030460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *18030460
+description: Mathematical expression evaluator for infix notation
+email:
 - mail@daniel-mendler.de
-executables: []
-
+executables:
+- evaluator
 extensions: []
-
-extra_rdoc_files: 
-- Manifest.txt
-files: 
-- lib/evaluator.rb
-- test/test_evaluator.rb
+extra_rdoc_files: []
+files:
+- .travis.yml
+- Gemfile
 - README.markdown
 - Rakefile
-- Manifest.txt
-has_rdoc: true
-homepage: 
+- bin/evaluator
+- evaluator.constants
+- evaluator.gemspec
+- lib/evaluator.rb
+- test/evaluator_test.rb
+homepage: http://github.com/minad/evaluator
+licenses: []
 post_install_message: 
-rdoc_options: 
-- --main
-- README.markdown
-require_paths: 
+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: 
+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: evaluator
-rubygems_version: 1.3.1
+rubygems_version: 1.8.15
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Mathematical expression evaluator
-test_files: 
-- test/test_evaluator.rb
+test_files: []

data/Manifest.txt

@@ -1,5 +0,0 @@
-lib/evaluator.rb
-test/test_evaluator.rb
-README.markdown
-Rakefile
-Manifest.txt

data/test/test_evaluator.rb

@@ -1,169 +0,0 @@
-require 'test/unit'
-require 'evaluator'
-
-class TestEvaluator < Test::Unit::TestCase
-  def test_binary_operators
-    assert_equal 42, Evaluator('42 || false')
-    assert_equal true, Evaluator('false || nil || true')
-    assert_equal 42, Evaluator('42 or false')
-    assert_equal true, Evaluator('false or nil or true')
-
-    assert_equal 42, Evaluator('true && 42')
-    assert_equal nil, Evaluator('nil && 1')
-    assert_equal 42, Evaluator('true and 42')
-    assert_equal nil, Evaluator('nil and 1')
-
-    assert Evaluator('1+1==2')
-    assert Evaluator("'abc' == 'a'+'b'+'c'")
-
-    assert Evaluator('1+1 != 3')
-    assert Evaluator("'xxx' != 'a'+'b'+'c'")
-
-    assert Evaluator('1<=1')
-    assert Evaluator('1<=2')
-    assert Evaluator('1>=1')
-    assert Evaluator('2>=1')
-    assert(!Evaluator('1<1'))
-    assert Evaluator('1<2')
-    assert(!Evaluator('1>1'))
-    assert Evaluator('2>1')
-
-    assert_equal 3, Evaluator('1+2')
-    assert_equal 'xyz', Evaluator('"x"+"yz"')
-    assert_equal 'a1b', Evaluator("'a'+string 1+'b'")
-    assert_equal 'a1b', Evaluator("'a'+string(1)+'b'")
-
-    assert_equal 3, Evaluator('5-2')
-    assert_equal(-1, Evaluator('3-4'))
-
-    assert_equal 12, Evaluator('3*4')
-    assert_equal 'ababab', Evaluator('"ab"*3')
-
-    assert_equal 3, Evaluator('12/4')
-
-    assert_equal 10, Evaluator('103. div 10.')
-
-    assert_equal 3, Evaluator('7 mod 4')
-    assert_equal 3, Evaluator('7 % 4')
-
-    assert_equal 1024, Evaluator('2 ** 10')
-
-    assert_equal 8, Evaluator('2 << 2')
-    assert_equal 32, Evaluator('256 >> 3')
-
-    assert_equal 2, Evaluator('6 & 2')
-    assert_equal 7, Evaluator('1 | 2 | 4')
-    assert_equal 1, Evaluator('9 ^ 8')
-  end
-
-  def test_unary_operators
-    assert_equal(-1, Evaluator('-1'))
-    assert_equal(-2, Evaluator('-(1+1)'))
-    assert_equal(-42, Evaluator('---42'))
-    assert_equal 42, Evaluator('----42')
-    assert_equal(-9, Evaluator('3*-3'))
-    assert_equal(9, Evaluator('3*+3'))
-  end
-
-  def test_precendence
-    assert_equal 16, Evaluator('1+3*5')
-    assert_equal 16, Evaluator('3*5+1')
-    assert_equal 23, Evaluator('3*5+2**3')
-  end
-
-  def test_constants
-    assert_equal Math::PI, Evaluator('PI')
-    assert_equal Math::E, Evaluator('E')
-    assert_equal Complex::I, Evaluator('I')
-    assert_equal true, Evaluator('trUe')
-    assert_equal false, Evaluator('fAlSe')
-    assert_equal nil, Evaluator('niL')
-  end
-
-  def test_numeric_functions
-    assert_equal 13, Evaluator('gcd(26, 39)')
-    assert_equal 78, Evaluator('lcm(26, 39)')
-    assert_equal Math.cos(42), Evaluator('cos 42')
-    assert_equal Math.sin(42), Evaluator('sin 42')
-    assert_equal Math.cos(42), Evaluator('cos 42')
-    assert_equal Math.tan(42), Evaluator('tan 42')
-    assert_equal Math.sinh(42), Evaluator('sinh 42')
-    assert_equal Math.cosh(42), Evaluator('cosh 42')
-    assert_equal Math.tanh(42), Evaluator('tanh 42')
-    assert_equal Math.asin(0.5), Evaluator('asin .5')
-    assert_equal Math.acos(0.5), Evaluator('acos .5')
-    assert_equal Math.atan(0.5), Evaluator('atan .5')
-    assert_equal Math.asinh(0.5), Evaluator('asinh .5')
-    assert_equal Math.atanh(0.5), Evaluator('atanh .5')
-    assert_equal Math.sqrt(42) + 1, Evaluator('sqrt 42 + 1')
-    assert_equal Math.log(42) + 3, Evaluator('log 42 + 3')
-    assert_equal Math.log(42) + 3, Evaluator('ln 42 + 3')
-    assert_equal Math.log10(42) + 3, Evaluator('log10 42 + 3')
-    assert_equal Math.log(42)/Math.log(2) + 3, Evaluator('log2 42 + 3')
-    assert_equal 3 * Math.exp(42), Evaluator('3 * exp 42')
-    assert_equal Math.erf(2), Evaluator('erf 2')
-    assert_equal Math.erfc(2), Evaluator('erfc 2')
-    assert_equal 42, Evaluator('floor 42.3')
-    assert_equal 42, Evaluator('ceil 41.6')
-    assert_equal 3.5, Evaluator('float("3.5")')
-    assert_equal "3.5", Evaluator('string(3.5)')
-    assert_equal 3, Evaluator('int("3.5")')
-    assert_equal 3, Evaluator('int(3.6)')
-    srand(42); x = rand; srand(42)
-    assert_equal x, Evaluator('rand')
-    assert_equal Complex(1,-2), Evaluator('conj(1+2*i)')
-    assert_equal 2, Evaluator('Im(1+2*i)')
-    assert_equal 1, Evaluator('Re(1+2*i)')
-    assert_equal 3, Evaluator('round(3.4)')
-    assert_equal 4, Evaluator('round(3.5)')
-    assert_equal 6, Evaluator('abs -6')
-    assert_equal 3, Evaluator('plus 3')
-    assert_equal(-3, Evaluator('minus 3'))
-    assert_equal false, Evaluator('!3')
-    assert_equal ~3, Evaluator('~3')
-  end
-
-  def test_string_functions
-    assert_equal 'bcd', Evaluator('substr("abcde", 1, 3)')
-    assert_equal 4, Evaluator('len("abcd")')
-    assert_equal 'abc', Evaluator('strip "  abc "')
-    assert_equal 'cba', Evaluator('reverse "abc"')
-    assert_equal 2, Evaluator('index("abcdefg", "cde")')
-    assert_equal 7, Evaluator('rindex("abcdefgcdef", "cde")')
-  end
-
-  def test_variables
-    assert_equal 14, Evaluator('a+b*c', :a => 2, :b => 3, :c => 4)
-    assert_equal 14, Evaluator('a+b*C', 'A' => 2, 'b' => 3, :c => 4)
-    assert_equal 14, Evaluator('alpha+beta*GAMMA', 'ALPHA' => 2, 'bEtA' => 3, 'gamma' => 4)
-  end
-
-  def test_errors
-    assert_raise(SyntaxError) { Evaluator('(((((((((((((3+3))') }
-    assert_raise(SyntaxError) { Evaluator('1+2)') }
-    assert_raise(SyntaxError) { Evaluator('1+2+3+') }
-    assert_raise(SyntaxError) { Evaluator('1 + floor') }
-    assert_raise(NameError) { Evaluator('42*a+3') }
-    assert_raise(NameError) { Evaluator('abc10') }
-    assert_raise(NameError) { Evaluator('abc10d') }
-  end
-
-  def test_numbers
-    assert_equal 0xABCDEF123, Evaluator('0xABCDEF123')
-    assert_equal 01234, Evaluator('01234')
-    assert_equal 234, Evaluator('234 ')
-    assert_equal 0.123, Evaluator('.123')
-    assert_equal 0.123, Evaluator('0.123')
-    assert_equal 123.0, Evaluator('123.')
-    assert_equal 123e-42, Evaluator('123e-42')
-    assert_equal 0.123e-42, Evaluator('.123e-42')
-    assert_equal 2.123e-42, Evaluator('2.123e-42')
-  end
-
-  def test_strings
-    assert_equal "abc'a", Evaluator('"abc\'a"')
-    assert_equal 'abc"a', Evaluator('"abc\"a"')
-    assert_equal 'abc"a', Evaluator("'abc\"a'")
-    assert_equal "abc'a", Evaluator("'abc\\'a'")
-  end
-end