**GO-25**

**SciRPN**

**Pocket Calculator**

**GO-25 SciRPN** **closely simulates the venerable HP-25C Programmable Pocket Scientific
Calculator.**
The HP-25C was released in 1976 and sold for a MSRP of $195.
Virtually indistinguishable from the real item in operation, **GO-25** is a powerful yet
simple retro calculator.

- Capabilities At A Glance
- Introduction
- The Calculator Display
- The Stack
- Auxiliary Information Views
- Function Keys
- Programming Keys
- Three Modes Of Operation
- Key Codes
- Running A Program
- Storing and Organizing Programs
- Importing Programs
**GO-25**Program Format- Editing Programs Inline
- Sharing Programs
- User Contributed Programs
- Improper Mathematical Operations
- Gesture Summary
- Support

**Capabilities At A Glance**

- RPN (Reverse Polish Notation)
- Four stack registers
- Ten storage registers
- Math, trigonometric, polar/rectangular, logarithmic, statistical, power functions
- Copy and paste
- Programmable, with annotated program listing, and memory for 99 program steps
- Fast, slow or single step program execution
- Three separate windows for stack/storage registers, keystroke log, and program source code
- Program import via pasteboard or from other Apps
- Program export via printer, email, pasteboard or to others Apps

**Introduction**

This document is not an exhaustive reference manual; rather, it's a terse outline of the calculator's function and programming keys.

In this document normal calculator keys are shown in bold, such as **+**, or **CHS**, or **4**, or **Σ+**.
Most keys can perform two other functions, however, one labeled in blue and and one labeled in gold. To execute one of these functions
you first touch the corresponding colored *prefix key*,
either **g**
or **f**,
followed by the desired function key.

So to compute the sine of a number
you'd touch two keys, the **f** prefix key followed by the **4** key.
However, this document will simply show the key as **sin**: the font color
implies which prefix character is used. Similarly, touching the two keys **g**
and **4** executes the arcsine function **sin ^{-1}**. The only
exception to this convention is when discussing programming and keycodes.

The **PRGM-RUN** switch
controls the two basic calculator modes. In **RUN** mode, key presses are executed immediately and results shown
in the calculator display area. In **PRGM** mode, key presses are stored in program memory for later execution.
It's important to realize which mode the calculator is in, as it has ramifications that affect other operational characteristics
of the device.

(As you'll learn later there are two variants of **RUN** mode, for three actual calculator modes.)

**The Calculator Display**

The **GO-25** LED window acts as a display area, as well as a touch sensitive input area
that initiates further activities not available on an actual HP-25C. The calculator display is also modal, so what it displays
and how it reacts to touches depends on the setting of the **PRGM-RUN** switch.

In **RUN** mode the display shows the **X** stack register, usually the result of the latest calculation.
*Tapping the display in RUN mode
brings up the Copy / Paste menu*, allowing you to export the value of

**X**, or import a new value of

**X**.

In **GO-25**, numbers in the display normally appear rounded to only two decimal places.
For example, the fixed constant Π, which is actually in the calculator as 3.14159265358979, normally
appears in the display as 3.14 (unless you tell the calculator to show you the number
rounded to a greater or lesser number of decimal places).

Although a number is normally shown to only two decimal places, **GO-25** always computes
internally
using each number as a 14-digit mantissa and a two-digit exponent of 10.

Three keys control how numbers are displayed.
**FIX** allows numbers to be displayed in fixed decimal point format,
**SCI** displays numbers in scientific notation format, and
**ENG** displays numbers in engineering notation,
with exponents of 10 shown in multiples of three (e.g., 10^{3}, 10^{-6}, 10^{9}) . Display control
alters only the manner in which a number is displayed, the actual number itself is not altered by any of the display control keys.

To select a display mode press one of the display mode keys
followed by a number key to specify the number of decimal places (**0-9**) to which the display is to be rounded.

**GO-25** switches the display from fixed point notation to full scientific notation
(**SCI** **7**) whenever the number is too large or too small to be seen with a
fixed decimal point.
This feature keeps you from missing unexpectedly large or small answers.

You can key in numbers multiplied by powers of 10 by pressing **EEX** (enter exponent of ten). You can save time when
keying in exact powers
of 10 by merely pressing **EEX** and then pressing the desired power of 10. To key in negative exponents of 10, key in the number,
press **EEX**, press **CHS** to make the exponent negative, then key in the power of 10.

When a number is greater than 9.9999999 x 10^{99} an overflow has occurred and
**9.9999999+99** is displayed instead. Other illegal operations, such as a divide by zero,
display the word
**Error**, then set the illegal number to zero.

In **PRGM** mode the calculator display shows the current program step. The left-most two digits are the actual program step number, and the
remaining digits represent the step's instruction opcodes, fully described in the section Key Codes.
It's this mode that allows you to manually enter a program into the calculator, just like an authentic HP-25C.
*Tapping the display in PRGM mode
brings up the Import PRGM / Share PRGM menu*, allowing you to transfer

**GO-25**programs to / from the App.

**The Stack**

Automatic storage of intermediate results is the reason that **GO-25** slides so
easily through the most complex equations. The displayed **X** register, which is the only visible register
in the calculator display,
is one of four registers inside the calculator that are positioned to form the automatic memory stack.
We label these registers **X**, **Y**, **Z**, and **T**. They are "stacked" one on top of the other with the
displayed **X** register on the bottom.

The **R↓** (roll down) and **X⇔Y** (**X** exchange **Y**) keys allow you to
review the stack contents or to shift data within the stack for computation at any time. Each time you press the **R↓** key
the stack contents shift downward one register, with the contents of **X** rotating up to the **T** register.
Notice that the contents of the registers are shifted - the registers themselves maintain their positions.
Always remember, though, that it takes four presses of the **R↓** key to return the contents to their original registers.

The **X⇔Y** (**X** exchange **Y**) key exchanges the contents of the **X** and **Y** registers
without affecting the **Z** and **T** registers.

To clear the displayed **X** register only, press **CLX**. To clear the entire automatic memory stack, including the
displayed **X** register, press **CLEAR STK** (clear stack).
This replaces all numbers in the stack with zeros.

The **ENTER** key lifts the stack, by copying the contents of **Z** into **T**, **Y** into **Z**, **X**
into **Y**,
hence losing the contents of **T** and duplicating the contents of **X**.

The opposite of lifting the stack is called dropping the stack. When the stack drops, **Y** is copied to **X**,
**Z** is copied to **Y**, and **T** is copied to **Z**, hence losing the contents of **X** and duplicating the
contents of **T**.

**Auxiliary Information Views**

**GO-25** provides views of the calculator's internal state unavailable on the real hardware.
This makes using the calculator, and programming and debugging code much easier. Access to this additional information is
controlled by a ** swipe-up gesture** on the calculator body proper, or a

**on the display. If the information view is visible, a swipe-up or double-tap hides the view. If the view is not visible, the information view appears. So a swipe-up or double-tap toggles the visibility of the auxiliary information.**

*double-tap*Similar to the calculator display, the information that's displayed is dependent on the setting of the **PRGM-RUN** switch.

In **RUN** mode the 4 stack registers, the 10 storage registers, and the **LAST X**
register are displayed. *Also note
in the lower-right corner a flip tab:
touching the tab flips the window and shows up to 100 lines of RUN mode key-press history.*

In **PRGM** mode the program listing is shown. The listing displays the program name and description, and the step numbers,
opcodes and pneumonics for all program steps. Both the program listing and program description are scrollable and editable.

The current step pointer (**SP**) is highlighted in blue. In **RUN** mode this is the next instruction
to be executed via **SST** or **R/S**. In **PRGM** mode you edit the step *following* the **SP** unless you've turned
on **GO-25 Step Editing** from the **Settings** menu, in which case you edit the **SP** directly.

In **PRGM** mode you can also move the blue selection to any step by just touching the step. If you touch and hold a program listing step,
a contextual menu appears so you can add any extended **GO-25** opcodes described in the
section GO-25 Program Format.

(Note: unlike for iPhone
and iPod touch, which have tiny screens, on iPad both information views are by default always visible, but you can hide them
with two swipe-up gestures or two double-taps, if desired, one in **PRGM** mode and one in **RUN** mode.)

**Function Keys**

**Recovering From Mistakes**In addition to the four stack registers that automatically store intermediate results,

**GO-25**also contains a separate automatic register, the**LAST X**register. This register preserves the value in the displayed**X**register before a new function is performed.**Prefix Clear**The

**CLEAR PREFIX**key will clear a blue prefix key, a gold prefix key,**STO**,**RCL**, or**GTO**. To clear a prefix you have mistakenly pressed, merely press**CLEAR PREFIX**, then press the correct key.**Absolute Value**Some calculations require the absolute value, or magnitude, of a number. To obtain the absolute value of the number in the display, press

**ABS**.**Integer Portion**To extract and display the integer portion of a number, press

**INT**. The fractional portion of the number is lost. The entire number, of course, is preserved in the**LAST X**register.**Fractional Portion**To place only the fractional portion of a number into the displayed X-register, press

**FRAC**. The integer portion of the number is lost. The entire number, of course, is preserved in the**LAST X**register.**Reciprocals**To calculate the reciprocal of a number in the displayed

**X**register, press**1/X**.**Square Roots**To calculate the square root of a number in the displayed

**X**register, press**√X**.**Squaring**To square a number in the displayed

**X**register, press**X²**.**Using Pi**The value Π accurate to 14 places (3.14159265358979) is provided as a fixed constant in

**GO-25**. Merely press**Π**whenever you need it in a calculation.**Percentages**The

**%**key is a two-number function that allows you to compute percentages. To find the percentage of a number:- key in the base number
- press
**ENTER** - key in the number representing percent rate
- press
**%**

For example, to calculate the sales tax on a purchase, the purchase price is the base number and the sales tax is the percentage rate.

When

**%**is pressed, the calculated answer writes over the percentage rate in the**X**register, and the base number is preserved in the**Y**register. Since the purchase price is now in the**Y**register and the amount of tax is in the**X**register, the total amount can be obtained by simply adding.**Storage Registers**In addition to automatic storage of intermediate results that is provided by the four-register automatic memory stack,

**GO-25**also has ten addressable storage registers that are unaffected by operations within the stack. These storage registers allow you to set aside numbers as constants or for use in later calculations, and they can be used either manually or as part of a program. The addresses of the storage registers are indicated by number keys**0**through**9**.To store a value appearing in the display, press

**STO**followed by a number key**0**through**9**specifying the register address where the value is to be stored. When a number is stored, it is merely copied into the storage register.To copy a number from one of the storage registers into the displayed

**X**register, press the**RCL**key followed by the number key of the register address.Recalling a number causes the stack to lift unless the preceding keystroke was

**ENTER**,**CLX**or**Σ+**.When you recall a number, it is copied from the storage register into

**X**, and it also remains in the storage register. You can recall a number from a storage register any number of times without altering it; the number will remain in the storage register as a 10-digit number with a two-digit exponent of 10 until you overwrite it by storing another number there, or until you clear the storage registers.To clear the number from a single storage register, simply store the quantity zero in the register by pressing

**0 STO**followed by the number key**0**through**9**of the register address. To clear data from all manual storage registers at once, without affecting data in other portions of the calculator, press**CLEAR REG**. This places zero in all ten of the storage registers.**Storage Register Arithmetic**Arithmetic is performed

*upon the contents of the storage register*by pressing**STO**, followed by the arithmetic function key, followed in turn by the register address.**STO + 1**(Contents of storage register**R**plus_{1}**X**, and sum placed into**R**.)_{1}**STO - 0**(Contents of storage register**R**minus_{0}**X**, and difference placed into**R**.)_{0}**STO x 7**(Contents of storage register**R**multiplied_{7}**X**, and product placed into**R**.)_{7}**STO ÷ 4**(Contents of storage register**R**divided by_{4}**X**, and quotient placed into**R**.)_{4}

**X**register and the rest of the stack remain unchanged.If the magnitude of a number in any of the ten storage registers exceeds 9.999999999 x 10

^{99}, the display immediately shows**OF**(overflow) to indicate that a storage register has overflowed.**Trigonometric Functions****GO-25**provides you with six trigonometric functions. It also calculates angles in decimal degrees, radians, or grads; and it converts between decimal degrees and degrees, minutes, seconds. Use**DEG**,**RAD**or**GRD**to specify the degree mode.Note: 360 degrees = 2Π radians = 400 grads.

The six trigonometric functions provided by the calculator are:

**sin**(sine)**sin**(arc sine)^{-1}**cos**(cosine)**cos**(arc cosine)^{-1}**tan**(tangent)**tan**(arc tangent)^{-1}

Each trigonometric function assumes angles in decimal degrees, radians, or grads. Trigonometric functions are one-number functions, so to use them you key in the number, then press the function keys.

**Hours, Minutes, Seconds**The

**→H.MS***(to hours, minutes, seconds)*key converts decimal hours to the format of hours, minutes and seconds. To see the digits for*seconds*, you should specify**FIX****4**display format.Conversely, the

**→H***(to decimal hours)*key is used to change hours, minutes, seconds into decimal hours.The

**→H**and**→H.MS**keys also permit you to change degrees, minutes, seconds to decimal degrees, and vice versa. The conversion is important because trigonometric functions in**GO-25**operate on angles in decimal degrees, but not in degrees, minutes, seconds. In order to calculate any trigonometric function of an angle given in degrees, minutes, seconds, you must first convert the angle to decimal degrees.**Polar/Rectangular Coordinate Conversion**Two functions are provided for polar/rectangular coordinate conversion. To convert values in the

**X**and**Y**registers, (representing rectangular**x, y**coordinates, respectively) to polar**r, Θ**coordinates (magnitude and angle, respectively), press**→P**. Magnitude**r**then appears in the**X**register and angle**Θ**is placed in the**Y**register.Conversely, to convert values in the

**X**and**Y**registers (representing polar**r, Θ**respectively) to rectangular coordinates (**x, y**respectively), press**→R**. Coordinate**x**then appears in the**X**register and coordinate**y**is placed in the**Y**register.**Logarithms****GO-25**computes both natural and common logarithms as well as their inverse functions (antilogarithms):**ln**is log_{e}(natural log). It takes the log of the value in**X**to base*e*(2.718...).is antilog*e*^{x}_{e}(natural antilog). It raises*e*(2.718...) to the power of the value in**X**. (To display the value of*e*, press**1**.)*e*^{x}**log**is log_{10}(common log). It computes the log of the value in the**X**register to base 10.**10**is antilog^{x}_{10}(common antilog). It raises 10 to the power of the value in the**X**register.

**Raising Numbers to Powers****Y**permits you to raise a positive number (either an integer or a decimal) to any power. In conjunction with^{x}**1/X**,**Y**provides a simple way to extract roots. For example, the cube root of 5 is equivalent to 5^{x}^{1/3}.**Summations**Pressing the

**Σ+**key automatically gives you several different sums and products of the values in the**X**and**Y**registers at once. In order to make these values accessible for sophisticated statistics problems, they are automatically placed by the calculator into storage registers**R**through_{3}**R**(_{8}**GO-25**extension).*The only time that information is automatically accumulated in the storage registers is when the*Before you begin any calculations using the**Σ+**key is used.**Σ+**key, you should first clear the storage registers of data by pressing**CLEAR REG**.When you press the

**Σ+**key each of the following operations is performed on the data in the**X**and**Y**registers:- The square of the number in
**Y**is added to the contents of storage register**R**(_{8}**GO-25**extension). - The number in
**X**is added to the contents of storage register**R**._{7} - The square of the number in
**X**is added to the contents of storage register**R**._{6} - The number in
**X**is multiplied by the contents of the**Y**register, and the product added to storage register**R**._{5} - The number in
**Y**is added to the contents of storage register**R**._{4} - The number 1 is added to storage register
**R**, and the total number in_{3}**R**is then written into the display (the stack does not lift)._{3}

Thus, each press of the

**Σ+**key updates these summations and multiplications. The contents of the displayed**X**register and the applicable storage registers are as follows:**X**is*n*, the number of entries.**R**is_{3}*n*, the number of entries.**R**is ΣY, summation of_{4}**Y**values.**R**is ΣX*Y, summation of products of_{5}**X**and**Y**values.**R**is ΣX_{6}^{2}, summation of**X**values.^{2}**R**is ΣX, summation of_{7}**X**values.**R**is ΣY_{8}^{2}, summation of**Y**values (^{2}**GO-25**extension).

In addition, the

**Y**value present before the last press of the**Σ+**key is retained in the**Y**register, while the**X**value present before**Σ+**was pressed is retained in the**LAST X**register. To see any of the summations at any time, you have only to recall the contents of the desired storage register. (In the case of the**Σ+**key, recalling storage register contents or keying in a number simply writes over the number of entries (*n*) that is displayed. The stack does not lift.)- The square of the number in
**Mean**The mean (arithmetic average) of data entered and summed using the

**Σ+**key is available by using the (*mean*) key. When you press , the mean of the values of**X**is calculated using the data in storage registers**R**(_{3}*n*) and**R**(Σx)._{7}**Standard Deviation**The standard deviation (a measure of dispersion around the mean) is calculated using data in the applicable storage registers and the

**s**(standard deviation) key. Pressing**s**uses the data in registers**R**(_{3}*n*),**R**(Σx_{6}^{2}) and**R**(Σx)._{7}**Correcting Summations**If you key in an incorrect value and have not pressed

**Σ+**press**CLX**and key in the correct value. If one of the values is changed, or if you discover after you have pressed the**Σ+**key that one of the values is in error, you can correct the summations by using the**Σ-**key as follows:- Key the
*incorrect*data pair into the**X**and**Y**registers. - Press
**Σ-**to delete the incorrect data. - Key in the correct values for
**X**and**Y**. (If one value of an**X,Y**data pair is incorrect, both values must be deleted and reentered .) - Press
**Σ+**.

- Key the
**Vector Summations**The

**Σ+**key can be used to sum any quantities that are in the**X**and**Y**registers. You can even perform vector addition and subtraction using rectangular to polar coordinate conversion and the**Σ+**and**Σ-**keys.

**Programming Keys**

**PRGM**Switch the

**PRGM-RUN**switch to**PRGM**to enter program steps into the calculator. Function keys are recorded in program memory. Display shows program memory step number and the keycode (keyboard row and location in row) of the function key.To clear program memory and reset the step pointer to the beginning of program memory press

**CLEAR PRGM**. (Note that**CLEAR PRGM**cannot be recorded in program memory; otherwise, there would be no way to clear program memory!)**SST**This key, single step, also cannot be recorded in program memory in

**PRGM**mode, as it's used to advance the step pointer forward for examining and/or changing program steps. (Used in automatic**RUN**mode, the**SST**key displays the step number and keycode of the current program memory step when pressed; executes instruction, displays result, and moves to next step when released.)**BST**This key, back step, also cannot be recorded in program memory in

**PRGM**mode, as it's used to move the step pointer backwards for examining and/or changing program steps. (Used in automatic**RUN**mode, the**BST**key displays the step number and keycode of the previous program memory step when pressed; moves to previous step when released - the program is not run in reverse.)**GTO**Go to. Executed as a recorded program instruction, followed by a two-digit step number, causes the calculator to execute the instruction at the specified step number next, and continue program execution sequentially from there. (Used via the keyboard, positions the internal step pointer.)

**R/S**Run/Stop. Executed as a recorded program instruction, stops program execution. (Use via the keyboard, begins execution of a stored program. Stops execution if program is running.)

**PAUSE**Pause. Executed as a recorded program instruction, stops program execution for 1 second and displays contents of the

**X**register, then resumes program execution.**NOP**No operation. Calculator executes no operation and continues program execution sequentially with the instruction in the next program memory step.

**X<Y****X≥Y****X≠Y****X=Y****X<0****X≥0****X≠0****X=0**Conditionals. Each tests the value in the

**X**register against that in the**Y**register or 0 as indicated. If true, the calculator executes the instruction in the next program memory step. If false, the calculator skips the next step and continues execution after the skipped program step.

**Three Modes Of Operation**

There are three ways to use your **GO-25** calculator:

- Manual
**RUN**ModeThe functions and operations you have learned about in previous sections are performed manually one at a time with the

**PRGM-RUN**switch set to**RUN**. These functions combined with the automatic register stack enable you to calculate any problem with ease. **PRGM**ModeIn

**PRGM**(program) mode the functions and operations you have learned about are not executed, but instead are recorded in a part of the calculator called program memory for later execution. All operations on the keyboard except three can be recorded for later execution with the**PRGM-RUN**switch set to**PRGM**. The three operations that cannot be recorded are:**SST****BST****CLEAR PRGM**

These three operations work in

**PRGM**mode to help you write and record your programs.- Automatic
**RUN**Mode**GO-25**can also be used to automatically execute a list of operations with the**PRGM-RUN**switch set to**RUN**if they have previously been recorded in program memory. Instead of your having to press each key manually, the recorded operations are executed sequentially in automatic**RUN**mode when you press**R/S**(run /stop). You press only one key and the entire list of recorded operations is executed much more quickly than you could have executed them yourself.

**Key Codes**

Let's write a program to compute the volume of a sphere.
For this discussion go into Settings and ensure that **GO-25 Step Editing** is turned on.

First, set the **PRGM-RUN** switch to **PRGM** so that the sequence of keystrokes will be recorded for later execution.
Second, press **CLEAR PRGM** to clear the calculator of previous programs.
The display will show:

This tells you that you are at step00

**00**, the beginning of program memory. Step

**00**contains an automatic stop instruction and cannot be used to record your program keystrokes. Program keystrokes are recorded in steps

**01**through

**99**. The program memory for

**GO-25**is separate from the four stack registers, the

**LAST X**register, and the ten storage registers.

With **00** displayed in **PRGM** mode, you are ready to key in your program.
Surface area of a sphere is calculated using the formula **A = Πd²**. The short list of keys for the area of
a sphere program is:

Press the first key of the program and the display will change to:g X; square the diameter^{2}g Π; load X with Π x ; multiply d² by Π

Since it's impossible to key anything into step01 15

**00**this first key is recorded in step

**01**. The two numbers on the right of the display designate the key stored in that step. Each key on the keyboard has a two-digit keycode. For convenience, the digit keys are coded

**00**through

**09**. All other keys are coded by their position on the keyboard. The first digit denotes the row of the key and the second digit the number of the key in that row. So

**15**tells you that the key is in the first row on the calculator and that it is the fifth key in that row, the

**g**key. This handy matrix system allows you to easily determine the code for each instruction without using a reference table.

To conserve program memory when using prefixed functions, the keycodes for the prefix and the function are merged into one step.
For an example of this press the second key of the program, **X ^{2}**, and the display will change to:

Whoa, what just happened? The calculator is smart enough the realize that program step02 13 00

**01**is complete, and has stored that step into program memory and advanced its internal step pointer to step

**02**, ready for you to key in the next instruction. To see step

**01**just look at the program listing view if it's visible. If it's not visible make it so with a swipe-up, or touch the

**BST**key to back-step the step pointer so that step

**01**is visible in the calculator display. You will see this:

01 15 02

The two-number code **01** on the left side of the display designates the step number of program memory
that is being displayed. The two pairs of numbers on the right side of the display indicate that the function **X ^{2}**
has been recorded in that step of program memory. Digits 1 and 5 denote the

**g**key. Digits 0 and 2 denote the

**2**key. The operation stored then, is

**g**

**2**which is the

**X**function. In every case, a single operation uses only one step of program memory.

^{2}Before proceeding to enter the rest of the program, if you used the **BST** key to review step **01**, now touch
the **SST** key to single-step back to step **02**. *To edit a step it must be visible in the calculator display.*

The keys for finding the area of a sphere and their corresponding codes are shown below. Press each remaining key in turn and verify the keycodes shown in the display.

In this case, a program consisting of five keystrokes takes only three steps of program memory.g X01 15 02^{2}g Π02 15 73 x 03 61

**Running A Program**

Here's the program we developed in the previous section:

01 15 02 02 15 73 03 61

Programs are executed in automatic **RUN** mode. So first set the **PRGM-RUN** switch to **RUN**.
Next press **GTO 00**. This operation resets the calculator so that program execution will begin
from step **00** (pressing **CLEAR PRGM** in **RUN** mode accomplishes the same thing).
Then, key in a value for a diameter and press **R/S** in **RUN** mode to run your program.
The operations stored in program memory are executed sequentially downward from step **00**. First step **01** is executed,
then step **02**, then step **03**, and then step **04**, which now contains a special instruction, **GTO 00**. For example,
if you entered a diameter of 1.3, the computed surface area is 5.31.

The **GTO 00** instruction in step **04** is not an instruction you keyed in yourself.
It was already there. If you press **CLEAR PRGM** in **PRGM** mode, program memory is filled with **GTO 00** instructions.
The three-step program you keyed in replaced three of these instructions.

A **GTO 00** instruction in the program tells the calculator to go to step **00** and execute the
automatic stop instruction there next. If **R/S** is pressed again in automatic **RUN** mode, the
calculator will begin executing instructions from step **00** as it did the first time.
Each time the calculator executes the program, it ends execution at step **00**, ready to begin again.

If you had recorded a 99-step program, after executing step **99** the calculator would execute the automatic stop instruction
stored in step **00**. Then you would have to press **R/S** to execute the program again.

**Storing and Organizing Programs**

Beginning with iOS 11 managing your programs is relatively easy using Apple's **Files** App. **Files** not only provides a storage location for your programs such as iCloud Drive or Dropbox, but also allows you to create subfolders and maneuver between them, which means you can setup a file hierachy that is meaningful to you. To take advantage of theses capabilities, incorporate **Files** in your import and export workflows. *Tapping the display in PRGM mode
brings up the Import PRGM / Share PRGM menu*, allowing you to transfer

**GO-25**programs to / from the App.

- To export a program to
**Files**select**Share PRGM**from this menu:**Open In Another App****Save to Files**, which runs**Files**- Navigate to the destination folder
**Add**

- To import a program from
**Files**:- First run the
**Files**App - Naviagte to the desired folder
- Long touch the desired program to display the Action menu
**Share****Copy to GO-25**, which runs**GO-25**- This displays the standard
**Import PRGM**menu with your desired program as one of the items

- First run the

Additional help is available in the following sections **Importing Programs** and **Sharing Programs**.

**Importing Programs**

On an actual HP-25C programs are entered using the calculator keys. That method works with
**GO-25** as well, but it's often easier
to edit your programs in another App and import them into **GO-25**
(*activate the Import menu by touching the calculator's display in PRGM mode*). For
instance, you can use

**GO-25**, and import the pasteboard data. As a bonus, when you are finished editing the program simply email it to yourself for later filing in your

**GO-25**programs folder.

You also have a **My Programs** container that uses iTunes File Sharing to sync programs between your computer and **GO-25**.

Alternately, Apps like **Files** use the iOS Document Model and have a menu to open their
documents in another App (labelled variously as **Add to appName**,

**Copy to**,

*appName***Open in**, or

*appName***Save to**). If such an App sends a program (named, say,

*appName***SurfaceAreaOfSphere-go25.txt**) to

**GO-25**, that program's name appears in the

**Import PRGM**window.

Finally, a small selection of programs is included in **GO-25**'s **Sample Programs** container.

**GO-25**Program FormatAn HP-25C program consists of simple digits representing step numbers and opcodes.
A **GO-25** program extends that by allowing comments, as well as supporting four new opcodes: **DMP**, **BEL**, **SEC**
and **RND**.

The comment character is a semi-colon. All comments appearing before the first program step **01** are collectively
called the program description and appear in the top
of the program listing window. This window is editable, and the descriptive text is saved with the program steps when
the program is exported. A **CLEAR PRGM** does not automatically erase the program description - you can do that by cutting the text
(touch and hold, Select All, Cut).

A **GO-25** program has one convention that you are encouraged to adhere to:
*the first line of descriptive text is the program name*: the program name line must begin with the comment character ";",
and end with the characters "-go25.txt". If a program name cannot be found

**Untitled-go25.txt**is used. The extension "-go25.txt" was chosen to remind humans what the document contains, and to remind computers that it's not a binary file.

; SurfaceAreaOfSphere-go25.txt ; ; Compute the surface area of a ; sphere using the formula: ; ; A = πd² ; ; ; ENTRY: ; X = diameter of sphere. ; ; EXIT: ; X = surface area of sphere. ; ; 01 15 02 ; X² 02 15 73 ; Π 03 61 ; xIf comments appear on individual program steps they are discarded and ignored when the program is imported.

**GO-25** supports four special keycodes not available on a real HP-25C, keycode **80**, **DMP**, keycode
**81**, **BEL**, keycode **82**, **SEC**, and keycode **83**, **RND**.
You cannot key these instructions in, but they can be part of a program imported into the calculator. In **PRGM** mode,
if you touch and hold a program listing step, a contextual menu appears so you can add any extended **GO-25** opcodes.

**DMP**(80) dumps the step pointer and the stack and memory registers to the paper tape for debugging.**BEL**(81) sounds a tram bell.**BEL**(14 81) sounds BEL1 (win), while**BEL**(15 81) sounds BEL2 (lose).**SEC**(82) stores the second of the day 0 - 86,399 in**X**, handling the stack just like an**RCL**.**RND**(83) replaces**X**with a random integer 0 < abs(**X**) < 2^{32}, without otherwise changing the stack.

**Editing Programs Inline**

Program step zero has a special **Edit** button that enables insertion and removal of **NOP** instructions, as well as re-arrangement of program steps using gripper pads.

Touching a green plus inserts a **NOP** *before* that step, and simultaneously drops program step 99. Touching the red minus removes that **NOP**. Touching and dragging a gripper pad moves that program step, re-inserting it when you have reached the destination and released the gripper.

All **GTO** targets are automatically re-sequenced.

**Sharing Programs**

You can export a program in various ways using the **Share PRGM** menu item (*activate the Share menu by touching the calculator's display in PRGM mode*).
Besides the pasteboard, email
and printing, you also have a

**My Programs**container that uses iTunes File Sharing to sync programs between your computer and

**GO-25**.

**GO-25**
also supports the iOS Document Model and allows other Apps to open its program files via the **Open In Another App** menu item. When sending a program to another App,
**GO-25**
uses the program name to identify the program. For example, use this option to export a program to the **Files** App.

You also have a **My Programs** container that uses iTunes File Sharing to sync programs between your computer and **GO-25**.

**User Contributed Programs**

Unsupported programs that you may copy to the pasteboard and then import into **GO-25** while in **PRGM** mode.

## Complex Operations-go25.txt

; Complex Operations-go25.txt ; Written by Eddie Shore ; May 8, 2011 ; ; V 1 ; ; This program calculates the following: ; 1. (a + bi)^n. (principal power and root) ; 2. exp(a + bi) ; 3. ln(a + bi) ; ; ; Registers: ; R0 = temp ; R1 = real part ; R2 = imaginary part ; R3 = power ; ; Results: ; y stack: imaginary part ; x stack: real part ; ; ; Example: ; Find (2.8 + 2i)^4, exp(2.8 + 2i), and ln(2.8 + 2i) ; ; Store the complex number to be operated on: ; 2.8 STO 1 ; 2 STO 2 ; 4 STO 3 ; for the power: ; 1 R/S. (-110.6944 + 86.0160i) ; for the exponential: ; 2 R/S (-6.8434 + 14.9531i) ; for the natural logarithm ; 3 R/S (1.2357 + .6202i) 01 23 00 ; STO 0 02 01 ; 1 03 14 71 ; x=y 04 13 15 ; GTO 15 05 22 ; R↓ 06 02 ; 2 07 14 71 ; x=y 08 13 33 ; GTO 33 09 22 ; R↓ 10 03 ; 3 11 14 71 ; x=y 12 13 45 ; GTO 45 13 22 ; R↓ 14 13 00 ; GTO 00 15 24 02 ; RCL 2 16 24 01 ; RCL 1 17 15 09 ; →P 18 24 03 ; RCL 3 19 14 03 ; y^x 20 23 00 ; STO 0 21 21 ; Swap xy 22 24 03 ; RCL 3 23 61 ; X 24 31 ; ENTER 25 14 04 ; sin 26 24 00 ; RCL 0 27 61 ; X 28 21 ; Swap xy 29 14 05 ; cos 30 24 00 ; RCL 0 31 61 ; X 32 13 00 ; GTO 00 33 15 33 ; RAD 34 24 01 ; RCL 1 35 15 07 ; e^x 36 24 02 ; RCL 2 37 14 04 ; sin 38 21 ; Swap xy 39 61 ; X 40 14 73 ; LASTx 41 24 02 ; RCL 2 42 14 05 ; cos 43 61 ; X 44 13 00 ; GTO 00 45 15 33 ; RAD 46 24 02 ; RCL 2 47 24 01 ; RCL 1 48 15 09 ; →P 49 14 07 ; ln 50 13 00 ; GTO 00

## Derivative-go25.txt

; Derivative-go25.txt ; Derivative Program ; Calculate the numeric derivative ; ; Instructions: ; 1. When entering the program, the function for the required derivative starts on Step 27 ; 2. Use R0 as the independent variable. You can use R5, R6, and R7 for constants. ; 3. Store a tolerance level in R1. I recommend 0.01. ; 4. The last four lines of the program MUST be: ; RCL 04 ; x=0 ; GTO 10 ; GTO 19 ; The function can have at most 19 steps (for classic HP 25) or 69 steps (GO 25 App). ; The example function (listed in line 27) is ln x + 3x - 10.8074 ; ; Formula (HP 67): ; [f(x+Δx/2)-f(x-Δx/2)]/Δx = f'(x) 01 00 ; 0 02 23 04 ; STO 04 03 24 00 ; RCL 00 04 24 01 ; RCL 01 05 02 ; 2 06 71 ; ÷ 07 51 ; + 08 23 00 ; STO 00 09 13 27 ; GTO 27 10 22 ; R↓ 11 23 02 ; STO 02 12 01 ; 1 13 23 04 ; STO 04 14 24 00 ; RCL 00 15 24 01 ; RCL 01 16 41 ; - 17 23 00 ; STO 00 18 13 27 ; GTO 27 19 22 ; R↓ 20 23 03 ; STO 03 21 32 ; CHS 22 24 02 ; RCL 02 23 51 ; + 24 24 01 ; RCL 01 25 71 ; ÷ 26 13 00 ; GTO 00 27 24 00 ; RCL 00 28 14 07 ; ln 29 24 00 ; RCL 00 30 03 ; 3 31 61 ; x 32 51 ; + 33 01 ; 1 34 00 ; 0 35 73 ; . 36 08 ; 8 37 00 ; 0 38 07 ; 7 39 04 ; 4 40 41 ; - 41 24 04 ; RCL 04 42 15 71 ; X=0 43 13 10 ; GTO 10 44 13 19 ; GTO 19 45 13 00 ; GTO 00

## Lower Incomplete Gamma-go25.txt

; Lower Incomplete Gamma-go25.txt ; Ported from HP 65 Math PAC 2 ; Similar to the Gamma function but ; γ(a,x) = Integral(e^-t t^(a-1) dt from 0 to x) ; ; a and x must be positive ; ; Instructions: a ENTER x R/S ; ; You can approximate the Gamma function by setting x high enough. According to Viktor Toth from rskey.org, for any a<50, setting x=30 gives the gamma approximation accurate from 8 to 12 digits 01 23 01 ; STO 01 02 21 ; Swap XY 03 23 02 ; STO 02 04 14 03 ; Y^X 05 24 02 ; RCL 02 06 71 ; ÷ 07 23 03 ; STO 03 08 24 01 ; RCL 01 09 24 02 ; RCL 02 10 01 ; 1 11 51 ; + 12 23 02 ; STO 02 13 71 ; ÷ 14 24 03 ; RCL 03 15 61 ; x 16 23 03 ; STO 03 17 51 ; + 18 14 61 ; X≠Y 19 13 08 ; GTO 08 20 24 01 ; RCL 01 21 15 07 ; e^X 22 71 ; ÷ 23 13 00 ; GTO 00

## Midpoint Rule-go25.txt

; Midpoint Rule-go25.txt ; Numerical Integration using the Midpoint Formula ; Property of Eddie Shore ; ; Instructions: ; 1. Store lower limit in R1 ; 2. Store upper limit in R2 ; 3. Store number of intervals in R3 ; 4. In run mode, press f CLEAR PRGM and the R/S ; ; Input the function at Step 32. End the function with the instruction GTO 20. Registers R0 and R7 are free. The function starts with x_i on the x-stack. ; ; Registers Used ; R1 = a ; R2 = b ; R3 = n ; R4 = h = (b - a)/n ; R5 = sum ; R6 = counter ; ; The example function included in this program is: ; 2 + cos(2 sqrt(x)) ; {RAD SQRT 2 x COS 2 + GTO 20} 01 01 ; 1 02 23 06 ; STO 06 03 00 ; 0 04 23 05 ; STO 05 05 24 02 ; RCL 02 06 24 01 ; RCL 01 07 41 ; - 08 24 03 ; RCL 03 09 71 ; ÷ 10 23 04 ; STO 04 11 24 06 ; RCL 06 12 73 ; . 13 05 ; 5 14 41 ; - 15 24 04 ; RCL 04 16 61 ; x 17 24 01 ; RCL 01 18 51 ; + 19 13 32 ; GTO 32 20 23 51 05 ; STO + 05 21 01 ; 1 22 23 51 06 ; STO + 06 23 24 06 ; RCL 06 24 24 03 ; RCL 03 25 14 41 ; X

## Sum-go25.txt

; sum-go25.txt ; Sum Program (Updated Instructions) ; Eddie Shore, 4/10/2011 ; The registers used in this program are: ; R1 = initially, the user will load the lower limit. Register 1 will also act as the independent variable in the function (i) ; R2 = the upper limit, which the user loads ; R3 = the sum, calculated during the program ; The function starts at Step 16. ; Required ending commands: ; GTO 05 ; Instructions: ; 1. In RUN Mode, press GTO 16 ; 2. Switch to PRGM mode, enter the function. Anything previously written will be overwritten (replaced). The program loads R_1 (i) in the display. The Register for the independent variable is R_1. End the function with the command GTO 05. ; 3. Switch to RUN mode. Load the lower limit in R_0 and the upper limit in R_1. ; 4. Press f CLEAR PRGM, R/S. ; R1 = a, independent variable in f(R1) ; R2 = b ; R3 = sum ; ; Enter your function, f(R1) at line 16. The function MUST end with GTO 05. ; The function can be anything. As a example: the Zeta Function (slow converging) to calculate ζ(2). ; Preload R1 and R2 before running the program. 01 00 ; 0 02 23 03 ; STO 03 03 24 01 ; RCL 01 04 13 16 ; GTO 16 05 23 51 03 ; STO + 03 06 01 ; 1 07 23 51 01 ; STO + 01 08 24 01 ; RCL 01 09 24 02 ; RCL 02 10 14 41 ; X

**Improper Mathematical Operations**

If you attempt a calculation containing an improper operation -
say, division by zero - the display will show Error. To clear, press **CLX**.

The following are improper operations:

**÷**where**X**= 0**Y**where^{x}**Y**< 0 with**X**not an integer, or where**Y**= 0 with**X**< 0**√X**where**X**< 0-
**1/X**where**X**= 0 **log**where**X**<= 0**ln**where**X**<= 0**sin**where absolute value of^{-1}**X**> 1**cos**where absolute value of^{-1}**X**> 1**STO ÷**where**X**= 0- where
*n*<= 0 **s**where*n*<= 0

**Gesture Summary**

- Shake to clear
**X**. - Single tap the display for Copy / Paste in
**RUN**mode. - Single tap the display for Import PRGM / Share PRGM in
**PRGM**mode. - Swipe-up in
**RUN**mode to show/hide the stack, memory and paper tape views. - Swipe-up in
**PRGM**mode to show/hide the program description and listing views. - Double tap the display to show/hide the stack/program listing views.
- Two-finger pan for iPad to reposition the stack, program and calculator views.
- Touch and hold
**SST**or**BST**in**RUN**mode to display the next or previous step, respectively. - Touch a program listing line to make it the current
**SP**. - Touch a program listing line to dismiss the keyboard while editing the program description.
- Touch and hold a program listing step for 0.75 second (long touch) to add special opcodes.
- Tap blue-hatched flip tab to alternate between stack/memory and paper tape views.
- Swipe up and down to scroll program description, program listing and sample programs views.
- Swipe left and right to manipulate slide switches, if activated in
**Settings**. - Flick left on the display to erase last mantissa character entered.
- Triple tap the display to show/hide the Info button .

**Support**

Copyright (©) 2010 - 2018 BigCatOs. All rights reserved. | Contact