calculo 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 647451e4c1e42739a7571ef0deb0db5bd4af3555
+  data.tar.gz: e27e02406f3fa7446749996881a986f81694dc49
+SHA512:
+  metadata.gz: ca50356dc05252792acf85230babbbd64fb34e11bd1d6e486133722d46f9a0c8d6c50554155164e2081464ceff7e0db62ed9984b4217b0d871245d10b067a76a
+  data.tar.gz: 4e45b33979518f68c2a67769999299e8741a67cfa1ba9294ee96761b2c75b6eb8c25b8563f018e2c1aa1c0370745385822564080691d0831445d9664e6809cde

data/README.md

@@ -0,0 +1,5 @@
+# Calculo
+A calculator specifically designed to support any kind of mathematical syntax
+you throw at it.
+
+Consider it The AD to [BC](https://www.gnu.org/software/bc/), the AC to [DC](https://packages.debian.org/jessie/dc)

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rake/testtask'
+require 'rake/dmg'
+
+Rake::DmgTask.new 'calculo', '1.0.0' do |dmg|
+        dmg.source_files.include('bin/*')
+        dmg.source_files.include('calculo/*')
+        dmg.source_files.include('test/*')
+        dmg.source_files.include('README.md')
+        dmg.strip = 'build'
+end
+
+Rake::TestTask.new do |t|
+        t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/bin/calculo

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'calculo'
+
+options = {}
+OptionParser.new do |opts|
+        opts.banner = "Usage: calculo.rb [options]"
+        opts.on("-t","--type TYPE",String,"The type of expression to be computed") do |type|
+                options[:type] = type
+        end
+
+        opts.on("-e","--expr EXPR","The expression to be computed") do |expr|
+                options[:expr] = expr
+        end
+        opts.on("-f","--file FILE",String,"Reads expressions from a file") do |file|
+                options[:file] = file
+        end
+        opts.on("-h","--help","Prints this help") do
+                puts opts
+        end
+end.parse!
+
+def cli_eval(string,type)
+        if type == 'lisp' or type ==  'reverse-lisp' or type == 'reverse'
+                cli = Lisp.new(string,type)
+                output = "#{cli.string} : #{cli.result}"
+                return output
+        elsif type == 'rpn' or type == 'postfix' or type == 'pn' or type == 'prefix' or type == 'infix'
+                cli = MathNotation.new(string,type)
+                output = "#{cli.string} : #{cli.result}"
+                return output
+        end
+end
+
+if not options.empty?
+        if options.has_key?(:file)
+                File.open(options[:file]).each_line do |line|
+                        puts(cli_eval(line,options[:type]))
+                end
+
+        elsif options.has_key?(:expr)
+                puts(cli_eval(options[:expr],options[:type]))
+
+        elsif options.has_key?(:type)
+                Repl.new("=>",options[:type])
+        end
+else
+        Repl.new("=>","infix")
+end

data/lib/calculo/lisp.rb

@@ -0,0 +1,58 @@
+require 'parse'
+class Lisp
+        attr_accessor :string
+        attr_accessor :type
+        attr_accessor :array
+        attr_accessor :result
+
+        def initialize(string, type)
+                @string = string
+                @type = type
+                @array = parse(@string)
+                @result = eval_lisp(@array)
+        end
+
+        @private
+        def execute(array,type)
+                case type
+                when 'lisp'
+                        array[2..-2].reduce(array[1].to_sym)
+                when 'reverse-lisp' || 'reverse'
+                        array[1..-3].reverse.reduce(array[-2].to_sym)
+                end
+        end
+
+        def innermost_pair(array)
+                l_parens = []
+                r_parens = []
+
+                array.each_with_index do |item, index|
+
+                        if item == "("
+                                l_parens.push(index)
+
+                        elsif item == ")"
+                                r_parens.push(index)
+                        end
+                end
+
+                total_length = l_parens.length + r_parens.length
+                return [total_length, l_parens[-1], r_parens[0]]
+        end
+
+        def eval_lisp(array)
+                length, l, r = innermost_pair(array)
+                result = execute(array[l..r],type)
+
+                if length > 2
+                        # Inserts the result in between the portions
+                        # of the array not including the portion just
+                        # used to calculate the result
+                        new_array = array[0..(l-1)] + [result] + array[(r+1)..-1]
+                        eval_lisp(new_array)
+
+                elsif length == 2
+                        return result
+                end
+        end        
+end

data/lib/calculo/math.rb

@@ -0,0 +1,56 @@
+require 'parse'
+require 'shunting_yard'
+class MathNotation
+        attr_accessor :type
+        attr_accessor :string
+        attr_accessor :array
+        attr_accessor :result
+
+        def initialize(string,type)
+                @string = string
+                if type == 'infix'
+                        @type = 'rpn'
+                        @array = shunting_yard(parse(@string))
+                        @result = eval_rpn(@array)
+                else
+                        @array = parse(@string)
+                        @type = type
+                        if @type == 'prefix' or @type == 'pn'
+                                @result = eval_pn(@array)
+                        elsif @type == 'postfix' or @type == 'rpn'
+                                @result = eval_rpn(@array)
+                        end
+                end
+        end
+
+        @private
+        def eval_pn(array)
+                operators = ['+','-','^','%','/','**','*']
+                stack = []
+                array.reverse.each{|item|
+                        if operators.include?(item)
+                                num2,num1 = stack.pop(2)
+                                result = num1.method(item).call(num2)
+                                stack.push(result)
+                        else
+                                stack.push(item)
+                        end
+                }
+                return stack.pop
+        end
+
+        def eval_rpn(array)
+                operators = ['+','-','^','%','/','**','*']
+                stack = []
+                array.each{|item|
+                        if operators.include?(item)
+                                num1,num2 = stack.pop(2)
+                                result = num1.method(item).call(num2)
+                                stack.push(result)
+                        else
+                                stack.push(item)
+                        end
+                }
+                return stack.pop
+        end
+end

data/lib/calculo/parse.rb

@@ -0,0 +1,20 @@
+def parse(string)
+        # First regex puts a space after a parenthesis/math operation,
+        # Second regex a space between a digit and a parenthesis/math
+        # operation(s)
+        # Third regex converts any double spaces into single space
+        # Fourth regex converts to the exponent operator used in ruby
+        # split seperates the characters based on a space
+
+        op_re = Regexp.new(/([^\d\w\s\-])/)
+        dig_op_re = Regexp.new(/\d[^\d\w\s]+/)
+        dbl_space_re = Regexp.new(/\s{2,}/)
+        exp_re = Regexp.new(/\^/)
+        dig_re = Regexp.new(/\d+/)
+        array = string.gsub(op_re,'\1 ').gsub(dig_op_re){ |s| s.chars.join(' ')}.gsub(dbl_space_re,' ').gsub(exp_re,'**').split(' ')
+
+        # Regex finds if array element matches a digit, and converts it
+        # to a float.
+        array = array.map{|x| dig_re.match(x) != nil ? x.to_f : x}
+        return array
+end

data/lib/calculo/repl.rb

@@ -0,0 +1,110 @@
+require 'IO/console'
+require 'os'
+require 'pry'
+
+class Repl
+        attr_accessor :history
+        attr_accessor :prompt
+        attr_accessor :type
+        def initialize(prompt,type)
+                @history = []
+                @og_prompt = prompt
+                @prompt = "[#{@history.length}]" + @og_prompt + " "
+                @type = type
+                clear_screen()
+                calculo_loop()
+        end
+
+        def clear_screen
+                if OS.linux? or OS.mac? or OS.bsd?
+                        system('clear')
+                elsif OS.windows?
+                        system('cls')
+                end
+        end
+
+        def calculo_print(history)
+                history.each_with_index.map{|x,i| puts("#{i} : #{x}\n")}
+        end
+
+        def repl_eval(input)
+                # syntax for changing prompt/type is:
+                # set prompt/type = 'foo'
+                # or set prompt/type 'foo'
+                if input.start_with?("set","change")
+                        @history.push(input)
+                        input_array = input.split(' ')
+
+                        if input_array[1] == "prompt" and input_array.last != "prompt"
+                                @og_prompt = input_array.last
+                                @prompt = "[#{@history.length}]" + @og_prompt + " "
+                                return "prompt is now #{@prompt}"
+
+                        elsif input_array[1] == "type" and input_array.last != "type"
+                                @type = input_array.last        
+                                return "type is now #{@type}"
+                        else
+                                return "Error: variable can not be changed"
+                        end
+
+                # If input is simply history, print all of the history
+                # can also use ruby range syntax, STARTING AT 0
+                # for example: history 0..-2 will print all but the
+                # last entry of history 
+                elsif input.start_with?("history")
+                        @history.push(input)
+                        if input == "history"
+                                return calculo_print(@history)
+                        else
+                                input_array = input.split(' ')
+                                input_range = input_array[-1]
+                                if input_range.length == 1
+                                        return @history[input_range.to_i]
+                                elsif input_range.length == 4
+                                        return calculo_print(@history[(input_range.chars.first.to_i)..(input_range.chars.last.to_i)])
+                                elsif input_range.length == 5
+                                        return calculo_print(@history[(input_range.chars.first.to_i)..(input_range.chars.drop(2).to_i)])
+                                end
+                        end
+
+                elsif input.start_with?("clear")
+                        @history.push(input)
+                        if input == "clear"
+                                return clear_screen()
+                        elsif input == "clear history"
+                                @history = []
+                                return "History is now blank"
+                        end
+
+                elsif input == "exit" or input == "quit"
+                        return "Exiting calculo!"
+
+                else 
+                        if @type == 'lisp' or @type == 'reverse-lisp' or @type == 'reverse'
+                               repl_class = Lisp.new(input,@type)
+                               calculo_output = "#{repl_class.string} : #{repl_class.result}"
+                               @history.push(calculo_output)
+                               return calculo_output
+                                       
+                        elsif @type == 'postfix' or @type == 'infix' or @type == 'prefix' or @type == 'pn' or @type == 'rpn'
+                               repl_class = MathNotation.new(input,@type)
+                               calculo_output = "#{repl_class.string} : #{repl_class.result}"
+                               @history.push(calculo_output)
+                               return calculo_output
+                       end
+                end
+        end
+
+        def calculo_loop(output="Welcome to calculo!")
+                input = nil
+                while output != "Exiting calculo!"
+                        puts(output)
+                        @prompt = "[#{@history.length}]" + @og_prompt + " "
+                        print(@prompt)
+                        input = gets.chomp
+                        output = repl_eval(input)
+                end
+                puts(output)
+                exit(1)
+        end
+end

data/lib/calculo/shunting_yard.rb

@@ -0,0 +1,32 @@
+def shunting_yard(infix_array)
+        operators = {'+' => 2, '-' => 2, '*' => 3, '/' => 3, '>' => 4, '<' => 4, '=' => 4, '%' => 4, '**' => 4}
+        rpn_expr = []
+        op_stack = []
+
+        infix_array.each do |item|
+                if operators.has_key?(item)
+                        op2 = op_stack.last
+                        if operators.has_key?(op2) and ((op2 == "**" and operators[item] < operators[op2]) or (op2 != "**" and operators[item] <= operators[op2]))
+                                rpn_expr.push(op_stack.pop)
+                        end
+                        op_stack.push(item)
+
+                elsif item == "("
+                        op_stack.push(item)
+
+                elsif item == ")"
+                        until op_stack.last == "("
+                                rpn_expr.push(op_stack.pop)
+                        end
+                        op_stack.pop
+                else
+                        rpn_expr.push(item)
+                end
+        end
+
+        until op_stack.empty?
+                rpn_expr.push(op_stack.pop)
+        end
+
+        return rpn_expr
+end

data/lib/calculo.rb

@@ -0,0 +1,3 @@
+require 'calculo/math'
+require 'calculo/lisp'
+require 'calculo/repl'

data/test/test.rb

@@ -0,0 +1,129 @@
+require_relative "../lib/calculo/lisp"
+require_relative "../lib/calculo/math"
+require "minitest/autorun"
+
+class TestLisp < MiniTest::Test
+        def setup
+                @type = "lisp"
+                @string = "( - ( + ( / 18 ( ^ 3 2 ) ) 12 ) 13 )"
+                @array = ["(", "-", "(", "+", "(", "/", 18.0, "(", "**", 3.0, 2.0, ")", ")", 12.0, ")", 13.0, ")"]
+                @result = 1
+                @Lisp = Lisp.new(@string, @type)
+        end
+
+        def test_type_access
+                assert_equal(@type, @Lisp.type)
+        end
+
+        def test_string_access
+                assert_equal(@string, @Lisp.string)
+        end
+
+        def test_array_access
+                assert_equal(@array, @Lisp.array)
+        end
+
+        def test_results
+                assert_equal(@result, @Lisp.result)
+        end
+end
+
+class TestReverseLisp < MiniTest::Test
+        def setup
+                @type = "reverse-lisp"
+                @string = "( 13 ( 12 ( ( 2 3 ^ ) 18 / ) + ) - )"
+                @array = ["(", 13.0, "(", 12.0, "(", "(", 2.0, 3.0, "**", ")", 18.0, "/", ")", "+", ")", "-", ")"]
+                @result = 1
+                @ReverseLisp = Lisp.new(@string, @type)
+        end
+
+        def test_type_access
+                assert_equal(@type, @ReverseLisp.type)
+        end
+
+        def test_string_access
+                assert_equal(@string, @ReverseLisp.string)
+        end
+
+        def test_array_access
+                assert_equal(@array, @ReverseLisp.array)
+        end
+
+        def test_results
+                assert_equal(@result, @ReverseLisp.result)
+        end
+end
+
+class TestPN < MiniTest::Test
+        def setup
+                @type = "pn"
+                @string = "- + / 18 ^ 3 2 12 13"
+                @array = ['-', '+', '/', 18.0, '**', 3.0, 2.0, 12.0, 13.0]
+                @result = 1
+                @PN = MathNotation.new(@string, @type)
+        end
+
+        def test_type_access
+                assert_equal(@type, @PN.type)
+        end
+
+        def test_string_access
+                assert_equal(@string, @PN.string)
+        end
+
+        def test_array_access
+                assert_equal(@array, @PN.array)
+        end
+
+        def test_result_access
+                assert_equal(@result, @PN.result)
+        end
+end
+
+class TestRPN < MiniTest::Test
+        def setup
+                @type = "rpn"
+                @string = "12 18 3 2 ^ / 13 - +"
+                @array = [12.0, 18.0, 3.0, 2.0, "**", "/", 13.0, "-", "+"]
+                @result = 1
+                @RPN = MathNotation.new(@string, @type)
+        end
+
+        def test_string_access
+                assert_equal(@string, @RPN.string)
+        end
+
+        def test_array_access
+                assert_equal(@array, @RPN.array)
+        end
+
+        def test_result_access
+                assert_equal(@result, @RPN.result)
+        end
+end
+
+class TestInfix < MiniTest::Test
+        def setup
+                @type = "rpn" 
+                @string = "12 + 18 / ( 3 ^ 2 ) - 13"
+                @rpn_array = [12.0, 18.0, 3.0, 2.0, "**", "/", 13.0, "-", "+"]
+                @result = 1
+                @Infix = MathNotation.new(@string, "infix")
+        end
+
+        def test_type
+                assert_equal(@type, @Infix.type)
+        end
+
+        def test_string_access
+                assert_equal(@string, @Infix.string)
+        end
+
+        def test_shunting_yard
+                assert_equal(@rpn_array, @Infix.array)
+        end
+
+        def test_result_access
+                assert_equal(@result, @Infix.result)
+        end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: calculo
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Noah Holt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: os
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake_dmg
+  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'
+- !ruby/object:Gem::Dependency
+  name: ocra
+  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 calculator for the command line supporting postfix, prefix, infix,
+  and lisp notation (plus a REPL)
+email: noahryanholt@gmail.com
+executables:
+- calculo
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- README.md
+- test/test.rb
+- lib/calculo.rb
+- lib/calculo/lisp.rb
+- lib/calculo/parse.rb
+- lib/calculo/math.rb
+- lib/calculo/shunting_yard.rb
+- lib/calculo/repl.rb
+- bin/calculo
+homepage: https://github.com/noaoh/calculo
+licenses:
+- GPLv3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- bin
+- test
+- lib/calculo
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14.1
+signing_key: 
+specification_version: 4
+summary: A calculator for the command line
+test_files: []