RubyGems - bitwiseCalc - Versions diffs - 1.5.0 → 1.6.0 - Mend

bitwiseCalc 1.5.0 → 1.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5fda77d07643c6b2454ecb235fcf345aa95e5ae0
-  data.tar.gz: eca2f46eeb79c3a80c65c8e0a4c73e97838337be
+  metadata.gz: 291ba8693f8476a508712b9ca6b7fa690435b8ec
+  data.tar.gz: 4679cc129d07100ab9bac21999c8ae59bdb07406
 SHA512:
-  metadata.gz: 3d3ef0aa78d70027b726d470d887a656d4a9fd719be088ace02845c35fc0291f6386ac4aafd05a260782d644e4692f1e9c1fde2bd4ea2ae300462b5bbb2638d3
-  data.tar.gz: 4e412b353af419aa280addbe63bc42a79a74163b57d43c5f53fff3b23da718de24312553fa5301ca036eb4a1699c8d49548bd1f063421810f93c6e49410b3cef
+  metadata.gz: 1ef57bd68037118cc9642ee42a6caf5e52b65f578d2a5c5cfc2a9c0ddee8e34c92266ac2c86a6f0b87e216401f0d62693375ccb09de2ec03c95228cb62e5e9d9
+  data.tar.gz: d42b86871d3ee653c38dfcbee311b19e6e30edd50c104b3e5ea8f1f04a6ed94f4412d655acde58bbca3f100fcc6e2ac8bf0f541317ba62c4c49ea91867afdbdb

data/lib/bitwiseCalc CHANGED Viewed

@@ -3,258 +3,220 @@
 # @Name:   Vargas, Hector
 # @Email:  vargash1@wit.edu
 # @Date:   2015-02-23 10:23:20
-# @Last Modified by:   Hector Vargas
-# @Last Modified time: 2016-01-09 19:20:07
+# @Last modified by:   vargash1
+# @Last modified time: Tuesday, May 10th 2016, 5:19:18 pm
 require 'colorize'
 class BoolCalc
     def initialize()
         @x = nil; @y = nil; @ans = nil; @operation = nil
-        # Valid Operations
-        @ops = ['NOT','SHR','SHL','AND','OR','XOR',
-                'RAD','ROL','ROR','MUL','DIV','ADD',
-                'SUB','MOD','POW','NOR','NAND','XNOR']
+        # Valid Operations
+        @ops = { :NOT => "Bitwise Not", :SHR => "Shift Right",
+                 :SHL => "Shift Left", :AND => "Logical And",
+                 :OR => "Logical Or", :XOR => "Exclusive Or",
+                 :RAD => "Display Radixes", :ROL => "Circular Rotate Left",
+                 :ROR => "Circular Rotate Right", :MUL => "Multiply",
+                 :DIV => " Division", :ADD => "Addition",
+                 :SUB => "Subtraction", :MOD => "Modulus",
+                 :POW => "Exponentiation", :NOR => "Negated OR",
+                 :NAND => "Negated AND", :XNOR => "Complement XOR"}
         # Option Hash
-        @options = {nocolor:false, grouped: false, bit4: true, bit64: true}
+        @options = { nocolor: false, grouped: false, bit4: true,
+                     bit64: true, ipnum: false, nargs: false }
     end
     # Outputs num in radixes mentioned in program description.
     def print_all_radix(num)
-        num_base10 = num.to_s(10)
-        if @options[:grouped]
-            num_base10 = num.to_s(10).reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
-        end
-        print "Base 10:\t".yellow; print "#{num_base10}\n"
-        print "Base 16:\t".yellow; print "#{num.to_s(16)}\n"
-        print "Base 8: \t".yellow; print "#{num.to_s(8)}\n"
+        base10 = num.to_s(10)
+        base10 = base10.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse! if @options[:grouped]
         print "Base 2:\n".yellow
         print_nice_binary(num)
+        puts "Base 8: ".yellow; puts "\t#{num.to_s(8)}"
+        puts "Base 10:".yellow; puts "\t#{base10}"
+        puts "Base 16:".yellow; puts "\t#{num.to_s(16)}"
     end
     # Executes desired operation.
     def execute()
-        case
-        when(@operation == 'RAD')
+        case @operation
+        when 'RAD'
             return
-        when (@operation == 'AND')
+        when 'AND'
             @ans = @x & @y
-        when (@operation == 'NAND')
-            @ans = ~(@x & @y)
-        when (@operation == 'OR')
+        when 'NAND'
+            @ans = ~(@x & @y)
+        when 'OR'
             @ans = @x | @y
-        when (@operation == 'NOR')
+        when 'NOR'
             @ans = ~(@x | @y)
-        when (@operation == 'XOR')
-            @ans = @x ^ @y
-        when (@operation == 'XNOR')
+        when 'XOR'
+            @ans = @x ^ @y
+        when 'XNOR'
             @ans = ~(@x ^ @y)
-        when (@operation == 'NOT')
+        when 'NOT'
             @ans = ~@x
-        when (@operation == 'SHR')
+        when 'SHR'
             @ans = @x >> @y
-        when (@operation == 'SHL')
+        when 'SHL'
             @ans = @x << @y
-        when (@operation == 'ROL')
+        when 'ROL'
             binarr = int_to_binarr(@x)
-            binarr = rol(binarr)
-            @ans = binarr.join.to_i(2)
-        when(@operation == 'ROR')
+            @ans = rol(binarr).join.to_i(2)
+        when 'ROR'
             binarr = int_to_binarr(@x)
-            binarr = ror(binarr)
-            @ans = (binarr.join).to_i(2)
-        when(@operation == 'MUL')
+            @ans = ror(binarr).join.to_i(2)
+        when 'MUL'
             @ans = @x * @y
-        when(@operation == 'ADD')
+        when 'ADD'
             @ans = @x + @y
-        when(@operation == 'DIV')
+        when 'DIV'
             @ans = @x / @y
-        when(@operation == 'SUB')
+        when 'SUB'
             @ans = @x - @y
-        when(@operation == 'MOD')
+        when 'MOD'
             @ans = @x % @y
-        when(@operation == 'POW')
+        when 'POW'
             @ans = @x ** @y
         end
     end
     # Neatly displays results
     def print_results()
-        String.disable_colorization = true if (@options[:nocolor])
-        print "\t---------------------------------------\n".green
+        String.disable_colorization = true if @options[:nocolor]
+        separator = "\t---------------------------------------\n"
+        print separator.green
         print_all_radix(@x)
-        if (@y != nil && @operation != "NOT")
-            puts "\t---------------------------------------\n".green
+        # print 2 passed num only if
+        if @y != nil && @operation != "NOT"
+            puts separator.green
             print_all_radix(@y)
         end
         # rad simply outputs num(s) in multiple radixes
-        if (@operation != "RAD")
+        if @operation != "RAD"
             puts "\n\t-------------#{@operation} Result-----------------".green
             print_all_radix(@ans)
-        end
+        end
     end
     # Detect any errors before operation execution
     def check_for_errors()
-        # no op read
-        abort("ERROR, Expected Operation".red) if (@operation.nil?)
-        # make sure binary ops have binary input
-        restriction = ((@operation != "NOT" && @operation != "RAD") &&@y.nil?)
+        # no operation read
+        abort("ERROR, Expected Operation".red) if @operation.nil?
+        # make sure binary operations have binary input
+        restriction = @operation != "NOT" && @operation != "RAD" && @y.nil?
         # also make sure we have read at least 1 number
-        if restriction || @x.nil?
+        if restriction || @x.nil?
             abort("ERROR, Expected Number(s) for Operation:\t#{@operation}".red)
         end
         # div by zero
-        if ((@operation == "DIV" || @operation == "MOD") && (@y == 0))
+        if (@operation == "DIV" || @operation == "MOD") && @y == 0
             abort("ERROR, Divide by 0 for Operation:\t#{@operation}".red)
-        end
-    end
-    # Use regular expressions to parse arguments passed.
+        end
+    end
+    # Parse arguments passed.
     def parse_args()
         #exit if no args passed; parse flags only if needed
-        usage() if ARGV.empty?
-        parse_flags if (ARGV[0][0] == "-")
-        ARGV.each do |a|
-            case
+        usage if ARGV.empty?
+        parse_flags if ARGV[0][0] == "-"
+        ARGV.each do |arg|
+            case arg
             #check if valid operation choice
-            when (a == a[/[a-zA-Z]*/])
-                @ops.each do |ops_elem|
-                    if (a.upcase == ops_elem)
-                        @operation = ops_elem
-                    end
-                end
-            #hex val was read
-            when(a == a[/0[xX][0-9a-fA-F]+/])
-                if (@x == nil) ? @x = a.to_i(16): @y = a.to_i(16)
-                end
-            #binary val was read
-            when(a == a[/0[bB][0-1]+/])
-                if (@x == nil) ? @x = a.to_i(2): @y = a.to_i(2)
-                end
-            #octal val was read
-            when(a == a[/0[0-7]+/])
-                if (@x == nil) ? @x = a.to_i(8): @y = a.to_i(8)
-                end
-            #decimal val was read
-            when (is_number(a))
-                if (@x == nil) ? @x = a.to_i: @y = a.to_i
-                end
+            when arg[/[a-zA-Z]+/]
+                @operation = arg.upcase if @ops.has_key?(arg.upcase.to_sym)
+            #hex number
+            when arg[/0[xX][0-9a-fA-F]+/]
+                @x == nil ? @x = arg.to_i(16) : @y = arg.to_i(16)
+            #binary number
+            when arg[/0[bB][0-1]+/]
+                @x == nil ? @x = arg.to_i(2) : @y = arg.to_i(2)
+            #octal number
+            when arg[/0[0-7]+/]
+                @x == nil ? @x = arg.to_i(8) : @y = arg.to_i(8)
+            #decimal number
+            when arg[/[0-9]+/]
+                @x == nil ? @x = arg.to_i : @y = arg.to_i
             end
         end
     end
     # Parses flags, only called if flags passed are detected.
     def parse_flags()
         flags = ARGV[0]
-        flags.split("").each do |f|
-            case
-            when f == "n"
+        flags.split("").each do |flag|
+            case flag
+            when "n"
                 @options[:nocolor] = true
-            when f == "h"
+            when "h"
                 usage
-            when f == "f"
+            when "f"
                 @options[:bit4] = false
-            when f == "s"
+            when "s"
                 @options[:bit64] = false
-            when f == "g"
+            when "g"
                 @options[:grouped] = true
             end
         end
     end
-    # Simple way to check if our number is truly a number
-    def is_number(num)
-        is_num = ((num.to_f.to_s == num.to_s) || (num.to_i.to_s == num.to_s))
-        return is_num
-    end
     def usage()
         puts """
         Description:
             A simple bitwise calculator that executes the operations noted below.
             It can accept Octal, Hexadecimal, Decimal, and Binary inputs.
-            It will output in above mentioned radixes, binary output
-            will have 32,64,128, and up to 256 bit format. The results are printed to
-            STDOUT.
-            Note this was intended to be a command line interface tool only.
+            It will output in above mentioned radixes.
+            Binary output will have 32, 64, 128, and up to 256 bit format.
+            The results are printed to the console.
         Usage:
-            Pass arguments to the program as shown below.
-            Note that binary output is spaced every 4 bits.
-            Every 64 bits, a newline is added for readability.
-            Colorized output is also enabled by default.
-            Of course you can disable these if you wish.
-            For additional help/screenshots:
-            <https://github.com/vargash1/Bitwise-Calculator>
+            Pass arguments to the program as shown below. Note that binary output
+            is spaced every 4 bits. Every 64 bits, a newline is added for readability.
+            For additional help/examples:
+                https://github.com/vargash1/Bitwise-Calculator
             Unary Operations:
-                bitwiseCalc <flag> <num> <operation>
+                bitwiseCalc [flag] <number> <operation>
             Binary Operations:
-                bitwiseCalc <flag> <num> <operation> <num>
+                bitwiseCalc [flag] <number> <operation> <number>
             Passing a number in a radix other than base10:
-                <base_2_num>  = 0b[0-1]
-                <base_8_num>  = 0[0-7]
-                <base_16_num> = 0x[0-9a-f]
+                <base_2_number>  = 0b[0-1]
+                <base_8_number>  = 0[0-7]
+                <base_16_number> = 0x[0-9a-f]
         Flags:
             -f
-                disables spacing every 4 bits in binary output
+                disables spacing every 4 bits in binary output(enabled by default)
             -s
-                disables newline every 64 bits in binary output
+                disables newline every 64 bits in binary output(enabled by default)
             -n
-                disables colorized output
+                disables colorized output(enabled by default)
             -h
-                outputs usage and exits
-            -g
-                outputs base 10 numbers in grouped form
-        Operations:
-            NOT
-                Bitwise NOT, or complement of input.
-            RAD
-                Diplays Input(s) in metioned radixes.
-            AND
-                Logical AND.
-            NAND
-                Negative AND.
-            OR
-                Logical inclusive OR.
-            NOR
-                Negative OR.
-            XOR
-                Logical exclusive OR.
-            XNOR
-                Logical complement of XOR.
-            SHR
-                Right logical shift.
-            SHL
-                Left logical shift.
-            ROR
-                Right circular rotate.
-            ROL
-                Left circular rotate.
-            MUL
-                Multiplication.
-            DIV
-                Division.
-            ADD
-                Addition.
-            SUB
-                Subtraction.
-            MOD
-                Modulus.
-            POW
-                Exponentiation.
-            """
+                displays this message and exits
+            -g
+                outputs base 10 numbers in grouped form(with commas)
+        Operations:"""
+        @ops.each_pair do |key,val|
+            puts "\t #{key}\n\t\t#{val}"
+        end
         exit
     end
     # Outputs number in Binary form for easier reading
+    # Will print in increments of 32,64,128, and then 256
     # Will print 64 bits before moving to the next line
     def print_nice_binary(num)
-        case
-        when num <= 2 ** 31
+        if num <= 2 ** 31
             max = 31
-        when num <= 2 ** 63
+        elsif num <= 2 ** 63
             max = 63
-        when num <= 2 ** 127
+        elsif num <= 2 ** 127
             max = 127
         else
             max = 255
@@ -262,14 +224,13 @@ class BoolCalc
         puts "\t#{max+1} Bit Format(MSB First)".yellow
         print "\t"
         max.downto(0) do |n|
-            case
-            when ((n+1)%64 == 0) && @options[:bit64]
-                print "\n\t"
-            when ((n+1)%4 == 0) && @options[:bit4]
-                print " "
+            if (n+1)%64 == 0 && @options[:bit64]
+                    print "\n\t"
+            elsif (n+1)%4 == 0 && @options[:bit4]
+                print " "
             end
             print num[n]
-        end
+        end
         puts
     end
     #Converts an integer to a binary array
@@ -280,11 +241,11 @@ class BoolCalc
         end
         tmparr
     end
-    # Rotate right implementation
+    # Rotate right implementation
     def ror(tmparr)
         arr_tail = tmparr.length-2
         for i in 1..@y
-            #save least significant bit(end of array)
+            #save least significant bit(end of array)
             lsb = tmparr[-1]
             for j in 0..arr_tail
                 if j == 0
@@ -294,15 +255,14 @@ class BoolCalc
                 #save next element, make next element previously saved elem
                 tmp2 = tmparr[j+1]
                 tmparr[j+1] = tmp1
-                tmp1 = tmp2
+                tmp1 = tmp2
             end
             #assign least significant bit(end of array) to head of array
             tmparr[0] = lsb
         end
-        print tmparr.length
         tmparr
     end
-    # Rotate left implementation
+    # Rotate left implementation
     def rol(tmparr)
         arr_tail = tmparr.length-2
         for i in 1..@y
@@ -315,8 +275,8 @@ class BoolCalc
             #assign most significant bit to tail
             tmparr[-1] = msb
         end
-        tmparr
-    end
+        tmparr
+    end
 end
 def main()
     runtime = BoolCalc.new()
@@ -325,5 +285,4 @@ def main()
     runtime.execute()
     runtime.print_results()
 end
-main()
+main()

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitwiseCalc
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Hector Vargas
 autorequire:
 bindir: lib
 cert_chain: []
-date: 2016-01-09 00:00:00.000000000 Z
+date: 2016-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -58,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.2.5
+rubygems_version: 2.6.2
 signing_key:
 specification_version: 4
 summary: BitWise Calculator CLI tool