early 8080 Floating Point Code, calculator chips, and "math coprocessors"

This Web page and archive built by Herb Johnson. last edit Nov 10 2022. The content on this Web page is copyrighted Herb Johnson (C) 2022. - Herb

This Web page began with descriptions of LLL's early BASIC and ODT which supported floating-point math for the 8080, and an alternative floating pont library from Chuck Falconer. I added information on calculator chip "math processors" and actual "floating point chips", which are described. These are not "math coprocessors" like the Intel 8087 because these other chips are I/O devices; they are not microprocessor "coprocessors" which take over from the microprocessor to run different (floating point) instructions. I update this page and content from time to time. If you have experience or interests in these items, please contact me.

As the size of all these documents adds up, I'm reluctant to add them to my Web site. But I can provide copies upon request. The LLL material has no copy restrictions. - Herb Johnson

Lawrence Livermore Floating point package and BASIC for the 8008 and 8080

Summary: Lawrence Livermore (National) Labs produced an 8080 floating point package in 1975, based on 8008 code. Soon after they offered a BASIC which accessed that code. Versions became available in the CP/M community and in Dr Dobb's Journal and in an IEEE publication; but they were incomplete. I made them available on my Web site several years ago. These programs as corrected became available here on my site; copies have since appeared on other Web sites.

1975: Here is the PDF of the original LLL floating point document:


   UCRL-51940, "Floating-Point Package for Intel 8008 and 8080 Microprocessors"
   by Michael D. Maples
   Lawrence Livermore Laboratory,
   University of California/Livermore, California 94550,
   October 24, 1975

This document includes sources for floating add, subtract, divide, multiply and square root. In recent years the OSTI Web site haven't had it available for some reason. Copies can be found on the Web.

Here's other LLL publications about LLL BASIC, floating-point or ODT (debugger). They are:

DODT for MCS-8 microcomputer, Oct 1974. This is an 8008 debugger. These LLL publications are freely available (US Govt publications are not copyrighted) and have been online for several years (from 2019). LInk is to a catalog entry, which should link to a PDF. I have a copy available if needed.

USer's Guide to LLL BASIC", April 1976 and Users Guide to the LLL Basic Interpreter, June 1977. The June version is very similar to the April version. I have copies available if these go offline. These are both user-guides, no source-code provided.

In Jan 1977, a version of the LLL BASIC and floating point was published in Dr. Dobb's Journal Vol 2 no 1. In recent years the Dr. Dobbs'content has "emerged" on the Web. I have a copy if needed. For some reason the square-root code was not referenced or included.

There was a brief article in IEEE Computer magazine; the reference at the IEEE Web site is: "Real-Time Microcomputer Applications Using LLL Basic," Computer , vol.10, no.9, pp.14,21, Sept. 1977. IEEE charges for copies of its articles and actively prohibits online distribution. The article lists three programs, one in assembly language; better examples are available in the user's guides cited above. But in 2018, I found a Web link to the article at computer.org

Also, Interface Age published the BASIC and float code, by John Dickenson and Jerry Barber and others from LLL, in four parts from Dec 1976 to March 1977. Copies of Interface Age were on the Internet Archives as of 2021. Again, I can provide a copy if asked. Again, no square root.

(Thanks to Neil McNeight for the osti, IEEE and bitsavers references.)

1980's: A version of the code was offered on CPMUG disks #2 and disk #10; as part of LLL "floating point BASIC". Files and folders with the contents of those disks, can be obtained from the retroarchive Web site as CPMUG010.ARK and CPMUG002.ARK. But here they are as modern ZIP files, cpmug010.zip and cpmug002.zip They should also be on archives or images of the Walnut Creek CP/M CD-ROM, found on many Web CP/M archive sites. Of course "010" is code from disk #10, and "002" from disk #2. These archives don't include the square-root. of the original "floating point" document and PDF.

The code submitted for disk #2 includes simple CP/M I/O code; for disk #10 that additional code includes CP/M file system support. Disk #10 code includes references to floating-point code. There's no other obvious changes to the LLL code between the two disks. It looks like CP/M disk 10 includes the code listed in the Interface Age articles, plus the floating-point code presumably in part 3.

Sept 2006: Emmanuel Roche, AKA "French Luser", led a discussion in com.os.cpm (an old Usenet CP/M email discussion group) about 8080 floating point code. Roche posted part of the LLL document text but not the code of the document. Later, Roche provided privately to me his version of the source code, with square root code included, and more commentary.

For some time, this Web page carried multiple versions of the floating-point source and discussions about differences. In 2015, I simply took the CPMUG #2 code and produced a version which 1) is verified against the LLL documented version 2) includes the square-root and 3) includes the simple CP/M code from disk #2 as cited above. My thanks to Bill Beech; we took turns editing and assembling the source, and comparing the octal produced against the octal-based listing in the LLL document.

Here's the 8080 ASM source for the Lawrence Livermore 1975 floating point package. Additional code added in the CPMUG disk #2 is noted. Here's an octal-based 8080 listing of that code, which can be compared to the octal listing. The assembly is courtesy of Bill Beech and his 8080 cross assembler.

Note the title of the LLL document is "8008 and 8080....". The 8080 code they provided is code compatible with Intel's 8008 mnemonics as revised by them around 1975. Here's an 8008 assembly listing of almost the same LLL code. The differences are that decimal constants in the 8080 source were appended with "D", so that the assembler would not assume they were octal. Assembly errors in this listing are due to the added CP/M code. I'm not aware if the resulting 8008 code has been tested on an 8008 simulator or physical computer. Thanks again to Bill Beech for some of this work and his commentary.

Square root

Here's the 1975 LLL float code for square root, as published. I hand typed the code into an ASM file and then assembled it. As best I can tell, the binary matches the binary in the 1975 listing.

other work

I've not worked on restoring a version of the entire LLL BASIC with floating-point; only restoring the floating-point portion of that code set. Floating calls from BASIC, are described in the published documents; except calling "sqrt" was only described in the 1975 LLL document. CALLing external routines is described in the LLL BASIC manual and article #1 in Interface Age. In Aug 2018 I've transscribed a BASIC plot program and 8080 assembly CALLed code into this document.

Apparently in 2017, Phillip Stevens obtained a copy of my LLL floating-point descriptions of this Web page, and copies of the relevant documents and sources, and created a github page. He did not ask me, but he at least linked back to this Web page. On github, they assembled a form of the LLL 8080 floating-point code (they also converted to Z80), and they wrote Z80 code to drive an AM9511. Their goal was to compare the two, for use with two Z80 hardware projects: YAZ180 and RC2014. is the relevant github link for Phillip Steven's work as obtained from here and as I've described.

Falconer Floating Point 8080 code

In March and April 1979, a two-part article and code was published in Dr. Dobb's Journal: "Falconer Floating Point Arithemtic" by Charles B, Falconer. (Note: Charles Falconer passed away in June 2012.)

This code was requested on Sept 2006 in the comp.os.cpm discussion group. It was originally published in Dr. Dobb's Journal in 1979, and other places later including Intel's "INSITE" library for 8008 8080 code. Apparently the author, Chuck or Charles Falconer, has lost his hard-drive archives of various versions of this code. If other people have a "digital" version they might contact him, or me. Roche posted one version of this in March 2001; Chuck Falconer says it's a "much improved version" of the DDJ code. In Oct 2006, Roche sent me his copies of what he posted; they include the tab stops not in the comp.os.cpm files so I've replaced them here. Here are also other ORIGINAL files Roche posted; some responses by Mr. Falconer; and another posted comment on the DDJ docs by Mr. Falconer.

part 1 of 5 of the code INTARITH.ASM;
part 2 of 5 of the code FLTARITH.ASM;
part 3 of 5 of the code FLTINPUT.ASM;
part 4 of 5 of the code FLTOUT.ASM;
part 5 of 5 of the code FUNCTION.ASM;
the text of the DDJ article;
the text of the DDJ article in WordStar format;
improved multiply, posted by Falconer;
docs from DDJ article, posted by Falconer;
comments on docs, posted by Falconer.

COSMAC 1802 floating point codes

In 1979, Paul Wasserman of Union, NJ (USA) wrote an article published in Dr Dobb's Journal #37, May 1979 Volume 4, titled A Floating Point Subroutine Package for the 1802. He produced code based on PL/M coded methods in the book "Microprocessor Programming for Computer Hobbyists" by Neil Graham, published by Tab books. The code supports four binary bytes of mantissa and two bytes binary exponent and fundamental arithmatic operations and binary/decimal conversion. His article provided a hex-listing of the code, showed address locations in the code (to relocate it); but no source. In early 2021 I disassembled the binary into assembly language based on PL/M code in the Graham book; and reproduced the article. Here's the code and article and related information. Dr Dobbs Journal at the time, released code and information published for use as I performed. Please contact me if you have further interest. - Herb Johnson

Floating point hardware in the 70's microprocessor era

Floating point chips

In the 1970's, Intel and AMD made two cross-compatible models of floating-point processor chips. Intel and AMD may have had some cross-licensing agreement because some physical chips identify both Intel and AMD. I don't know which company announced or produced "first". These are I/O devices: the processor under software control, sends the chip data and an instruction; eventually the chip signals "I'm done" and the processor accesses the results. It can take hundreds or thousands of microseconds, as they are apparently running many calculations to approximate the functions provided.

AMD 9511, 9511A - compatible with Intel 8231; probably announced & produced in 1978-79
AMD 9512 - compatible with Intel 8232, IEEE floating point
Intel 8231, 8231A - non-IEEE floating point format, supported sine, cosine, tangent, etc. Data sheets dated Sept 1987
Intel 8232 - IEEE floating point format but no sine, cosine, tan, etc.
Data sheets for these are available by Web search; check "bitsavers.org".

These chips were intended to supplement a microprocessor and are generally accessed as an I/O location. Some implement an IEEE floating point standard, some used another standard. Some ran from a 1MHz clock, some a 2MHz clock. These chips were available commercially for many years, but always sold above $100 each. In the early 2000's, these chips were worth something like $50 each for use; by the 2010's they seem to be several or a few tens of dollars (watch out for counterfits). "Chip collectors" pay more for specific models and physical features like gold, purple, ceramic, etc.

In the S-100 world, these chips were supported by the Compupro System Support 1 (SS1) card, TDL's (Technical Design Labs) SMB card, and other S-100 cards. Pascal MT+ software had an option to use the AMD chip. In the Apple world, the Apple Lisa 2 had a socket for the AMD chip. On a Github page, there's a version of the LLL code and a conversion to Z80 and an alternative that operates an AMD 9511 math chip.

A reference article: S. Cheng and Rallapalli K (authors), "Am 9512: Single chip floating point processor". In Conference Record, (IEEE) WESCON, 1980. Paper no. 14/4.

hardware floating point processors

In the minicomputer days, many companies made "floating point processors" as one or multiple PC boards. A few S-100 companies offered floating point boards, using discrete logic to make an actual arithmetic-processor.

Northstar was one of the earliest, with their S-100 Floating Point Board (FPB). It used a 74181 4-bit processor and "microcode" PROMS to perform floating point operations. A version of Northstar BASIC was supported by this board. I think I have a copy of that program. Here's a link to my NorthStar Web page which includes some FPB-A information. I have manuals which include schematics and "dumps" of the PROMs that perform the calculations.

I"ll be glad to list here, other 8-bit vintage microcomputers which used dedicated floating-point hardware; if you give me details. - Herb

Chips that do math

There's a number of 1970's and 1980's logic ICs which integrate functions of adders or multipliers. Some of the simpler ones were added to various microprocessor-based designs, or they were part of "floating point math" boards added to minicomputers. Some were originally part of minicomputer CPUs themselves. The TI 74181 is a 4-bit logic unit that does add/and/or logic; other TTL IC's provide additional logic/math functions. The RCA 1855 was a CMOS 8-bit multiplier; multiple 1855's could multiply more bits. Not many of these were part of the hobby/personal microcomputing world of the 1970's and 80's. Early Intel Multibus products included a floating-point board made from bit-slice processors. Some "modern" TTL computer kits use TTL logic to implement simple computers instead of microprocessors.

Some logic microcontroller boards were part of floppy disk drive or hard-drive controllers on microcomputers. In the early 1970's, only these specialized designs were fast enough to support the data rates from these mass storage devices. An example is Dr. Torode's first generation of floppy controllers which ran CP/M on the earliest S-100 systems. Many early floppy controllers and hard-disk controllers, used specialized computing logic or their own microprocessors. Of course, specialized single-chip or chip-set controllers, include specialized microprocessors.

calculator chips as "math processors"

Calculator chips preceeded the microprocessor; the origin of the Intel 4004 was as a calculator chip that was software programmable rather than programed-in-mask at the factory. A few of these calculator chips, were redesigned to have a byte-wide hardware interface, rather than use actual calculator chips which required simulation of a keyboard and a 7-segment display. The National MM57109 was accessable as a byte-wide device like any other I/O "chip"; it was still a BCD (decimal) calculator.

A number of boards available from microcomputer manufacturers of the 1970's and early '80's, had options to support a calculator chip. These are not "math coprocessors" because 1) they are addressed in memory or as I/O devices; 2) they did not execute program instructions, only data-as-instructions from a software program, 3) they were really, really slow. But they were cheap at the time and of course were a solved-problem, no math programming needed.

The Netronics ELF II, a COSMAC 180 based computer, included an I/O board with the National MM57109. In an online discussion group "cosmacelf" at groups.io in Sept 2019, my good friend and 1970's digital designer Lee Hart had this to say: "[The MM57109] chip was in fact a mask-programmed 4-bit microcomputer, originally designed [by National Semiconductor] as a calculator chip. So it was straightforward for National to re-program a version of their regular calculator chip as a math coprocessor. It makes sense. T.I. was driving everyone else out of the calculator chip business. National probably saw the MM57109 as a way to get a few more sales out of their existing calculator hardware and software design. Interestingly enough, 4-bit micros are still around [in the 2010's]. They still dominate the low-end calculator, clock, and appliance control market. They are dirt-cheap, and take a miniscule amount of power. Just *try* to make a $2 solar-powered calculator without one! [These 4-bit micros] never saw much hobby use, because they were all mask programmed [during manufacturing]. So users needed special development chips and systems."

I'll be glad to list here, other 8-bit vintage microcomputers which used these calculator chips; if you give me details. - Herb


Herb Johnson
New Jersey, USA
follow this link to email me @ my email address

Copyright © 2022 Herb Johnson