bitwiseCalc 1.4.11 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d03c669c232793101e0477a7f62b964d82a441a
-  data.tar.gz: b4185ed96cf87cc044ed3486bc561ea1d80d5009
+  metadata.gz: 5fda77d07643c6b2454ecb235fcf345aa95e5ae0
+  data.tar.gz: eca2f46eeb79c3a80c65c8e0a4c73e97838337be
 SHA512:
-  metadata.gz: 22dccc77bd2f55efadd1f4b9b61e57ffe82bfa60939b62a47938442282477a8e35ab1cdf09557b6a7b71f519249a3c5fd81f5fcc0a24057828ba7c67dcd3c155
-  data.tar.gz: 371cfa6219ce7dfaa03c7e9b5bbacccfe5b1105c86bdcc6e20d66fd45d804957be85c9ae19033c4b8cf349b265b1f87711939312e70536efd995a1c69124371b
+  metadata.gz: 3d3ef0aa78d70027b726d470d887a656d4a9fd719be088ace02845c35fc0291f6386ac4aafd05a260782d644e4692f1e9c1fde2bd4ea2ae300462b5bbb2638d3
+  data.tar.gz: 4e412b353af419aa280addbe63bc42a79a74163b57d43c5f53fff3b23da718de24312553fa5301ca036eb4a1699c8d49548bd1f063421810f93c6e49410b3cef

data/lib/bitwiseCalc

@@ -3,8 +3,8 @@
 # @Name:   Vargas, Hector
 # @Email:  vargash1@wit.edu
 # @Date:   2015-02-23 10:23:20
-# @Last Modified by:   vargash1
-# @Last Modified time: 2015-09-17 20:41:15
+# @Last Modified by:   Hector Vargas
+# @Last Modified time: 2016-01-09 19:20:07
 require 'colorize'
 class BoolCalc
     def initialize()
@@ -13,12 +13,16 @@ class BoolCalc
         @ops = ['NOT','SHR','SHL','AND','OR','XOR',
                 'RAD','ROL','ROR','MUL','DIV','ADD',
                 'SUB','MOD','POW','NOR','NAND','XNOR']
-        # Flags
-        @no_color = false
+        # Option Hash
+        @options = {nocolor:false, grouped: false, bit4: true, bit64: true}
     end
     # Outputs num in radixes mentioned in program description.
     def print_all_radix(num)
-        print "Base 10:\t".yellow; print "#{num.to_s(10)}\n"
+        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"
         print "Base 2:\n".yellow
@@ -48,13 +52,13 @@ class BoolCalc
         when (@operation == 'SHL')
             @ans = @x << @y
         when (@operation == 'ROL')
-            int_to_binary_arr()
-            rol()
-            @ans = (@bit64_array_x.join).to_i(2)
+            binarr = int_to_binarr(@x)
+            binarr = rol(binarr)
+            @ans = binarr.join.to_i(2)
         when(@operation == 'ROR')
-            int_to_binary_arr()
-            ror()
-            @ans = (@bit64_array_x.join).to_i(2)
+            binarr = int_to_binarr(@x)
+            binarr = ror(binarr)
+            @ans = (binarr.join).to_i(2)
         when(@operation == 'MUL')
             @ans = @x * @y
         when(@operation == 'ADD')
@@ -71,6 +75,8 @@ class BoolCalc
     end
     # Neatly displays results
     def print_results()
+        String.disable_colorization = true if (@options[:nocolor])
+        
         print "\t---------------------------------------\n".green
         print_all_radix(@x)
         if (@y != nil && @operation != "NOT")
@@ -86,35 +92,31 @@ class BoolCalc
     
     # Detect any errors before operation execution
     def check_for_errors()
-        # no operation read
+        # no op read
         abort("ERROR, Expected Operation".red) if (@operation.nil?)
-        # at least one number read to continue
-        abort("ERROR, Expected Number(s) for #{@operation}".red) if (@x.nil?)
-
+        
+        # make sure binary ops have binary input 
+        restriction = ((@operation != "NOT" && @operation != "RAD") &&@y.nil?)
+        # also make sure we have read at least 1 number
+        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))
             abort("ERROR, Divide by 0 for Operation:\t#{@operation}".red)
         end 
-
-        # make sure binary operations have binary input 
-        restriction = (@operation != "NOT" && @operation != "RAD")
-        if restriction && (@y.nil?)  
-            abort("ERROR, Expected Number(s) for Operation:\t#{@operation}".red)
-        end
     end 
     
     # Use regular expressions to parse arguments passed.
-    def parse_args(arr = nil)
+    def parse_args()
         #exit if no args passed; parse flags only if needed
         usage() if ARGV.empty? 
         parse_flags if (ARGV[0][0] == "-")
         
-        # for using in a script
-        arr = ARGV if arr.nil?
-        
-        arr.each do |a|
+        ARGV.each do |a|
             case 
-            #if ARGV[a] is letters only,check if its a valid operation
+            #check if valid operation choice
             when (a == a[/[a-zA-Z]*/])
                 @ops.each do |ops_elem|
                     if (a.upcase == ops_elem)
@@ -144,10 +146,19 @@ class BoolCalc
     def parse_flags()
         flags = ARGV[0]
         flags.split("").each do |f|
-            usage() if f.upcase == "H" 
-            @no_color = true if f.upcase == "N"
+            case
+            when f == "n"
+                @options[:nocolor] = true
+            when f == "h"
+                usage
+            when f == "f"
+                @options[:bit4] = false
+            when f == "s"
+                @options[:bit64] = false
+            when f == "g"
+                @options[:grouped] = true
+            end
         end
-        String.disable_colorization = true if (@no_color)
     end
     # Simple way to check if our number is truly a number
     def is_number(num)
@@ -160,12 +171,19 @@ class BoolCalc
             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, and up to 128 bit format. The results are printed to
-            STDOUT.  
+            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.
+
         Usage:
-            Any flags passed MUST come first.
-            Numbers, and operation order DOES NOT MATTER.
-            Binary operations WILL be parsed left to right.
+            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>
 
             Unary Operations:
                 bitwiseCalc <flag> <num> <operation>
@@ -177,11 +195,17 @@ class BoolCalc
                 <base_2_num>  = 0b[0-1]
                 <base_8_num>  = 0[0-7]
                 <base_16_num> = 0x[0-9a-f]
-        Flags: 
+        Flags:
+            -f
+                disables spacing every 4 bits in binary output 
+            -s
+                disables newline every 64 bits in binary output
             -n
-                disables colorized output(enabled by default)
+                disables colorized output
             -h
                 outputs usage and exits
+            -g 
+                outputs base 10 numbers in grouped form
         Operations:
             NOT 
                 Bitwise NOT, or complement of input.   
@@ -223,75 +247,75 @@ class BoolCalc
         exit
     end
     # Outputs number in Binary form for easier reading
-    # Plus it lets user see what is going on.
+    # Will print 64 bits before moving to the next line
     def print_nice_binary(num)
-        if num <= (2**31)
-            puts "\t32 Bit Format(MSB First)".yellow
-            print "\t"
-            31.downto(0) do |n| 
-                print num[n]
-                if (n%4 == 0); print " " end
-            end
-            puts
-        end
-        if num <= (2**63)
-            puts "\n\t64 Bit Format(MSB First)".yellow
-            print "\t"
-            63.downto(0) do |n|
-                print num[n]
-                print " " if (n%4 == 0) 
-            end
+        case
+        when num <= 2 ** 31
+            max = 31
+        when num <= 2 ** 63
+            max = 63
+        when num <= 2 ** 127
+            max = 127
         else
-            puts "\n\t128 Bit Format(MSB First)".yellow
-            print "\t"
-            127.downto(0) do |n|
-                print"\n\t" if (n == 63)
-                print num[n]
-                print " " if (n%4 == 0)
-            end
+            max = 255
         end
+        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 " " 
+            end
+            print num[n]
+        end  
         puts
     end
     #Converts an integer to a binary array
-    def int_to_binary_arr()
-        @bit64_array_x = []
-        63.downto(0) do |n|
-            @bit64_array_x << @x[n]
+    def int_to_binarr(arr)
+        tmparr = []
+        255.downto(0) do |n|
+            tmparr << arr[n]
         end
+        tmparr
     end
     # Rotate right implementation 
-    def ror()
-        arr_tail = @bit64_array_x.length-2
+    def ror(tmparr)
+        arr_tail = tmparr.length-2
         for i in 1..@y
             #save least significant bit(end of array) 
-            lsb = @bit64_array_x[-1]
+            lsb = tmparr[-1]
             for j in 0..arr_tail
                 if j == 0
-                    tmp1 = @bit64_array_x[j+1]
-                    @bit64_array_x[j+1] = @bit64_array_x[j]
+                    tmp1 = tmparr[j+1]
+                    tmparr[j+1] = tmparr[j]
                 end
                 #save next element, make next element previously saved elem
-                tmp2 = @bit64_array_x[j+1]
-                @bit64_array_x[j+1] = tmp1
+                tmp2 = tmparr[j+1]
+                tmparr[j+1] = tmp1
                 tmp1 = tmp2  
             end
             #assign least significant bit(end of array) to head of array
-            @bit64_array_x[0] = lsb
+            tmparr[0] = lsb
         end
+        print tmparr.length
+        tmparr
     end
     # Rotate left implementation 
-    def rol()
-        arr_tail = @bit64_array_x.length-2
+    def rol(tmparr)
+        arr_tail = tmparr.length-2
         for i in 1..@y
             #save most significant bit(beginning of array)
-            msb = @bit64_array_x[0]
+            msb = tmparr[0]
             for j in 0..arr_tail
                 #assign next element in array to current element in array
-                @bit64_array_x[j] = @bit64_array_x[j+1]
+                tmparr[j] = tmparr[j+1]
             end
             #assign most significant bit to tail
-            @bit64_array_x[-1] = msb
-        end 
+            tmparr[-1] = msb
+        end
+        tmparr 
     end       
 end
 def main()
@@ -302,3 +326,4 @@ def main()
     runtime.print_results()
 end
 main()  
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitwiseCalc
 version: !ruby/object:Gem::Version
-  version: 1.4.11
+  version: 1.5.0
 platform: ruby
 authors:
 - Hector Vargas
 autorequire: 
 bindir: lib
 cert_chain: []
-date: 2015-09-17 00:00:00.000000000 Z
+date: 2016-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -30,7 +30,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.7.7
-description: A simple BitWise Calculator that can peform arithmetic
+description: A simple CLI  BitWise Calculator that can peform arithmetic
 email: hjvargas1213@gmail.com
 executables:
 - bitwiseCalc
@@ -61,5 +61,5 @@ rubyforge_project:
 rubygems_version: 2.2.5
 signing_key: 
 specification_version: 4
-summary: BitWise Calculator
+summary: BitWise Calculator CLI tool
 test_files: []