FixedPt 0.0.1

data/ext/Makefile

@@ -0,0 +1,140 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /usr/lib/ruby/1.8/i386-linux
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+prefix = $(DESTDIR)/usr
+exec_prefix = $(prefix)
+sitedir = $(DESTDIR)/usr/local/lib/site_ruby
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+archdir = $(rubylibdir)/$(arch)
+sbindir = $(exec_prefix)/sbin
+datadir = $(prefix)/share
+includedir = $(prefix)/include
+infodir = $(prefix)/info
+sysconfdir = $(DESTDIR)/etc
+mandir = $(datadir)/man
+libdir = $(exec_prefix)/lib
+sharedstatedir = $(prefix)/com
+oldincludedir = $(DESTDIR)/usr/include
+sitearchdir = $(sitelibdir)/$(sitearch)
+bindir = $(exec_prefix)/bin
+localstatedir = $(DESTDIR)/var
+sitelibdir = $(sitedir)/$(ruby_version)
+libexecdir = $(exec_prefix)/libexec
+
+CC = gcc
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+
+CFLAGS   =  -fPIC -Wall -g -O2  -fPIC 
+CPPFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir)  
+CXXFLAGS = $(CFLAGS) 
+DLDFLAGS =   
+LDSHARED = $(CC) -shared
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby1.8
+RUBY_SO_NAME = ruby1.8
+arch = i386-linux
+sitearch = i386-linux
+ruby_version = 1.8
+ruby = /usr/bin/ruby1.8
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = install -p
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 0644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = $(libdir)
+LIBPATH =  -L"$(libdir)"
+DEFFILE = 
+
+CLEANFILES = 
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl -lcrypt -lm   -lc
+SRCS = fixedpt.c
+OBJS = fixedpt.o
+TARGET = fixedpt
+DLLIB = $(TARGET).so
+STATIC_LIB = 
+
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).so $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile extconf.h conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb pre-install-rb-default: $(RUBYLIBDIR)
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+$(RUBYLIBDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
+
+.c.o:
+	$(CC) $(CFLAGS) $(CPPFLAGS) -c $<
+
+$(DLLIB): $(OBJS)
+	@-$(RM) $@
+	$(LDSHARED) $(DLDFLAGS) $(LIBPATH) -o $@ $(OBJS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h

data/ext/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile("fixedpt")

data/ext/fixedpt.c

@@ -0,0 +1,351 @@
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include "ruby.h"
+static int id_rawval;
+static int id_ival;
+static int id_bits;
+static int id_binpt;
+static int id_sign;
+static int id_maxint;
+//static int sign;
+static VALUE minus_one;
+static VALUE positive_one;
+
+//#define max(A,B) ( (A) > (B) ? (A):(B))
+//#define min(A,B) ( (A) < (B) ? (A):(B))
+
+int max(int a, int b)
+{
+  return ( a > b ? a : b );
+}
+
+int min(int a, int b)
+{
+  return ( a < b ? a : b );
+}
+
+static VALUE fp_check_sign(VALUE self, VALUE val)
+{
+  double i = NUM2DBL(val);
+  //printf("i is: %f\n",i);
+
+  if(i < 0.0) {
+   // retval = -1;
+   rb_iv_set(self,"@sign",minus_one);
+  }else {
+   // retval = 1;
+   rb_iv_set(self,"@sign",positive_one);
+  }
+  //return INT2FIX(retval);
+  return self;
+}
+
+static VALUE fix_abs(VALUE fix)
+{
+    long i = FIX2LONG(fix);
+
+    if (i < 0) i = -i;
+
+    return LONG2NUM(i);
+}
+
+
+static VALUE rfp_init(VALUE self, VALUE rawval, VALUE total_bits, VALUE binpt)
+{
+  VALUE sign;
+  rb_iv_set(self,"@rawval",fix_abs(rawval));
+  rb_iv_set(self,"@bits",total_bits);
+  rb_iv_set(self,"@binpt",binpt);
+  if( FIX2INT(rawval) < 0){
+    sign = INT2FIX(-1);
+  } else {
+    sign = INT2FIX(1);
+  }
+  rb_iv_set(self,"@sign",sign);
+  return self;
+}
+
+static VALUE rfp_rawval(VALUE self)
+{
+  return rb_iv_get(self,"@rawval");
+}
+
+static VALUE rfp_bits(VALUE self)
+{
+  return rb_iv_get(self,"@bits");
+}
+
+static VALUE rfp_binpt(VALUE self)
+{
+  return rb_iv_get(self,"@binpt");
+}
+
+
+static VALUE rfp_sign(VALUE self)
+{
+  return rb_iv_get(self,"@sign");
+}
+//FixedPt methods
+
+static VALUE fp_set_overflow(VALUE self, VALUE boolval)
+{
+  rb_iv_set(self,"@overflow",boolval);
+  return self;
+}
+
+static VALUE fp_rawval(VALUE self)
+{
+  return rb_iv_get(self,"@ival");
+}
+static VALUE fp_ival(VALUE self)
+{
+  return rb_iv_get(self,"@ival");
+}
+
+static VALUE fp_bits(VALUE self)
+{
+  return rb_iv_get(self,"@bits");
+}
+
+static VALUE fp_int_width(VALUE self)
+{
+  return rb_iv_get(self,"@int_width");
+}
+
+static VALUE fp_frac_width(VALUE self)
+{
+  return rb_iv_get(self,"@frac_width");
+}
+
+static VALUE fp_binpt(VALUE self)
+{
+  return rb_iv_get(self,"@binpt");
+}
+
+static VALUE fp_sign(VALUE self)
+{
+  return rb_iv_get(self,"@sign");
+}
+
+static VALUE fp_maxint(VALUE self)
+{
+  return rb_iv_get(self,"@maxint");
+}
+
+static VALUE fp_value(VALUE self)
+{
+  //int sign   = FIX2INT(fp_sign(self));
+  long sign   = FIX2LONG(fp_sign(self));
+  //int ival   = FIX2INT(fp_ival(self));
+
+  long ival   = FIX2LONG(fp_ival(self));
+  //return (INT2FIX(ival * sign));
+  return (LONG2FIX(ival * sign));
+}
+
+static VALUE fp_check_for_overflow(VALUE self, VALUE result)
+{
+  
+  long val   = FIX2LONG(result);
+  int binpt  = FIX2INT(fp_binpt(self));
+  int bits   = FIX2INT(fp_bits(self));
+  long maxint= FIX2LONG(fp_maxint(self));
+  long tmpval;
+  if(binpt == bits) return result;
+  if((tmpval = val >> binpt)  > maxint ){
+    //printf("OVERFLOW\n"); 
+    //result = LONG2FIX(pow(2,(bits-1)));
+   
+    result = rb_funcall(self,rb_intern("send"),2,rb_iv_get(self,"@overflow_handler"),result);
+    if(tmpval > FIX2LONG(rb_iv_get(self,"@max_int_value")))
+      rb_iv_set(self,"@max_int_value",LONG2NUM(tmpval));
+  }
+  return result;
+}
+
+static VALUE fp_saturate(VALUE self, VALUE result)
+{
+  return ( LONG2FIX( pow(2,(FIX2INT(fp_bits(self))))-1 ) );
+}
+
+/*
+static VALUE fp_check_sizes(VALUE self, VALUE other)
+{
+  int this_binpt  = FIX2INT(fp_binpt(self));
+  int other_binpt = FIX2INT(fp_binpt(other));
+  if(this_binpt != other_binpt ){
+    rb_raise(rb_eRuntimeError, "binary points don't match: ( %d != %d)\n",this_binpt, other_binpt); 
+  }
+  return self; 
+}
+*/
+
+static VALUE fp_calc_min_max(VALUE self)
+{
+  int bits    = FIX2INT(fp_bits(self));
+  int binpt   = FIX2INT(fp_binpt(self)); 
+  int intbits = bits - binpt;
+  long maxint  = pow(2,intbits)-1;
+  rb_iv_set( self,"@maxint", LONG2FIX(maxint) ) ;
+  rb_iv_set( self,"@minint", LONG2FIX(-1*maxint) ) ;
+  return self;
+}
+
+/*
+static VALUE fp_sizes_differ(VALUE self, VALUE other)
+{
+  VALUE ret_bool = T_FALSE;
+  int selfbits     = FIX2INT(fp_bits(self));
+  int otherbits    = FIX2INT(fp_bits(other));
+  int selfbinpt    = FIX2INT(fp_binpt(self));
+  int otherbinpt   = FIX2INT(fp_binpt(other));
+
+  //if( (FIX2INT(fp_bits(self)) != FIX2INT(fp_bits(other))) || (FIX2INT(fp_binpt(self)) != FIX2INT(fp_binpt(other)))  )
+  if((selfbits != otherbits) || (selfbinpt != otherbinpt))
+  { 
+    
+    printf("  self size is: %d  other size is: %d\n", selfbits,otherbits);
+    printf("  self binpt is: %d  other binpt is: %d\n", selfbinpt,otherbinpt);
+    ret_bool = T_TRUE;		  
+  }
+  return  ret_bool;
+}
+*/
+
+static VALUE fp_adjust_sizes(VALUE self, VALUE other)
+{
+  //make array to return:
+  VALUE ret_array = rb_ary_new();
+  int self_width  = FIX2INT(fp_int_width(self));
+  int other_width = FIX2INT(fp_int_width(other));
+  int self_frac_width  = FIX2INT(fp_frac_width(self));
+  int other_frac_width = FIX2INT(fp_frac_width(other));
+  rb_ary_push(ret_array, INT2FIX(max(self_width,other_width)));
+  rb_ary_push(ret_array, INT2FIX(max(self_frac_width,other_frac_width)));
+  
+  return ret_array;
+}
+
+/*
+static VALUE fp_multiply(VALUE self, VALUE other)
+{
+  VALUE result;
+
+  fp_check_sizes(self,other);
+  result = (FIX2INT(fp_value(self)) * FIX2INT(fp_value(other)) >> FIX2INT(fp_binpt(self)) );
+  result = fp_check_for_overflow(self,LONG2FIX(result)); 
+  return result;
+}
+*/
+
+/*
+static VALUE fp_init(VALUE self, VALUE val, VALUE total_bits, VALUE binpt)
+{
+  char* name = rb_class2name(rb_obj_class(val));
+  switch (TYPE(val)) {
+    case T_FIXNUM:
+      rb_funcall(self,rb_intern("construct_from_fixnum"),3,val,total_bits,binpt);
+      //printf("T_FIXNUM:\n");
+      //rb_iv_set(self,"@rawval",val);
+      //rb_iv_set(self,"@bits",total_bits);
+      //rb_iv_set(self,"@binpt",binpt);
+      //rb_iv_set(self,"@sign", INT2FIX(check_sign(val)));
+      break;
+    case T_FLOAT:
+      //printf("T_FLOAT:\n");
+      rb_funcall(self,rb_intern("construct_from_float"),3,val,total_bits,binpt);
+      break;
+    default:
+      //printf("*FixedPT:\n");
+      if( ! strcmp(name,"RawFixedPt") ){
+        //printf("RawFixedPT:\n");
+        //rb_iv_set(self,"@ival",rb_funcall(val,id_rawval,0) );
+        //rb_iv_set(self,"@bits",rb_funcall(val,id_bits,0) );
+        //rb_iv_set(self,"@binpt",rb_funcall(val,id_binpt,0) );
+	//rb_iv_set(self,"@sign",rb_funcall(val,id_sign,0) );
+        //this should be a bit faster:
+        rb_iv_set(self,"@ival",rfp_rawval(val));
+        rb_iv_set(self,"@bits",rfp_bits(val));
+        rb_iv_set(self,"@binpt",rfp_binpt(val));
+	rb_iv_set(self,"@sign",rfp_sign(val));
+
+      }else if( ! strcmp(name,"FixedPt") ){
+        //printf("FixedPT:\n");
+        rb_iv_set(self,"@ival",fp_ival(val));
+        rb_iv_set(self,"@bits",fp_bits(val));
+        rb_iv_set(self,"@binpt",fp_binpt(val));
+	rb_iv_set(self,"@sign",fp_sign(val));
+      }else {
+        rb_raise(rb_eTypeError, "not a valid value");
+      }
+      break;
+  }
+  int diff= FIX2INT(rb_iv_get(self,"@bits"))-FIX2INT(rb_iv_get(self,"@binpt"));
+  rb_iv_set(self,"@maxint", LONG2FIX((pow(2,diff ))-1 ) ) ;
+  return self;
+}
+*/
+/*
+static VALUE fp_init(VALUE self, VALUE val, VALUE total_bits, VALUE binpt)
+{
+   //rb_funcall(self,rb_intern("from_fixnum"),3,val,total_bits,binpt);
+   char* name = rb_class2name(rb_obj_class(val));
+   int type = TYPE(val);
+   printf("type: %d\n",type);
+   printf("class name: %s\n",name);
+   printf("T_FIXNUM:\n");
+   rb_iv_set(self,"@rawval",val);
+   rb_iv_set(self,"@bits",total_bits);
+   rb_iv_set(self,"@binpt",binpt);
+   rb_iv_set(self,"@sign", INT2FIX(check_sign(val)));
+   return self;
+}
+*/
+
+VALUE cRawFixedPt;
+VALUE cFixedPt;
+
+void Init_fixedpt() {
+  //class RawFixedPt
+  cRawFixedPt = rb_define_class("RawFixedPt", rb_cObject);
+  rb_define_method(cRawFixedPt,"initialize", rfp_init, 3);
+  rb_define_method(cRawFixedPt,"rawval",rfp_rawval,0);
+  rb_define_method(cRawFixedPt,"bits",rfp_bits,0);
+  rb_define_method(cRawFixedPt,"binpt",rfp_binpt,0);
+  rb_define_method(cRawFixedPt,"sign",rfp_sign,0);
+
+  //class FixedPt
+  cFixedPt = rb_define_class("FixedPt",rb_cObject);
+  //rb_define_method(cFixedPt,"initialize",fp_init,3);
+  rb_define_method(cFixedPt,"check_sign",fp_check_sign,1);
+  rb_define_method(cFixedPt,"rawval",fp_rawval,0);
+  rb_define_method(cFixedPt,"ival",fp_ival,0);
+  rb_define_method(cFixedPt,"bits",fp_bits,0);
+  rb_define_method(cFixedPt,"binpt",fp_binpt,0);
+  rb_define_method(cFixedPt,"sign",fp_sign,0);
+  rb_define_method(cFixedPt,"maxint",fp_maxint,0);
+  //rb_define_method(cFixedPt,"check_sizes",fp_check_sizes,1);
+  rb_define_method(cFixedPt,"value",fp_value,0);
+  //rb_define_method(cFixedPt,"multiply",fp_value,1);
+  rb_define_method(cFixedPt,"check_for_overflow",fp_check_for_overflow,1);
+  rb_define_method(cFixedPt,"calc_min_max",fp_calc_min_max,0);
+  //rb_define_method(cFixedPt,"sizes_differ?",fp_sizes_differ,1);
+  rb_define_method(cFixedPt,"adjust_sizes",fp_adjust_sizes,1);
+  rb_define_method(cFixedPt,"saturate",fp_saturate,1);
+  //rb_define_method(cFixedPt," fp_set_overflow(VALUE self, VALUE boolval)
+  //
+
+  //create symbols here:
+  id_rawval    = rb_intern("rawval");
+  id_ival      = rb_intern("ival");
+  id_bits      = rb_intern("bits");
+  id_binpt     = rb_intern("binpt");
+  id_sign      = rb_intern("sign");
+  id_maxint    = rb_intern("maxint");
+
+  minus_one    = INT2NUM(-1);
+  positive_one = INT2NUM(1);
+}
+
+

data/lib/fixedpt/fixedpt.rb

@@ -0,0 +1,411 @@
+class Numeric
+  def to_fp(wid,binpt)
+    FixedPt.new(self,wid,binpt)
+  end
+end
+
+module FPHelpers
+
+  def max(x,y)
+    return x > y ? x : y
+  end
+
+  def min(x,y)
+    return x < y ? x : y
+  end
+
+end
+
+include FPHelpers
+class OverflowException < RangeError
+end
+
+begin
+  #require '/home/phil/development/fixedpt/ext/fixedpt.so'
+  require 'fixedpt.so'
+rescue LoadError
+  puts "Couldn't find ext/fixedpt.so: thing's will run slow, but it'll work"
+
+  class RawFixedPt #used only to make FixedPt constructor easier (see case statment below)
+    attr_reader :rawval, :bits, :binpt, :sign
+    def initialize(rawval,total_bits,binpt)#,sign)
+      @rawval = rawval
+      @bits   = total_bits
+      @binpt  = binpt
+      #@sign   = sign
+      @sign  = if rawval < 0
+               -1
+	     else
+               1
+             end
+      @rawval = rawval.abs
+
+      puts "@rawval = #{rawval}, @bits = #{@bits}, @binpt = #{binpt}, @sign = #{@sign}" if $DEBUG
+    end
+
+  end
+
+  class FixedPt
+
+  def calc_min_max
+    #TODO: What about simulating 2's complement?
+    #for 2's comp:  positive @maxint = (2**(@bits-@binpt-1)-1) 
+    #               negative @minint = -(2**(@bits-@binpt)-1)
+    @maxint = (2**(@bits-@binpt) - 1) 
+    @minint = -(2**(@bits-@binpt-1) ) 
+  end
+
+  def check_sign(val)
+    puts "check_sign(#{val})" if $DEBUG
+    if val < 0
+      @sign = -1
+    else
+      @sign = 1
+    end
+  end
+
+  def size
+    @bits
+  end
+
+  def adjust_sizes(other)
+    return [ max(self.int_width, other.int_width), max(self.frac_width, other.frac_width)]
+  end
+
+  def check_for_overflow(result)
+    @overflow = false
+    return result if @binpt == @bits
+    #shift result right binpt times
+    puts "result is: #{result}" if $DEBUG
+    puts "if((#{result >> @binpt} ) > #{@maxint} )" if $DEBUG
+    if ((tmpval = result >> @binpt ) > @maxint )
+      @overflow = true
+      if(tmpval > @max_int_value)
+        @max_int_value = tmpval
+      end
+      result = self.send @overflow_handler, result
+    end
+    result
+  end
+
+  def saturate(result)
+    #NOTE: result below is the maximal result for this number of bits
+    result = (2**@bits - 1)
+  end
+
+  def truncate(result)
+    result & (2**@bits-1)  
+  end
+
+  end #FixedPt
+  #end of rescue
+else
+end
+
+class FixedPt
+  attr_accessor  :ival, :bits, :maxint, :minint, :binpt, :sign, :int_width, :frac_width
+  attr_reader :max_int_value, :overflow
+  def initialize(val,total_bits=nil,binpt=nil,overflow_handler=:saturate)
+    #TODO: what if total_bits and binpt are nil?
+    #raise "binpt should be less than total_bits!" if binpt > total_bits
+    @overflow = false
+    @overflow_handler = overflow_handler
+    @max_int_value = 0
+    case val
+    when Fixnum
+      construct_from_fixnum(val,total_bits,binpt)
+    when Float
+      construct_from_float(val,total_bits,binpt)
+    when FixedPt #essentially a copy constructor
+      #was:@ival = val.ival
+      @ival = check_for_overflow(val.ival)
+      @bits = total_bits || val.bits #so you can override total # of bits
+      @binpt= val.binpt #but binpt should remain at same position(for now)
+      @sign = val.sign
+      @frac_width = @binpt
+      @int_width  = @bits - @binpt
+
+    when RawFixedPt
+      #construct a FixedPt with a RawFixedPt
+      @ival = val.rawval
+      @bits = val.bits
+      @binpt= val.binpt
+      @sign = val.sign
+      @frac_width = @binpt
+      @int_width  = @bits - @binpt
+    else
+    end
+  end
+
+  def check_binpt
+    raise "binpt should be less than total_bits!" if @binpt >= @total_bits
+  end
+  def value
+    @ival*@sign
+  end
+
+  def construct_from_fixnum(val,total_bits,binpt)
+    @bits = total_bits
+    @binpt= binpt
+    calc_min_max
+    check_sign(val)
+    #was:@ival = (val.abs << binpt)  
+    @ival = check_for_overflow(val.abs << binpt)  
+    @frac_width = @binpt
+    @int_width  = @bits - @binpt
+    puts "@ival is: #{@ival}" if $DEBUG
+  end
+
+  def construct_from_float(val,total_bits,binpt)
+    @bits = total_bits
+    @binpt= binpt
+    @frac_width = binpt
+    @int_width  = total_bits - binpt
+    calc_min_max
+    check_sign(val)
+    #was:@ival = (val*(2**@binpt)).round.abs #NOTE:do we want to round or not?
+    #then:@ival = check_for_overflow(val*(2**@binpt)).round.abs #NOTE:do we want to round or not?
+    #now:
+    from_float(val)
+  end
+
+  def from_float(val)
+    #was: (val*(2**@binpt)).round.abs #NOTE:do we want to round or not?
+    @ival = check_for_overflow((val*(2**@binpt)).round.abs) #NOTE:do we want to round or not?
+  end
+
+  def assign(val)
+    case val
+    when Float
+      #was:@ival = from_float(val)
+      from_float(val)
+      check_sign(val)
+    when Fixnum
+      @ival = (val << @binpt )
+      check_sign(val)
+    when FixedPt
+      from_FixedPt(val)
+    else
+    end
+  end
+
+  def from_FixedPt(other)
+    if sizes_differ?(other)
+      other = FixedPt.new(other.to_f,@bits,@binpt)  
+    end
+    @ival = check_for_overflow(other.raw)
+    @sign = other.sign
+  end
+
+  def raw
+    @ival
+  end
+
+  def to_bin
+    #str = sprintf("%0#{@bits}b",@ival)
+    str = if @sign < 0
+      sprintf("%0#{@bits}b",2**@bits-@ival)
+    else
+      sprintf("%0#{@bits}b",@ival)
+    end
+    return str
+  end
+
+  def to_binary
+    str = self.to_bin
+    values = str.split('')
+    values.insert(@bits-@binpt,".")
+    values.join('')
+  end
+
+  def to_int
+    (@ival >> @binpt)
+  end
+
+  def to_i
+    to_int
+  end
+
+  def to_s
+    to_int.to_s 
+  end
+
+  #convert our limited representation back to float
+  def to_f
+    f = self.to_int.to_f
+    puts " Initial f is: #{f}" if $DEBUG
+    puts " self.raw is: #{self.raw}" if $DEBUG
+    x = self.raw
+    (0 .. (@binpt -1)).each {|i|
+       puts "... is is: #{i} " if $DEBUG
+       delta = x[i]*(1.0/(2**(@binpt-i)))
+       puts "... delta is: #{delta} x[#{i}] is #{x[i]}" if $DEBUG
+       f += delta
+    }
+    puts "@sign is #{@sign}" if $DEBUG
+    f *@sign
+  end
+
+
+  def to_fp(wid=@bits,binpt=@binpt)
+    self
+  end
+
+
+  def sizes_differ? (other)
+    return ( self.binpt != other.binpt || self.bits != other.bits )
+  end
+
+  def /(other)
+    #pass the buck: implement in terms of multiplication
+    result = ((self) * (FixedPt.new((1.0/other.to_f),@bits,@binpt)))  
+    return result
+  end
+
+  def *(other)
+    if Fixnum === other || Float === other
+      other = FixedPt.new(other,@bits,@binpt) 
+    end
+    if sizes_differ?(other)
+      
+      int_width,frac_width = adjust_sizes(other) 
+      a = FixedPt.new(self.to_f,(int_width+frac_width),frac_width)
+      b = FixedPt.new(other.to_f,(int_width+frac_width),frac_width)
+      return (a * b)
+    else
+      result = ((self.value) * (other.value))  
+      return FixedPt.new(RawFixedPt.new(result,(2*@bits),2*@binpt),nil,nil)
+    end
+    #end
+  end
+
+  #perhaps this could be called 'increase_resolution'
+  #effect: it preserves the integer portion of the number and
+  #increases the number of positions to the right of the binary point
+  #this increasing resolution
+  def shift_left(num) #for conversion purposes
+    #maintain same integer range, add fractional bits
+    result = FixedPt.new(RawFixedPt.new(((self.raw) << num),(@bits+num),(@binpt+num)),nil,nil)
+  end
+
+  def shift_right(num) #for conversion purposes, integer portion should
+	               #be preserved
+    if num > @binpt
+      raise "can't shift right #{num} positions: only #{@binpt} positions"
+    end
+    return FixedPt.new(RawFixedPt.new((self.raw>>num),(@bits-num),(@binpt-num)),nil,nil) 
+  end
+
+
+  def <<(num)
+    result = FixedPt.new(RawFixedPt.new(((self.raw)<<num),@bits,@binpt),@bits,@binpt)
+  end
+
+  def ranged_int_part
+    @ival = (@ival & 2**@bits-1)
+  end
+
+  def +(other) #assume result size is self size
+      if Fixnum === other || Float === other
+        other = FixedPt.new(other,@bits,@binpt) 
+      end
+      if sizes_differ?(other)
+        int_width,frac_width = adjust_sizes(other) 
+	a = FixedPt.new(self.to_f,(int_width+frac_width),frac_width)
+	b = FixedPt.new(other.to_f,(int_width+frac_width),frac_width)
+        return (a + b)
+      else
+        result = (self.value ) + (other.value ) 
+        return FixedPt.new(RawFixedPt.new(result, @bits, @binpt),nil,nil )#,sign))
+      end
+  end
+
+  def coerce(other)
+    if Integer === other
+      [other, self.value]
+    else
+      [other.to_f,self.to_f]
+    end
+  end
+
+  def -(other) #assume result size is self size
+    if Fixnum === other || Float === other
+      other = FixedPt.new(other,@bits,@binpt) 
+    end
+    if sizes_differ?(other)
+      int_width,frac_width = adjust_sizes(other) 
+      a = FixedPt.new(self.to_f,(int_width+frac_width),frac_width)
+      b = FixedPt.new(other.to_f,(int_width+frac_width),frac_width)
+      return (a - b)
+    else
+      result = (self.value ) - (other.value ) 
+      return FixedPt.new(RawFixedPt.new(result, @bits, @binpt),nil,nil )#,sign))
+    end
+  end
+
+  private
+
+end
+
+
+
+
+if $0 == __FILE__
+
+a = FixedPt.new(4.25,6,2)
+puts a.to_binary
+b = FixedPt.new(2,2,0)
+puts b.to_binary
+c = a*b
+puts c.to_binary
+start = Time.now
+10000.times do |i|
+   a = FixedPt.new(9,4,1)
+end 
+puts Time.now - start
+exit  
+  x = FixedPt.new(8,6,1)
+  puts "x.to_binary: #{x.to_binary}"
+  y = FixedPt.new(2,4,2)
+  puts "y.to_binary: #{y.to_binary}"
+  puts "sizes differ" if x.sizes_differ? y
+  z = x + y
+  puts z.to_binary
+  z1 = z - y
+  puts z1.to_binary
+  
+  z3 = x * y
+  puts z3.to_binary
+
+  exit
+  FRAC_PART = 3 
+  INT_PART  = 3
+  WIDTH = FRAC_PART + INT_PART
+  fixed = FixedPt.new(3,4,2) 
+  puts "fixed is: #{fixed}"
+  fixedfloat = FixedPt.new(-(1/3.0),WIDTH,FRAC_PART)
+  puts "fixedfloat is: #{fixedfloat}"
+  puts "fixedfloat.raw is: 0x#{sprintf("%x",fixedfloat.raw)}"
+ 
+  puts "binary: "+fixedfloat.to_binary+ " = #{fixedfloat.to_f}"
+  
+
+  multiplicand = FixedPt.new(6,WIDTH,FRAC_PART)
+  results = fixedfloat * multiplicand
+  puts "binary: "+results.to_binary+ " = #{results.to_f}"
+
+  foo =  FixedPt.new(-(9/16.0),4,4)
+  puts "#{foo.to_binary}  #{foo.to_f}"
+  foo =  FixedPt.new(-(1.0),4,1)
+  puts "#{foo.to_binary}  #{foo.to_f}"
+  foo =  FixedPt.new(-(2.0),4,1)
+  puts "#{foo.to_binary}  #{foo.to_f}"
+  foo =  FixedPt.new(-(4.0),4,1)
+  puts "#{foo.to_binary}  #{foo.to_f}"
+  foo =  FixedPt.new(-(5.0),4,1)
+  puts "#{foo.to_binary}  #{foo.to_f} minint:#{foo.minint} maxint:#{foo.maxint}"
+
+  foo = FixedPt.new((1/3.0),11,3)
+  puts "#{foo.to_binary}  #{foo.to_f}"
+
+end

data/test/test_fixedpt.rb

@@ -0,0 +1,262 @@
+# Code Generated by ZenTest v. 2.3.0
+#Couldn't find ext/fixedpt.so: thing's will run slow, but it'll work
+#                 classname: asrt / meth =  ratio%
+#                   FixedPt:    0 /   33 =   0.00%
+#                   Numeric:    0 /    1 =   0.00%
+#                RawFixedPt:    0 /    1 =   0.00%
+#                 FPHelpers:    0 /    2 =   0.00%
+
+require 'test/unit' unless defined? $ZENTEST and $ZENTEST
+require 'fixedpt'
+
+class TestFixedPt < Test::Unit::TestCase
+  def setup
+    
+  end
+
+  def test_subtract
+    raise NotImplementedError, 'Need to write test_subtract'
+  end
+  def test_add
+    raise NotImplementedError, 'Need to write test_add'
+  end
+  def test_multiply
+    #raise NotImplementedError, 'Need to write test_multiply'
+    a = FixedPt.new(4.25,5,2)
+    b = FixedPt.new(2,2,0)
+    c = a*b
+    assert_match("001000.1000",c.to_binary)
+    assert_equal(8.5,c.to_f)
+    assert_equal(6,c.int_width)
+    assert_equal(4,c.frac_width)
+    d = FixedPt.new(-1,2,0)
+    e = b*d
+    assert_equal(-2,e.value)
+  end
+
+  def test_divide
+    raise NotImplementedError, 'Need to write test_divide'
+  end
+
+  def test_adjust_sizes
+    raise NotImplementedError, 'Need to write test_adjust_sizes'
+  end
+
+  def test_append
+    raise NotImplementedError, 'Need to write test_append'
+  end
+
+  def test_assign
+    raise NotImplementedError, 'Need to write test_assign'
+  end
+
+  def test_binpt
+    raise NotImplementedError, 'Need to write test_binpt'
+  end
+
+  def test_binpt_equals
+    raise NotImplementedError, 'Need to write test_binpt_equals'
+  end
+
+  def test_bits
+    raise NotImplementedError, 'Need to write test_bits'
+  end
+
+  def test_bits_equals
+    raise NotImplementedError, 'Need to write test_bits_equals'
+  end
+
+  def test_calc_min_max
+    raise NotImplementedError, 'Need to write test_calc_min_max'
+  end
+
+  def test_check_binpt
+    raise NotImplementedError, 'Need to write test_check_binpt'
+  end
+
+  def test_check_for_overflow
+    #raise NotImplementedError, 'Need to write test_check_for_overflow'
+    a = FixedPt.new(9.5,4,1)
+    assert_match("111.1",a.to_binary)
+    assert_equal(true,a.overflow)
+    b = FixedPt.new(22.125,16,9)
+    assert_match("0010110.001000000",b.to_binary)
+    assert_equal(false,b.overflow)
+  end
+
+  def test_check_sign
+    raise NotImplementedError, 'Need to write test_check_sign'
+  end
+
+  def test_coerce
+    raise NotImplementedError, 'Need to write test_coerce'
+  end
+
+  def test_construct_from_fixnum
+    raise NotImplementedError, 'Need to write test_construct_from_fixnum'
+  end
+
+  def test_construct_from_float
+    raise NotImplementedError, 'Need to write test_construct_from_float'
+  end
+
+  def test_frac_width
+    raise NotImplementedError, 'Need to write test_frac_width'
+  end
+
+  def test_frac_width_equals
+    raise NotImplementedError, 'Need to write test_frac_width_equals'
+  end
+
+  def test_from_FixedPt
+    raise NotImplementedError, 'Need to write test_from_FixedPt'
+  end
+
+  def test_from_float
+    raise NotImplementedError, 'Need to write test_from_float'
+  end
+
+  def test_int_width
+    raise NotImplementedError, 'Need to write test_int_width'
+  end
+
+  def test_int_width_equals
+    raise NotImplementedError, 'Need to write test_int_width_equals'
+  end
+
+  def test_ival
+    raise NotImplementedError, 'Need to write test_ival'
+  end
+
+  def test_ival_equals
+    raise NotImplementedError, 'Need to write test_ival_equals'
+  end
+
+  def test_max_int_value
+    raise NotImplementedError, 'Need to write test_max_int_value'
+  end
+
+  def test_maxint
+    raise NotImplementedError, 'Need to write test_maxint'
+  end
+
+  def test_maxint_equals
+    raise NotImplementedError, 'Need to write test_maxint_equals'
+  end
+
+  def test_minint
+    raise NotImplementedError, 'Need to write test_minint'
+  end
+
+  def test_minint_equals
+    raise NotImplementedError, 'Need to write test_minint_equals'
+  end
+
+  def test_plus
+    raise NotImplementedError, 'Need to write test_plus'
+  end
+
+  def test_ranged_int_part
+    raise NotImplementedError, 'Need to write test_ranged_int_part'
+  end
+
+  def test_raw
+    raise NotImplementedError, 'Need to write test_raw'
+  end
+
+  def test_saturate
+    raise NotImplementedError, 'Need to write test_saturate'
+  end
+
+  def test_shift_left
+    raise NotImplementedError, 'Need to write test_shift_left'
+  end
+
+  def test_shift_right
+    raise NotImplementedError, 'Need to write test_shift_right'
+  end
+
+  def test_sign
+    raise NotImplementedError, 'Need to write test_sign'
+  end
+
+  def test_sign_equals
+    raise NotImplementedError, 'Need to write test_sign_equals'
+  end
+
+  def test_size
+    raise NotImplementedError, 'Need to write test_size'
+  end
+
+  def test_sizes_differ_eh
+    raise NotImplementedError, 'Need to write test_sizes_differ_eh'
+  end
+
+  def test_times
+    raise NotImplementedError, 'Need to write test_times'
+  end
+
+  def test_to_bin
+    #raise NotImplementedError, 'Need to write test_to_bin'
+    a = FixedPt.new(42,7,1)
+    assert_match("1010100",a.to_bin)
+  end
+
+  def test_to_binary
+    #raise NotImplementedError, 'Need to write test_to_binary'
+    a = FixedPt.new(9,4,0)
+    assert_match("1001.",a.to_binary)
+    b = FixedPt.new(12.25,6,2)
+    assert_match("1100.01",b.to_binary)
+  end
+
+  def test_to_f
+    raise NotImplementedError, 'Need to write test_to_f'
+  end
+
+  def test_to_fp
+    raise NotImplementedError, 'Need to write test_to_fp'
+  end
+
+  def test_to_i
+    raise NotImplementedError, 'Need to write test_to_i'
+  end
+
+  def test_to_int
+    raise NotImplementedError, 'Need to write test_to_int'
+  end
+
+  def test_truncate
+    raise NotImplementedError, 'Need to write test_truncate'
+  end
+
+  def test_value
+    raise NotImplementedError, 'Need to write test_value'
+  end
+end
+
+class TestNumeric < Test::Unit::TestCase
+  def test_to_fp
+    raise NotImplementedError, 'Need to write test_to_fp'
+  end
+end
+
+class TestRawFixedPt < Test::Unit::TestCase
+  def test_binpt
+    raise NotImplementedError, 'Need to write test_binpt'
+  end
+
+  def test_bits
+    raise NotImplementedError, 'Need to write test_bits'
+  end
+
+  def test_rawval
+    raise NotImplementedError, 'Need to write test_rawval'
+  end
+
+  def test_sign
+    raise NotImplementedError, 'Need to write test_sign'
+  end
+end
+
+# Number of errors detected: 5

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.1
+specification_version: 1
+name: FixedPt
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2005-06-23
+summary: Fixed point class
+require_paths: 
+  - lib
+  - ext
+author: Phil Tomson
+email: philtomson@gmail.com
+homepage: http://fixedpt.rubyforge.org
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+files: 
+  - lib/fixedpt
+  - lib/fixedpt/fixedpt.rb
+  - ext/fixedpt.c
+  - ext/extconf.rb
+  - ext/Makefile
+  - ext/fixedpt.o
+  - ext/fixedpt.so
+  - test/test_fixedpt.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: 
+  - ext/extconf.rb
+requirements: []
+dependencies: []