596 lines
12 KiB
C++
596 lines
12 KiB
C++
// This may look like C code, but it is really -*- C++ -*-
|
|
/*
|
|
Copyright (C) 1988 Free Software Foundation
|
|
written by Kurt Baudendistel (gt-eedsp!baud@gatech.edu)
|
|
adapted for libg++ by Doug Lea (dl@rocky.oswego.edu)
|
|
|
|
This file is part of GNU CC.
|
|
|
|
GNU CC is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY. No author or distributor
|
|
accepts responsibility to anyone for the consequences of using it
|
|
or for whether it serves any particular purpose or works at all,
|
|
unless he says so in writing. Refer to the GNU CC General Public
|
|
License for full details.
|
|
|
|
Everyone is granted permission to copy, modify and redistribute
|
|
GNU CC, but only under the conditions described in the
|
|
GNU CC General Public License. A copy of this license is
|
|
supposed to have been given to you along with GNU CC so you
|
|
can know your rights and responsibilities. It should be in a
|
|
file named COPYING. Among other things, the copyright notice
|
|
and this notice must be preserved on all copies.
|
|
*/
|
|
|
|
#ifndef _Fix24_h
|
|
#ifdef __GNUG__
|
|
#pragma once
|
|
#pragma interface
|
|
#endif
|
|
#define _Fix24_h 1
|
|
|
|
#include <stream.h>
|
|
#include <std.h>
|
|
|
|
// extra type definitions
|
|
|
|
typedef struct {
|
|
long u;
|
|
unsigned long l;
|
|
} twolongs;
|
|
|
|
// constant definitions
|
|
|
|
static const int
|
|
Fix24_shift = 31;
|
|
|
|
static const double
|
|
Fix24_fs = 2147483648., // 2^Fix24_shift
|
|
Fix24_mult = Fix24_fs,
|
|
Fix24_div = 1./Fix24_fs,
|
|
Fix24_max = 1. - .5/Fix24_fs,
|
|
Fix24_min = -1.;
|
|
|
|
static const unsigned long
|
|
Fix24_msb = 0x80000000L,
|
|
Fix24_lsb = 0x00000100L,
|
|
Fix24_m_max = 0x7fffff00L,
|
|
Fix24_m_min = 0x80000000L;
|
|
|
|
static const double
|
|
Fix48_fs = 36028797018963968., // 2^(24+Fix24_shift)
|
|
Fix48_max = 1. - .5/Fix48_fs,
|
|
Fix48_min = -1.,
|
|
Fix48_div_u = 1./Fix24_fs,
|
|
Fix48_div_l = 1./Fix48_fs;
|
|
|
|
static const twolongs
|
|
Fix48_msb = { 0x80000000L, 0L },
|
|
Fix48_lsb = { 0L, 0x00000100L },
|
|
Fix48_m_max = { 0x7fffff00L, 0xffffff00L },
|
|
Fix48_m_min = { 0x80000000L, 0L };
|
|
|
|
//
|
|
// Fix24 class: 24-bit Fixed point data type
|
|
//
|
|
// consists of a 24-bit mantissa (sign bit & 23 data bits).
|
|
//
|
|
|
|
class Fix24
|
|
{
|
|
friend class Fix48;
|
|
|
|
long m;
|
|
|
|
long assign(double d);
|
|
operator double();
|
|
Fix24(long i);
|
|
Fix24(int i);
|
|
|
|
|
|
public:
|
|
Fix24();
|
|
Fix24(Fix24& f);
|
|
Fix24(double d);
|
|
Fix24(Fix48& f);
|
|
|
|
~Fix24();
|
|
|
|
Fix24& operator=(Fix24& f);
|
|
Fix24& operator=(double d);
|
|
Fix24& operator=(Fix48& f);
|
|
|
|
friend long& mantissa(Fix24& f);
|
|
friend double value(Fix24& f);
|
|
|
|
Fix24 operator + ();
|
|
Fix24 operator - ();
|
|
|
|
friend Fix24 operator + (Fix24& f, Fix24& g);
|
|
friend Fix24 operator - (Fix24& f, Fix24& g);
|
|
friend Fix48 operator * (Fix24& f, Fix24& g);
|
|
friend Fix24 operator * (Fix24& f, int g);
|
|
friend Fix24 operator * (int g, Fix24& f);
|
|
friend Fix24 operator / (Fix24& f, Fix24& g);
|
|
friend Fix24 operator << (Fix24& f, int b);
|
|
friend Fix24 operator >> (Fix24& f, int b);
|
|
|
|
Fix24& operator += (Fix24& f);
|
|
Fix24& operator -= (Fix24& f);
|
|
Fix24& operator *= (Fix24& f);
|
|
Fix24& operator *= (int b);
|
|
Fix24& operator /= (Fix24& f);
|
|
|
|
Fix24& operator <<=(int b);
|
|
Fix24& operator >>=(int b);
|
|
|
|
friend int operator == (Fix24& f, Fix24& g);
|
|
friend int operator != (Fix24& f, Fix24& g);
|
|
friend int operator >= (Fix24& f, Fix24& g);
|
|
friend int operator <= (Fix24& f, Fix24& g);
|
|
friend int operator > (Fix24& f, Fix24& g);
|
|
friend int operator < (Fix24& f, Fix24& g);
|
|
|
|
friend istream& operator >> (istream& s, Fix24& f);
|
|
friend ostream& operator << (ostream& s, Fix24& f);
|
|
|
|
void overflow(long&);
|
|
void range_error(long&);
|
|
};
|
|
|
|
|
|
//
|
|
// Fix48 class: 48-bit Fixed point data type
|
|
//
|
|
// consists of a 48-bit mantissa (sign bit & 47 data bits).
|
|
//
|
|
|
|
class Fix48
|
|
{
|
|
friend class Fix24;
|
|
|
|
twolongs m;
|
|
|
|
twolongs assign(double d);
|
|
operator double();
|
|
Fix48(twolongs i);
|
|
|
|
public:
|
|
Fix48();
|
|
Fix48(Fix48& f);
|
|
Fix48(Fix24& f);
|
|
Fix48(double d);
|
|
~Fix48();
|
|
|
|
Fix48& operator = (Fix48& f);
|
|
Fix48& operator = (Fix24& f);
|
|
Fix48& operator = (double d);
|
|
|
|
friend twolongs& mantissa(Fix48& f);
|
|
friend double value(Fix48& f);
|
|
|
|
Fix48 operator + ();
|
|
Fix48 operator - ();
|
|
|
|
friend Fix48 operator + (Fix48& f, Fix48& g);
|
|
friend Fix48 operator - (Fix48& f, Fix48& g);
|
|
friend Fix48 operator * (Fix48& f, int g);
|
|
friend Fix48 operator * (int g, Fix48& f);
|
|
friend Fix48 operator << (Fix48& f, int b);
|
|
friend Fix48 operator >> (Fix48& f, int b);
|
|
|
|
friend Fix48 operator * (Fix24& f, Fix24& g);
|
|
|
|
Fix48& operator += (Fix48& f);
|
|
Fix48& operator -= (Fix48& f);
|
|
Fix48& operator *= (int b);
|
|
Fix48& operator <<=(int b);
|
|
Fix48& operator >>=(int b);
|
|
|
|
friend int operator == (Fix48& f, Fix48& g);
|
|
friend int operator != (Fix48& f, Fix48& g);
|
|
friend int operator >= (Fix48& f, Fix48& g);
|
|
friend int operator <= (Fix48& f, Fix48& g);
|
|
friend int operator > (Fix48& f, Fix48& g);
|
|
friend int operator < (Fix48& f, Fix48& g);
|
|
|
|
friend istream& operator >> (istream& s, Fix48& f);
|
|
friend ostream& operator << (ostream& s, Fix48& f);
|
|
|
|
void overflow(twolongs& i);
|
|
void range_error(twolongs& i);
|
|
};
|
|
|
|
|
|
// active error handler declarations
|
|
|
|
typedef void (*Fix24_peh)(long&);
|
|
typedef void (*Fix48_peh)(twolongs&);
|
|
|
|
extern Fix24_peh Fix24_overflow_handler;
|
|
extern Fix48_peh Fix48_overflow_handler;
|
|
|
|
extern Fix24_peh Fix24_range_error_handler;
|
|
extern Fix48_peh Fix48_range_error_handler;
|
|
|
|
|
|
// error handler declarations
|
|
|
|
#if defined(SHORT_NAMES) || defined(VMS)
|
|
#define set_overflow_handler sohndl
|
|
#define set_range_error_handler srnghdl
|
|
#endif
|
|
|
|
extern Fix24_peh set_Fix24_overflow_handler(Fix24_peh);
|
|
extern Fix48_peh set_Fix48_overflow_handler(Fix48_peh);
|
|
extern void set_overflow_handler(Fix24_peh, Fix48_peh);
|
|
|
|
extern Fix24_peh set_Fix24_range_error_handler(Fix24_peh);
|
|
extern Fix48_peh set_Fix48_range_error_handler(Fix48_peh);
|
|
extern void set_range_error_handler(Fix24_peh, Fix48_peh);
|
|
|
|
extern void
|
|
Fix24_ignore(long&),
|
|
Fix24_overflow_saturate(long&),
|
|
Fix24_overflow_warning_saturate(long&),
|
|
Fix24_warning(long&),
|
|
Fix24_abort(long&);
|
|
|
|
extern void
|
|
Fix48_ignore(twolongs&),
|
|
Fix48_overflow_saturate(twolongs&),
|
|
Fix48_overflow_warning_saturate(twolongs&),
|
|
Fix48_warning(twolongs&),
|
|
Fix48_abort(twolongs&);
|
|
|
|
#if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES)
|
|
|
|
inline Fix24::~Fix24() {}
|
|
|
|
inline Fix24::Fix24(long i)
|
|
{
|
|
m = i;
|
|
}
|
|
|
|
inline Fix24::Fix24(int i)
|
|
{
|
|
m = i;
|
|
}
|
|
|
|
inline Fix24::operator double()
|
|
{
|
|
return Fix24_div * m;
|
|
}
|
|
|
|
inline Fix24::Fix24()
|
|
{
|
|
m = 0;
|
|
}
|
|
|
|
inline Fix24::Fix24(Fix24& f)
|
|
{
|
|
m = f.m;
|
|
}
|
|
|
|
inline Fix24::Fix24(double d)
|
|
{
|
|
m = assign(d);
|
|
}
|
|
|
|
inline Fix24::Fix24(Fix48& f)
|
|
{
|
|
m = f.m.u;
|
|
}
|
|
|
|
inline Fix24& Fix24::operator=(Fix24& f)
|
|
{
|
|
m = f.m;
|
|
return *this;
|
|
}
|
|
|
|
inline Fix24& Fix24::operator=(double d)
|
|
{
|
|
m = assign(d);
|
|
return *this;
|
|
}
|
|
|
|
inline Fix24& Fix24::operator=(Fix48& f)
|
|
{
|
|
m = f.m.u;
|
|
return *this;
|
|
}
|
|
|
|
inline long& mantissa(Fix24& f)
|
|
{
|
|
return f.m;
|
|
}
|
|
|
|
inline double value(Fix24& f)
|
|
{
|
|
return double(f);
|
|
}
|
|
|
|
inline Fix24 Fix24::operator+()
|
|
{
|
|
return m;
|
|
}
|
|
|
|
inline Fix24 Fix24::operator-()
|
|
{
|
|
return -m;
|
|
}
|
|
|
|
inline Fix24 operator+(Fix24& f, Fix24& g)
|
|
{
|
|
long sum = f.m + g.m;
|
|
if ( (f.m ^ sum) & (g.m ^ sum) & Fix24_msb )
|
|
f.overflow(sum);
|
|
return sum;
|
|
}
|
|
|
|
inline Fix24 operator-(Fix24& f, Fix24& g)
|
|
{
|
|
long sum = f.m - g.m;
|
|
if ( (f.m ^ sum) & (-g.m ^ sum) & Fix24_msb )
|
|
f.overflow(sum);
|
|
return sum;
|
|
}
|
|
|
|
inline Fix24 operator*(Fix24& a, int b)
|
|
{
|
|
return a.m * b;
|
|
}
|
|
|
|
inline Fix24 operator*(int b, Fix24& a)
|
|
{
|
|
return a * b;
|
|
}
|
|
|
|
inline Fix24 operator<<(Fix24& a, int b)
|
|
{
|
|
return a.m << b;
|
|
}
|
|
|
|
inline Fix24 operator>>(Fix24& a, int b)
|
|
{
|
|
return (a.m >> b) & 0xffffff00L;
|
|
}
|
|
|
|
inline Fix24& Fix24:: operator+=(Fix24& f)
|
|
{
|
|
return *this = *this + f;
|
|
}
|
|
|
|
inline Fix24& Fix24:: operator-=(Fix24& f)
|
|
{
|
|
return *this = *this - f;
|
|
}
|
|
|
|
inline Fix24& Fix24::operator*=(Fix24& f)
|
|
{
|
|
return *this = *this * f;
|
|
}
|
|
|
|
inline Fix24& Fix24:: operator/=(Fix24& f)
|
|
{
|
|
return *this = *this / f;
|
|
}
|
|
|
|
inline Fix24& Fix24:: operator<<=(int b)
|
|
{
|
|
return *this = *this << b;
|
|
}
|
|
|
|
inline Fix24& Fix24:: operator>>=(int b)
|
|
{
|
|
return *this = *this >> b;
|
|
}
|
|
|
|
inline Fix24& Fix24::operator*=(int b)
|
|
{
|
|
return *this = *this * b;
|
|
}
|
|
|
|
inline int operator==(Fix24& f, Fix24& g)
|
|
{
|
|
return f.m == g.m;
|
|
}
|
|
|
|
inline int operator!=(Fix24& f, Fix24& g)
|
|
{
|
|
return f.m != g.m;
|
|
}
|
|
|
|
inline int operator>=(Fix24& f, Fix24& g)
|
|
{
|
|
return f.m >= g.m;
|
|
}
|
|
|
|
inline int operator<=(Fix24& f, Fix24& g)
|
|
{
|
|
return f.m <= g.m;
|
|
}
|
|
|
|
inline int operator>(Fix24& f, Fix24& g)
|
|
{
|
|
return f.m > g.m;
|
|
}
|
|
|
|
inline int operator<(Fix24& f, Fix24& g)
|
|
{
|
|
return f.m < g.m;
|
|
}
|
|
|
|
inline istream& operator>>(istream& s, Fix24& f)
|
|
{
|
|
double d;
|
|
s >> d;
|
|
f = d;
|
|
return s;
|
|
}
|
|
|
|
inline ostream& operator<<(ostream& s, Fix24& f)
|
|
{
|
|
return s << double(f);
|
|
}
|
|
|
|
inline Fix48::~Fix48() {}
|
|
|
|
inline Fix48::Fix48(twolongs i)
|
|
{
|
|
m = i;
|
|
}
|
|
|
|
inline Fix48:: operator double()
|
|
{
|
|
/*
|
|
* Note: can't simply do Fix48_div_u * m.u + Fix48_div_l * m.l, because
|
|
* m.u is signed and m.l is unsigned.
|
|
*/
|
|
return (m.u >= 0)? Fix48_div_u * m.u + Fix48_div_l * m.l :
|
|
(Fix48_div_u * ((unsigned long)(m.u & 0xffffff00))
|
|
+ Fix48_div_l * m.l) - 2;
|
|
}
|
|
|
|
inline Fix48::Fix48()
|
|
{
|
|
m.u = 0;
|
|
m.l = 0;
|
|
}
|
|
|
|
inline Fix48::Fix48(Fix48& f)
|
|
{
|
|
m = f.m;
|
|
}
|
|
|
|
inline Fix48::Fix48(Fix24& f)
|
|
{
|
|
m.u = f.m;
|
|
m.l = 0;
|
|
}
|
|
|
|
inline Fix48::Fix48(double d)
|
|
{
|
|
m = assign(d);
|
|
}
|
|
|
|
inline Fix48& Fix48::operator=(Fix48& f)
|
|
{
|
|
m = f.m;
|
|
return *this;
|
|
}
|
|
|
|
inline Fix48& Fix48::operator=(Fix24& f)
|
|
{
|
|
m.u = f.m;
|
|
m.l = 0;
|
|
return *this;
|
|
}
|
|
|
|
inline Fix48& Fix48::operator=(double d)
|
|
{
|
|
m = assign(d);
|
|
return *this;
|
|
}
|
|
|
|
inline twolongs& mantissa(Fix48& f)
|
|
{
|
|
return f.m;
|
|
}
|
|
|
|
inline double value(Fix48& f)
|
|
{
|
|
return double(f);
|
|
}
|
|
|
|
inline Fix48 Fix48::operator+()
|
|
{
|
|
return m;
|
|
}
|
|
|
|
inline Fix48 Fix48::operator-()
|
|
{
|
|
twolongs n;
|
|
n.l = -m.l;
|
|
n.u = ~m.u + ((n.l ^ m.l) & Fix24_msb ? 0 : Fix24_lsb);
|
|
return Fix48(n);
|
|
}
|
|
|
|
inline Fix48 operator*(int b, Fix48& a)
|
|
{
|
|
return a * b;
|
|
}
|
|
|
|
inline Fix48& Fix48::operator+=(Fix48& f)
|
|
{
|
|
return *this = *this + f;
|
|
}
|
|
|
|
inline Fix48& Fix48::operator-=(Fix48& f)
|
|
{
|
|
return *this = *this - f;
|
|
}
|
|
|
|
inline Fix48& Fix48::operator*=(int b)
|
|
{
|
|
return *this = *this * b;
|
|
}
|
|
|
|
inline Fix48& Fix48::operator<<=(int b)
|
|
{
|
|
return *this = *this << b;
|
|
}
|
|
|
|
inline Fix48& Fix48::operator>>=(int b)
|
|
{
|
|
return *this = *this >> b;
|
|
}
|
|
|
|
inline int operator==(Fix48& f, Fix48& g)
|
|
{
|
|
return f.m.u == g.m.u && f.m.l == g.m.l;
|
|
}
|
|
|
|
inline int operator!=(Fix48& f, Fix48& g)
|
|
{
|
|
return f.m.u != g.m.u || f.m.l != g.m.l;
|
|
}
|
|
|
|
inline int operator>=(Fix48& f, Fix48& g)
|
|
{
|
|
return f.m.u >= g.m.u || (f.m.u == g.m.u && f.m.l >= g.m.l);
|
|
}
|
|
|
|
inline int operator<=(Fix48& f, Fix48& g)
|
|
{
|
|
return f.m.u <= g.m.u || (f.m.u == g.m.u && f.m.l <= g.m.l);
|
|
}
|
|
|
|
inline int operator>(Fix48& f, Fix48& g)
|
|
{
|
|
return f.m.u > g.m.u || (f.m.u == g.m.u && f.m.l > g.m.l);
|
|
}
|
|
|
|
inline int operator<(Fix48& f, Fix48& g)
|
|
{
|
|
return f.m.u < g.m.u || (f.m.u == g.m.u && f.m.l < g.m.l);
|
|
}
|
|
|
|
inline istream& operator>>(istream& s, Fix48& f)
|
|
{
|
|
double d;
|
|
s >> d;
|
|
f = d;
|
|
return s;
|
|
}
|
|
|
|
inline ostream& operator<<(ostream& s, Fix48& f)
|
|
{
|
|
return s << double(f);
|
|
}
|
|
|
|
|
|
#endif
|
|
#endif
|
|
|