The Sharp PC-1300S Pocket Computer

Introduced in 1979, this is an odd machine to try to characterize. It's too big to fit into a shirt or jacket pocket, yet it's small enough to be considered portable. It'll run on its internal batteries, but the bright display and printer all but require that it be plugged in. It's lighter than it looks (1.5 lbs, about double a 19C, 60% of a 97), with a brushed aluminum faceplate and black plastic body.

(For the first known photograph of me with the calculator, click here.) (And yes, that other calculator in the above photo is a 15c+, not the original 15C and not the later 15C Limited Edition. But this isn't about that.)

I don't know how many of these were built, but my machine has a three-digit serial number and the sticker doesn't look like it has room for more than four digits.


As a scientific calculator, it fits between the HP 35 and 45, adding DMS and Degrees/Radians/Grads to the former and lacking the latter's factorial, statistics, percent, and unit conversions. It also has absolute value, integer portion, and sign, which aren't glaring lacks unless programming.

As a portable (if not quite pocketable) computer, it offers 42 data storage registers, 640 "steps" of program memory, a magnetic card reader for program storage, and a built-in printer. Its alpha capability is limited to prompts and labels for display and printing. That puts it well ahead of the HP 67/97 which came out three years earlier, but pales compared to the 41C which came out later the same year and the 75C/D which came out three years later. Sharp likens the programming language to a stripped-down FORTRAN but I'd consider it a stripped-down BASIC. It does not have continuous memory; the memory contents are cleared when the power is turned off.


Here's a simple program to sum up the reciprocals of the first 100 positive integers:
00; 0=>S
01; DO 1,100
02; S+1/A=>S
03; CNT
04; DSP S
05; END
It runs in a little under thirty seconds; pathetic by current standards (the WP 34S does it almost instantaneously) but about twice as fast as the more-or-less contemporary 19C. It scores about 617 in the Loops of addition benchmark, again about twice as fast as the 19C. Timing was done by hand; there is no clock in the machine (Okay, the CPU must have a clock, but you know what I mean).

By the way, notice that the DO loop uses A as an implied index. This also implies that DO loops cannot be nested. Other control structures include the GTO (goto); GTS (goto subroutine); IF, though without an ELSE; and HLT (halt), which can be used for prompting. Conditional tests are for equality, inequality, greater-than-or-equal-to, and greater-than. There's also a single flag that can be set, cleared, and tested. PRT (print) and DSP (display) output to the printer and display respectively. FED (feed) prints a blank line. Branches can be to line numbers or alphanumeric labels.

As you probably surmised from the program listing, there are 26 data storage registers A through Z. In addition, any register can be used as an index register. Put a value 0-41 in any register, say C, then XC will use that value as an index, 0-25 referring to A-Z and 26-41 referring to additional registers. It's like the 19C/29C in that the higher-numbered registers can be accessed only indirectly, but unlike the 19C/29C any register can be used as an index.

The display is bright and readable. The electrostatic printer is fast and puts on quite a light show in a darkened room, not to mention being noisy. Neither allows for arbitrary graphics, being limited to the included character set.


The machine comes with a hefty book listing about 150 programs running the usual gamut from math to surveying to circuit analysis to games. It does not come with anything like the standard pac that comes with the 67/97 (no pre-recorded programs). Before any of the programs can be used, they must be keyed in. They can be saved to cards afterwards, of course, but the machine only comes with five blank cards, which severely limits the size of one's program library. Additional cards (and rolls of the foil paper for the printer) were available from Sharp, but I have no idea where to get any now. And of course the 324-page program book and the 64-page owner's manual are in Japanese.

Incidentally, both books are for the PC-1300. There's a four-page leaflet giving "corrections" to the manual to make it fit the PC-1300S. It basically amounts to saying that there are 42 memory registers instead of 26 and 640 steps of program memory instead of 256. None of the programs are longer than 256 steps.

The card reader is manually powered: you insert the card and pull it out (just like swiping a credit card). Like the 67/97, the card can be inserted into a slot to remind the user what the program does, though here it's above the display, further from the keyboard. The card itself is a hard clear plastic, with a white writable surface for labelling. Note the provision for labelling the five softkeys. Those keys call their respective routines when the calculator is in the DEF mode as set by the slide switch to the right of the π key.

Notice the optical timing marks along the edges: Sharp provides little black stickers to put over them to write-protect the cards. I assume a felt-tip pen would work as well, if one wanted to permanently write-protect a card.


Despite the claims on some other websites, this is a ten-digit machine, not a twelve-digit machine. Even the manual says ten digits plus/minus one unit in the last place. It also seems to round toward zero on some operations: the last digit of 1/6 is "6" and the last digit of 1/7 is "8". 1/(1/6) is greater than 6 while 1/(1/7) is less than 7. It's reversed on the 15c+. It also drops the eleventh digit instead of rounding, that is, 1+9E-10 gives 1 instead of 1.000000001. This can lead to slightly different results over a long series of calculations as compared to a ten-digit HP machine. For example, the program given earlier produces 5.187377472 on the 1300S while the 15c+ produces 5.187377520. The twelve-digit result from my 50g is 5.18737751761. (Before criticizing my results, please calculate the sum the "wrong" way, from 1 to 100 instead of from 100 down to 1.)

However, π is provided to twelve digits and maintains the extra digits when stored into a register. The sequence π=>A,100000*(A-3.14159) produces 0.265359 whereas 1/6=>A,100000*(A-.16666) produces 0.66666. Calculating π+0 or π*1 loses those extra digits so that π+0-π and 1*π-π both produce -5.9E-10. Strange. The sine of π is 0. The sine of π-π is 0. The sine of 1*π-π is -5.9E-10. The sine of π+0-π is -5.9E-10. The sine of π-π+0 is 0. Very strange.

The common logarithm seems to be a bit flaky. Log 2 is 0.30103, log 5 is 0.69897, both of which are only correct to eight digits, but log 3 is correct to ten digits. The natural logarithm seems better; ln 5 / ln 10 gives log 5 to ten digits while ln 2 / ln 10 is off by one in the tenth digit.


A slightly more substantial program than the first example calculates and prints the first 229 decimal digits of π in about fourteen hours. (Actually, it does 39 registers of six digits each for 234 digits, but the first register just contains the single-digit integer portion.) The code is based on that presented in Katie Wasserman's article. The number of digits and the time compare favorably with other machines from the seventies, though of course later machines have more memory and are faster.
00; 1551=>B
01; DO 3,41
02; 0=>XA,CNT
03; 0=>C,41=>A,DSP B
04; C+XA*INT (B/2)=>C,C-1E6*(INT (C/1E6))=>XA,INT (C/1E6)=>C
05; A-1=>A,IF A=>2,GTO 04
06; 0=>C
07; DO 3,41
08; C+XA=>C,INT(C/B)=>XA,1E6*(C-B*INT(C/B))=>C,CNT
09; D+2=>D,B-2=>B,IF B>1,GTO 03
10; DO 3,41
12; END

The program uses less than a third of the available program memory. If the remaining memory could somehow be converted to data registers then the program could calculate more than double the digits (at more than quadruple the time).


The programming language is a little quirky. A subroutine call returns to the line following the call, not the instruction. Thus anything on the line following the GTS <line_number> or GTS <label> instruction gets ignored. Likewise, anything on the line following the DO <lower_limit> , <upper_limit> instruction also gets ignored, even the first time through the loop. The DO loop always increments the index by one, though the program can store a new value into the A register to affect the loop.

As mentioned earlier, there is no ELSE keyword to go with the IF. If the condition is true then the remainder of the line is executed otherwise execution drops to the next line.


Program editing is a little more awkward than I think it needs to be, even by 1979 standards. There're no up/down-arrow keys so to move to the next line you have to press the right-arrow key repeatedly until the cursor gets to the end of the line and then wraps to the next line. And likewise, to go up you have to repeatedly press the left-arrow key. This would be easier if the arrow keys repeated while you held them down, but they don't. Alternatively, you can switch out of program mode, press GTO <line_number> , or GTO <label> , and then switch back to program mode.

The editor defaults to replace mode. The INS key does not switch to insert mode. Instead it lets you insert one program step. To insert the sequence A=>B, you have to press INS A INS => INS B INS , or INS INS INS INS A => B , or some intermediate combination. The INS key does not repeat.

The DEL key deletes a single program step. Again, this key does not repeat.

At least insert and delete are available, unlike my first programmable calculator, the venerable HP-25.

Keywords cannot be spelled out, they must be entered using the dedicated, possibly shifted, key functions.


More to come...