🚀 go-pugleaf

I'd like to find out about language support for fixed-point arithmetic.

I am aware of only two types of support for such a data type:

  Ada supports an intrinsic fixed-point type that allows the user 
      to specify the range (maximum absolute value supported) and 
      scale (maximum required step-size). It is intended to be
      implemented via an integer arithmetic unit to provide (1) fixed-
      accuracy computations and (2) efficient execution in embedded
      systems without floating-point hardware support.

      The ideas for Ada's fixed-point type came from some other
      embedded systems lanaguages, but it is the only ``modern''
      language that supports a fixed-point type.

  C++ and other object-oriented languages (such as Ada) that support
      data type synthesis (constructors/destructors, infix operators,
      etc.) can be used to build fixed-point data types.  
      
      If we are interested in efficient execution and fixed-accuracy
      computations, as the Ada fixed-point intrinsic type is, we
      must note that, as with any other user-defined type, such fixed-
      point data types can be constructed only of existing language 
      components.  This means that we can construct such types only in 
      the manner that Ada does---integer arithmetic is the implementation 
      method and a fixed-point type has a specified range and scale.
      Such data types will not be as efficient as the built-in Ada type,
      since they have to carry around a lot of baggage that can't be
      integrated in to the code, but that's life in the fast lane.

      If we are interested in the fixed-point data type only for the
      purposes of simulation, however, we can construct fixed-point
      data types that do many more things---saturation overflow, 
      delayed multiplication, automatic scale adjustment, etc.

Why am I intereted in such fixed-point data types? Well, Programmable
DSP (Digital Signal Processing) chips have become commonplace, but a
programming medium (in the form of a fixed-point data type) and a
programming methodology (that would help the programmer pick range
and scale parameters) have not materialized. 

I would like to proceed with some ideas to (hopefully) produce thesis 
quality material on this topic, but I have discovered a disconcerting
fact---there doesn't appear to be any literature on this topic!  A
better statement might be that I can't find any literature on this 
topic, and this makes me very uncomfortable since I'm sure that there
must be some out there!

I know of only a few articles dealing with this topic from a language 
design standpoint:

  Froggatt, Fixed-point conversion, multiplication, and division in Ada,
    Ada Letters, Vol. 7, No. 1, Jan-Feb 1987, pp. 71-81
    (A rationale for the Ada fixed-point data type)

  Nelson, Pascal-F, IEEE ElectroTechnology Review, 1986
    (I haven't read this one yet)

  Pepe and Rogers, Simulation of fixed-point operations with high-level
    languages, IEEE Trans. on ASSP, Vol. ASSP-35, No. 1, p. 116-18,
    Jan 1987 
    (Fortran subroutines)

  Johnson, [I can't find the reference right now]
    (C++ classes for fixed-point simulation)
    
I have tried on-line library searches, scoured the ACM Computing
Guide for the last ~5 years, and asked local CS profs, and come up
dry! Can anyone out there in netland put me on the trail of some
research/articles on language design for fixed-point arithmetic?
Any help at all (including references and personal contacts) will
be greatly appreciated.

Please respond, and please respond by e-mail! If you are interested
in the results of my search, e-mail a result-request as well.

Thanks.
kurt
-- 
Kurt Baudendistel --- GRA
Georgia Tech, School of Electrical Engineering, Atlanta, GA  30332
internet: baud@eedsp.gatech.edu         uucp: gatech!gt-eedsp!baud