keisan 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 32b53dd19dc29bced6d98d110f7d11c0a7d22ea5
-  data.tar.gz: d55ec179a6f8b1e597cb322e42bab4ed0b959fed
+  metadata.gz: 1e9c5a4aead65a954cbf6f2dc06d4ccb579e0edf
+  data.tar.gz: 2bbd7406b68ac4bd56f589fab026c303cf474edb
 SHA512:
-  metadata.gz: a4c87fabd551121df563306488410003e9291b1569330ca3da65d833b9e9e97f925dcbc3d07e23cb9c5e05272b8fe74028766388064e0713ff66d625261a5752
-  data.tar.gz: cdfef6449002d021fe83b10457959e5d1bccf81aa569be908e6ba98026f0adc2df44eeb3a60b6d013126e6d278992cd8a50b4c397c11460656a33574f0234ad7
+  metadata.gz: f71593bb29b2f3c088eb1f2ea759c80cdf9afc8a93f2f6f4ed30e9b706a3e528d07f57930d0397c1f4e8c27a927d058fc2fbb9f3961ff2abf3c5a33aac7770fb
+  data.tar.gz: a2239cf26bb7d53c650308b2110b6f097801dc90a57bb5b69d1348a4b32902e74f6a2fb275eebcbd64d64f24865685bf2f442288cd976df3359996642a83aaae

data/.travis.yml

@@ -1,8 +1,6 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.2.6
-  - 2.3.3
-  - 2.4.0
-  - 2.4.1
-before_install: gem install bundler -v 1.14.6
+  - 2.3.5
+  - 2.4.2
+before_install: gem install bundler -v 1.16.0

data/README.md

@@ -11,7 +11,7 @@ Keisan ([計算, to calculate](https://en.wiktionary.org/wiki/%E8%A8%88%E7%AE%97
 
 Add this line to your application's Gemfile:
 
-```ruby
+```
 gem 'keisan'
 ```
 
@@ -25,14 +25,47 @@ Or install it yourself as:
 
 ## Usage
 
+### REPL
+
+The command `bin/keisan` will open up an interactive REPL.  The commands you type in to this REPL are relayed to an internal `Keisan::Calculator` class and displayed back to you.
+
+![alt text](screenshots/repl.png "Keisan built-in REPL")
+
 ### Calculator class
 
-The functionality of `keisan` can be demonstrated by using the `Keisan::Calculator` class.  The `evaluate` method evaluates an expression by parsing it into an abstract syntax tree (AST), then evaluating any member functions/variables given.
+The functionality of `keisan` can be demonstrated by using the `Keisan::Calculator` class.  The `evaluate` method evaluates an expression by parsing it into an abstract syntax tree (AST), then evaluating any member functions/variables given.  There is also a `simplify` method that allows undefined variables and functions to exist, and will just return the simplified AST.
 
 ```ruby
 calculator = Keisan::Calculator.new
 calculator.evaluate("15 + 2 * (1 + 3)")
 #=> 23
+calculator.simplify("1*(0*2+x*g(t))").to_s
+#=> "x*g(t)"
+```
+
+For users who want access to the parsed abstract syntax tree, you can use the `ast` method to parse any given expression.
+
+```ruby
+calculator = Keisan::Calculator.new
+ast = calculator.ast("x**2+1")
+ast.to_s
+#=> "(x**2)+1"
+ast.class
+#=> Keisan::AST::Plus
+ast.children[0].class
+#=> Keisan::AST::Exponent
+ast.children[0].children[0].class
+#=> Keisan::AST::Variable
+ast.children[0].children[0].name
+#=> "x"
+ast.children[0].children[1].class
+#=> Keisan::AST::Number
+ast.children[0].children[1].value
+#=> 2
+ast.children[1].class
+#=> Keisan::AST::Number
+ast.children[1].value
+#=> 1
 ```
 
 ##### Specifying variables
@@ -40,6 +73,7 @@ calculator.evaluate("15 + 2 * (1 + 3)")
 Passing in a hash of variable (`name`, `value`) pairs to the `evaluate` method defines variables
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("3*x + y**2", x: -2.5, y: 3)
 #=> 1.5
 ```
@@ -47,6 +81,7 @@ calculator.evaluate("3*x + y**2", x: -2.5, y: 3)
 It will raise an error if an variable is not defined
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("x + 1")
 #=> Keisan::Exceptions::UndefinedVariableError: x
 ```
@@ -54,6 +89,7 @@ calculator.evaluate("x + 1")
 It is also possible to define variables in the string expression itself
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("x = 10*n", n: 2)
 calculator.evaluate("3*x + 1")
 #=> 61
@@ -64,6 +100,7 @@ calculator.evaluate("3*x + 1")
 Just like variables, functions can be defined by passing a `Proc` object as follows
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("2*f(1+2) + 4", f: Proc.new {|x| x**2})
 #=> 22
 ```
@@ -71,6 +108,7 @@ calculator.evaluate("2*f(1+2) + 4", f: Proc.new {|x| x**2})
 It will raise an error if a function is not defined
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("f(2) + 1")
 #=> Keisan::Exceptions::UndefinedFunctionError: f
 ```
@@ -78,6 +116,7 @@ calculator.evaluate("f(2) + 1")
 Note that functions work in both regular (`f(x)`) and postfix (`x.f()`) notation.  The postfix notation requires the function to take at least one argument.  In the case of `a.f(b,c)`, this is translated internally to `f(a,b,c)`.  If there is only a single argument to the function, the braces can be left off: `x.f`.
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("[1,3,5,7].size()")
 #=> 4
 calculator.evaluate("[1,3,5,7].size")
@@ -87,6 +126,7 @@ calculator.evaluate("[1,3,5,7].size")
 It is even possible to do more complicated things like follows
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.define_function!("f", Proc.new {|x| [[x-1,x+1], [x-2,x,x+2]]})
 calculator.evaluate("4.f")
 #=> [[3,5], [2,4,6]]
@@ -103,6 +143,7 @@ calculator.evaluate("4.f[1].size")
 Like variables, it is also possible to define functions in the string expression itself.
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("f(x) = n*x", n: 10) # n is local to this definition only
 calculator.evaluate("f(3)")
 #=> 30
@@ -115,6 +156,7 @@ calculator.evaluate("n") # n only exists in the definition of f(x)
 This form even supports recursion, but you must explicitly allow it.
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator = Keisan::Calculator.new(allow_recursive: false)
 calculator.evaluate("my_fact(n) = if (n > 1, n*my_fact(n-1), 1)")
 #=> Keisan::Exceptions::InvalidExpression: Unbound function definitions are not allowed by current context
@@ -136,6 +178,7 @@ calculator.evaluate("my_fact(5)")
 Just like in Ruby, lists can be defined using square brackets, and indexed using square brackets
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("[2, 3, 5, 8]")
 #=> [2, 3, 5, 8]
 calculator.evaluate("[[1,2,3],[4,5,6],[7,8,9]][1][2]")
@@ -145,15 +188,55 @@ calculator.evaluate("[[1,2,3],[4,5,6],[7,8,9]][1][2]")
 They can also be concatenated using the `+` operator
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("[3, 5] + [x, x+1]", x: 10)
 #=> [3, 5, 10, 11]
 ```
 
+Keisan also supports the following useful list methods,
+
+```ruby
+calculator = Keisan::Calculator.new
+calculator.evaluate("[1,3,5].size")
+#=> 3
+calculator.evaluate("[1,3,5].max")
+#=> 5
+calculator.evaluate("[1,3,5].min")
+#=> 1
+calculator.evaluate("[1,3,5].reverse")
+#=> [5,3,1]
+calculator.evaluate("[[1,2],[3,4]].flatten")
+#=> [1,2,3,4]
+calculator.evaluate("range(5)")
+#=> [0,1,2,3,4]
+calculator.evaluate("range(5,10)")
+#=> [5,6,7,8,9]
+calculator.evaluate("range(0,10,2)")
+#=> [0,2,4,6,8]
+```
+
+Keisan also supports the basic functional programming operators `map` (or `collect`), `filter` (or `select`), and `reduce` (or `inject`).
+
+```ruby
+calculator = Keisan::Calculator.new
+calculator.evaluate("map([1,3,5], x, 2*x)")
+#=> [2,6,10]
+calculator.simplify("[1,3,5].map(x, y*x**2)").to_s
+#=> "[y,9*y,25*y]"
+calculator.evaluate("select([1,2,3,4], x, x % 2 == 0)")
+#=> [2,4]
+calculator.evaluate("[-2,-1,0,1,2].filter(x, x > 0)")
+#=> [1,2]
+calculator.evaluate("[1,2,3,4,5].inject(1, total, x, total*x)")
+#=> 120
+```
+
 ##### Logical operations
 
 `keisan` understands basic boolean logic operators, like `<`, `<=`, `>`, `>=`, `&&`, `||`, `!`, so calculations like the following are possible
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("1 > 0")
 #=> true
 calculator.evaluate("!!!true")
@@ -165,6 +248,7 @@ calculator.evaluate("x >= 0 && x < 10", x: 5)
 There is also a useful ternary `if` function defined
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("2 + if(1 > 0, 10, 29)")
 #=> 12
 ```
@@ -174,6 +258,7 @@ calculator.evaluate("2 + if(1 > 0, 10, 29)")
 The basic bitwise operations, NOT `~`, OR `|`, XOR `^`, and AND `&` are also available for use
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("2 + 12 & 7")
 #=> 6
 ```
@@ -183,6 +268,7 @@ calculator.evaluate("2 + 12 & 7")
 `keisan` also can parse in strings, and access the characters by index
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("'hello'[1]")
 #=> "e"
 ```
@@ -192,6 +278,7 @@ calculator.evaluate("'hello'[1]")
 Using the prefixes `0b`, `0o`, and `0x` (standard in Ruby) indicates binary, octal, and hexadecimal numbers respectively.
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("0b1100")
 #=> 12
 calculator.evaluate("0o775")
@@ -205,10 +292,11 @@ calculator.evaluate("0x1f0")
 `keisan` has a couple methods for doing random operations, `rand` and `sample`.  For example,
 
 ```ruby
-calculator.evaluate("rand(10)")
-#=> 3
-calculator.evaluate("sample([2, 4, 6, 8])")
-#=> 8
+calculator = Keisan::Calculator.new
+(0...10).include? calculator.evaluate("rand(10)")
+#=> true
+[2,4,6,8].include? calculator.evaluate("sample([2, 4, 6, 8])")
+#=> true
 ```
 
 If you want reproducibility, you can pass in your own `Random` object to the calculator's context.
@@ -227,6 +315,7 @@ calculator2 = Keisan::Calculator.new(context: Keisan::Context.new(random: Random
 `keisan` includes all standard methods given by the Ruby `Math` class.
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("log10(1000)")
 #=> 3.0
 ```
@@ -234,6 +323,7 @@ calculator.evaluate("log10(1000)")
 Furthermore, the following builtin constants are defined
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("PI")
 #=> 3.141592653589793
 calculator.evaluate("E")
@@ -245,13 +335,15 @@ calculator.evaluate("I")
 This allows for simple calculations like
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("E**(I*PI)+1")
-=> (0.0+0.0i)
+#=> (0.0+0.0i)
 ```
 
 There is a `replace` method that can replace instances of a variable in an expression with another expression.  The form is `replace(original_expression, variable_to_replace, replacement_expression)`.  Before the replacement is carried out, the `original_expression` and `replacement_expression` are `evaluate`d, then instances in the original expression of the given variable are replaced by the replacement expression.
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.evaluate("replace(x**2, x, 3)")
 #=> 9
 ```
@@ -269,17 +361,29 @@ The derivative operation is also builtin to Keisan as the `diff` function.
 ```ruby
 calculator = Keisan::Calculator.new
 calculator.evaluate("diff(4*x, x)")
+#=> 4
 calculator.evaluate("replace(diff(4*x**2, x), x, 3)")
 #=> 24
 ```
 
+This also works intelligently with user defined functions.
+
+```ruby
+calculator = Keisan::Calculator.new
+calculator.evaluate("f(x, y) = x**2 + y")
+calculator.simplify("diff(f(2*t, t+1), t)").to_s
+#=> "1+(8*t)"
+calculator.evaluate("replace(diff(f(2*t, t+1), t), t, 3)")
+#=> 1+8*3
+```
+
 ### Adding custom variables and functions
 
 The `Keisan::Calculator` class has a single `Keisan::Context` object in its `context` attribute.  This class is used to store local variables and functions.  These can be stored using either the `define_variable!` or `define_function!` methods, or by using the assignment operator `=` in an expression that is evaluated.  As an example of pre-defining some variables and functions, see the following
 
 ```ruby
+calculator = Keisan::Calculator.new
 calculator.define_variable!("x", 5)
-#=> 5
 calculator.evaluate("x + 1")
 #=> 6
 calculator.evaluate("x + 1", x: 10)

data/bin/keisan

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "keisan"
+require "keisan/repl"
+
+Keisan::Repl.new.start

data/lib/keisan.rb

@@ -58,7 +58,6 @@ require "keisan/functions/default_registry"
 require "keisan/variables/registry"
 require "keisan/variables/default_registry"
 require "keisan/context"
-require "keisan/function_definition_context"
 
 require "keisan/token"
 require "keisan/tokens/comma"

data/lib/keisan/ast.rb

@@ -10,36 +10,60 @@ module KeisanNumeric
   def to_node
     Keisan::AST::Number.new(self)
   end
+
+  def value(context = nil)
+    self
+  end
 end
 
 module KeisanString
   def to_node
     Keisan::AST::String.new(self)
   end
+
+  def value(context = nil)
+    self
+  end
 end
 
 module KeisanTrueClass
   def to_node
     Keisan::AST::Boolean.new(true)
   end
+
+  def value(context = nil)
+    self
+  end
 end
 
 module KeisanFalseClass
   def to_node
     Keisan::AST::Boolean.new(false)
   end
+
+  def value(context = nil)
+    self
+  end
 end
 
 module KeisanNilClass
   def to_node
     Keisan::AST::Null.new
   end
+
+  def value(context = nil)
+    self
+  end
 end
 
 module KeisanArray
   def to_node
     Keisan::AST::List.new(map {|n| n.to_node})
   end
+
+  def value(context = nil)
+    self
+  end
 end
 
 class Numeric; prepend KeisanNumeric; end

data/lib/keisan/ast/assignment.rb

@@ -11,16 +11,45 @@ module Keisan
         lhs = children.first
         rhs = children.last
 
-        case lhs
-        when Keisan::AST::Variable
+        if is_variable_definition?
           evaluate_variable(context, lhs, rhs)
-        when Keisan::AST::Function
+        elsif is_function_definition?
           evaluate_function(context, lhs, rhs)
         else
           raise Keisan::Exceptions::InvalidExpression.new("Unhandled left hand side #{lhs} in assignment")
         end
       end
 
+      def simplify(context = nil)
+        evaluate(context)
+      end
+
+      def unbound_variables(context = nil)
+        variables = super(context)
+        if is_variable_definition?
+          variables.delete(children.first.name)
+        else
+          variables
+        end
+      end
+
+      def unbound_functions(context = nil)
+        functions = super(context)
+        if is_function_definition?
+          functions.delete(children.first.name)
+        else
+          functions
+        end
+      end
+
+      def is_variable_definition?
+        children.first.is_a?(Keisan::AST::Variable)
+      end
+
+      def is_function_definition?
+        children.first.is_a?(Keisan::AST::Function)
+      end
+
       private
 
       def evaluate_variable(context, lhs, rhs)
@@ -32,6 +61,7 @@ module Keisan
 
         rhs_value = rhs.value(context)
         context.register_variable!(lhs.name, rhs_value)
+        # Return the variable assigned value
         rhs
       end
 
@@ -41,11 +71,7 @@ module Keisan
         end
 
         argument_names = lhs.children.map(&:name)
-        function_definition_context = Keisan::FunctionDefinitionContext.new(
-          parent: context,
-          arguments: argument_names
-        )
-        rhs = rhs.evaluate(function_definition_context)
+        function_definition_context = context.spawn_child(shadowed: argument_names, transient: true)
 
         unless rhs.unbound_variables(context) <= Set.new(argument_names)
           raise Keisan::Exceptions::InvalidExpression.new("Unbound variables found in function definition")
@@ -60,8 +86,8 @@ module Keisan
           Keisan::Functions::ExpressionFunction.new(
             lhs.name,
             argument_names,
-            rhs,
-            function_definition_context
+            rhs.simplify(function_definition_context),
+            context.transient_definitions
           )
         )