In addition to function plotting, which was still a novelty in the mid 1980s, it features a programming language with conditional branches and loops. The idea of a handheld programmable computer was very intriguing to me, and I entertained myself through hours of boring classes by seeing what I could push it to do. I was only vaguely aware of the BASIC-programmable pocket computers at the time, and they were out of my reach price-wise while this was a lot more affordable to a high schooler at $90.
This is a true, consistent, algebraic calculator. Expressions are entered exactly as they appear on paper. Unlike most so-called "algebraic calculators", even advanced functions like trigonometric functions and other transcendental operations are entered algebraicly. For example, to calculate the sine of 30 degrees you key in
SIN 30= instead of the more typical
In the COMP and AER-I modes, it also understands implied multiplication. For example,
(6+3)(4-2) are both valid expressions.
My calculator was stolen out of my locker about a year after I bought it, and I reverted to using a Sharp EL-512 scientific (non-graphical) calculator that my parents had given me in junior high, but it was also stolen just a few weeks later. So I bought another EL-5200, which served me for several years until the flex connection between the membrane secondary keyboard and the main calculator body wore out. By this time I was halfway through college, so I did what every other engineering student did in 1992 and bought an HP 48.
These days, repairing that broken flex connection would have been well within my capability, but at the time I thought the calculator was a lost cause and tossed it out. In a fit of nostalgia, I obtained the one pictured above via eBay in 2009. It's been a lot of fun relearning how to take advantage of this calculator's extensive features. It's not as powerful as an HP 48, but it's more intuitive and for most arithmetical operations it's faster to use.
Ironically, I lack the manuals for this calculator. Once, I had two sets of manuals after I bought the second one. However, I threw them away when I disposed of the broken unit. Alas, there is very little information about this calculator on the web. It's been over 20 years since I last used this model on a daily basis, but between my patchy memory and some experimentation I have relearned how to use most of this calculator's features. As I learn more, I will update this page.
There is a related model called the EL-9000 that as near as I can tell is simply the European version of this one. I am not sure if there are any real differences between the two (such as amount of RAM), but I don't think so. Everything on this page should apply to the EL-9000 as well.
Significant Digits 12 internal
Exponent Range +/-99 Display 16x4 characters
Memory 26 named scalar registers A-Z
26 named matrices/arrays A-Z, by default unallocated
5120 bytes for programs, variables, arrays, & statistical data
Expansion CE-50P thermal printer/cassette interface Main Power 2x CR2032 coin cells Memory Backup CR2032 coin cell Size 5.5" x 6.5" x 0.5" Weight 5 oz
ModesThe calculator has four modes, selected by a slider switch on the left side of the main body. AER-I and AER-II are programming modes, used only to enter programs.
COMP is the normal computational mode, used for performing arithmetic and most other types of calculations, plotting function graphs, and for executing programs written in one of the AER modes.
STAT is a special statistics mode, used for calculating one- and two-variable statistics, and for plotting statistical graphs. A few keys are redefined in this mode to more quickly enter data.
Quick TipsThe directional arrow keys immediately below the screen are represented in the text below by
[DOWN] [UP] [LEFT] [RIGHT].
- The contrast of the screen can be adjusted using
[SHIFT][UP]. Hold down the arrow key to adjust it more rapidly.
- T>G>D (
[2ndF][DOWN]) cycles between the regular computational (text) screen, graphics screen, and data entry screen while in COMP mode.
- M.CK or Memory ChecK (
[2ndF][RIGHT]) shows memory usage and how much free memory is left. This status is only shown while you hold down the arrow key.
- Like most Sharp calculators, there are 4 display modes: regular, fixed, scientific, and engineering. In regular it will display all significant digits (up to the precision of the calculator), while the other 3 modes display a set number of digits.
[TAB][number key]sets the number of digits to display in those modes. MDF or MoDiFy (
[2ndF][TAB]) will round the current value to the set number of displayed digits.
- The command history can be reviewed by the
[PB](PlayBack) key. Use the up and down arrows to scroll through the list. (Repeatedly pressing
[PB]will also scroll up.) A previous command can be editing or re-run from this list. If there is a command history that can be reviewed, an up arrow indicator will be shown at the lower-left of the screen. CA or Clear All (
[2nd][CL]) will clear the command history (but not stored variables or programs).
- The previous result can be recalled at any time through the special ANS variable (
- CL or CLear (
[CL]) merely clears the main text display and the current entry. It does not erase the command history, graphics screen, or the ANS variable.
Computational FeaturesGenerally, this device functions the same as most Sharp scientific calculators, except that it is fully algebraic, even for the transcendental functions, which are usually entered postfix on other calculators. However, there are a few other features which may require some additional explanation.
Scalar RegistersThe calculator has 26 pre-defined scalar registers, named A to Z. Values are stored in them by issuing
[STO][letter]. You can either use the letter to represent its stored value in an expression, such as:
Register M takes the place of the typical single memory register present on many less sophisticated calculators, and in addition to the normal access methods above it has 3 dedicated keys:
[RM]recalls its value (the same as doing
[=>M]stores a value (the same as doing
[M+]adds the current value to M and stores the result. This is a shortcut to doing
Matrix/Array RegistersThe 26 names A to Z are re-used for array variables, but refer to separate memories. By default, none of them are pre-allocated and all have dimensions of 0x0, taking up no memory. In order to define an array, it first needs to be dimensioned using DIM. For example:
[DOWN]keys to navigate to specific elements, and enter data by typing in the number and pressing
[=], which is redefined as the SET key for data entry. You can enter register names or even expressions in this screen, which evaluate immediately and the result is stored into the element if no error occurs.
Array elements can be directly accessed by referencing them with bracket expressions, for example X or X[1,4] would refer to the 4th element of the array defined above. You can store and recall from these elements just like you would with a scalar register. The first element index is 1, so there is no A. Trying to access an element outside of the dimensioned range results in an Error 5 (Dimension Error).
Defining an array doesn't prevent you from also using the scalar register with the same name. After dimensioning, arrays are always accessed through their elements using brackets (or with the MAT prefix in matrix mode), so there is no ambiguity between A and A.
The S array is used by the STAT mode to store data, so it is probably best to avoid using it if you care about losing your array data.
To clear an array and free its allocated memory, go to the data screen with the
[DATA] key, navigate to the array you want to delete, and press
[2ndF][CL]. It will prompt for confirmation, to confirm press
[COMP/ENT]. Any other key will abort the erase operation.
To exit the data screen and go back to the regular screen, use the
[2ndF][DOWN] keys to execute T>G>D.
Polar/Rectangular ConversionsRectangular-to-polar conversions and the inverse are a bit unusual because they provide a two-value result. You convert to polar using
The r portion of the polar coordinate will be returned immediately, and the θ portion will be stored in scalar register Z.
Convert from polar to rectangular using
The x portion will be returned immediately, with y stored in scalar register Z.
Matrix MathMatrix mode is a special sub-mode of COMP mode. To toggle matrix mode, use
[2ndF][+]. Matrices can actually be entered without being in this mode, since there is no difference between a matrix and an array. However, to do any matrix operations the calculator needs to be in this mode. Matrices/arrays also have the single-letter names A-Z, the same as the scalar registers, but they are not the same locations. They need to be pre-allocated with the desired size using DIM. Both one- and two-dimensional arrays are supported. For example:
When doing matrix calculations, prefix matrix variables with the keyword MAT (same key as
[f()=/?], no shifting required), or else it will think you mean the scalar register instead. For example, to calculate the determinant of matrix A, you would do:
DET MAT A=
Function GraphingGraphing in COMP mode assumes the dependent variable is Y and the independent variable is X (note the caps). The Y is implied in the expression to graph and not actually entered directly. Here is a simple example of graphing a quadratic function (enter this in COMP mode):
GRAPH X2+2X-3AUTO DRAW
[DRAW]executes immediately. Unlike many calculators, it won't show you the graph as it draws, instead displaying "COMPUTING" with flashing left- and right-arrows while it draws off-screen. When it is done, it automatically switches to the graphics screen.
After the graph is produced, hitting
[SOLVE] will find any on-screen roots. Hitting
[SOLVE] again will find the next on-screen root. If a root exists but is off-screen, the calculator will not find it.
A dot cursor can be moved along the curve manually using the
[RIGHT] buttons. Navigating off the edge of the screen will cause it to scroll, which can help find off-screen roots, but this is slow. By default, it will display the X-coordinate of the cursor while navigating. To switch between X-coordinate, Y-coordinate, and no coordinate use the X<->Y function (
AUTO autoscales the Y-axis only. The X-axis range can be set before graphing by pushing the
[RANGE] key, which brings up a special range-setting screen. You can adjust both X- and Y- axis ranges, but the Y-values will be adjusted automatically during plotting unless you leave out the AUTO keyword. The values are entered the same way you enter array and matrix data. Push
[RANGE] a second time (or third if you only changed X values) to exit the range-setting screen when done.
Multiple functions will plot on top of each other on the screen as long as the graphics screen isn't cleared. The graphics screen can be manually cleared using G.CL or Graphics CLear (
[2ndF][LEFT]). Autoscaling a function by drawing it with AUTO will also clear the screen.
ProgrammingSharp calls their non-BASIC calculator programming languages "Algebraic Expression Reserve," or AER. It seems that different Sharp calculator models share some similarities in programming model but the details of each AER implementation vary significantly between models. So understanding how to use AER on the classic EL-5100, for example, is only slightly helpful in learning how to program an EL-5200.
Syntax checking is done at run-time (unlike most HPs, which check during program entry). This makes it possible to save partially-completed programs and finish them later, or use the programming space for notes instead of programs.
Some special symbols are available only in the AER modes. They can be useful for program and variable names, such as α and β. These are brought up with the SYMBOL function (
[2ndF][D]). To exit this symbol screen without actually selecting something hit
Subscripts are available by keying
[SHIFT][number key]. Note that they don't actually function as indices (use array brackets for that), just special characters for variable names.
The program editor is quite nice for a calculator. When the slider is moved to an AER mode, it automatically takes you to the first empty program slot to start a new program. If an existing program is shown, hitting
[COMP/ENT] will take you to the first empty program slot. Then press
[COMP/ENT] to create the main routine and begin editing. You can navigate around the screen using the arrow keys, and both insert
[INS] and delete
[2ndF][INS] functions are available.
[COMP/ENT] saves the current program, while changing the mode slider position or hitting
[PRO]will cancel the current editing session.
To edit an existing program, press
[PRO] while in an AER mode to cycle through the current programs in that mode. A program will only show up while in the AER mode it was written in. To edit the program, press either
[2ndF][UP] to cycle through the main routine and subroutines.
You can store several programs (up to 99 I think), and give them each a name to tag the program number. The program number sequence is shared between AER-I and AER-II programs, so that there will be only one program 7, for example. They are selected for execution while in COMP mode through the
AER-IThere are actually two versions of AER on the EL-5200, called AER-I and AER-II. AER-I is a relatively simple variant, optimized for numerical functions. Programs optionally take the form of
f(var1, ...). Only the regular memories are available, represented by the capital letters A through Z. This restriction allows for some byte-saving shorthand notations, in particular expressions like
4Xevaluate to 4 times X as is expected mathematically.
AER-I doesn't do anything that can't also be done in AER-II. What it does provide is a way to produce extremely small byte-saving programs for straightforward formula programs.
AER-IIAER-II is more sophisticated. In addition to the regular memories, local program variables are also available, using lower-case letters. These variables can have longer names, which improve program clarity. (E.g. dist is more descriptive than D.) However, this freedom entails a restriction: shorthand implied multiplication between variables is no longer allowed because of potential ambiguities. So
4abmust now be written as
4a x b.
Local variables differ from the regular named registers in a few ways. They are assigned values using the equals sign in an assign statement, similar to most computer languages. For example, to assign a value of 6 to the variable a use a=6 instead of 6 STO a like you would with a named register. Similarly, RCL does not work on a local variable, instead use the variable itself in an expression.
AER-II programs can prompt for variables using a simple form of input statement.
Branching & LoopingDespite the presence of conditional tests and loops, there are significant restrictions on their use. Branches can only either execute code within brackets or not, and cannot jump around to other places in the code beyond looping back. Jumps cannot overlap, although they can be nested. There are no logical operators for the conditional tests, so they are limited to simple comparisons between two values. There is no user input other than simple prompting for values or storing values in the
Zmemories ahead of time. Clever programming can produce useful applications despite these limitations, but some things such as interactive games are impossible to write.
Note that each looping operator and must exist in pairs. If a loop back can occur from multiple places in the code, even when embedded within conditional tests, there need to be matching "loop to" points for each "loop back."
SubroutinesSubroutines provide a convenient way to break up programs structurally, and reduce the amount of memory they consume by putting frequently-used blocks of codes in a single place. They also help deal with the size limit imposed on individual routines. Main programs and subroutines have the same byte limit, although I don't know exactly what this limit is.
Subroutines do have some major limitations. Only calculations and statements can be contained in them. Unfortunately, conditional branches and loop operators are not valid in subroutines and generate an Error 1 (Syntax Error). A subroutine can be called from inside conditional brackets or from within a loop, but the conditional or loop must exist in the main routine.
All variables are global within a program, even "local" variables. When a local variable is created inside a subroutine it can then be used by the main routine or another subroutine. A "local" variable simply means that it is not visible by other programs or directly accessible in COMP mode.
To create a new subroutine, use SUB: (
[2ndF][N]). Up to 10 subroutines per program can be created, numbering 1 to 9 and then 0. A subroutine call is made by pressing
[2ndF][number key], using the number of the subroutine being called. The subroutine call will be represented in the code by an inverted (white-on-black) number.
Example ProgramsNone of these example programs are ground-breaking by any means. I present them here as academic examples in the hope they may help other collectors and owners of EL-5200 calculators understand how to use the AER modes, especially if they lack the manuals.
Fibonacci Sequence (AER-I or AER-II)This program calculates and displays the Fibonacci sequence 1, 1, 2, 3, 5, 8... It generates one new number in the sequence every time the
[COMP/ENT]button is pressed. It demonstrates looping. The program will end if any key other than
NOTE: The M+ in this program is the
[M+] key (single command), not a separate M and +.
In AER-II, this same program can be entered but because the keyboard now enters lower-case by default you need to shift each register name to capitalize it:
Quadratic Equation (AER-II)This program finds the roots of second-order polynomials in the form of aX2+bX+c=0 using the quadratic equation. It will find both real and complex roots. It demonstrates the use of conditional branches and subroutines on the EL-5200. While not really necessary in this case (everything could easily fit inside the main routine), the subroutines nicely break up the real and complex root calculations.
This program uses a nifty technique for saving a few bytes. It takes advantage of the fact that unknown variables are automatically prompted for values when first encountered. Strictly speaking, this means that a program doesn't need to explicity prompt for any variables. But in this case, b is the first new variable encountered, and I wanted a to be prompted for first. So a is explicitly prompted for with
a=?, but then b and c are prompted for automatically.
Programming ElementsHere is a short guide to a few of the less-obvious programming elements. Note that the
[2ndF]key indicated applies to either the hard key on the lefthand keyboard or the equivalent membrane key on the righthand keyboard.
Main routine of program. All programs include a main routine. This is automatically opened when a new program is created. AER-I
Creates a new subroutine. The first subroutine is 1:. A program may have up to 10 subroutines.
Switching between existing subroutines and the main routine in the editor is done by pressing
To call a subroutine within a program, use
AER-I Starts a function with f( and encloses single-letter variable names of input variables. Pressing this key again produces the closing )=. The variables inside will be prompted for in order. This is used as the typical, but optional, beginning of an AER-I program. Example usage:
AER-II Prompts the user for a value to assign to preceding variable. AER-I
Ends the current program or subroutine. Only needed if terminating before the end of code, for example, as a result of a conditional test. AER-I
Stores a value into a regular memory location (A-Z). AER-I
Skips display of preceding calculation and goes on to next code without pausing. It is only required when needed to resolve ambiguities in the code, such as when an AER-II program statement ends with a local variable and the next statement begins with one as well. AER-I
Displays the result of the preceding calculation and waits for the user to press
[COMP/ENT]before continuing. The program is actually stopped by this, and COMP is used to resume execution. Any other key will end the program.
Marks the end of a loop and jumps back to the corresponding loop to point. AER-I
Marks the beginning of a loop. Note that there must be exactly one loop to point for every loop back point. If there are two paths back to the beginning of a loop, put two of these in a row at the loop beginning. AER-I
Encloses code that executes only if the preceding conditional test is true. This key sequence alternates between generating the opening and the closing bracket . The right array bracket key
[2ndF][C]may be substituted for this key to generate a closing bracket as well.
Encloses code that executes only if the preceding conditional test is false. This key sequence alternates between generating the opening and the closing bracket . The right array bracket key
[2ndF][C]may be substituted for this key to generate a closing bracket as well.