keisan 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5118e044fef1a400782707bed4cff70265f601ed
-  data.tar.gz: 54db3071552f280ed42f2b86e714ebb1b8a356da
+  metadata.gz: cdf00ba25b7bc64cde85408ef0f56ad56bece933
+  data.tar.gz: ebccd470d71300d5968b2efaf38cd7dccd39b675
 SHA512:
-  metadata.gz: 1219fa0069d41b5b5295320d82ebb5ec82a9c11c01b94eae5adfafa932cc603db4185fcd47676bb36b45716a276436b8a71ec8aa175d0de2b2058f2b816440eb
-  data.tar.gz: aad7604a738e66b385c40dd3cf78a6d2a8c28ebeb8c35e206f35d81d5ae8aed3d8256de70dfd34ff47161d53ef671f1380631588adb20c65086739953d34d8d2
+  metadata.gz: 64889b4e5947a90b46ad1a404b8ee4401cc0ac34d7ef18ca26f150f44208dd61a130cc5c2fed6dcba3c5ffa9ce4ff36b26721e5c64516feb146d15afe8ebaf93
+  data.tar.gz: 114a84f7120b53c028d7f0fa5226aa01e034e593c911713bd5a394feef3ff436b52045c753a1c1dd796652f2cf9680b7c1d8a4dc6fa44fe5c53e2caedcd1775a

data/.gitignore

@@ -7,6 +7,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+/keisan-*.gem
 
 # rspec failure tracking
 .rspec_status

data/README.md

@@ -1,7 +1,8 @@
 # Keisan
 
+[![Gem Version](https://badge.fury.io/rb/keisan.svg)](https://badge.fury.io/rb/keisan)
 [![Build Status](https://travis-ci.org/project-eutopia/keisan.png?branch=master)](https://travis-ci.org/project-eutopia/keisan)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 [![Hakiri](https://hakiri.io/github/project-eutopia/keisan/master.svg)](https://hakiri.io/github/project-eutopia/keisan)
 
 Keisan ([計算, to calculate](https://en.wiktionary.org/wiki/%E8%A8%88%E7%AE%97#Japanese)) is a Ruby library for parsing equations into an abstract syntax tree.  This allows for safe evaluation of string representations of mathematical/logical expressions.
@@ -122,6 +123,41 @@ calculator.evaluate("'hello'[1]")
 #=> "e"
 ```
 
+##### Binary, octal, and hexadecimal numbers
+
+Using the prefixes `0b`, `0o`, and `0x` (standard in Ruby) indicates binary, octal, and hexadecimal numbers respectively.
+
+```ruby
+calculator.evaluate("0b1100")
+#=> 12
+calculator.evaluate("0o775")
+#=> 504
+calculator.evaluate("0x1f0")
+#=> 496
+```
+
+##### Random numbers
+
+`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
+```
+
+If you want reproducibility, you can pass in your own `Random` object to the calculator's context.
+
+```ruby
+calculator1 = Keisan::Calculator.new(Keisan::Context.new(random: Random.new(1234)))
+calculator2 = Keisan::Calculator.new(Keisan::Context.new(random: Random.new(1234)))
+5.times.map {calculator1.evaluate("rand(1000)")}
+#=> [815, 723, 294, 53, 204]
+5.times.map {calculator2.evaluate("rand(1000)")}
+#=> [815, 723, 294, 53, 204]
+```
+
 ##### Builtin variables and functions
 
 `keisan` includes all standard methods given by the Ruby `Math` class.

data/lib/keisan.rb

@@ -1,4 +1,3 @@
-require "cmath"
 require "active_support"
 require "active_support/core_ext"
 

data/lib/keisan/ast/builder.rb

@@ -3,32 +3,22 @@ module Keisan
     class Builder
       # Build from parser
       def initialize(string: nil, parser: nil, components: nil)
-        if string.nil? && parser.nil? && components.nil?
-          raise Keisan::Exceptions::InternalError.new("Require parser or components")
+        if [string, parser, components].select(&:nil?).size != 2
+          raise Keisan::Exceptions::InternalError.new("Require one of string, parser or components")
         end
 
-        if string.present?
+        if !string.nil?
           @components = Keisan::Parser.new(string: string).components
-        elsif parser.present?
+        elsif !parser.nil?
           @components = parser.components
         else
           @components = Array.wrap(components)
         end
 
-        @nodes = @components.split {|component|
-          component.is_a?(Keisan::Parsing::Operator)
-        }.map {|group_of_components|
-          node_from_components(group_of_components)
-        }
+        @nodes = nodes_split_by_operators(@components)
         @operators = @components.select {|component| component.is_a?(Keisan::Parsing::Operator)}
 
-        @priorities = @operators.map(&:priority)
-
-        while @operators.count > 0
-          priorities = @operators.map(&:priority)
-          max_priority = priorities.uniq.max
-          consume_operators_with_priority!(max_priority)
-        end
+        consume_operators!
 
         unless @nodes.count == 1
           raise Keisan::Exceptions::ASTError.new("Should end up with a single node")
@@ -45,7 +35,41 @@ module Keisan
 
       private
 
+      def nodes_split_by_operators(components)
+        components.split {|component|
+          component.is_a?(Keisan::Parsing::Operator)
+        }.map {|group_of_components|
+          node_from_components(group_of_components)
+        }
+      end
+
       def node_from_components(components)
+        unary_components, node, indexing_components = *unarys_node_indexings(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
+            }
+          )
+        end
+
+        # Apply prefix unary operators
+        unary_components.reverse.each do |unary_component|
+          node = unary_component.node_class.new(node)
+        end
+
+        node
+      end
+
+      # Returns an array of the form
+      # [unary_operators, middle_node, postfix_indexings]
+      # 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)
         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}
@@ -64,25 +88,11 @@ module Keisan
           raise Keisan::Exceptions::ASTError.new("have too many components")
         end
 
-        unary_components = index_of_unary_components.map {|i| components[i]}
-        indexing_components = index_of_indexing_components.map {|i| components[i]}
-
-        node = node_of_component(components[unary_components.size])
-
-        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
-            }
-          )
-        end
-
-        unary_components.reverse.each do |unary_component|
-          node = unary_component.node_class.new(node)
-        end
-
-        node
+        [
+          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]}
+        ]
       end
 
       def node_of_component(component)
@@ -117,10 +127,20 @@ module Keisan
         end
       end
 
+      def consume_operators!
+        while @operators.count > 0
+          priorities = @operators.map(&:priority)
+          max_priority = priorities.uniq.max
+          consume_operators_with_priority!(max_priority)
+        end
+      end
+
       def consume_operators_with_priority!(priority)
         # Treat back-to-back operators with same priority as one single call (e.g. 1 + 2 + 3 is add(1,2,3))
         while @operators.any? {|operator| operator.priority == priority}
-          next_operator_group = @operators.each.with_index.to_a.split {|operator,i| operator.priority != priority}.select(&:present?).first
+          next_operator_group = @operators.each.with_index.to_a.split {|operator,i|
+            operator.priority != priority
+          }.select {|ops| !ops.empty?}.first
           operator_group_indexes = next_operator_group.map(&:last)
 
           first_index = operator_group_indexes.first

data/lib/keisan/calculator.rb

@@ -7,16 +7,18 @@ module Keisan
     end
 
     def evaluate(expression, definitions = {})
-      local_context = context.spawn_child
-      definitions.each do |name, value|
-        case value
-        when Proc
-          local_context.register_function!(name, value)
-        else
-          local_context.register_variable!(name, value)
+      context.spawn_child do |local|
+        definitions.each do |name, value|
+          case value
+          when Proc
+            local.register_function!(name, value)
+          else
+            local.register_variable!(name, value)
+          end
         end
+
+        Keisan::AST::Builder.new(string: expression).ast.value(local)
       end
-      Keisan::AST::Builder.new(string: expression).ast.value(local_context)
     end
 
     def define_variable!(name, value)

data/lib/keisan/context.rb

@@ -10,7 +10,11 @@ module Keisan
     end
 
     def spawn_child
-      self.class.new(parent: self)
+      if block_given?
+        yield self.class.new(parent: self)
+      else
+        self.class.new(parent: self)
+      end
     end
 
     def function(name)

data/lib/keisan/functions/default_registry.rb

@@ -28,15 +28,6 @@ module Keisan
             end
           )
         end
-
-        %i(exp sin cos).each do |method|
-          registry.register!(
-            :"c#{method}",
-            Proc.new do |z|
-              CMath.send(method, z)
-            end
-          )
-        end
       end
 
       def self.register_branch_methods!(registry)

data/lib/keisan/functions/registry.rb

@@ -13,7 +13,7 @@ module Keisan
 
       def [](name)
         return @hash[name] if @hash.has_key?(name)
-        return @parent[name] if @parent.present? && @parent.has_name?(name)
+        return @parent[name] if !@parent.nil? && @parent.has_name?(name)
         return default_registry[name] if @use_defaults && default_registry.has_name?(name)
         raise Keisan::Exceptions::UndefinedFunctionError.new name
       end

data/lib/keisan/parser.rb

@@ -7,7 +7,7 @@ module Keisan
         raise Keisan::Exceptions::InternalError.new("Invalid arguments")
       end
 
-      if string.present?
+      if !string.nil?
         @tokens = Tokenizer.new(string).tokens
       else
         raise Keisan::Exceptions::InternalError.new("Invalid argument: tokens = #{tokens}") if tokens.nil? || !tokens.is_a?(Array)
@@ -67,8 +67,10 @@ module Keisan
         end
 
       elsif @components[-1].is_a?(Parsing::Element)
+        # A word followed by a "round group" is actually a function: e.g. sin(x)
         if @components[-1].is_a?(Parsing::Variable) && token.type == :group && token.group_type == :round
           add_function_to_components!(token)
+        # Here it is a postfix Indexing (access elements by index)
         elsif token.type == :group && token.group_type == :square
           add_indexing_to_components!(token)
         else
@@ -78,7 +80,7 @@ module Keisan
         end
 
       else
-        raise Keisan::Exceptions::InternalError.new("Invalid parsing!")
+        raise Keisan::Exceptions::ParseError.new("Token cannot be parsed, #{token.string}")
       end
     end
 

data/lib/keisan/tokenizer.rb

@@ -20,13 +20,26 @@ module Keisan
     attr_reader :expression, :tokens
 
     def initialize(expression)
-      @expression = expression.split(Keisan::Tokens::String.regex).map.with_index {|s,i| i.even? ? s.gsub(/\s+/, "") : s}.join
-
+      @expression = self.class.strip_whitespace(expression)
       @scan = @expression.scan(TOKEN_REGEX)
+      @tokens = tokenize!
+    end
 
+    def self.strip_whitespace(expression)
+      # Do not allow whitespace between variables, numbers, and the like; they must be joined by operators
+      raise Keisan::Exceptions::TokenizingError.new if expression.gsub(Tokens::String.regex, "").match /\w\s+\w/
+
+      # Only strip whitespace outside of strings, e.g.
+      # "1 + 2 + 'hello world'" => "1+2+'hello world'"
+      expression.split(Keisan::Tokens::String.regex).map.with_index {|s,i| i.even? ? s.gsub(/\s+/, "") : s}.join
+    end
+
+    private
+
+    def tokenize!
       tokenizing_check = ""
 
-      @tokens = @scan.map do |scan_result|
+      tokens = @scan.map do |scan_result|
         i = scan_result.find_index {|token| !token.nil?}
         token_string = scan_result[i]
         tokenizing_check << token_string
@@ -36,6 +49,8 @@ module Keisan
       unless tokenizing_check == @expression
         raise Keisan::Exceptions::TokenizingError.new("Expected \"#{@expression}\", tokenized \"#{tokenizing_check}\"")
       end
+
+      tokens
     end
   end
 end

data/lib/keisan/tokens/number.rb

@@ -2,10 +2,13 @@ module Keisan
   module Tokens
     class Number < Token
       INTEGER_REGEX = /\d+/
+      BINARY_REGEX = /0b[0-1]+/
+      OCTAL_REGEX = /0o[0-7]+/
+      HEX_REGEX = /0x[0-9a-fA-F]+/
       FLOATING_POINT_REGEX = /\d+\.\d+/
-      SCIENTIFC_NOTATION_REGEX = /\d+(?:\.\d+)e(?:\+|\-)?\d+/
+      SCIENTIFIC_NOTATION_REGEX = /\d+(?:\.\d+)?e(?:\+|\-)?\d+/
 
-      REGEX = /(\d+(?:\.\d+)?(?:e(?:\+|\-)?\d+)?)/
+      REGEX = /(#{BINARY_REGEX}|#{OCTAL_REGEX}|#{HEX_REGEX}|\d+(?:\.\d+)?(?:e(?:\+|\-)?\d+)?)/
 
       def self.regex
         REGEX
@@ -13,9 +16,9 @@ module Keisan
 
       def value
         case string
-        when SCIENTIFC_NOTATION_REGEX, FLOATING_POINT_REGEX
+        when /\A#{SCIENTIFIC_NOTATION_REGEX}\z/.freeze, /\A#{FLOATING_POINT_REGEX}\z/.freeze
           Float(string)
-        when INTEGER_REGEX
+        else
           Integer(string)
         end
       end

data/lib/keisan/tokens/word.rb

@@ -1,7 +1,7 @@
 module Keisan
   module Tokens
     class Word < Token
-      REGEX = /([a-zA-Z0-9_]*[a-zA-Z][a-zA-Z0-9_]*)/
+      REGEX = /([a-zA-Z_]\w*)/
 
       def self.regex
         REGEX

data/lib/keisan/variables/registry.rb

@@ -13,7 +13,7 @@ module Keisan
 
       def [](name)
         return @hash[name] if @hash.has_key?(name)
-        return @parent[name] if @parent.present? && @parent.has_name?(name)
+        return @parent[name] if !@parent.nil? && @parent.has_name?(name)
         return default_registry[name] if @use_defaults && default_registry.has_name?(name)
         raise Keisan::Exceptions::UndefinedVariableError.new name
       end

data/lib/keisan/version.rb

@@ -1,3 +1,3 @@
 module Keisan
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: keisan
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Christopher Locke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-24 00:00:00.000000000 Z
+date: 2017-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport