keisan 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2d556d5ef3e67015596fee5856e2fe0b27295b227f7d4edf8cb41c037aed98b
-  data.tar.gz: c8c20ac6ba6a9ad27654931238a2dbafcbbbc509b58fd2a74161b7a38b3edaab
+  metadata.gz: 25f0cd7f7a5bd124a62c244a270bb4db0632fc0ce295d7f55fa25409eae66473
+  data.tar.gz: 5cdeae27276969608966b56891abe91fe8b2bddaef9f7ef3fdeb6a3fe6696176
 SHA512:
-  metadata.gz: 9ccc5172adc0b5ebafabe3cd5846fb455ada6e1351c94deab4da5bfd38617c0e0692258e9384d760d25b88a899b46de1899b1688850bfac8ddcdd432091ddf50
-  data.tar.gz: cb2ca195319a744f3ee9b56ef7df14d8dfcf36dbcafcbe1e675a858f232457d39cb3fe96d7f056a26746630d4a7f1c47a8fe6fc75a880683cd2120428a448ff6
+  metadata.gz: 32d761e97663ad54bc37d2e3894875068daa8567ae521dd877879a94f66417c752cc338eba7f1a06bbe23f2a1455fce7751690323fcf4948f243d8254c69f1b4
+  data.tar.gz: 6c62bfc43752fe4918022e0217227c4a31d1fae6225bf70d65bc61afb025dbef5af74597055b1216a4ef9d261252e2f2d9ac26467319e33c4c842a2764711053

data/.travis.yml

@@ -1,7 +1,9 @@
 sudo: false
 language: ruby
+before_install:
+  - gem install bundler
 rvm:
-  - 2.3.6
-  - 2.4.3
-  - 2.5.0
-before_install: gem install bundler -v 1.16.1
+  - 2.4.9
+  - 2.5.7
+  - 2.6.5
+  - 2.7.0

data/README.md

@@ -340,7 +340,7 @@ calculator.evaluate("[2, 3, 7, 11].has_element(11)")
 
 ##### Bitwise operations
 
-The basic bitwise operations, NOT `~`, OR `|`, XOR `^`, and AND `&` are also available for use
+The basic bitwise operations, NOT `~`, OR `|`, XOR `^`, AND `&`, and left/right bitwise shifts (`<<` and `>>`) are also available for use
 
 ```ruby
 calculator = Keisan::Calculator.new
@@ -485,6 +485,7 @@ calculator.evaluate("puts x**2") # prints "25\n" to STDOUT
 
 #### Bitwise operators
 - `&`, `|`, `^`: bitwise **and**, **or**, **xor** operators
+- `<<`, `>>` bitwise shift operators
 - `~`: unary bitwise not
 
 #### Indexing of arrays/hashes

data/keisan.gemspec

@@ -21,10 +21,12 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = ">= 2.3.0"
 
-  spec.add_development_dependency "coveralls"
-  spec.add_development_dependency "bundler", "~> 1.14"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency "cmath", "~> 1.0"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-stack_explorer"
+  spec.add_development_dependency "simplecov"
 end

data/lib/keisan.rb

@@ -37,6 +37,8 @@ require "keisan/ast/bitwise_operator"
 require "keisan/ast/bitwise_and"
 require "keisan/ast/bitwise_or"
 require "keisan/ast/bitwise_xor"
+require "keisan/ast/bitwise_left_shift"
+require "keisan/ast/bitwise_right_shift"
 require "keisan/ast/logical_operator"
 require "keisan/ast/logical_and"
 require "keisan/ast/logical_or"
@@ -78,10 +80,12 @@ require "keisan/tokens/assignment"
 require "keisan/tokens/arithmetic_operator"
 require "keisan/tokens/logical_operator"
 require "keisan/tokens/bitwise_operator"
+require "keisan/tokens/bitwise_shift"
 require "keisan/tokens/word"
 require "keisan/tokens/line_separator"
 require "keisan/tokens/unknown"
 
+require "keisan/string_and_group_parser"
 require "keisan/tokenizer"
 
 require "keisan/parsing/component"
@@ -128,6 +132,8 @@ require "keisan/parsing/bitwise_or"
 require "keisan/parsing/bitwise_xor"
 require "keisan/parsing/bitwise_not"
 require "keisan/parsing/bitwise_not_not"
+require "keisan/parsing/bitwise_left_shift"
+require "keisan/parsing/bitwise_right_shift"
 require "keisan/parsing/logical_operator"
 require "keisan/parsing/logical_less_than"
 require "keisan/parsing/logical_greater_than"

data/lib/keisan/ast/bitwise_left_shift.rb

@@ -0,0 +1,17 @@
+module Keisan
+  module AST
+    class BitwiseLeftShift < BitwiseOperator
+      def self.symbol
+        :<<
+      end
+
+      def blank_value
+        0
+      end
+
+      def evaluate(context = nil)
+        children[1..-1].inject(children.first.evaluate(context)) {|total, child| total << child.evaluate(context)}
+      end
+    end
+  end
+end

data/lib/keisan/ast/bitwise_right_shift.rb

@@ -0,0 +1,17 @@
+module Keisan
+  module AST
+    class BitwiseRightShift < BitwiseOperator
+      def self.symbol
+        :>>
+      end
+
+      def blank_value
+        0
+      end
+
+      def evaluate(context = nil)
+        children[1..-1].inject(children.first.evaluate(context)) {|total, child| total >> child.evaluate(context)}
+      end
+    end
+  end
+end

data/lib/keisan/ast/node.rb

@@ -45,10 +45,18 @@ module Keisan
         raise Exceptions::NonDifferentiableError.new
       end
 
+      def differentiated(variable, context = nil)
+        deep_dup.differentiate(variable, context)
+      end
+
       def replace(variable, replacement)
         self
       end
 
+      def replaced(variable, replacement)
+        deep_dup.replace(variable, replacement)
+      end
+
       def coerce(other)
         [other.to_node, self]
       end
@@ -132,6 +140,14 @@ module Keisan
         BitwiseOr.new([self, other.to_node])
       end
 
+      def <<(other)
+        BitwiseLeftShift.new([self, other.to_node])
+      end
+
+      def >>(other)
+        BitwiseRightShift.new([self, other.to_node])
+      end
+
       def >(other)
         LogicalGreaterThan.new([self, other.to_node])
       end

data/lib/keisan/ast/number.rb

@@ -111,6 +111,26 @@ module Keisan
         end
       end
 
+      def <<(other)
+        other = other.to_node
+        case other
+        when Number
+          Number.new(value << other.value)
+        else
+          super
+        end
+      end
+
+      def >>(other)
+        other = other.to_node
+        case other
+        when Number
+          Number.new(value >> other.value)
+        else
+          super
+        end
+      end
+
       def >(other)
         other = other.to_node
         case other

data/lib/keisan/ast/operator.rb

@@ -13,6 +13,8 @@ module Keisan
         "%":  [2,  85, :left],   # Modulo
         "+":  [2,  80, :left],   # Plus
         # "-":  [2,  80, :left], # Minus
+        "<<": [2,  75, :left],   # Bitwise left shift
+        ">>": [2,  75, :left],   # Bitwise right shift
         "&":  [2,  70, :left],   # Bitwise and
         "^":  [2,  65, :left],   # Bitwise xor
         "|":  [2,  65, :left],   # Bitwise or

data/lib/keisan/ast/unary_inverse.rb

@@ -19,7 +19,7 @@ module Keisan
         @children = [child.simplify(context)]
         case child
         when Number
-          Number.new(Rational(1,child.value(context))).simplify(context)
+          Number.new(child.value**-1)
         else
           (child ** -1).simplify(context)
         end

data/lib/keisan/ast/variable.rb

@@ -13,7 +13,13 @@ module Keisan
 
       def value(context = nil)
         context ||= Context.new
-        variable_node_from_context(context).value(context)
+        node = variable_node_from_context(context)
+        case node
+        when Variable
+          node
+        else
+          node.value(context)
+        end
       end
 
       def unbound_variables(context = nil)
@@ -78,9 +84,7 @@ module Keisan
 
       def variable_node_from_context(context)
         variable = context.variable(name)
-        if variable.is_a?(Cell)
-          variable = variable.node
-        end
+        variable = variable.node if variable.is_a?(Cell)
         variable
       end
     end

data/lib/keisan/functions/cmath_function.rb

@@ -4,7 +4,9 @@ module Keisan
   module Functions
     class CMathFunction < MathFunction
       def initialize(name, proc_function = nil)
-        super(name, proc_function || Proc.new {|arg| CMath.send(name, arg)})
+        super(name, proc_function || Proc.new {|arg|
+          CMath.send(name, arg)
+        })
       end
     end
   end

data/lib/keisan/functions/expression_function.rb

@@ -5,7 +5,11 @@ module Keisan
 
       def initialize(name, arguments, expression, transient_definitions)
         super(name, arguments.count)
-        @expression = expression.deep_dup
+        if expression.is_a?(::String)
+          @expression = AST::parse(expression)
+        else
+          @expression = expression.deep_dup
+        end
         @arguments = arguments
         @transient_definitions = transient_definitions
       end
@@ -70,17 +74,20 @@ module Keisan
 
         local = local_context_for(context)
 
-        # expression.differentiate(variable, context)
-
-        argument_values = ast_function.children.map {|child| child.evaluate(local)}
+        argument_values = ast_function.children.map {|child| child.evaluated(local)}
 
         argument_derivatives = ast_function.children.map do |child|
-          child.differentiate(variable, context)
+          child.differentiated(variable, context)
         end
 
+        partial_derivatives = calculate_partial_derivatives(context)
+
         AST::Plus.new(
           argument_derivatives.map.with_index {|argument_derivative, i|
-            partial_derivative = partial_derivatives[i].replace(argument_variables[i], argument_values[i])
+            partial_derivative = partial_derivatives[i]
+            argument_variables.each.with_index {|argument_variable, j|
+              partial_derivative = partial_derivative.replaced(argument_variable, argument_values[j])
+            }
             AST::Times.new([argument_derivative, partial_derivative])
           }
         )
@@ -92,9 +99,9 @@ module Keisan
         @argument_variables ||= arguments.map {|argument| AST::Variable.new(argument)}
       end
 
-      def partial_derivatives
-        @partial_derivatives ||= argument_variables.map.with_index do |variable, i|
-          partial_derivative = expression.differentiate(variable)
+      def calculate_partial_derivatives(context)
+        argument_variables.map.with_index do |variable, i|
+          partial_derivative = expression.differentiated(variable, context)
         end
       end
 

data/lib/keisan/functions/proc_function.rb

@@ -28,7 +28,7 @@ module Keisan
 
         ast_function.instance_variable_set(
           :@children,
-          ast_function.children.map {|child| child.evaluate(context).to_node}
+          ast_function.children.map {|child| child.simplify(context).to_node}
         )
 
         if ast_function.children.all? {|child| child.well_defined?(context)}
@@ -44,7 +44,7 @@ module Keisan
 
         ast_function.instance_variable_set(
           :@children,
-          ast_function.children.map {|child| child.evaluate(context)}
+          ast_function.children.map {|child| child.simplify(context)}
         )
 
         if ast_function.children.all? {|child| child.is_a?(AST::ConstantLiteral)}

data/lib/keisan/functions/replace.rb

@@ -10,19 +10,19 @@ module Keisan
         evaluate(ast_function, context).value(context)
       end
 
-      def evaluate(ast_function, context = nil)
+      def simplify(ast_function, context = nil)
         context ||= Context.new
         expression, variable, replacement = expression_variable_replacement(ast_function)
 
-        expression = expression.evaluate(context)
-        replacement = replacement.evaluate(context)
+        expression = expression.simplify(context)
+        replacement = replacement.simplify(context)
 
-        expression.replace(variable, replacement).evaluate(context)
+        expression.replace(variable, replacement).simplify(context)
       end
 
-      def simplify(ast_function, context = nil)
+      def evaluate(ast_function, context = nil)
         context ||= Context.new
-        evaluate(ast_function, context).simplify(context)
+        simplify(ast_function, context).evaluate(context)
       end
 
       private

data/lib/keisan/parser.rb

@@ -241,6 +241,8 @@ module Keisan
       :"&"  => Parsing::BitwiseAnd,
       :"|"  => Parsing::BitwiseOr,
       :"^"  => Parsing::BitwiseXor,
+      :<<   => Parsing::BitwiseLeftShift,
+      :>>   => Parsing::BitwiseRightShift,
       :"==" => Parsing::LogicalEqual,
       :"!=" => Parsing::LogicalNotEqual,
       :"&&" => Parsing::LogicalAnd,

data/lib/keisan/parsing/bitwise_left_shift.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module Parsing
+    class BitwiseLeftShift < BitwiseOperator
+      def node_class
+        AST::BitwiseLeftShift
+      end
+    end
+  end
+end

data/lib/keisan/parsing/bitwise_right_shift.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module Parsing
+    class BitwiseRightShift < BitwiseOperator
+      def node_class
+        AST::BitwiseRightShift
+      end
+    end
+  end
+end

data/lib/keisan/string_and_group_parser.rb

@@ -0,0 +1,193 @@
+module Keisan
+  class StringAndGroupParser
+    class Portion
+      attr_reader :start_index, :end_index
+
+      def initialize(start_index)
+        @start_index = start_index
+      end
+    end
+
+    class StringPortion < Portion
+      attr_reader :string
+
+      def initialize(expression, start_index)
+        super(start_index)
+
+        @string = expression[start_index]
+        @end_index = start_index + 1
+
+        while @end_index < expression.size
+          if expression[@end_index] == quote_type
+            @string << quote_type
+            @end_index += 1
+            # Successfully parsed the string
+            return
+          end
+
+          n, c = process_next_character(expression, @end_index)
+          @string << c
+          @end_index += n
+        end
+
+        raise Keisan::Exceptions::TokenizingError.new("Tokenizing error, no closing quote #{quote_type}")
+      end
+
+      def size
+        string.size
+      end
+
+      def to_s
+        string
+      end
+
+      private
+
+      # Returns number of processed input characters, and the output character
+      def process_next_character(expression, index)
+        # escape character
+        if expression[index] == "\\"
+          return [2, escaped_character(expression[index + 1])]
+        else
+          return [1, expression[index]]
+        end
+      end
+
+      def quote_type
+        @string[0]
+      end
+
+      def escaped_character(character)
+        case character
+        when "\\", '"', "'"
+          character
+        when "a"
+          "\a"
+        when "b"
+          "\b"
+        when "r"
+          "\r"
+        when "n"
+          "\n"
+        when "s"
+          "\s"
+        when "t"
+          "\t"
+        else
+          raise Keisan::Exceptions::TokenizingError.new("Tokenizing error, unknown escape character: \"\\#{character}\"")
+        end
+      end
+    end
+
+    class GroupPortion < Portion
+      attr_reader :opening_brace, :closing_brace ,:portions, :size
+
+      OPENING_TO_CLOSING_BRACE = {
+        "(" => ")",
+        "{" => "}",
+        "[" => "]",
+      }
+
+      def initialize(expression, start_index)
+        super(start_index)
+
+        case expression[start_index]
+        when OPEN_GROUP_REGEX
+          @opening_brace = expression[start_index]
+        else
+          raise Keisan::Exceptions::TokenizingError.new("Internal error, GroupPortion did not start with brace")
+        end
+
+        @closing_brace = OPENING_TO_CLOSING_BRACE[opening_brace]
+
+        parser = StringAndGroupParser.new(expression, start_index: start_index + 1, ending_character: closing_brace)
+        @portions = parser.portions
+        @size = parser.size + 2
+
+        if start_index + size > expression.size || expression[start_index + size - 1] != closing_brace
+          raise Keisan::Exceptions::TokenizingError.new("Tokenizing error, group with opening brace #{opening_brace} did not have closing brace")
+        end
+      end
+
+      def to_s
+        opening_brace + portions.map(&:to_s).join + closing_brace
+      end
+    end
+
+    class OtherPortion < Portion
+      attr_reader :string
+
+      def initialize(expression, start_index)
+        super(start_index)
+
+        case expression[start_index]
+        when STRING_CHARACTER_REGEX, OPEN_GROUP_REGEX, CLOSED_GROUP_REGEX
+          raise Keisan::Exceptions::TokenizingError.new("Internal error, OtherPortion should not have string/braces at start")
+        else
+          index = start_index + 1
+        end
+
+        while index < expression.size
+          case expression[index]
+          when STRING_CHARACTER_REGEX, OPEN_GROUP_REGEX, CLOSED_GROUP_REGEX
+            break
+          else
+            index += 1
+          end
+        end
+
+        @end_index = index
+        @string = expression[start_index...end_index]
+      end
+
+      def size
+        string.size
+      end
+
+      def to_s
+        string
+      end
+    end
+
+    # An ordered array of "portions", which
+    attr_reader :portions, :size
+
+    STRING_CHARACTER_REGEX = /["']/
+    OPEN_GROUP_REGEX = /[\(\{\[]/
+    CLOSED_GROUP_REGEX = /[\)\}\]]/
+
+    # Ending character is used as a second ending condition besides expression size
+    def initialize(expression, start_index: 0, ending_character: nil)
+      index = start_index
+      @portions = []
+
+      while index < expression.size && (ending_character.nil? || expression[index] != ending_character)
+        case expression[index]
+        when STRING_CHARACTER_REGEX
+          portion = StringPortion.new(expression, index)
+          index = portion.end_index
+          @portions << portion
+
+        when OPEN_GROUP_REGEX
+          portion = GroupPortion.new(expression, index)
+          index += portion.size
+          @portions << portion
+
+        when CLOSED_GROUP_REGEX
+          raise Keisan::Exceptions::TokenizingError.new("Tokenizing error, unexpected closing brace #{expression[start_index]}")
+
+        else
+          portion = OtherPortion.new(expression, index)
+          index += portion.size
+          @portions << portion
+        end
+      end
+
+      @size = index - start_index
+    end
+
+    def to_s
+      portions.map(&:to_s).join
+    end
+  end
+end

data/lib/keisan/tokenizer.rb

@@ -1,13 +1,12 @@
 module Keisan
   class Tokenizer
     TOKEN_CLASSES = [
-      Tokens::Group,
-      Tokens::String,
       Tokens::Null,
       Tokens::Boolean,
       Tokens::Word,
       Tokens::Number,
       Tokens::Assignment,
+      Tokens::BitwiseShift,
       Tokens::LogicalOperator,
       Tokens::ArithmeticOperator,
       Tokens::BitwiseOperator,
@@ -26,8 +25,22 @@ module Keisan
 
     def initialize(expression)
       @expression = self.class.normalize_expression(expression)
-      @scan = @expression.scan(TOKEN_REGEX)
-      @tokens = tokenize!
+
+      portions = StringAndGroupParser.new(@expression).portions
+
+      @tokens = portions.inject([]) do |tokens, portion|
+        case portion
+        when StringAndGroupParser::StringPortion
+          tokens << Tokens::String.new(portion.to_s)
+        when StringAndGroupParser::GroupPortion
+          tokens << Tokens::Group.new(portion.to_s)
+        when StringAndGroupParser::OtherPortion
+          scan = portion.to_s.scan(TOKEN_REGEX)
+          tokens += tokenize!(scan)
+        end
+
+        tokens
+      end
     end
 
     def self.normalize_expression(expression)
@@ -45,8 +58,8 @@ module Keisan
       expression.gsub(/#[^;]*/, "")
     end
 
-    def tokenize!
-      @scan.map do |scan_result|
+    def tokenize!(scan)
+      scan.map do |scan_result|
         i = scan_result.find_index {|token| !token.nil?}
         token_string = scan_result[i]
         token = TOKEN_CLASSES[i].new(token_string)

data/lib/keisan/tokens/assignment.rb

@@ -13,7 +13,9 @@ module Keisan
          \% |
          \& |
          \| |
-         \^
+         \^ |
+         \<\< |
+         \>\>
         )?
         \=
         (?!\=) # negative lookahead to prevent matching ==

data/lib/keisan/tokens/bitwise_shift.rb

@@ -0,0 +1,23 @@
+module Keisan
+  module Tokens
+    class BitwiseShift < Operator
+      LEFT_SHIFT = /(?:<<)/
+      RIGHT_SHIFT = /(?:>>)/
+
+      REGEX = /(#{LEFT_SHIFT}|#{RIGHT_SHIFT})/
+
+      def self.regex
+        REGEX
+      end
+
+      def operator_type
+        case string
+        when LEFT_SHIFT
+          :<<
+        when RIGHT_SHIFT
+          :>>
+        end
+      end
+    end
+  end
+end

data/lib/keisan/tokens/group.rb

@@ -1,19 +1,13 @@
 module Keisan
   module Tokens
     class Group < Token
-      REGEX = /(\((?:[^\[\]\(\)\{\}]*+\g<1>*+)*+\)|\[(?:[^\[\]\(\)\{\}]*+\g<1>*+)*+\]|\{(?:[^\[\]\(\)\{\}]*+\g<1>*+)*+\})/
-
       attr_reader :sub_tokens
 
       def initialize(string)
-        super
+        @string = string
         @sub_tokens = Tokenizer.new(string[1...-1]).tokens
       end
 
-      def self.regex
-        REGEX
-      end
-
       # Either :round, :square
       def group_type
         case string[0]

data/lib/keisan/tokens/string.rb

@@ -1,10 +1,8 @@
 module Keisan
   module Tokens
     class String < Token
-      REGEX = /(\"[^\"]*\"|\'[^\']*\')/
-
-      def self.regex
-        REGEX
+      def initialize(string)
+        @string = string
       end
 
       def value

data/lib/keisan/version.rb

@@ -1,3 +1,3 @@
 module Keisan
-  VERSION = "0.8.0"
+  VERSION = "0.8.1"
 end

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: keisan
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Christopher Locke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-23 00:00:00.000000000 Z
+date: 2020-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: cmath
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '1.0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A library for parsing equations into an abstract syntax tree for evaluation
 email:
 - project.eutopia@gmail.com
@@ -117,8 +131,10 @@ files:
 - lib/keisan/ast/arithmetic_operator.rb
 - lib/keisan/ast/assignment.rb
 - lib/keisan/ast/bitwise_and.rb
+- lib/keisan/ast/bitwise_left_shift.rb
 - lib/keisan/ast/bitwise_operator.rb
 - lib/keisan/ast/bitwise_or.rb
+- lib/keisan/ast/bitwise_right_shift.rb
 - lib/keisan/ast/bitwise_xor.rb
 - lib/keisan/ast/block.rb
 - lib/keisan/ast/boolean.rb
@@ -219,10 +235,12 @@ files:
 - lib/keisan/parsing/arithmetic_operator.rb
 - lib/keisan/parsing/assignment.rb
 - lib/keisan/parsing/bitwise_and.rb
+- lib/keisan/parsing/bitwise_left_shift.rb
 - lib/keisan/parsing/bitwise_not.rb
 - lib/keisan/parsing/bitwise_not_not.rb
 - lib/keisan/parsing/bitwise_operator.rb
 - lib/keisan/parsing/bitwise_or.rb
+- lib/keisan/parsing/bitwise_right_shift.rb
 - lib/keisan/parsing/bitwise_xor.rb
 - lib/keisan/parsing/boolean.rb
 - lib/keisan/parsing/component.rb
@@ -266,11 +284,13 @@ files:
 - lib/keisan/parsing/unary_plus.rb
 - lib/keisan/parsing/variable.rb
 - lib/keisan/repl.rb
+- lib/keisan/string_and_group_parser.rb
 - lib/keisan/token.rb
 - lib/keisan/tokenizer.rb
 - lib/keisan/tokens/arithmetic_operator.rb
 - lib/keisan/tokens/assignment.rb
 - lib/keisan/tokens/bitwise_operator.rb
+- lib/keisan/tokens/bitwise_shift.rb
 - lib/keisan/tokens/boolean.rb
 - lib/keisan/tokens/colon.rb
 - lib/keisan/tokens/comma.rb
@@ -308,8 +328,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: An equation parser and evaluator