keisan 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 853e03daadbd41d992a803a03c49183858f8190c
-  data.tar.gz: '098542c4dbe94d7b95ae4b7e56c7a5d29116a3f5'
+  metadata.gz: ca29cf77de26f26d32436c705ad47f229e215c43
+  data.tar.gz: cedc1ffcca1d1a46fbca4cee21750f2398c84ee5
 SHA512:
-  metadata.gz: 55efb1ed9bf111ac270cc6d91810f9ecfed944b6b6fa630fc63908f826f26ae806b17eb9908c48266c41e3bbedfb67c1a21ca1315cbc04441523f007c846f93e
-  data.tar.gz: 5a6f72a02901a01ee2705bc3d12a8cc661cde9961375007bec235a40a78f402ca93b6a8417b26c04c826efb67137936b5da90c6a336d160398130f7ffa11e984
+  metadata.gz: fae0c6a0db729b392ea89440dc0b4dff033a9f0e7159f725ba7bcaa0b3e16861c1aebfec2d2cdcfc5cde719aee995caabfb7fafa865797732a8db6c4b184ced7
+  data.tar.gz: 02257ba4395e73e2950ff09eefa272cdd49e1299f4bcec5a558c73e3a87147a3e09b4cde59bc4fa1ab935d801d88e9282dc4cea97e53b497cb94155154c23fd8

data/README.md

@@ -51,6 +51,14 @@ calculator.evaluate("x + 1")
 #=> Keisan::Exceptions::UndefinedVariableError: x
 ```
 
+It is also possible to define variables in the string expression itself
+
+```ruby
+calculator.evaluate("x = 10*n", n: 2)
+calculator.evaluate("3*x + 1")
+#=> 61
+```
+
 ##### Specifying functions
 
 Just like variables, functions can be defined by passing a `Proc` object as follows
@@ -67,6 +75,57 @@ calculator.evaluate("f(2) + 1")
 #=> Keisan::Exceptions::UndefinedFunctionError: f
 ```
 
+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.evaluate("[1,3,5,7].size()")
+#=> 4
+calculator.evaluate("[1,3,5,7].size")
+#=> 4
+```
+
+It is even possible to do more complicated things like follows
+
+```ruby
+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]]
+calculator.evaluate("4.f[0]")
+#=> [3,5]
+calculator.evaluate("4.f[0].size")
+#=> 2
+calculator.evaluate("4.f[1]")
+#=> [2,4,6]
+calculator.evaluate("4.f[1].size")
+#=> 3
+```
+
+Like variables, it is also possible to define functions in the string expression itself.
+
+```ruby
+calculator.evaluate("f(x) = n*x", n: 10) # n is local to this definition only
+calculator.evaluate("f(3)")
+#=> 30
+calculator.evaluate("f(0-a)", a: 2)
+#=> -20
+calculator.evaluate("n") # n only exists in the definition of f(x)
+#=> Keisan::Exceptions::UndefinedVariableError: n
+```
+
+This form even supports recursion!
+
+```ruby
+calculator.evaluate("my_fact(n) = if (n > 1, n*my_fact(n-1), 1)")
+calculator.evaluate("my_fact(0)")
+#=> 1
+calculator.evaluate("my_fact(1)")
+#=> 1
+calculator.evaluate("my_fact(2)")
+#=> 2
+calculator.evaluate("my_fact(5)")
+#=> 120
+```
+
 ##### Lists
 
 Just like in Ruby, lists can be defined using square brackets, and indexed using square brackets
@@ -213,6 +272,39 @@ calculator.evaluate("f(2)")
 #=> 6
 ```
 
+## Supported elements/operators
+
+`keisan` supports the following operators and elements.
+
+#### Numbers, variables, functions, lists
+- `150`, `-5.67`, `6e-5`: regular numbers
+- `x`, `_myvar1`: variables
+- `(` and `)`: round brackets for grouping parts to evaluate first
+- `[0, 3, 6, 9]`: square brackets with comma separated values to denote lists
+- `f(x,y,z)`, `my_function(max([2.5, 5.5]))`, `[2,4,6,8].size`: functions using `(` `)` brackets (optional if using postfix notation and only takes a single argument)
+
+#### Arithmetic operators
+- `+`, `-`, `*`, `/`: regular arithmetic operators
+- `**`: Ruby style exponent notation (to avoid conflict with bitwise xor `^`)
+- `%`: Ruby modulo operator, sign of `a % b` is same as sign of `b`
+- `+`, `-`: Unary plus and minus
+
+#### Logical operators
+- `<`, `>`, `<=`, `>=`: comparison operators
+- `==` and `!=`: logical equality check operators
+- `&&` and `||`: logical operators, **and** and **or**
+- `!`: unary logical not
+
+#### Bitwise operators
+- `&`, `|`, `^`: bitwise **and**, **or**, **xor** operators
+- `~`: unary bitwise not
+
+#### Indexing of arrays
+- `list[i]`: for accessing elements in an array
+
+#### Assignment
+- `=`: can be used to define variables and functions
+
 ## Development
 
 After checking out the repository, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.  You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/keisan.rb

@@ -11,6 +11,7 @@ require "keisan/variables/registry"
 require "keisan/variables/default_registry"
 require "keisan/context"
 
+require "keisan/ast/priorities"
 require "keisan/ast/node"
 
 require "keisan/ast/literal"
@@ -33,6 +34,7 @@ require "keisan/ast/arithmetic_operator"
 require "keisan/ast/plus"
 require "keisan/ast/times"
 require "keisan/ast/exponent"
+require "keisan/ast/modulo"
 require "keisan/ast/function"
 require "keisan/ast/bitwise_operator"
 require "keisan/ast/bitwise_and"
@@ -41,6 +43,8 @@ require "keisan/ast/bitwise_xor"
 require "keisan/ast/logical_operator"
 require "keisan/ast/logical_and"
 require "keisan/ast/logical_or"
+require "keisan/ast/logical_equal"
+require "keisan/ast/logical_not_equal"
 require "keisan/ast/logical_less_than"
 require "keisan/ast/logical_greater_than"
 require "keisan/ast/logical_less_than_or_equal_to"
@@ -53,6 +57,7 @@ require "keisan/ast/builder"
 
 require "keisan/token"
 require "keisan/tokens/comma"
+require "keisan/tokens/dot"
 require "keisan/tokens/group"
 require "keisan/tokens/number"
 require "keisan/tokens/operator"
@@ -73,6 +78,9 @@ require "keisan/parsing/number"
 require "keisan/parsing/string"
 require "keisan/parsing/null"
 require "keisan/parsing/boolean"
+require "keisan/parsing/dot"
+require "keisan/parsing/dot_word"
+require "keisan/parsing/dot_operator"
 require "keisan/parsing/variable"
 require "keisan/parsing/function"
 require "keisan/parsing/group"
@@ -93,6 +101,7 @@ require "keisan/parsing/minus"
 require "keisan/parsing/times"
 require "keisan/parsing/divide"
 require "keisan/parsing/exponent"
+require "keisan/parsing/modulo"
 require "keisan/parsing/bitwise_operator"
 require "keisan/parsing/bitwise_and"
 require "keisan/parsing/bitwise_or"
@@ -106,12 +115,15 @@ require "keisan/parsing/logical_less_than_or_equal_to"
 require "keisan/parsing/logical_greater_than_or_equal_to"
 require "keisan/parsing/logical_and"
 require "keisan/parsing/logical_or"
+require "keisan/parsing/logical_equal"
+require "keisan/parsing/logical_not_equal"
 require "keisan/parsing/logical_not"
 require "keisan/parsing/logical_not_not"
 
 require "keisan/parser"
 
 require "keisan/calculator"
+require "keisan/evaluator"
 
 module Keisan
 end

data/lib/keisan/ast/bitwise_and.rb

@@ -1,15 +1,11 @@
 module Keisan
   module AST
     class BitwiseAnd < BitwiseOperator
-      def self.priority
-        31
-      end
-
       def arity
         2..Float::INFINITY
       end
 
-      def symbol
+      def self.symbol
         :"&"
       end
 

data/lib/keisan/ast/bitwise_or.rb

@@ -1,15 +1,11 @@
 module Keisan
   module AST
     class BitwiseOr < BitwiseOperator
-      def self.priority
-        11
-      end
-
       def arity
         2..Float::INFINITY
       end
 
-      def symbol
+      def self.symbol
         :"|"
       end
 

data/lib/keisan/ast/bitwise_xor.rb

@@ -1,15 +1,11 @@
 module Keisan
   module AST
     class BitwiseXor < BitwiseOperator
-      def self.priority
-        21
-      end
-
       def arity
         2..Float::INFINITY
       end
 
-      def symbol
+      def self.symbol
         :"^"
       end
 

data/lib/keisan/ast/builder.rb

@@ -44,16 +44,11 @@ module Keisan
       end
 
       def node_from_components(components)
-        unary_components, node, indexing_components = *unarys_node_indexings(components)
+        unary_components, node, postfix_components = *unarys_node_postfixes(components)
 
-        # Apply postfix indexing operators
-        indexing_components.each do |indexing_component|
-          node = indexing_component.node_class.new(
-            node,
-            indexing_component.arguments.map {|parsing_argument|
-              Builder.new(components: parsing_argument.components).node
-            }
-          )
+        # Apply postfix operators
+        postfix_components.each do |postfix_component|
+          node = apply_postfix_component_to_node(postfix_component, node)
         end
 
         # Apply prefix unary operators
@@ -64,34 +59,62 @@ module Keisan
         node
       end
 
+      def apply_postfix_component_to_node(postfix_component, node)
+        case postfix_component
+        when Keisan::Parsing::Indexing
+          postfix_component.node_class.new(
+            node,
+            postfix_component.arguments.map {|parsing_argument|
+              Builder.new(components: parsing_argument.components).node
+            }
+          )
+        when Keisan::Parsing::DotWord
+          Keisan::AST::Function.build(
+            postfix_component.name,
+            [node]
+          )
+        when Keisan::Parsing::DotOperator
+          Keisan::AST::Function.build(
+            postfix_component.name,
+            [node] + postfix_component.arguments.map {|parsing_argument|
+              Builder.new(components: parsing_argument.components).node
+            }
+          )
+        else
+          raise Keisan::Exceptions::ASTError.new("Invalid postfix component #{postfix_component}")
+        end
+      end
+
       # Returns an array of the form
-      # [unary_operators, middle_node, postfix_indexings]
+      # [unary_operators, middle_node, postfix_operators]
       # unary_operators is an array of Keisan::Parsing::UnaryOperator objects
       # middle_node is the main node which will be modified by prefix and postfix operators
-      # postfix_indexings is an array of Keisan::Parsing::Indexing objects
-      def unarys_node_indexings(components)
+      # postfix_operators is an array of Keisan::Parsing::Indexing, DotWord, and DotOperator objects
+      def unarys_node_postfixes(components)
         index_of_unary_components = components.map.with_index {|c,i| [c,i]}.select {|c,i| c.is_a?(Keisan::Parsing::UnaryOperator)}.map(&:last)
         # Must be all in the front
         unless index_of_unary_components.map.with_index.all? {|i,j| i == j}
           raise Keisan::Exceptions::ASTError.new("unary operators must be in front")
         end
 
-        index_of_indexing_components = components.map.with_index {|c,i| [c,i]}.select {|c,i| c.is_a?(Keisan::Parsing::Indexing)}.map(&:last)
-        unless index_of_indexing_components.reverse.map.with_index.all? {|i,j| i + j == components.size - 1 }
-          raise Keisan::Exceptions::ASTError.new("indexing components must be in back")
+        index_of_postfix_components = components.map.with_index {|c,i| [c,i]}.select {|c,i|
+          c.is_a?(Keisan::Parsing::Indexing) || c.is_a?(Keisan::Parsing::DotWord) || c.is_a?(Keisan::Parsing::DotOperator)
+        }.map(&:last)
+        unless index_of_postfix_components.reverse.map.with_index.all? {|i,j| i + j == components.size - 1 }
+          raise Keisan::Exceptions::ASTError.new("postfix components must be in back")
         end
 
-        num_unary    = index_of_unary_components.size
-        num_indexing = index_of_indexing_components.size
+        num_unary   = index_of_unary_components.size
+        num_postfix = index_of_postfix_components.size
 
-        unless num_unary + 1 + num_indexing == components.size
+        unless num_unary + 1 + num_postfix == components.size
           raise Keisan::Exceptions::ASTError.new("have too many components")
         end
 
         [
           index_of_unary_components.map {|i| components[i]},
           node_of_component(components[index_of_unary_components.size]),
-          index_of_indexing_components.map {|i| components[i]}
+          index_of_postfix_components.map {|i| components[i]}
         ]
       end
 
@@ -116,11 +139,23 @@ module Keisan
         when Keisan::Parsing::Group
           Builder.new(components: component.components).node
         when Keisan::Parsing::Function
-          Keisan::AST::Function.new(
+          Keisan::AST::Function.build(
+            component.name,
             component.arguments.map {|parsing_argument|
               Builder.new(components: parsing_argument.components).node
-            },
-            component.name
+            }
+          )
+        when Keisan::Parsing::DotWord
+          Keisan::AST::Function.build(
+            component.name,
+            [node_of_component(component.target)]
+          )
+        when Keisan::Parsing::DotOperator
+          Keisan::AST::Function.build(
+            component.name,
+            [node_of_component(component.target)] + component.arguments.map {|parsing_argument|
+              Builder.new(components: parsing_argument.components).node
+            }
           )
         else
           raise Keisan::Exceptions::ASTError.new("Unhandled component, #{component}")

data/lib/keisan/ast/exponent.rb

@@ -1,10 +1,6 @@
 module Keisan
   module AST
     class Exponent < ArithmeticOperator
-      def self.priority
-        30
-      end
-
       def arity
         (2..2)
       end
@@ -13,7 +9,7 @@ module Keisan
         :right
       end
 
-      def symbol
+      def self.symbol
         :**
       end
 

data/lib/keisan/ast/function.rb

@@ -11,9 +11,58 @@ module Keisan
       def value(context = nil)
         context = Keisan::Context.new if context.nil?
         argument_values = children.map {|child| child.value(context)}
-        function = context.function(name)
+        function = function_from_context(context)
         function.call(context, *argument_values)
       end
+
+      def unbound_functions(context = nil)
+        context ||= Keisan::Context.new
+
+        functions = children.inject(Set.new) do |res, child|
+          res | child.unbound_functions(context)
+        end
+
+        context.has_function?(name) ? functions : functions | Set.new([name])
+      end
+
+      def function_from_context(context)
+        @override || context.function(name)
+      end
+    end
+
+    class If < Function
+      def value(context = nil)
+        unless (2..3).cover? children.size
+          raise Keisan::Exceptions::InvalidFunctionError.new("Require 2 or 3 arguments to if")
+        end
+
+        bool = children[0].value(context)
+
+        if bool
+          children[1].value(context)
+        else
+          children.size == 3 ? children[2].value(context) : nil
+        end
+      end
+
+      def unbound_functions(context = nil)
+        context ||= Keisan::Context.new
+
+        children.inject(Set.new) do |res, child|
+          res | child.unbound_functions(context)
+        end
+      end
+    end
+
+    class Function
+      def self.build(name, arguments = [])
+        case name.downcase
+        when "if"
+          If.new(arguments, name)
+        else
+          Function.new(arguments, name)
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/logical_and.rb

@@ -1,15 +1,11 @@
 module Keisan
   module AST
     class LogicalAnd < LogicalOperator
-      def self.priority
-        22
-      end
-
       def arity
         2..Float::INFINITY
       end
 
-      def symbol
+      def self.symbol
         :"&"
       end