keisan 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5118e044fef1a400782707bed4cff70265f601ed
+  data.tar.gz: 54db3071552f280ed42f2b86e714ebb1b8a356da
+SHA512:
+  metadata.gz: 1219fa0069d41b5b5295320d82ebb5ec82a9c11c01b94eae5adfafa932cc603db4185fcd47676bb36b45716a276436b8a71ec8aa175d0de2b2058f2b816440eb
+  data.tar.gz: aad7604a738e66b385c40dd3cf78a6d2a8c28ebeb8c35e206f35d81d5ae8aed3d8256de70dfd34ff47161d53ef671f1380631588adb20c65086739953d34d8d2

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,6 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+  - 2.4.1
+before_install: gem install bundler -v 1.14.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in keisan.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2017 Christopher Barry Locke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,188 @@
+# 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)
+[![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.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'keisan'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install keisan
+
+## Usage
+
+### 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.
+
+```ruby
+calculator = Keisan::Calculator.new
+calculator.evaluate("15 + 2 * (1 + 3)")
+#=> 23
+```
+
+##### Specifying variables
+
+Passing in a hash of variable (`name`, `value`) pairs to the `evaluate` method defines variables
+
+```ruby
+calculator.evaluate("3*x + y**2", x: -2.5, y: 3)
+#=> 1.5
+```
+
+It will raise an error if an variable is not defined
+
+```ruby
+calculator.evaluate("x + 1")
+#=> Keisan::Exceptions::UndefinedVariableError: x
+```
+
+##### Specifying functions
+
+Just like variables, functions can be defined by passing a `Proc` object as follows
+
+```ruby
+calculator.evaluate("2*f(1+2) + 4", f: Proc.new {|x| x**2})
+#=> 22
+```
+
+It will raise an error if a function is not defined
+
+```ruby
+calculator.evaluate("f(2) + 1")
+#=> Keisan::Exceptions::UndefinedFunctionError: f
+```
+
+##### Lists
+
+Just like in Ruby, lists can be defined using square brackets, and indexed using square brackets
+
+```ruby
+calculator.evaluate("[2, 3, 5, 8]")
+#=> [2, 3, 5, 8]
+calculator.evaluate("[[1,2,3],[4,5,6],[7,8,9]][1][2]")
+#=> 6
+```
+
+They can also be concatenated using the `+` operator
+
+```ruby
+calculator.evaluate("[3, 5] + [x, x+1]", x: 10)
+#=> [3, 5, 10, 11]
+```
+
+##### Logical operations
+
+`keisan` understands basic boolean logic operators, like `<`, `<=`, `>`, `>=`, `&&`, `||`, `!`, so calculations like the following are possible
+
+```ruby
+calculator.evaluate("1 > 0")
+#=> true
+calculator.evaluate("!!!true")
+#=> false
+calculator.evaluate("x >= 0 && x < 10", x: 5)
+#=> true
+```
+
+There is also a useful ternary `if` function defined
+
+```ruby
+calculator.evaluate("2 + if(1 > 0, 10, 29)")
+#=> 12
+```
+
+##### Bitwise operations
+
+The basic bitwise operations, NOT `~`, OR `|`, XOR `^`, and AND `&` are also available for use
+
+```ruby
+calculator.evaluate("2 + 12 & 7")
+#=> 6
+```
+
+##### String
+
+`keisan` also can parse in strings, and access the characters by index
+
+```ruby
+calculator.evaluate("'hello'[1]")
+#=> "e"
+```
+
+##### Builtin variables and functions
+
+`keisan` includes all standard methods given by the Ruby `Math` class.
+
+```ruby
+calculator.evaluate("log10(1000)")
+#=> 3.0
+```
+
+Furthermore, the following builtin constants are defined
+
+```ruby
+calculator.evaluate("pi")
+#=> 3.141592653589793
+calculator.evaluate("e")
+#=> 2.718281828459045
+calculator.evaluate("i")
+#=> (0+1i)
+```
+
+This allows for simple calculations like
+
+```ruby
+calculator.evaluate("e**(i*pi)+1")
+=> (0.0+0.0i)
+```
+
+### 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.  As an example of pre-defining some variables and functions, see the following
+
+```ruby
+calculator.define_variable!("x", 5)
+#=> 5
+calculator.evaluate("x + 1")
+#=> 6
+calculator.evaluate("x + 1", x: 10)
+#=> 11
+calculator.evaluate("x + 1")
+#=> 6
+```
+
+Notice how when passing variable values directly to the `evaluate` method, it only shadows the value of 5 for that specific calculation.  The same thing works for functions
+
+```ruby
+calculator.define_function!("f", Proc.new {|x| 3*x})
+#=> #<Keisan::Function:0x005570f935ecc8 @function_proc=#<Proc:0x005570f935ecf0@(pry):6>, @name="f">
+calculator.evaluate("f(2)")
+#=> 6
+calculator.evaluate("f(2)", f: Proc.new {|x| 10*x})
+#=> 20
+calculator.evaluate("f(2)")
+#=> 6
+```
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`.  To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/project-eutopia/keisan.  If there is any functionality you would like (e.g. new functions), feel free to open a [new issue](https://github.com/project-eutopia/keisan/issues/new).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "keisan"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/keisan.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'keisan/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "keisan"
+  spec.version       = Keisan::VERSION
+  spec.authors       = ["Christopher Locke"]
+  spec.email         = ["project.eutopia@gmail.com"]
+
+  spec.summary       = %q{An equation parser and evaluator}
+  spec.description   = %q{A library for parsing equations into an abstract syntax tree for evaluation}
+  spec.homepage      = "https://github.com/project-eutopia/keisan"
+  spec.licenses      = %w(MIT)
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 2.4.0'
+
+  spec.add_dependency "activesupport", ">= 4.2.2"
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-stack_explorer"
+end

data/lib/keisan.rb

@@ -0,0 +1,118 @@
+require "cmath"
+require "active_support"
+require "active_support/core_ext"
+
+require "keisan/version"
+require "keisan/exceptions"
+
+require "keisan/function"
+require "keisan/functions/registry"
+require "keisan/functions/default_registry"
+require "keisan/variables/registry"
+require "keisan/variables/default_registry"
+require "keisan/context"
+
+require "keisan/ast/node"
+
+require "keisan/ast/literal"
+require "keisan/ast/number"
+require "keisan/ast/string"
+require "keisan/ast/null"
+require "keisan/ast/boolean"
+require "keisan/ast/variable"
+
+require "keisan/ast/parent"
+require "keisan/ast/unary_operator"
+require "keisan/ast/unary_plus"
+require "keisan/ast/unary_minus"
+require "keisan/ast/unary_inverse"
+require "keisan/ast/unary_bitwise_not"
+require "keisan/ast/unary_logical_not"
+require "keisan/ast/unary_identity"
+require "keisan/ast/operator"
+require "keisan/ast/arithmetic_operator"
+require "keisan/ast/plus"
+require "keisan/ast/times"
+require "keisan/ast/exponent"
+require "keisan/ast/function"
+require "keisan/ast/bitwise_operator"
+require "keisan/ast/bitwise_and"
+require "keisan/ast/bitwise_or"
+require "keisan/ast/bitwise_xor"
+require "keisan/ast/logical_operator"
+require "keisan/ast/logical_and"
+require "keisan/ast/logical_or"
+require "keisan/ast/logical_less_than"
+require "keisan/ast/logical_greater_than"
+require "keisan/ast/logical_less_than_or_equal_to"
+require "keisan/ast/logical_greater_than_or_equal_to"
+require "keisan/ast/function"
+require "keisan/ast/list"
+require "keisan/ast/indexing"
+
+require "keisan/ast/builder"
+
+require "keisan/token"
+require "keisan/tokens/comma"
+require "keisan/tokens/group"
+require "keisan/tokens/number"
+require "keisan/tokens/operator"
+require "keisan/tokens/string"
+require "keisan/tokens/null"
+require "keisan/tokens/boolean"
+require "keisan/tokens/arithmetic_operator"
+require "keisan/tokens/logical_operator"
+require "keisan/tokens/bitwise_operator"
+require "keisan/tokens/word"
+
+require "keisan/tokenizer"
+
+require "keisan/parsing/component"
+
+require "keisan/parsing/element"
+require "keisan/parsing/number"
+require "keisan/parsing/string"
+require "keisan/parsing/null"
+require "keisan/parsing/boolean"
+require "keisan/parsing/variable"
+require "keisan/parsing/function"
+require "keisan/parsing/group"
+require "keisan/parsing/round_group"
+require "keisan/parsing/square_group"
+require "keisan/parsing/list"
+require "keisan/parsing/indexing"
+require "keisan/parsing/argument"
+
+require "keisan/parsing/unary_operator"
+require "keisan/parsing/unary_plus"
+require "keisan/parsing/unary_minus"
+
+require "keisan/parsing/operator"
+require "keisan/parsing/arithmetic_operator"
+require "keisan/parsing/plus"
+require "keisan/parsing/minus"
+require "keisan/parsing/times"
+require "keisan/parsing/divide"
+require "keisan/parsing/exponent"
+require "keisan/parsing/bitwise_operator"
+require "keisan/parsing/bitwise_and"
+require "keisan/parsing/bitwise_or"
+require "keisan/parsing/bitwise_xor"
+require "keisan/parsing/bitwise_not"
+require "keisan/parsing/bitwise_not_not"
+require "keisan/parsing/logical_operator"
+require "keisan/parsing/logical_less_than"
+require "keisan/parsing/logical_greater_than"
+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_not"
+require "keisan/parsing/logical_not_not"
+
+require "keisan/parser"
+
+require "keisan/calculator"
+
+module Keisan
+end

data/lib/keisan/ast/arithmetic_operator.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module AST
+    class ArithmeticOperator < Operator
+      def associativity
+        :left
+      end
+    end
+  end
+end

data/lib/keisan/ast/bitwise_and.rb

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