rubic 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ce7e32bbc4068cda59ee86d64f3210c2b6272ae
-  data.tar.gz: d823d0e4f0c57f89681e0f14bb650ae700effef6
+  metadata.gz: 3fb42d61b5b7dfc4252cf900a2f9b11e891e65d7
+  data.tar.gz: 6eeb54706788bc451103169445cc0e1c7f1e765d
 SHA512:
-  metadata.gz: 80788b219b735f2c54aeaa57b5957e8018e8a5c34fbd074ed4fa6a85d43bed4f955eaa547f5f782ba9e482eb19233dafdf197ac77ece18d284c13f47dce0c12c
-  data.tar.gz: a1682bcb6a83ebff28c20da879a9bc73aa69cde0b8e86e06d2f6dbae37e74007fa5664ad8c66e115050b17af8fb683ded60c1179e1ea8b9a07471362033ea732
+  metadata.gz: a2430c6a05165a448a2176461f7c498dcb24fc55233f5a5a12ac2d6dfd9ff87d9840513fecc74744bead16510678258c4cdcac7971121926730be5f1db9702a2
+  data.tar.gz: 47f74178b95c7fd6184762ccee1413c73383efa85ee8ba80afdbf198c2855a2d0f0f94c60743bb196cef33b866d87f4164fdab995c51c3ac6350838cf3e1bfc1

data/Rakefile

@@ -3,16 +3,12 @@ require 'rake/testtask'
 
 Rake::TestTask.new do |t|
   t.libs << 'test'
+  t.pattern = 'test/**/test_*.rb'
 end
 
-namespace :racc do
-  desc 'Compile syntax file'
-  task :compile do
-    src = 'lib/rubic/parser.y'
-    dst = 'lib/rubic/parser.rb'
-    sh "bundle exec racc -o #{dst} #{src}"
-  end
+file 'lib/rubic/parser.rb' => 'lib/rubic/parser.y' do |t|
+  sh "bundle exec racc -o #{t.name} #{t.prerequisites.first}"
 end
 
-task :test => 'racc:compile'
+task :test => 'lib/rubic/parser.rb'
 task :default => :test

data/bin/rubic

@@ -3,18 +3,38 @@
 require 'rubic'
 require 'rubic/inspector'
 require 'readline'
+require 'optparse'
 
 using Rubic::Inspector
 
+def error(str)
+  $stderr.puts "\e[31m#{str}\e[0m"
+end
+
+
+rubic = Rubic::Interpreter.new
+
+opts = OptionParser.new
+opts.version = Rubic::VERSION
+opts.on('-r FILE', 'load FILE at startup') do |file|
+  File.open(file) do |f|
+    begin
+      rubic.evaluate(f.read)
+    rescue Rubic::RubicError => e
+      error "Error: #{e.message}"
+      exit false
+    end
+  end
+end
+opts.parse!(ARGV)
+
 if ARGV.size == 1
   file = ARGV.shift
   File.open(file) do |f|
-    rubic = Rubic::Interpreter.new
-
     begin
       rubic.evaluate(f.read)
     rescue Rubic::RubicError => e
-      puts "\e[31mError: #{e.message}\e[0m"
+      error "Error: #{e.message}"
       exit false
     end
   end
@@ -24,8 +44,6 @@ else
   puts "Welcome to interactive Rubic (v#{Rubic::VERSION})"
   puts 'Hit ^D to exit'
 
-  rubic = Rubic::Interpreter.new
-
   while input = Readline.readline(">> ", true)
     next if input.empty?
     while input.count('(') > input.count(')')
@@ -35,7 +53,7 @@ else
     begin
       puts '=> ' + rubic.evaluate(input).inspect
     rescue Rubic::RubicError => e
-      puts "\e[31mError: #{e.message}\e[0m"
+      error "Error: #{e.message}"
     end
   end
 end

data/lib/rubic/builtin/number.rb

@@ -1,13 +1,13 @@
+require 'cmath'
+require 'rubic/util'
+
 module Rubic
   module Builtin
     class Number
+      include Rubic::Util
+
       def +(*args)
-        args.reduce(0) do |res, i|
-          unless number? i
-            raise Rubic::TypeError, "operation `+' is not defined between `#{res}' and `#{i}'"
-          end
-          res + i
-        end
+        transitive_operation('+', 0, args) {|a, b| a + b }
       end
 
       def -(*args)
@@ -17,22 +17,12 @@ module Rubic
         when 1
           -args.first
         else
-          args.reduce do |res, i|
-            unless number? i
-              raise Rubic::TypeError, "operation `-' is not defined between `#{res}' and `#{i}'"
-            end
-            res - i
-          end
+          transitive_operation('-', args) {|a, b| a - b }
         end
       end
 
       def *(*args)
-        args.reduce(1) do |res, i|
-          unless number? i
-            raise Rubic::TypeError, "operation `*' is not defined between `#{res}' and `#{i}'"
-          end
-          res * i
-        end
+        transitive_operation('*', 1, args) {|a, b| a * b }
       end
 
       def /(*args)
@@ -40,41 +30,363 @@ module Rubic
         when 0
           raise Rubic::ArgumentError, "wrong number of arguments (0 for 1+)"
         when 1
-          1 / args.first
+          1.quo(args.first)
+        else
+          transitive_operation('/', args) {|a, b| a.quo(b) }
+        end
+      end
+
+      define_method '=' do |*args|
+        if args.size < 2
+          raise Rubic::ArgumentError, "wrong number of arguments (#{args.size} for 2+)"
         else
-          args.reduce do |res, i|
-            unless number? i
-              raise Rubic::TypeError, "operation `/' is not defined between `#{res}' and `#{i}'"
-            end
-            res / i
+          transitive_operation('=', args) do |a, b|
+            (a == b) ? b : (return false)
           end
+          true
         end
       end
 
-      def <(a, b)
-        unless number?(a) && number?(b)
-          raise Rubic::TypeError, "operation `<' is not defined between `#{a}' and `#{b}'"
+      def >(*args)
+        if args.size < 2
+          raise Rubic::ArgumentError, "wrong number of arguments (#{args.size} for 2+)"
+        else
+          transitive_operation('>', args) do |a, b|
+            (a > b) ? b : (return false)
+          end
+          true
         end
-        a < b
       end
 
-      def >(a, b)
-        unless number?(a) && number?(b)
-          raise Rubic::TypeError, "operation `>' is not defined between `#{a}' and `#{b}'"
+      def <(*args)
+        if args.size < 2
+          raise Rubic::ArgumentError, "wrong number of arguments (#{args.size} for 2+)"
+        else
+          transitive_operation('<', args) do |a, b|
+            (a < b) ? b : (return false)
+          end
+          true
         end
-        a > b
       end
 
-      define_method '=' do |a, b|
-        unless number?(a) && number?(b)
-          raise Rubic::TypeError, "operation `=' is not defined between `#{a}' and `#{b}'"
+      def >=(*args)
+        if args.size < 2
+          raise Rubic::ArgumentError, "wrong number of arguments (#{args.size} for 2+)"
+        else
+          transitive_operation('>=', args) do |a, b|
+            (a >= b) ? b : (return false)
+          end
+          true
+        end
+      end
+
+      def <=(*args)
+        if args.size < 2
+          raise Rubic::ArgumentError, "wrong number of arguments (#{args.size} for 2+)"
+        else
+          transitive_operation('<=', args) do |a, b|
+            (a <= b) ? b : (return false)
+          end
+          true
         end
-        a == b
       end
 
       def number?(suspect)
-        suspect.is_a?(Integer) || suspect.is_a?(Float)
+        suspect.is_a?(Numeric) || complex?(suspect)
       end
+
+      def complex?(suspect)
+        suspect.is_a?(Complex) || real?(suspect)
+      end
+
+      def real?(suspect)
+        suspect.is_a?(Float) || rational?(suspect)
+      end
+
+      def rational?(suspect)
+        suspect.is_a?(Rational) || integer?(suspect)
+      end
+
+      def integer?(suspect)
+        if suspect.is_a?(Float)
+          suspect == suspect.truncate # X.0
+        else
+          suspect.is_a?(Integer)
+        end
+      end
+
+      def exact?(suspect)
+        case suspect
+        when Complex
+          exact?(suspect.real) && exact?(suspect.imag)
+        when Float
+          false
+        when Rational
+          true
+        when Integer
+          true
+        else
+          false
+        end
+      end
+
+      def inexact?(suspect)
+        number?(suspect) && !exact?(suspect)
+      end
+
+      def zero?(suspect)
+        ensure_number suspect
+        suspect.zero?
+      end
+
+      def positive?(suspect)
+        ensure_real suspect
+        suspect > 0.0
+      end
+
+      def negative?(suspect)
+        ensure_real suspect
+        suspect < 0.0
+      end
+
+      def odd?(suspect)
+        ensure_integer suspect
+        suspect.to_i.odd?
+      end
+
+      def even?(suspect)
+        ensure_integer suspect
+        suspect.to_i.even?
+      end
+
+      def max(a, *args)
+        args.unshift(a)
+        exact = args.all? do |e|
+          ensure_real e
+          exact?(e)
+        end
+        exact ? args.max : exact_to_inexact(args.max)
+      end
+
+      def min(a, *args)
+        args.unshift(a)
+        exact = args.all? do |e|
+          ensure_real e
+          exact?(e)
+        end
+        exact ? args.min : exact_to_inexact(args.min)
+      end
+
+      def abs(num)
+        ensure_number num
+        num.abs
+      end
+
+      def quotient(a, b)
+        ensure_integer a, b
+        ret = a.quo(b).round
+        exact?(a) && exact?(b) ? ret : exact_to_inexact(ret)
+      end
+
+      def modulo(a, b)
+        ensure_integer a, b
+        ret = a.modulo(b)
+        exact?(a) && exact?(b) ? ret : exact_to_inexact(ret)
+      end
+
+      def remainder(a, b)
+        ensure_integer a, b
+        ret = a.remainder(b)
+        exact?(a) && exact?(b) ? ret : exact_to_inexact(ret)
+      end
+
+      def gcd(*args)
+        exact = true
+        ret = args.reduce(0) do |res, num|
+          ensure_integer num
+          exact &&= exact?(num)
+          res.gcd(num.to_i)
+        end
+        exact ? ret : exact_to_inexact(ret)
+      end
+
+      def lcm(*args)
+        exact = true
+        ret = args.reduce(1) do |res, num|
+          ensure_integer num
+          exact &&= exact?(num)
+          res.lcm(num.to_i)
+        end
+        exact ? ret : exact_to_inexact(ret)
+      end
+
+      def numerator(num)
+        ensure_real num
+        ret = num.to_r.numerator
+        exact?(num) ? ret : exact_to_inexact(ret)
+      end
+
+      def denominator(num)
+        ensure_real num
+        ret = num.to_r.denominator
+        exact?(num) ? ret : exact_to_inexact(ret)
+      end
+
+      def floor(num)
+        ensure_real num
+        num.floor
+      end
+
+      def ceiling(num)
+        ensure_real num
+        num.ceil
+      end
+
+      def truncate(num)
+        ensure_real num
+        num.truncate
+      end
+
+      def round(num)
+        ensure_real num
+        num.round
+      end
+
+      def rationalize(num, eps)
+        ensure_real num
+        normalize_number num.rationalize(eps)
+      end
+
+      def exp(num)
+        ensure_number num
+        CMath.exp(num)
+      end
+
+      def log(num)
+        ensure_number num
+        CMath.log(num)
+      end
+
+      def sin(num)
+        ensure_number num
+        CMath.sin(num)
+      end
+
+      def cos(num)
+        ensure_number num
+        CMath.cos(num)
+      end
+
+      def tan(num)
+        ensure_number num
+        CMath.tan(num)
+      end
+
+      def asin(num)
+        ensure_number num
+        CMath.asin(num)
+      end
+
+      def acos(num)
+        ensure_number num
+        CMath.acos(num)
+      end
+
+      def atan(*args)
+        case args.size
+        when 1
+          ensure_number args[0]
+          CMath.atan(args[0])
+        when 2
+          ensure_number args[0], args[1]
+          Complex(args[1], args[0]).angle
+        else
+          raise Rubic::ArgumentError, "wrong number of arguments (#{args.size} for 1..2)"
+        end
+      end
+
+      def sqrt(num)
+        ensure_number num
+        CMath.sqrt(num)
+      end
+
+      def expt(x, y)
+        ensure_number x, y
+        x ** y
+      end
+
+      define_method 'make-rectangular' do |x, y|
+        ensure_real x, y
+        normalize_number Complex(x, y)
+      end
+
+      define_method 'make-polar' do |x, y|
+        ensure_real x, y
+        normalize_number Complex.polar(x, y)
+      end
+
+      define_method 'real-part' do |num|
+        ensure_number num
+        num.real
+      end
+
+      define_method 'imag-part' do |num|
+        ensure_number num
+        num.imag
+      end
+
+      def magnitude(num)
+        ensure_number num
+        num.magnitude
+      end
+
+      def angle(num)
+        ensure_number num
+        num.angle
+      end
+
+      define_method 'inexact->exact' do |num|
+        ensure_number num
+        return num if exact?(num)
+        inexact_to_exact(num)
+      end
+
+      define_method 'exact->inexact' do |num|
+        ensure_number num
+        return num unless exact?(num)
+        exact_to_inexact(num)
+      end
+
+      private
+
+      def transitive_operation(opname, initial=nil, args)
+        initial = args.shift if initial.nil?
+        args.reduce(initial) do |res, num|
+          unless number?(num)
+            raise Rubic::TypeError, "operation `#{opname}' is not defined between `#{res}' and `#{num}'"
+          end
+          yield res, num
+        end
+      end
+
+      def ensure_number(*args)
+        args.each do |e|
+          raise Rubic::TypeError, "`#{e}' is not a number" unless number?(e)
+        end
+      end
+
+      def ensure_real(*args)
+        args.each do |e|
+          raise Rubic::TypeError, "`#{e}' is not a real number" unless real?(e)
+        end
+      end
+
+      def ensure_integer(*args)
+        args.each do |e|
+          raise Rubic::TypeError, "`#{e}' is not an integer" unless integer?(e)
+        end
+      end
+
     end
   end
 end