ref: 49bd8a86f3a07c4f54df94838c07fa653d725afa
dir: /sys/src/9/kw/fpi.c/
/*
* Floating Point Interpreter.
* shamelessly stolen from an original by ark.
*/
#include "fpi.h"
void
fpiround(Internal *i)
{
unsigned long guard;
guard = i->l & GuardMask;
i->l &= ~GuardMask;
if(guard > (LsBit>>1) || (guard == (LsBit>>1) && (i->l & LsBit))){
i->l += LsBit;
if(i->l & CarryBit){
i->l &= ~CarryBit;
i->h++;
if(i->h & CarryBit){
if (i->h & 0x01)
i->l |= CarryBit;
i->l >>= 1;
i->h >>= 1;
i->e++;
}
}
}
}
static void
matchexponents(Internal *x, Internal *y)
{
int count;
count = y->e - x->e;
x->e = y->e;
if(count >= 2*FractBits){
x->l = x->l || x->h;
x->h = 0;
return;
}
if(count >= FractBits){
count -= FractBits;
x->l = x->h|(x->l != 0);
x->h = 0;
}
while(count > 0){
count--;
if(x->h & 0x01)
x->l |= CarryBit;
if(x->l & 0x01)
x->l |= 2;
x->l >>= 1;
x->h >>= 1;
}
}
static void
shift(Internal *i)
{
i->e--;
i->h <<= 1;
i->l <<= 1;
if(i->l & CarryBit){
i->l &= ~CarryBit;
i->h |= 0x01;
}
}
static void
normalise(Internal *i)
{
while((i->h & HiddenBit) == 0)
shift(i);
}
static void
renormalise(Internal *i)
{
if(i->e < -2 * FractBits)
i->e = -2 * FractBits;
while(i->e < 1){
i->e++;
if(i->h & 0x01)
i->l |= CarryBit;
i->h >>= 1;
i->l = (i->l>>1)|(i->l & 0x01);
}
if(i->e >= ExpInfinity)
SetInfinity(i);
}
void
fpinormalise(Internal *x)
{
if(!IsWeird(x) && !IsZero(x))
normalise(x);
}
void
fpiadd(Internal *x, Internal *y, Internal *i)
{
Internal *t;
i->s = x->s;
if(IsWeird(x) || IsWeird(y)){
if(IsNaN(x) || IsNaN(y))
SetQNaN(i);
else
SetInfinity(i);
return;
}
if(x->e > y->e){
t = x;
x = y;
y = t;
}
matchexponents(x, y);
i->e = x->e;
i->h = x->h + y->h;
i->l = x->l + y->l;
if(i->l & CarryBit){
i->h++;
i->l &= ~CarryBit;
}
if(i->h & (HiddenBit<<1)){
if(i->h & 0x01)
i->l |= CarryBit;
i->l = (i->l>>1)|(i->l & 0x01);
i->h >>= 1;
i->e++;
}
if(IsWeird(i))
SetInfinity(i);
}
void
fpisub(Internal *x, Internal *y, Internal *i)
{
Internal *t;
if(y->e < x->e
|| (y->e == x->e && (y->h < x->h || (y->h == x->h && y->l < x->l)))){
t = x;
x = y;
y = t;
}
i->s = y->s;
if(IsNaN(y)){
SetQNaN(i);
return;
}
if(IsInfinity(y)){
if(IsInfinity(x))
SetQNaN(i);
else
SetInfinity(i);
return;
}
matchexponents(x, y);
i->e = y->e;
i->h = y->h - x->h;
i->l = y->l - x->l;
if(i->l < 0){
i->l += CarryBit;
i->h--;
}
if(i->h == 0 && i->l == 0)
SetZero(i);
else while(i->e > 1 && (i->h & HiddenBit) == 0)
shift(i);
}
#define CHUNK (FractBits/2)
#define CMASK ((1<<CHUNK)-1)
#define HI(x) ((short)((x)>>CHUNK) & CMASK)
#define LO(x) ((short)(x) & CMASK)
#define SPILL(x) ((x)>>CHUNK)
#define M(x, y) ((long)a[x]*(long)b[y])
#define C(h, l) (((long)((h) & CMASK)<<CHUNK)|((l) & CMASK))
void
fpimul(Internal *x, Internal *y, Internal *i)
{
long a[4], b[4], c[7], f[4];
i->s = x->s^y->s;
if(IsWeird(x) || IsWeird(y)){
if(IsNaN(x) || IsNaN(y) || IsZero(x) || IsZero(y))
SetQNaN(i);
else
SetInfinity(i);
return;
}
else if(IsZero(x) || IsZero(y)){
SetZero(i);
return;
}
normalise(x);
normalise(y);
i->e = x->e + y->e - (ExpBias - 1);
a[0] = HI(x->h); b[0] = HI(y->h);
a[1] = LO(x->h); b[1] = LO(y->h);
a[2] = HI(x->l); b[2] = HI(y->l);
a[3] = LO(x->l); b[3] = LO(y->l);
c[6] = M(3, 3);
c[5] = M(2, 3) + M(3, 2) + SPILL(c[6]);
c[4] = M(1, 3) + M(2, 2) + M(3, 1) + SPILL(c[5]);
c[3] = M(0, 3) + M(1, 2) + M(2, 1) + M(3, 0) + SPILL(c[4]);
c[2] = M(0, 2) + M(1, 1) + M(2, 0) + SPILL(c[3]);
c[1] = M(0, 1) + M(1, 0) + SPILL(c[2]);
c[0] = M(0, 0) + SPILL(c[1]);
f[0] = c[0];
f[1] = C(c[1], c[2]);
f[2] = C(c[3], c[4]);
f[3] = C(c[5], c[6]);
if((f[0] & HiddenBit) == 0){
f[0] <<= 1;
f[1] <<= 1;
f[2] <<= 1;
f[3] <<= 1;
if(f[1] & CarryBit){
f[0] |= 1;
f[1] &= ~CarryBit;
}
if(f[2] & CarryBit){
f[1] |= 1;
f[2] &= ~CarryBit;
}
if(f[3] & CarryBit){
f[2] |= 1;
f[3] &= ~CarryBit;
}
i->e--;
}
i->h = f[0];
i->l = f[1];
if(f[2] || f[3])
i->l |= 1;
renormalise(i);
}
void
fpidiv(Internal *x, Internal *y, Internal *i)
{
i->s = x->s^y->s;
if(IsNaN(x) || IsNaN(y)
|| (IsInfinity(x) && IsInfinity(y)) || (IsZero(x) && IsZero(y))){
SetQNaN(i);
return;
}
else if(IsZero(x) || IsInfinity(y)){
SetInfinity(i);
return;
}
else if(IsInfinity(x) || IsZero(y)){
SetZero(i);
return;
}
normalise(x);
normalise(y);
i->h = 0;
i->l = 0;
i->e = y->e - x->e + (ExpBias + 2*FractBits - 1);
do{
if(y->h > x->h || (y->h == x->h && y->l >= x->l)){
i->l |= 0x01;
y->h -= x->h;
y->l -= x->l;
if(y->l < 0){
y->l += CarryBit;
y->h--;
}
}
shift(y);
shift(i);
}while ((i->h & HiddenBit) == 0);
if(y->h || y->l)
i->l |= 0x01;
renormalise(i);
}
int
fpicmp(Internal *x, Internal *y)
{
if(IsNaN(x) && IsNaN(y))
return 0;
if(IsInfinity(x) && IsInfinity(y))
return y->s - x->s;
if(x->e == y->e && x->h == y->h && x->l == y->l)
return y->s - x->s;
if(x->e < y->e
|| (x->e == y->e && (x->h < y->h || (x->h == y->h && x->l < y->l))))
return y->s ? 1: -1;
return x->s ? -1: 1;
}