I have spent quite a bit more time with Droid48 (emulator of HP48GX), so I wanted to provide a review:
My summary: It is very powerful, but with somewhat of a steep learning curve, not as user-friendly as we are accustomed to with modern programs. There is a rich texture of features built in and accessible, and with that rich texture comes a fairly complicated/diverse user interface.
If you think about it, the challenges of packing a lot of diverse features/commands, displays into relatively small calculator interface is similar to the challenge of packing a lot of features into an Android interface. It’s something HP worked on for along time, and they came up with a lot of creative solutions, but much different than standard Android since they had only keys, no touch-screen.
Several of the tools that HP used to pack a lot of interfacing capability:
1 – multiple uses for each key. Most keys can be pressed, or left-shift-pressed, or right-shift pressed for different functions. Additionally to create characters, there is alpha-press, alpha-left-shift-press and alpha-right-shift press. Not all of the choices available are displayed on the keyboard, and behavior of a given key or shifted key can depend on the context. I find I have to do a little bit of studying to remember if I need to left-shift or right shift in a given context. This is one of the things that contributes to the learning curve I mentioned.
2 – soft keys. The 6 keys at the top of the keyboard (just below the display) have changeable meanings depending on the context. Their current meaning is displayed in the display immediatley above. The NEXT key allows us to look at the next 6 choices when there are more than 6. Some of the menu choices have a special appearsance (like a folder) indicating that if we click on this, we get a whole new choice of menus (hierarchical menus).
So what can it do?
Let’s start with the simplest part: you can use it as a calculator. RPN as they call it, should not be a problem for most people.
So, you have a stack of theoretically unlimited size (limited only by memory) in which to store your numbers if you choose.
Stack may be is somewhat inconvenient, so you can also store your numbers as a named variable.
The named variables can be arranged within named directories, which can be nested to any level.
Browsing the directory structure is fairly easy using the soft-keys, in the context which is created after you press the VARS key.
So you can see we have a pretty elaborate and user-friendly system (stack and named variables stored in hierarhically-arrangable directories) for keeping track of the “numbers” in our calculator.
Now here’s a bit of elegance: the variables that we can manage using that system are not limited to numbers.... we can use that exact same system to handle any type of “object” that calculator deals with. Here are some of the object types (each occupies one spot in the stack or one named variable):
numbers (real)
complex numbers
unit objects (combination of number and a built-in unit)
vectors (1-D matrices)
matrices
strings
lists (sequence of objects of any object type... can be mixed within a lise)
algebraic ojbects (special type of string which contains expression or equation)
program objects (define a sequence of commands)
graphics objects
and more...
Now let’s talk about what you can do with some of these objects:
Dealing with complex number calculations proceeds identically to real number calculations. Use +, -., *, / ^ etc. Plus a few extra functions to convert between real and complex as needed.
UNITS!.... the calculator has a large library of built-in units. Units are handled in a transparent manner for the user (supply inputs in whatever units you want... possibly mixed units in single calculation...specify output units and calculator does all required conversions). Units are also easily handled by the other embedded applications (plotting, equation solving etc). One thing I am not 100% sure yet is how to deal with units I want that are not inside the pre-defined library. This is anyway a very useful feature and one I didn’t expect to find on a calculator. It is on-par with the unit-handling supplied by smath and quite a bit better than the unit handling of Matlab’s Mupad.
Algebraic Objects / equations - We can use these as an alternative to RPN to do a computaiton. The variables (like X) embedded within the expression can refer to a variable X if it exists in current directory path or anywhere above it (there are other structures for passing variables into the equation also).
There is also built-in equation editor with “pretty-print” that puts numerators, denominators, nested stuff in their right place. I don’t find a need for it since it never leaves the calculator.
Solvers – These numerically solve equations supplied as algebraic objects. An interface is presented where you can supply the input variables and pick any single one of the equation variables (not necessarily the one by itself of the left hand side of the equals) and it will be solved based on the supplied values of the other variables. Equations can use units or not at your discreation. If you want to use units, you can pre-load the variables with their units into the directory of the equation, it makes it a little easier to enter the variables with appropriate pre-selected units when you execute the solver. But you can certainly adjust the units on the fly as well.
Multiple-equation solver – leads you through a series of individual related equations, feeding results from one equation into the next. Keeps track of which variables are known and which equations have only one unknown (candidates as the next equation to solve). Can also press “ALL” and if you have N non-linear equations with N unknowns left, it will solve them all.
Matrices – a very full library of multiplication, inverse, singular value decompositon, eigenvalues/eigenvectors, row swap, column swap, row extract, column extract/add etc. For very large matrices you will be hindered by the memory size. There is also a matrix editor which resembles a spreadsheet interface.... pretty handy. Matrices can also house algebraic objects, but I havne’t used that feature
Strings - lots of built-in string handling functions
Lists – lots of built-in list handling functions.
Statistics – built in statistics applicsations.
Numerical integration – built in
Limited symbolic capabilities. Does include symbolic integration and differentiation and retrieving variable values in the current path, which are then automatically plugged into equations or experessions.
Plotting. There are quite a lot of plotting routines built in. An interesting thing is they don’t label the axis. Instead they give you the ability to move an x-y cursor around the plot with coordinates displayed.... can also lock onto one of the curves and scroll along that looking at coordinates. Also lots of built in ability to zoom in and zoom out and move around areas of the plot. I believe these tools are attempt to give a good view of the data, working within the constraint of limited dispay area. There are a lot of different plot types (15 at least IIRC), each with slightly different syntax. Surprisingly,, no simple X-Y plot with points connected by lines. But there is a workaround where you can build that using the parameteric plot type.
Graphics – Results of plotting can be saved to graphics object and manipulated and annotated. There is a set of drawing tools (line box, circle, pixel, invert, etc).
Input/output – There are tools supplied which allow you to create a dialogue box for interaction with user (INFORM)
Customization – There is quite a bit of ability to customize the keys and build custom soft-key menu’s to do whatever you want to gain easy access to the things you do frequently.
Customizations can be tied to directory. A certain menu combination can be tied to a certain directory so you have the menu you need when you are in that particular directory (the stuff you normally do with the programs and data stored there). Plotting options are also stored with directory, so if you customize your plot for that particular directory, it will come back the same next time. Libraries can also be linked to directories. The idea is that you will be doing the same type of tasks every time you visit the same directory, so it can remember the customizations you want for that directory.
All of the above is “built-in”. Of course since there is a program object type, you can build your own program. The programming language they supply is called User RPL. RPL is similar to RPN, but includes handling for al the objects supplied. The L stands for Lisp.. the language is supposed to be similar to Lisp and to Forth. Typical structured programming tools: It has If/then, Repeat until. Do while..... The ability to call other programs with arguments passed etc.
There is also a whole different layer of RPL called System RPL. It can do more and execute faster, but also is a little more dangerous since it accesses the machine at alower level. And there is also Assembly.
Extensive user documentation is available for free on-line (both the documentation and the ROM were released to public domain by HP after the HP48 was discontinued). For simple User RPL, there is:
Getting Started guide ~ 150 pages
User manual ~ 600 pages
Advanced User Reference ~ 700 pages.
(all free).
Again for the SystemRPL and assembly there is also documentaiton freely available.
I was talking about programming. There are a ton of programs that have been created by others that are freely available to be loaded into your HP. You can find them all at HPCalc.org
This includes:
simple word processors implemented on HP48
simple spreadsheets implemented on HP48 (cell48 and exAL)
simple databases implemented on HP48
Video games
There is a very crude Pascal coded in RPL available to run on HP48 = “HP Pascal Studio” (different than “HP Pascal” which does not run on 48)
“Erable”, which is supposed to be equal to Maple, and is incorporated into newer versions of the HP (HP49) to give improved symbolic capabilities. I hadn’t tried it out.... if I want symbolics I do it on my computer.
Alg48 – a large math package to extend capabilities.
There are memory management utilties.
There are varaible ‘hiders”. So you can store variables that you want to be accessible from program but don’t want them to clutter up your display when you browse a directory.
There is almost an endless supply of tweaks to the user-interace that people have built to get around long-standing annnoyances.
The HP48 had several kinds of memory: ROM (512k), user-RAM (128 unmerged, 256K merged), and then extended ROM/RAM available in port memory. Most of what we do is in user memory. The tools for accessing the port memory are a little different than for user-memory... another part of the learning curve. Some of these programs are provided as libraries which load into port memory. Installing them can be a little bit tricky... at least I haven’t fully gotten the hang of it yet.
I should mention there are a large number of companion programs you can use on your PC to work alongside your Droid48. The two huge ones imo are HP User Edit and Emu 48. When installed together, they allow you to emulate an HP48 on your PC (emu48). You can type and manage code easily in HP user edit. I have set it up so all my customizations and equations etc live in a master file in user edit, and I can load them back into Droid48 whenever I update them. It’s a lot easier to type in code on the PC then to hunt/peck on the calculator keyboard. And a lot easier to look at a large program at a glance, and cut/paste to move parts around etc. By the way you can include comments in the PC text version of your programs, the comments get wiped out in the calculator when you convert it to a calculator program.... another reason to keep the PC as your main programming environment for anything other than small tasks.
All in all, I hope you can see why I labeled it as very powerful, but also comes with a learning curve. Probably the best/only program available to develop detailed math calcs on Android. As I mentioned, the interface is somewhat clumsy on the calculator. It’s a little easier when you can use the PC for program development.
There is something else on the horizon...
The ND1. Built for smart-phones form the ground up.
Programs in either RPL or java.
Looks pretty slick.
At this point only available for i-phone...NOT for Android ;(
The developer told me it will be available for Android eventually:
=====================================
(2B)+(2B)' ?