# ZooMath - Glorified Adding Machine

 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,

• "+" posits,
• "-" negates,
• "/" reciprocates,
and so completes the number;
• "×" posits, too, but also locks it for subsequent self-multiplicative exponentiation.

A second number is supplied, and,

• "-" subtracts,
• "×" multiplies,
• "/" divides,
the first by the second, if the first is not locked in which case second is as at first.

Without the second number,

• "+" locks for subsequent self-additive multiplication (scaling),
• "-" negates (repeatably), but clears a lock,
• "/" reciprocates (repeatably but affects precision), also clears a lock,
• "×" locks for subsequent self-multiplicative exponentiation.

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, ABC, (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×10N, explicitly any precise-number radix in "C+R×N" implementing C×RN, completed by its final operation.

After the final number,

• "+" posits power, decimal powers too,
• "-" negates power,
• "/" reciprocates power,
but once finally as the stack is then fully evaluated to a completed number;
• "×" posits power too, but the third fully evaluates to completion without locking up higher.

(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/A1/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: 642 = 616 = 2.821109907:46@12 ('precisely')
MEMORY, FUNCTIONS, RELATIONS, and CONSTANTS are accessible by the ZooM, #: each access comprised of a ZooM, #, before or after a cell or code number (not arithmetically completed), and an arithmetic operation or second ZooM for completion:
• ZooM preceding, #M, writes to a memory/relation cell or code number, completed by operation, and clear-empties the display;
• ZooM succeeding, M#, reads a memory/function/relation/constant to the display, even multi-previewably, before operation.

(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  (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 , reducing it to now +4
• 3+×2#+ effects +3(+) = +34 =81 (after showing the contents of  after ZooM);  memory retains its value
FUNCTION:
• 30+92## retrieves function#92 of +30 ... that is as-if  were a calculating-memory#92 ( is the function per the keypanel notations, logarithmic, trigonometric, statistic, numeric special operations, etc.)
RELATION:
• 30+#87#88## puts +30 into  (eg. phi) and reads  (eg. sin:phi) of the [88:87] relation: implicitly-recalculated
• 1-#89×87## negates  (eg. cos:phi) and reads  (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 ex function)
• 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.  is 1.035616582:49 (mph metric/English 12-digit precisely)
DEEPER EXAMPLES:
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 
• ###1234567890# clear-empties the display and puts "..." into code-associated-cell , 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. )
QUEUE, (decimalpoint actuates push/pull, cf [5.] vs. )
ARRAY,
FRACTIONAL CELL-code-numbers access a single digit within a number (eg. [5.3] is the third digit of )
ALPHABETIC (segmented) letterings are demarcated by points, beginning with a point (eg. ".a.b.")
NOTES on clear, erasure, significance, display, power, stack, memory, functions, features:
• 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 ,, 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. "")
• 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.  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
(Note the revision group-then-pointer is for visibility: group keys first, its subselection is visibly local; excess functions locate on adjacent key-caps ... cf if pointer keys first, cf contemporaries, key-caps are visibly more-uniform but spread one-per.)

• 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)
ZooM (Z∞M) is the most powerful concept to glorify the adding machine since the handcrank.

A premise discovery under the title,