advanced RPN superset calculator -- "I can do it in 16 keys" |

[Related: 26+2 key alphanumeric key-entry]

I propose a 'minimal' 16-key data-and-control entry-pad to advance the state-of-the-art calculation-by-hand, consisting of--

The decimal digits, 0,1,2,3,4,5,6,7,8,9, decimal point, [.], the four arithmetic operations, +,-,×,/, and, the ZooM denoted # herein.

(#, is for website-font-commonality, alternatively understood 'not-unequal' or 'made equal', or depicturesque 'zoom' ¤, autc.)

And where--

The display consists of 10 decimal digits, 3 scale digits, 2 signs, and operational indicators: [and more advanced with multiple numbers]

Decimalpoint-numbers are precise to their significant digits, except, numbers with all-12 digits entered, are 'infinitely' precise (11-12th digits do not show but at the moment of appendation). The display rounds to 10 digits in integer, fixed-point, and engineering and electronics and scientific floating-point notations. Integers and scaled-integers -no decimal point- are also, 'infinitely' precise.

ZooMath calculates in 12 or more decimal digits to accumulate and retain precision for rounding, but shows only 10.

('Infinitely precise', has special meaning in calculation: Operations maintain significance, But once a number after operations falls out of 'infinitely precise', it does not resume 'infinitely precise' notation, n'even when seemingly infinitely precise; eg. 1.000000000:00 all digits calculated may not be an integer; This also applies in truncative functions where it has integer properties but not-definite-integer history ... the Entered tail-digit is assumed rounded, -but,- the Calculated tail-digit is truncate at 0-9 and appended with 0.5, as it averages 4.5-centered odd-symmetry: then crossover occurs as 5.5 rounds up and 4.5 rounds down.... An alternative interpretation assumes the last digit is repeating ad infinitum cf :29.999...= :30.000... like a vernier-9 scale. [See also Guarded Significant Figures])

During number-entry key-by-key, digits and decimalpoints can be removed by excess points; Holding the point key, rapidly deletes multiple digits. Simple scaling is achieved by holding the zero key and letting it enter multiple zero-digits quickly (up to 99): this is efficient also for quickly expressing the trailing zeros of 'infinitely' precise simple decimals.

Then, after keying the number,

and so completes the number;

A second number is supplied, and,

the first by the second, if the first is not locked in which case second is as at first.

Without the second number,

Before supplying a succeeding number,
a preceding "×" locks the prior number
for (self-multiplicative) exponentiation by a power:
completed by the next operation ...
Further application of "×" again "early locks"
its immediately preceding number:
for enabling exponential towers, A^{BC},
(but only three levels are allowed).

Similarly, "+" after a number completed by any operation,
locks it for (self-additive) multiplication by a scale factor ...
a further application of "×" then early-locks
its immediately preceding scale factor:
for scaling by powers of a radix,
implicitly radix-10 in "C+×N"
implementing C×10^{N},
explicitly any precise-number radix in "C+R×N"
implementing C×R^{N},
completed by its final operation.

After the final number,

but once finally as the stack is then fully evaluated to a completed number;

(For simplicity ZooMath does not stack operations higher.)

(Note also that doublet "++" locks for 'learners exponentiation'.)

Note then, negative-reciprocal-power A^{-1/B}
equaling 1/A^{1/B} is also accomplished by reciprocal-power
reciprocal-result, "A×B//".

EXAMPLES:

(EQUIPPED BEGINNERS, NOTE, that ZooM-ZooM, ##, clear-empties the display.)

(Also, Double-negative, "--", is the easiest way to clear a number-lockup on the
baseline.)

- 3+2- evaluates as +3-2 =1
- 5-2/ evaluates as -5/2 =-2.500000000:00 (all 12 digits ,'infinitely' precise)
- 9+×2/ evaluates as +9
^{(1/2)}=3 , and - 3.3-+×3- evaluates as -3.3@-3 =-0.0033
- Note that 3×2+ evaluates as 3
^{(+2)}=9 , where "×" both posited and early-locked - A negative power reciprocates the number, so,
16×2// accomplishes 16
^{(-(1/2))}=0.2500000000:00 (precisely) - 6×4×2× evaluates as an exponential tower with only-two early-locks:
6
^{42}= 6^{16}= 2.821109907:46@12 ('precisely')

(Writing to an unused or unlocked constant, edits it, allowing constants to be added, improved, or replaced ... a programming lock function keeps them more permanently; a recovery function can unlock and switch them with their original manufacture.)

EXAMPLES:

- MEMORY:
- 5+#2# puts +5 into [2] (memory#2), clear-emptying the display of +5 (Note also that it is retained in a used-values stack [.])
- 1-#2+ then adds -1 to [2], reducing it to now +4
- 3+×2#+ effects +3
^{(+[2])}= +3^{4}=81 (after showing the contents of [2] after ZooM); [2] memory retains its value

- FUNCTION:
- 30+92## retrieves function#92 of +30 ... that is as-if [92] were a calculating-memory#92 ([92] is the function per the keypanel notations, logarithmic, trigonometric, statistic, numeric special operations, etc.)

- RELATION:
- 30+#87#88## puts +30 into [87] (eg. phi) and reads [88] (eg. sin:phi) of the [88:87] relation: implicitly-recalculated
- 1-#89×87## negates [89] (eg. cos:phi) and reads [87] (phi:sin,cos) of the [87:88,89] relation
- (Note that a relation-write is readable: acting like a memory until another part of the relation is written)

- CONSTANT:
- The user must know the first 2-3-4-or-more...digits, eg:
- 314# reads the "pi" constant 3.141592653:59 (12-digit precisely, or more)
- 272#, 2718# read the "e" constant 2.718281828:46 (12-digit precisely);
(Note that 27# may be the e
^{x}function) - 602# reads the Avogadro's Number constant 6.0221367@23 (significantly)
- 624# reads the Coulomb's Number constant 6.241508@18 (significantly)
- (318# may read the reciprocal of "pi" 314#/ = .3183098861:84, precisely, or it may be another constant)
- (628# likewise may be useful for "2pi", or another) (Or the user may program 2314# as 2π, etc.)
- Near-unity constants are represented in epsilon format, eg. [035] is 1.035616582:49 (mph metric/English 12-digit precisely)

- THE USED-VALUES STACK (numbers stored below the 3-high operations-stack)
- The last displayed value (upon clearing) is in [.] for reuse (ie. ".#" rereads it, and pops-stack)

- TABLES OF CONSTANTS:
- Indexed sequence-like measured constants, eg. nuclear chemistry periodic table, can be facilely accomplished by Relation

- ASSOCIATIVE MEMORY:
- 666+#1996# puts +666 into isolated code-associated-cell [1996]
- ###1234567890# clear-empties the display and puts "..." into code-associated-cell [1234567890], thus deleting it

- VECTOR-STATISTICS:
- #+ appends-increments
- #- deletes-decrements
- #×, #/, assist formation of vector-arrays

- STACK, eg. 10-deep below each cell, increases registered memory
(decimalpoint actuates push/pop, cf [5.] vs. [5])

- QUEUE, (decimalpoint actuates push/pull, cf [5.] vs. [5])

- ARRAY,

- FRACTIONAL CELL-code-numbers access a single digit within a number
(eg. [5.3] is the third digit of [5])

- ALPHABETIC (segmented) letterings are demarcated by points,
beginning with a point (eg. ".a.b.")

- Double negative, --, is the easiest way to clear a number-lockup on the baseline
- ZooM-ZooM, ##, clear-empties "..." the display by "putting it nowhere" (empty; not as zero)
- Read without a completing operation, multi-previews contents (eg. 2#3#4#+ reads [2],[3],[4] which only last is added)
- Arithmetic on a "clear-empty" display is monadic: "..."A+ = A, "..."A× = A (but locked)
- Double clear-empty, ####, or leaving it untended a minute, turns off power

- KEY-DISPLAY INTERACTION
- Holding the ZooM key on a function, displays its name first
- Memory/constants/... (codes) appear within brackets "[]" (eg. "[43]")
- When a memory/constant is not found, the next higher is suggested (by ZooMath)
- (NB. Numbers begin with a digit, eg. 0.112)
- Functions and Relations, the first eighty are tiny-printed on-or-with the keycaps:
the first digit corresponds to a function-group, the second to a corner-pointer:
eg. [97] is found on function-group keycap-'9' at corner-'7', e.g. generally:--

[REVISED L-R 2008-07-14] - [n1] - lower left (of digit keycap n)
- [n2] - bottom (of digit keycap n)
- [n3] - lower right (of digit keycap n)
- [n4] - left (of digit keycap n)
- [n5], is a special type of memory, instead, eg. double-precision lower, or vector-y
- [n6] - right (of digit keycap n)
- [n7] - upper left (of digit keycap n)
- [n8] - top (of digit keycap n)
- [n9] - upper right (of digit keycap n)
- [n0], is a special type of memory, instead, eg. double-precision upper, or vector-x

ADDITIONAL COMMENTS:

- Number types include:
- finite scalar
- double precision, upper and lower halves with arithmetic-carry
- vector pairs (x,y)
- complex pair (x + iy) (& = ¢ + i$)
- polar coordinates (r,θ)
- complexors: quaternion (1ijk), octonion (1ijkLIJK)
- epsilon format (1+Δ)
- differential (x + ∂x)
- 1st-infinitesmal (∂x = x/∞)
- 1st-infinite (eg. 1.7∞ + 0.3∞ / 2 = 1.0∞)

- Units, checked and producted, [by-alpha-descriptor needs keypad development]
- As there are 20 special 2-digit memory codes, some 1-digit codes may be fast functions, instead, eg. 0# might be exp(x)

A premise discovery under the title,

'Majestic Service in a Solar System'

Nuclear Emergency Management