kalc 0.5.8 → 0.5.9

data/README.textile

@@ -36,9 +36,9 @@ OR(1 > 2, 3 < 2, 8 == 8) # true
 h3. Variable assignment
 
 <pre>
-a = 1
-b = 2
-d = a + b
+a := 1
+b := 2
+d := a + b
 </pre>
 
 h3.  Creating functions
@@ -62,6 +62,40 @@ DEFINE SAMPLE_LOOP(a) {
 }
 </pre>
 
+h3. Weirdness
+
+And here is where it gets a bit weird.  It has to look a bit like
+Excel, so you can expect things to look odd in places.
+
+For example, here is how you compare 2 variables:
+
+<pre>
+# Assign '1' to 'a' and '2' to 'b'
+
+a := 1
+b := 2
+
+# Does 'a' equal 'b'?
+
+a = b
+
+> false
+
+# Also, you can do this:
+
+a == b
+
+> false
+
+(a == a) && (b = b)
+
+> true
+
+</pre>
+
+'=' and '==' are both equality operators.  Use
+':=' for assignment.
+
 h4. More inside
 
 Not everything is documented yet.  As you can see, it is a mix of

data/bin/kalc

@@ -6,14 +6,9 @@ $LOAD_PATH.unshift(kalc_dir) unless $LOAD_PATH.include?(kalc_dir)
 require "kalc"
 require "pp"
 
-input = File.read(ARGV.first)
+if ARGV.first
+  input = File.read(ARGV.first)
 
-grammar = Kalc::Grammar.new
-g = grammar.parse(input)
-
-transform = Kalc::Transform.new
-ast = transform.apply(g)
-
-
-interpreter = Kalc::Interpreter.new
-puts interpreter.run(ast)
+  r = Kalc::Runner.new
+  puts r.run(input)
+end

data/examples/add.kalc

@@ -0,0 +1 @@
+1+1

data/examples/newton.kalc

@@ -0,0 +1,22 @@
+DEFINE AVERAGE(x, y) {
+  (x + y) / 2
+}
+
+DEFINE GOOD_ENOUGH(guess, x) {
+  (ABS(SQUARE(guess) - x)) < 0.001
+}
+
+DEFINE IMPROVE(guess, x) {
+  a := x / guess;
+  AVERAGE(guess, a)
+}
+
+DEFINE SQRT_ITER(guess, x) {
+  IF(GOOD_ENOUGH(guess, x), guess, SQRT_ITER(IMPROVE(guess, x), x))
+}
+
+DEFINE NEWTON_SQRT(x) {
+  SQRT_ITER(1.0, x)
+}
+
+PUTS NEWTON_SQRT(1024)

data/examples/subtract.kalc

@@ -0,0 +1 @@
+100 - 10

data/lib/kalc.rb

@@ -1,4 +1,5 @@
 require 'parslet'
+require 'logger'
 
 require 'kalc/version'
 require 'kalc/grammar'
@@ -9,6 +10,45 @@ require 'kalc/interpreter'
 require 'kalc/repl'
 
 module Kalc
+  class Runner
+    
+    attr_accessor :grammar
+    attr_accessor :transform
+    attr_accessor :interpreter
+    attr_accessor :ast
 
+    def initialize(debug = false)
+      @debug = debug
+      @log = Logger.new(STDOUT)
+      load_environment
+    end
+
+    def reload
+      load_environment
+    end
+
+    def run(expression)
+      if @debug
+        @log.debug "Evaluating #{expression}"
+        g = @grammar.parse_with_debug(expression)
+      else
+        g = @grammar.parse(expression)
+      end
+      @ast = @transform.apply(g)
+      @interpreter.run(ast)
+    end
+
+    private
+    def load_environment
+      @log.debug "Loading grammar" if @debug
+      @grammar = Kalc::Grammar.new
+      @log.debug "Loading transform" if @debug
+      @transform = Kalc::Transform.new
+      @log.debug "Loading interpreter" if @debug
+      @interpreter = Kalc::Interpreter.new
+      @log.debug "Loading stdlib" if @debug
+      @interpreter.load_stdlib(@grammar, @transform)
+    end
+  end
 end
 

data/lib/kalc/ast.rb

@@ -66,8 +66,6 @@ module Kalc
       end
     end
 
-
-
     class BooleanValue
       attr_reader :value
 
@@ -159,6 +157,8 @@ module Kalc
           @left <= @right
         when '>='
           @left >= @right
+        when '='
+          @left == @right
         when '=='
           @left == @right
         when '!='

data/lib/kalc/grammar.rb

@@ -74,7 +74,8 @@ class Kalc::Grammar < Parslet::Parser
             :equal => '==',
             :not_equal => '!=',
 
-            :assign => '=',
+            :assign => ':=',
+            :excel_equal => '=',
             :question_mark => '?',
 
             :subtract => '-',
@@ -194,10 +195,10 @@ class Kalc::Grammar < Parslet::Parser
         relational_expression.as(:right)).repeat.as(:ops)
   }
 
-  # 1 == 2
+  # 1 = 2
   rule(:equality_expression) {
     relational_expression.as(:left) >>
-      ((equal | not_equal) >>
+      ((excel_equal | equal | not_equal) >>
         equality_expression.as(:right)).repeat.as(:ops)
   }
 

data/lib/kalc/interpreter.rb

@@ -104,7 +104,7 @@ module Kalc
 
     end
 
-    def load_stdlibs(grammar, transform)
+    def load_stdlib(grammar, transform)
       stdlib = "#{File.dirname(__FILE__)}/stdlib.kalc"
       input = File.read(stdlib)
       g = grammar.parse(input)

data/lib/kalc/repl.rb

@@ -10,15 +10,8 @@ module Kalc
 
       puts heading
 
-      puts "= Loading grammar"
-      @grammar = Kalc::Grammar.new
-
-      puts "= Loading transform"
-      @transform = Kalc::Transform.new
-
-      puts "= Loading interpreter"
-      @interpreter = Kalc::Interpreter.new
-      @interpreter.load_stdlibs(@grammar, @transform)
+      # Load Kalc with debug
+      @kalc = Kalc::Runner.new(true)
 
       puts "You are ready to go.  Have fun!"
       puts ""
@@ -27,7 +20,7 @@ module Kalc
 
       function_list = [
         'quit', 'exit', 'functions', 'variables', 'ast'
-      ] + @interpreter.env.functions.map { |f| f.first }
+      ] + @kalc.interpreter.env.functions.map { |f| f.first }
 
       begin
         comp = proc { |s| function_list.grep( /^#{Regexp.escape(s)}/ ) }
@@ -40,15 +33,13 @@ module Kalc
             when (input == 'quit' || input == 'exit')
               break
             when input == "functions"
-              puts @interpreter.env.functions.map { |f| f.first }.join(", ")
+              puts @kalc.interpreter.env.functions.map { |f| f.first }.join(", ")
             when input == 'variables'
-              puts @interpreter.env.variables.map { |v| "#{v[0]} = #{v[1]}" }.join("\n\r")
+              puts @kalc.interpreter.env.variables.map { |v| "#{v[0]} = #{v[1]}" }.join("\n\r")
             when input == 'ast'
-              pp ast
+              pp @kalc.ast
             when input != ""
-              g = @grammar.parse_with_debug(input)
-              ast = @transform.apply(g)
-              puts @interpreter.run(ast)
+              puts @kalc.run(input)
             end
           rescue Parslet::ParseFailed => e
             puts e, g.root.error_tree

data/lib/kalc/stdlib.kalc

@@ -1,17 +1,28 @@
+DEFINE PLUS_ONE(x) {
+  x + 1
+}
+
+DEFINE MINUS_ONE(x) {
+  x - 1
+}
+
 DEFINE SQUARE(x) {
-  x * x * x
+  x * x
+}
+
+DEFINE CUBE(x) {
+  x * SQUARE(x)
 }
 
 DEFINE FIB(x) {
-  IF(x == 0, 0, IF(x == 1, 1, (FIB(x - 1) + FIB(x - 2))))
+  IF(x = 0, 0, IF(x = 1, 1, (FIB(x - 1) + FIB(x - 2))))
 }
 
 DEFINE FACTORIAL(x) {
-  IF(x == 0, 1, (x * FACTORIAL(x - 1)))
+  IF(x = 0, 1, (x * FACTORIAL(x - 1)))
 }
 
 DEFINE TOWERS_OF_HANOI(x) {
-  IF(x == 1, 1, (2 * TOWERS_OF_HANOI(x - 1) + 1))
+  IF(x = 1, 1, (2 * TOWERS_OF_HANOI(x - 1) + 1))
 }
 
-

data/lib/kalc/version.rb

@@ -1,3 +1,3 @@
 module Kalc
-  VERSION = "0.5.8"
+  VERSION = "0.5.9"
 end

data/spec/interpreter_spec.rb

@@ -25,22 +25,54 @@ describe Kalc::Interpreter do
 
   it { evaluate("10 >= 10").should == true }
 
+  it { evaluate("ABS(-1 + -2)").should == 3 }
+
   it "should be able to load variables" do
-    evaluate("a = 1; 1 + a").should == 2
-    evaluate("a = 1; b = 2; 1 + b").should == 3
+    evaluate("a := 1; 1 + a").should == 2
+    evaluate("a := 1; b := 2; 1 + b").should == 3
   end
 
   it "should be able to load single quoted variables" do
-    evaluate("'a' = 1; 1 + 'a'").should == 2
-    evaluate("'a' = 1; 'b' = 2; 'b' + 'a'").should == 3
+    evaluate("'a' := 1; 1 + 'a'").should == 2
+    evaluate("'a' := 1; 'b' := 2; 'b' + 'a'").should == 3
   
-    evaluate("'a b' = 1; 'a b' + 1").should == 2
+    evaluate("'a b' := 1; 'a b' + 1").should == 2
   end
 
   it { evaluate("((75.0)*(25.0))+((125.0)*(25.0))+((150.0)*(25.0))+((250.0)*(25.0))").should == 15000 }
 
   it { evaluate("(((40.0)/1000*(4380.0)*(200.0))-((40.0)/1000*(4380.0)*((((75.0)*(25.0))+((125.0)*(25.0))+((150.0)*(25.0))+((250.0)*(25.0)))/(10.0)/(40.0)/(0.8))))*(0.05)").should == 1341.375 }
 
+  context "Negative numbers" do
+    it { evaluate("-2").should == -2 }
+    it { evaluate("-1000").should == -1000 }
+    it { evaluate("-1000.0001").should == -1000.0001 }
+    it { evaluate("1 + -1").should == 0 }
+    it { evaluate("1 + -10").should == -9 }
+  end
+
+  context "Positive numbers" do
+    it { evaluate("1 + +1").should == 2 }
+    it { evaluate("1 + +1 - 1").should == 1 }
+    it { evaluate("+10000.0001").should == 10000.0001 }
+  end
+
+  context "Boolean value" do
+    it { evaluate("TRUE").should == true }
+    it { evaluate("FALSE").should == false }
+    it { evaluate("FALSE || TRUE").should == true }
+    it { evaluate("FALSE && TRUE").should == false }
+  end
+
+  context "Floating point number" do
+    it { evaluate("1.01").should == 1.01 }
+    it { evaluate("1.01 + 0.02").should == 1.03 }
+    it { evaluate("1.01 - 0.01").should == 1 }
+    it { evaluate("1.1 + 1.1").should == 2.2 }
+    it { evaluate("1.01 = 1.01").should == true }
+    it { evaluate("1.01 = 1.02").should == false }
+  end
+
   private
   def evaluate(expression)
     g = @grammar.parse(expression)

data/spec/stdlib_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+class Kalc::Stdlib
+
+end
+
+describe Kalc::Stdlib do
+  
+  before(:each) do
+    @grammar = Kalc::Grammar.new
+    @transform = Kalc::Transform.new
+  end
+
+  describe "PLUS_ONE" do
+    it { evaluate("PLUS_ONE(1)").should == 2 }
+    it { evaluate("PLUS_ONE(101)").should == 102 }
+    it { evaluate("PLUS_ONE(0)").should == 1 }
+    it { evaluate("PLUS_ONE(-1)").should == 0 }
+  end
+
+  describe "MINUS_ONE" do
+    it { evaluate("MINUS_ONE(1)").should == 0 }
+    it { evaluate("MINUS_ONE(101)").should == 100 }
+    it { evaluate("MINUS_ONE(0)").should == -1 }
+    it { evaluate("MINUS_ONE(-1)").should == -2 }
+  end
+
+  describe "SQUARE" do
+    it { evaluate("SQUARE(2)").should == 4 }
+    it { evaluate("SQUARE(4)").should == 16 }
+  end
+
+  describe "CUBE" do
+    it { evaluate("CUBE(2)").should == 8 }
+    it { evaluate("CUBE(4)").should == 64 }
+  end
+
+  describe "FIB" do
+    it { evaluate("FIB(1)").should == 1 }
+    it { evaluate("FIB(10)").should == 55 }
+  end
+
+  describe "FACTORIAL" do
+    it { evaluate("FACTORIAL(1)").should == 1 }
+    it { evaluate("FACTORIAL(5)").should == 120 }
+  end
+
+  describe "TOWERS_OF_HANOI" do
+    it { evaluate("TOWERS_OF_HANOI(4)").should == 15 }
+    it { evaluate("TOWERS_OF_HANOI(10)").should == 1023 }
+  end
+
+  private
+  def evaluate(expression)
+    r = Kalc::Runner.new
+    r.run(expression)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kalc
 version: !ruby/object:Gem::Version
-  version: 0.5.8
+  version: 0.5.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-16 00:00:00.000000000 Z
+date: 2012-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -73,6 +73,9 @@ files:
 - README.textile
 - bin/ikalc
 - bin/kalc
+- examples/add.kalc
+- examples/newton.kalc
+- examples/subtract.kalc
 - kalc.gemspec
 - lib/kalc.rb
 - lib/kalc/ast.rb
@@ -86,6 +89,7 @@ files:
 - spec/grammar_spec.rb
 - spec/interpreter_spec.rb
 - spec/spec_helper.rb
+- spec/stdlib_spec.rb
 homepage: https://github.com/mrcsparker/kalc
 licenses: []
 post_install_message: 
@@ -106,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: kalc
-rubygems_version: 1.8.19
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Small calculation language.
@@ -114,3 +118,4 @@ test_files:
 - spec/grammar_spec.rb
 - spec/interpreter_spec.rb
 - spec/spec_helper.rb
+- spec/stdlib_spec.rb