fixed_point 0.1.0

data/HISTORY.md

@@ -0,0 +1,14 @@
+HISTORY/Changelog
+=================
+
+0.1.0
+-----
+
+ Improved API, to_b, to_h, to_i, to_f
+ Working hex output
+
+0.0.1
+-----
+
+ Define number of integer and fractional bits with real/integer value input. 
+

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2011, Morgan Prior
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the organization nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/README.md

@@ -0,0 +1,35 @@
+FixedPoint
+============
+
+For modeling fixed point signed and unsigned data types and having nice function for printing hex and binary forms.
+
+Install
+-------
+
+    gem install fixed_point
+
+Usage
+-----
+
+Checkout the examples folder, but here are a few:
+ 
+    require 'fixed_point'
+
+    #Create fixed point format, Signed, 12 integer bits, 4 fractional bits
+    format  = FixedPoint::Format.new(1, 12, 4) 
+
+    #Create fixed_point with value 1024.75
+    fix_num = FixedPoint::Number.new(1024.75, format )
+
+    puts fix_num.to_f # Float
+    puts fix_num.to_h # Hexadecimal
+    puts fix_num.to_b # Binary
+    
+TODO
+----
+
+
+LICENSE
+-------
+
+See the LICENSE file

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rspec/core/rake_task'
+
+file_list = FileList['spec/*_spec.rb']
+
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.pattern = file_list
+  t.rspec_opts = ["--colour", "--format progress"]
+end
+
+desc 'Default: run specs.'
+task :default => 'spec'

data/lib/fixed_point.rb

@@ -0,0 +1,13 @@
+module FixedPoint
+  VERSION = '0.1.0'
+end
+
+begin
+  require_relative 'fixed_point/format'
+  require_relative 'fixed_point/fixdt'
+  require_relative 'fixed_point/number'
+rescue
+  require 'fixed_point/format'
+  require 'fixed_point/fixdt'
+  require 'fixed_point/number'
+end

data/lib/fixed_point/fixdt.rb

@@ -0,0 +1,8 @@
+module FixedPoint
+  class Fixdt < Format
+    #Designed to be compatible with Matlab/Simulink types
+    def initialize(signed, width, frac_bits)
+      super( signed, width-frac_bits, frac_bits )
+    end
+  end
+end #module FixedPoint

data/lib/fixed_point/format.rb

@@ -0,0 +1,55 @@
+module FixedPoint
+
+  class Format
+
+    attr_reader :signed, :int_bits, :frac_bits
+    
+    # Calculated attributes
+    attr_reader :width
+    attr_reader :resolution, :max_value, :min_value 
+    attr_reader :max_int_signed, :max_int_unsigned
+    attr_reader :max_frac
+    attr_reader :max_signed, :max_unsigned
+
+    def initialize(signed, int_bits, frac_bits)
+      @signed    = signed
+      @int_bits  = int_bits
+      @frac_bits = frac_bits
+
+      calculate_attributes(signed, int_bits, frac_bits)
+    end
+
+    def signed?
+      (@signed == 1)
+    end
+
+    #Format Should hold the maxim possible values
+    #not part of number (Value)
+    def calculate_attributes(signed, int_bits, frac_bits)
+      @width     = int_bits + frac_bits
+
+      #Calculate Number ranges
+      @resolution       = 2**(-@frac_bits)
+      @max_frac         = 1 - 2**(-@frac_bits)
+      @max_int_signed   = ( 2**(@int_bits - 1) - 1)
+      @max_int_unsigned = ( 2**@int_bits       - 1)
+      @max_signed       = @max_int_signed   + @max_frac
+      @max_unsigned     = @max_int_unsigned + @max_frac
+
+      @min_signed       = (-2**(@int_bits-1))
+      @min_unsigned     = 0
+
+      #Set Max/Min values
+      if signed?
+        @max_value = @max_signed
+        @min_value = @min_signed 
+      else 
+        @max_value = @max_unsigned
+        @min_value = @min_unsigned
+      end
+
+    end
+
+  end
+
+end #module FixedPoint

data/lib/fixed_point/number.rb

@@ -0,0 +1,312 @@
+module FixedPoint
+
+  class Number
+    attr_reader :source #Input value
+    attr_reader :format
+
+    ############################################
+    #### Note
+    ## All methods which set the @source value
+    ## must also set the @quantised value.
+    ## Every thing else is calculated on the fly
+    ## based on those 2 values
+    ############################################
+
+
+    ####################################
+    ### Init
+    ####################################
+    def initialize(number, input_format=Format.new(1,12,20), decimal_mark=".")
+      @source       = number
+      @format       = input_format
+      @decimal_mark = decimal_mark
+
+      @warnings     = false
+
+      #Now construct values based on config data
+      @quantised    = quantise_value( source )
+    end
+
+    ####################################
+    ### Number overflow/underflow flags 
+    ####################################
+    def overflow?
+      @overflow
+    end
+
+    def underflow?
+      @underflow
+    end
+
+    ####################################
+    ### Methods to return number formats
+    ####################################
+    def bin
+      binary
+    end
+
+    def hex
+      hexadecimal
+    end
+
+    #To Binary form
+    def to_b
+      binary
+    end
+
+    #To Hexadecimal form
+    def to_h
+      hexadecimal
+    end
+
+    #To Floating Point form, quantised version of _source_
+    def to_f
+      @quantised
+    end
+
+    #To Integer, limited integer part of _source_ 
+    def to_i
+      @quantised.to_i
+    end
+
+    # Method returns fractional section of fixed point type
+    # not a to_ method as it is not representative of the whole number
+    def frac
+      (@quantised - to_i)
+    end
+
+    def fraction
+      frac
+    end
+    
+    ####################################
+    ### Methods to calculate formats
+    ####################################
+    def binary
+      #Take signed quantised value and create binary string
+      if (@quantised < 0) and fraction.nonzero?
+        # Fractional numbers not negative
+        # So the integer part is 1 less than other wise would be and add 1+frac
+        ret_bin_int = (@format.max_int_unsigned + to_i  )
+        frac_value  = 1 + fraction
+      end
+
+      if (@quantised < 0) and fraction.zero?
+        ret_bin_int = (@format.max_int_unsigned + to_i + 1 )
+        frac_value  = fraction
+      end
+
+      if @quantised >= 0
+        ret_bin_int = self.to_i
+        frac_value  = fraction
+      end
+
+      ## Convert to binary String and extend to correct length
+      ret_bin_int = ret_bin_int.to_s(2).rjust(@format.int_bits, '0')
+
+      ## Normalise Fractional (fractional bits shifted to appear as integer)
+      ret_bin_frac = Integer(frac_value * 2**@format.frac_bits)
+      ret_bin_frac = ret_bin_frac.to_s(2).rjust(@format.frac_bits, '0' ) 
+
+      #Decide if we need to add Decimal( Binary ) Point
+      if @format.frac_bits > 0
+        binary_string = ret_bin_int +  @decimal_mark + ret_bin_frac
+      else 
+        binary_string = ret_bin_int
+      end
+
+      return binary_string
+    end 
+
+    def hexadecimal
+      #Clean Binary code (remove _ - . etc)
+      clean_binary = to_b.scan(/[01]/).join('')
+
+      #Convert to unsigned int then to hex
+      hex          = clean_binary.to_i(2).to_s(16)
+      hex_chars    = (@format.width/4.0).ceil
+
+      ## Extend to the correct length
+      ## Negative numbers will already have MSBs this if for small +VE
+      return hex.rjust(hex_chars, '0')
+    end
+
+    ####################################
+    ### Methods to set value from fixed point format
+    ####################################
+    def binary=(text)
+      if text.match(/([01]*)(.?)([01]*)/ )
+        set_int       = $1
+        int_bits      = $1.size 
+
+        @decimal_mark = $2
+        set_frac      = $3
+        frac_bits     = $3.size
+
+        #TODO Warn if the number of bits supplied does not match @format 
+
+        ## This should now create a new format type
+        #  Do not change the Signed format as can not detect that from bit pattern
+        @format = Format.new(@format.signed, int_bits, frac_bits)
+
+        ###########################
+        ### Routine to generate source from binary
+        ###########################
+        @source  = 0.0
+        index    = 0
+        set_int.reverse.each_char do |x|
+          if x == "1"
+            #If input is signed then MSB is negative
+            if ((index + 1) == @format.int_bits) and (@format.signed?)
+              @source = @source + -2**index 
+            else  
+              @source = @source + 2**index 
+            end
+          end
+          index = index + 1
+        end
+
+        index = 1
+        set_frac.each_char do |x|
+          if x == "1"
+            @source = @source + 2**-index
+          end
+          index = index + 1
+        end
+        ################################
+        
+        ## Set the Quantised value
+        @quantised = @source
+
+        return binary
+      else 
+        puts "ERROR invalid input binary\(#{text}\)"
+        return nil
+      end
+    end
+
+    #def hex=( text )
+    #end
+
+
+    #TODO
+    #def log
+    #def log2
+
+    def warnings( val=true )
+      @warnings = val
+    end
+
+    private
+
+    def check_for_overflow_underflow( source, format)
+      overflow  = false
+      underflow = false
+
+      #WARN +VE
+      if (source > 0) and (source > format.max_value)
+        puts "WARNING Maximum number is #{format.max_value} input was #{source}" if @warnings 
+        overflow = true
+      end
+
+      ##WARN -VE
+      if (source < 0) and (source < format.min_value)
+        puts "WARNING Minimum number is #{format.min_value} input was #{source}" if @warnings
+        underflow = true
+      end
+
+      return [overflow, underflow]
+    end
+
+
+    def quantise_value( source )
+      #Overflow / Underflow flags
+      @overflow, @underflow = check_for_overflow_underflow( source, @format)
+      
+      ## Create fractional only number
+      source_frac = source - source.to_i
+
+      #Logic for fractional negative numbers is different
+      if (( source < 0) and source_frac.nonzero? )
+        #Integer bits become 1 more negative
+        number_int  = Integer( source )-1
+
+        #The @fractional part inverts so int+frac = original number
+        number_frac = ( source - number_int)
+      else
+        # Create Integer only number
+        number_int  = source.to_i
+        
+        #Fractional Part
+        number_frac = source_frac
+      end
+
+
+      if overflow?
+        if @format.signed?
+          number_int  = @format.max_int_signed
+          number_frac = @format.max_frac
+        else
+          number_int  = @format.max_int_unsigned
+          number_frac = @format.max_frac
+        end
+      end
+
+      if underflow?
+        if @format.signed?
+          number_int  = 2**(@format.int_bits-1)
+          number_frac = 0
+        else
+          number_int  = 0
+          number_frac = 0
+        end
+      end
+
+      ##Roll the integer number over the number space so binary conversion gives correct Twos complement
+      if number_int < 0
+        number_int = @format.max_int_unsigned + (number_int + 1)
+      end
+
+      ###################################
+      ### Quantized Fractional value
+      ###################################
+      # Normalise, represent as integer
+      # Fractional data is removed by the integer.
+      # We are only left with @format.frac_bits worth of data
+      number_frac_quant = (number_frac * 2**@format.frac_bits).to_i / (2**@format.frac_bits).to_f
+
+      # TODO Comment on what this is actually doing
+      # some sought of signed conversion
+      if (@source < 0) and number_frac_quant.nonzero?
+        number_int        = number_int - @format.max_int_unsigned
+        number_frac_quant = number_frac_quant - 1
+      end
+
+      if (@source < 0) and number_frac_quant.zero?
+        number_int        = number_int - @format.max_int_unsigned - 1
+        number_frac_quant = 0
+      end
+
+      return (number_int + number_frac_quant)
+    end ## quantise_input
+
+
+
+
+   
+    ## Taking methd out until covered by tests
+    #def normalised
+    #  #This use to be only for positive numbers
+    #
+    #  # This function shiftes the fixedpoint number 
+    #  #   so it can be represented as an integer.
+    #  return  Integer((@quantised)*(2**@format.frac_bits))
+    #end
+
+    def FixedPoint_debug(msg)
+      if true == false
+        puts msg
+      end
+    end
+  end #class number
+end #module FixedPoint

data/spec/fixed_point_negative_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe FixedPoint do
+
+it "Negative Integers -1 " do
+  format = FixedPoint::Format.new(1,4,0)
+  fixt   = FixedPoint::Number.new(-1.0, format, "_")
+
+  fixt.source.should   == -1.0
+  fixt.to_f.should     == -1.0
+  fixt.to_i.should     == -1
+  fixt.frac.should == 0.0
+  fixt.to_h.should     == "f"
+  fixt.to_b.should     == "1111"
+end
+
+it "Negative Integers -2 " do
+  format = FixedPoint::Format.new(1,4,0)
+  fixt   = FixedPoint::Number.new(-2.0, format, "_")
+
+  fixt.source.should   == -2.0
+  fixt.to_f.should     == -2.0
+  fixt.to_i.should     == -2
+  fixt.frac.should     == 0.0
+  fixt.to_h.should     == "e"
+  fixt.to_b.should     == "1110"
+end
+
+it "Negative Integers -1.5 " do
+  format = FixedPoint::Format.new(1,4,4)
+  fixt   = FixedPoint::Number.new(-1.5, format, "_")
+
+  fixt.source.should   == -1.5
+  fixt.to_f.should     == -1.5
+  fixt.to_i.should     == -1
+  fixt.frac.should     == -0.5
+  fixt.to_h.should     == "e8"
+  fixt.to_b.should     == "1110_1000"
+end
+it "Negative Integers -2.25 " do
+  format = FixedPoint::Format.new(1,4,4)
+  fixt   = FixedPoint::Number.new(-2.25, format, "_")
+
+  fixt.source.should   == -2.25
+  fixt.to_f.should     == -2.25
+  fixt.to_i.should     == -2
+  fixt.frac.should     == -0.25
+  fixt.to_h.should     == "dc"
+  fixt.to_b.should     == "1101_1100"
+end
+
+end

data/spec/fixed_point_spec.rb

@@ -0,0 +1,311 @@
+require 'spec_helper'
+
+# def initialize(number, Format.new(signed=1, int_bits=12, frac_bits=20), decimal_mark=".")
+# source Input Number 
+# to_f   quantised value as float
+# to_i   quantised value as integer
+# frac   fractional part of quantised value
+# to_h   quantised value as string formatted as hex
+# to_b   quantised value as string formatted as binary
+#
+
+describe FixedPoint do
+
+  it "Returns 0.0 for initalise of 0" do
+    fixt = FixedPoint::Number.new(0)
+
+    fixt.source.should    == 0.0
+    fixt.to_f.should      == 0.0
+    fixt.to_i.should      == 0
+    fixt.frac.should      == 0.0
+    fixt.to_h.should      == "00000000"
+    fixt.to_b.should      == "000000000000.00000000000000000000"  
+end
+
+it "Integers 0 " do
+  format = FixedPoint::Format.new(1,8,0)
+  fixt   = FixedPoint::Number.new(7.0, format, "_")
+
+  fixt.source.should   == 7.0
+  fixt.to_f.should     == 7.0
+  fixt.to_i.should     == 7
+  fixt.frac.should     == 0.0
+  fixt.to_h.should     == "07"
+  fixt.to_b.should     == "00000111"
+end
+
+it "Different Decimal Mark _ instead of ." do
+  format = FixedPoint::Format.new(1,12,20)
+  fixt   = FixedPoint::Number.new(0, format, "_")
+
+  fixt.source.should   == 0.0
+  fixt.to_f.should     == 0.0
+  fixt.to_i.should     == 0
+  fixt.frac.should     == 0.0
+  fixt.to_h.should     == "00000000"
+  fixt.to_b.should     == "000000000000_00000000000000000000"
+end
+
+(1...20).to_a.reverse_each do |x|
+  int_bits = 12
+  it "Returns 0.0 for initalise of 0 with #{x} fractional bits" do
+    format = FixedPoint::Format.new(1, int_bits, x)
+    fixt   = FixedPoint::Number.new(0, format)
+    #fixt = FixedPoint::Number.new(0,1,int_bits,x)
+
+    fixt.source.should   == 0.0
+    fixt.to_f.should     == 0.0
+    fixt.to_i.should     == 0
+    fixt.frac.should     == 0.0
+    #Calculate hex length and fill with 0's
+    hex = ""
+    hex_length = ((x.to_f+int_bits.to_f)/4).ceil
+    hex_length.times { hex += "0" }
+    fixt.to_h.should     == hex
+    #Calculate binary fractional length and fill with 0's
+    lsbs = ""
+    x.times { lsbs += "0" }
+    fixt.to_b.should     == "000000000000.#{lsbs}"
+end
+end
+
+
+it "Zero fractional bits " do
+  format = FixedPoint::Format.new(1,12,0)
+  fixt   = FixedPoint::Number.new(0, format, "_")
+
+  fixt.source.should   == 0.0
+  fixt.to_f.should     == 0.0
+  fixt.to_i.should     == 0
+  fixt.frac.should == 0.0
+  fixt.to_h.should     == "000"
+  fixt.to_b.should     == "000000000000"
+end
+
+
+it "returns 2.5 for initalise of 2.5" do
+  fixt = FixedPoint::Number.new(2.5)
+
+  fixt.source.should   == 2.5
+  fixt.to_f.should     == 2.5
+  fixt.to_i.should     == 2
+  fixt.frac.should == 0.5
+  fixt.to_h.should     == "00280000"
+  fixt.to_b.should     == "000000000010.10000000000000000000"
+  end
+
+
+  it "Truncates fractional numbers correctly" do
+    format = FixedPoint::Format.new(1,12,1)
+    fixt   = FixedPoint::Number.new(2.501, format)
+
+    fixt.source.should   == 2.501
+    fixt.to_f.should     == 2.5
+    fixt.to_i.should     == 2
+    fixt.frac.should == 0.5
+    fixt.to_h.should     == "0005"
+    fixt.to_b.should     == "000000000010.1"
+  end
+
+  ##############################################
+  ###   Overflow Section
+  ##############################################
+  it "Forced Overflow 4 Int Bits, 0 fractional bits " do
+    format = FixedPoint::Format.new(1, 4, 0)
+    fixt   = FixedPoint::Number.new(2**3, format, "_")
+
+    fixt.source.should    == 2**3
+    fixt.to_f.should      == 2**3-1
+    fixt.to_i.should      == 2**3-1
+    fixt.frac.should  == 0.0
+    fixt.to_h.should      == "7"
+    fixt.to_b.should      == "0111"
+    fixt.overflow?.should  == true
+    fixt.underflow?.should == false
+  end
+
+  it "Forced Overflow Zero fractional bits " do
+    format = FixedPoint::Format.new(1, 12, 0)
+    fixt   = FixedPoint::Number.new(2**11, format, "_")
+
+    fixt.source.should    == 2**11
+    fixt.to_f.should      == 2**11-1
+    fixt.to_i.should      == 2**11-1
+    fixt.frac.should      == 0.0
+    fixt.to_h.should      == "7ff"
+    fixt.to_b.should      == "011111111111"
+    fixt.overflow?.should  == true
+    fixt.underflow?.should == false
+  end
+
+  it "Forced Overflow 4 fractional bits " do
+    format = FixedPoint::Format.new(1, 12, 4) 
+    fixt   = FixedPoint::Number.new(2**11, format, ".")
+
+    max_fractional_value  = (1.0/2) + (1.0/4) + (1.0/8) + (1.0/16)
+
+    fixt.source.should    == 2**11
+    fixt.to_f.should      == 2**11 -1 + max_fractional_value
+    fixt.to_i.should      == 2**11 -1
+    fixt.frac.should      == max_fractional_value
+    fixt.to_h.should      == "7fff"
+    fixt.to_b.should      == "011111111111.1111"
+    fixt.overflow?.should  == true
+    fixt.underflow?.should == false
+  end
+
+  it "Forced Overflow  Large overflow" do
+    format = FixedPoint::Format.new(1, 12, 4) 
+    fixt   = FixedPoint::Number.new(2**17, format, ".")
+
+    fixt.source.should    == 2**17
+
+    max_fractional_value = (1.0/2) + (1.0/4) + (1.0/8) + (1.0/16)
+
+    fixt.to_f.should      == 2**11 -1 + max_fractional_value
+    fixt.to_i.should      == 2**11 -1
+    fixt.frac.should      == max_fractional_value
+    fixt.to_h.should      == "7fff"
+    fixt.to_b.should      == "011111111111.1111"
+    fixt.overflow?.should  == true
+    fixt.underflow?.should == false
+  end
+
+  ##############################################
+  ###   Underflow Section
+  ##############################################
+  #Max Negative value
+  it "Forced Overflow Zero fractional bits " do
+    format = FixedPoint::Format.new(1, 12, 0) 
+    fixt   = FixedPoint::Number.new(-2**11, format, "_")
+
+    fixt.source.should    == -2**11
+    fixt.to_f.should      == -2**11
+    fixt.to_i.should      == -2**11
+    fixt.frac.should      == 0.0
+    fixt.to_h.should      == "800"
+    fixt.to_b.should      == "100000000000"
+    fixt.overflow?.should  == false
+    fixt.underflow?.should == false
+  end
+
+  it "Forced Overflow Zero fractional bits " do
+    format = FixedPoint::Format.new(1, 12, 0) 
+    fixt   = FixedPoint::Number.new(-2**11-1, format,"_")
+
+    fixt.source.should    == -2**11-1
+    fixt.to_f.should      == -2**11
+    fixt.to_i.should      == -2**11
+    fixt.frac.should      == 0.0
+    fixt.to_h.should      == "800"
+    fixt.to_b.should      == "100000000000"
+    fixt.overflow?.should  == false
+    fixt.underflow?.should == true
+  end
+
+  it "Forced Overflow 4 fractional bits " do
+    format = FixedPoint::Format.new(1, 12, 4) 
+    fixt   = FixedPoint::Number.new(-2**11-1, format, ".")
+
+    fixt.source.should    == -2**11-1
+    fixt.to_f.should      == -2**11
+    fixt.to_i.should      == -2**11
+    fixt.frac.should      == 0.0
+    fixt.to_h.should      == "8000"
+    fixt.to_b.should      == "100000000000.0000"
+    fixt.overflow?.should  == false
+    fixt.underflow?.should == true
+  end
+
+  it "Forced Overflow  Large overflow" do
+    format = FixedPoint::Format.new(1, 12, 4) 
+    fixt   = FixedPoint::Number.new(-2**17, format, ".")
+
+
+    fixt.source.should    == -2**17
+    fixt.to_f.should      == -2**11
+    fixt.to_i.should      == -2**11
+    fixt.frac.should      == 0.0
+    fixt.to_h.should      == "8000"
+    fixt.to_b.should      == "100000000000.0000"
+    fixt.overflow?.should  == false
+    fixt.underflow?.should == true
+  end
+
+
+  it "Creating via binary form 011_01" do
+    fixt = FixedPoint::Number.new(0)
+
+    fixt.binary = "011_01"
+    fixt.source.should    == 3.25
+    fixt.to_f.should      == 3.25
+    fixt.to_i.should      == 3
+    fixt.frac.should      == 0.25
+    fixt.to_h.should      == "0d"
+    fixt.to_b.should      == "011_01"
+    fixt.overflow?.should  == false
+    fixt.underflow?.should == false
+  end
+
+  it "Creating via binary form 0_1" do
+    fixt = FixedPoint::Number.new(0)
+
+    fixt.binary = "0_1"
+    fixt.source.should    == 0.5
+    fixt.to_f.should      == 0.5
+    fixt.to_i.should      == 0
+    fixt.frac.should      == 0.5
+    fixt.to_h.should      == "1"
+    fixt.to_b.should      == "0_1"
+    fixt.overflow?.should  == false
+    fixt.underflow?.should == false
+  end
+
+  it "Creating Signed via binary form 1000_1" do
+    fixt = FixedPoint::Number.new(0)
+
+    fixt.binary = "1000_1"
+    fixt.source.should    == -7.5
+    fixt.to_f.should      == -7.5
+    fixt.to_i.should      == -7
+    fixt.frac.should      == -0.5
+    fixt.to_h.should      == "11"
+    fixt.to_b.should      == "1000_1"
+    fixt.overflow?.should  == false
+    fixt.underflow?.should == false
+  end
+
+  it "Creating Unsigned via binary form 1000_1" do
+    format = FixedPoint::Format.new(0, 12, 20) 
+    fixt = FixedPoint::Number.new(0,format)
+
+    fixt.binary = "1000_1"
+    fixt.source.should    == 8.5
+    fixt.to_f.should      == 8.5
+    fixt.to_i.should      == 8
+    fixt.frac.should      == 0.5
+    fixt.to_h.should      == "11"
+    fixt.to_b.should      == "1000_1"
+    fixt.overflow?.should  == false
+    fixt.underflow?.should == false
+  end
+
+  it "Creating Unsigned binary form 1000_1 using Fixdt datatype" do
+    format = FixedPoint::Fixdt.new(0, 32, 20)  #Signed,width,frac_bits
+    fixt   = FixedPoint::Number.new(0,format)
+
+    fixt.binary = "1000_1"
+    fixt.source.should    == 8.5
+    fixt.to_f.should      == 8.5
+    fixt.to_i.should      == 8
+    fixt.frac.should      == 0.5
+    fixt.to_h.should      == "11"
+    fixt.to_b.should      == "1000_1"
+    fixt.overflow?.should  == false
+    fixt.underflow?.should == false
+  end
+
+  #need overflow test
+  #need underflow test
+  #Integer only binary test
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rspec'
+require 'fixed_point'

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: fixed_point
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Morgan Prior
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-21 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: Fixed Point numerical type for simulating fixed point calculations
+email: fixed_point_gem@amaras-tech.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- README.md
+- HISTORY.md
+- Rakefile
+- lib/fixed_point/fixdt.rb
+- lib/fixed_point/format.rb
+- lib/fixed_point/number.rb
+- lib/fixed_point.rb
+- spec/fixed_point_negative_spec.rb
+- spec/fixed_point_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://amaras-tech.co.uk/software/fixed_point
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Fixed Point numerical type
+test_files: []
+