# Notes on creating an FPU for the NOR computer.

A project log for Rubidium 2.0

This is an all in one spectrum and logic analyzer, robotics control platform, and modular synthesizer with audio in and sheet music out!

Earlier I mentioned throwing some code together where I began implementing a complete ALU for a hypothetical computer that uses only NOR gates, figuring that by working in C/C++ with an eye toward being able to port "whatever seems to work" to system C or even Verilog, then, well, why not?  Then I realized of course that since I eventually want to run UCSD Pascal, or perhaps Modula II, or even ADA on the Parallax Propeller 2 - then with a few other code tricks up my sleeve, this could become the basis for turning my Frame Lisp project into a full-fledged compiler.  So why not implement floating point, especially if I am going to eventually need it - for whatever this transmogrifies into?

So this is how 32-bit floating point multiplication works, and what IEEE-754 style looks like, even if it isn't fully tested for STRICT compliance with the standard or any standard - but it does seem to work, which is enough for now:

```real real::operator * (real arg)
{
short _sign;
real result;
short exp1 = this->exp()+arg.exp()-127;
unsigned int frac1, frac2, frac3, frac4, fracr;
unsigned short s1, s2;
unsigned char c1, c2;
_sign = this->s^arg.s;
frac1 = this->f;
frac2 = arg.f;
s1 = (frac1>>7);
s2 = (frac2>>7);
c1 = (frac1&0x7f);
c2 = (frac2&0x7f);
frac3 = (c1*s2+c2*s1)>>16;
frac4 = (s1*s2)>>9;
fracr = frac1+frac2+frac3+frac4;
if (fracr>0x007FFFFF)
{
fracr = ((fracr+(1<<23))>>1);
exp1++;
}
result.dw = (fracr&0x007FFFFF)|(exp1<<23)|(_sign<<31);
return result;
}
```

Oh, what fun!  Haven't tried compiling it yet on either the Propeller or for Arduino, but I do know that some versions of the Atmel architecture such as the Mega 2560 series have hardware multiplication at least as far as being able to 8-bit by 8-bit on the chip, so this could get interesting performance wise, let's say when the time comes so as to be able to compare the performance of a 6502 emulator running UCSD p-system Pascal, which itself runs as an emulated 16-bit p-machine running on the 6502 whether real or virtual, vs. whatever the performance might be for floating point if the p-machine were running under direct emulation.  I will be putting some code for this up on this site, as well as (eventually) on Git, for anyone who wants to tinker with a greatly simplified calculator example, which is now in the process of getting floating point!!

## Discussions 