(cache)JSCalc

JSCalc aims to be an as complete, convenient and orthogonal possible calculator that does not have text. Features:

Each button has up to 4 functions. Press the sub-section of a button with the mouse to perform that function.

The f↓ and g→ buttons only work in mobile mode (for small screens). In non-mobile mode, the individual labels of buttons can be pressed. f↓ accesses the bottom left function. g→ the top right function. Both combined accesses the bottom right function.

To paste a number from clipboard to the screen, use the paste input field below the calculator. Making the screen itself an input field and pasting in there does not play out well because the JavaScript calculator engine won't always recognize you changed the screen value that way since you didn't use any calculator buttons. Seperating this away into a separate input field with dedicated button clears away all confusion for both the user and the calculator. The input field is designed for pasting (CTRL+V), if you try to type numbers in here you'll notice the numbers appear in the calculator screen instead, because the number keys are already shortcuts for the number buttons of the calculator.

Keyboard shortcuts

A totally different type of shortcut is that you can click with the mouse on the indicators above the display to toggle these modes as well (where applicable).

The Hyp Shortcuts

Statistics and special memory register indices

Differences with typical calculators

Differences with typical RPN calculators

Stack convention

In RPN, if you enter three values, then the order you entered them in is: "z, y, x". That means, you enter them in the opposite order than the expected "x, y, z". For that reason, for example, the power button is labeled "y^x" and not "x^y": this ensures you can enter that power in an intuitive order, first the base, then the exponent. However, for a few operators you must take care as the input is in opposite order compared to intuition: these are rectangular->polar, polar->rectangular, rectangular->spherical, and spherical->rectangular. For example as the input of rectangular->polar is x and y, you enter y first, then x. But most operations do have an intuitive order, e.g. for an integral you enter the start of the interval first, then the end. The smaller than operator is defined as "y < x". And the power operator was already described earlier.

In ALG mode, the naming is the same. But, as there is no reason to invert them, here you enter x first, then y, for rectangular->polar, spherical->rectangular, etc...

To view the result of a 3-result operation (that is, spherical<->rectangular), in RPN mode, just use R↓ 2 times to see all 3 results. In ALG mode, however, R↓ does not exist (it is open parenthesis instead). There is another way though: the second result can be seen with x↔y as in RPN. But the third result can be seen by first pressing 3, then HYP, then x↔y. That key combination mirrors the top 3 stack values, thereby bringing the 3th value to the screen.

Display modes

If the base is another base than decimal (base 10), everything works exactly the same, except it uses the amount of digits for that base. The base is used for everything, including the exponent, angles of polar complex notation, etc... However, in any base other than 10, 'p' instead of 'e' is used for the exponential notation (Because e is a symbol in some bases)

E.g. the complex number that looks in decimal like 4.348606e23 i1.0072e23, looks in ternary: 1.211p1211 i1.021p1210, and in hexadecimal: 5.C15D84p13 i1.5540BAp13.

For complex numbers, all the above rules are applied separately to the real and imaginary part. In fraction mode, the real and imaginary part, or modulus and angle part are also a separate fraction. Two modes are available for complex numbers: rectangular and polar. In rectangular mode, the real and imaginary part are shown, separated by the symbol "i" in the middle. This is different than mathematical notation, because here i is a separator! What is written as 1+2i in mathematics, is displayed as 1 i2 here. Or what is written as -5i in mathematics, is displayed as 0 i-5 here (so it is NOT i minus real 5, but, i multiplied by -5). In polar mode, the modulus is displayed first, then an "L" symbol which represents the "angle" symbol as it would look on a 7-segment LCD screen, and the angle. The angle's display depends on the currently angle modes, e.g. when using degrees it's in range -180 - 180, if it's radians it's in range -pi - pi, etc... For example:

It is also possible to choose whether to use the dot or comma as decimal separator. Thousand separator can be enabled with HYP+./, and use the other character.

Programming

There are 26 independent programs. To select a current program, press SEL, followed by 0-9 or A-F, or +,-,*,/,SIN,COS,TAN,EXP,SQRT,POW (The value 26 is not related to the alphabet). The currently selected program is the one edited by P/R, executed by R/S, and the one used by integrate, solve, etc... The other programs are unused and untouched, until they are selected by SEL. The XEQ button, however, allows to easily execute another program without selecting it. Because they are incompatible, RPN and ALG mode each have their own independend programs. So in reality there are twice as much programs. In ALG mode, you never see the programs of RPN mode, and vice versa.

Entering a program

When entering a program, after each keystroke, it shows the current program step (line number) and a short letter code of the key on screen. The backspace button can be used to undo the last keystroke. The BST and SST keys move forwards and backwards in the program, allowing to view previous instructions and inserting new ones between there. Each key with a label or behind HYP has a short letter code, that is, functions behind f, g or HYP have their own short letter code and the modifier key is not programmed itself. However, other modifiers, such as MATRIX, are programmed as keystrokes and the key keeps its non modified short letter code.

For example, to enter a program that calculates x², press P/R, then x², then P/R again to exit programming mode. To enter a program to calculate sinc(x), which is sin(x) / x, first clear the previous program with PCLR. For an RPN program press P/R, ENTER, SIN, x↔y, /, P/R. For an algebraic program to do the same (however it has to use memory due to no RPN stack), press P/R, STO, 0, SIN, /, RCL, 0, ENTER, P/R. Then, to try out the program, e.g. to calculate sinc(5), press 5, then R/S, and the result is shown (0.0174311485495 if angle mode is in degrees).

Another example: The generalized fibbonaci number in RPN mode, 1/sqrt(5) * (φ^x - φ^(-x)*cos(pi * x). This program requires radians, so the first instruction is to enable radians. In programming mode, clear the program if it's not empty, then enter: RAD STO 0 5 SQRT 1/X φ RCL 0 POW φ RCL 0 +/- POW RCL 0 * π COS * - MUL

More examples, all in RPN, all assume being in program mode with cleared program. These example are here because these formulas are not in the calculator itself due to being easy to program.

Running a program

The other way to run the program is to use the XEQ button. This always runs a program from ip 0, and allows running other programs than the current one. After pressing XEQ, press 0-9 or A-F to select which program to run. E.g. if in "0" you made a program to calculate the error function, and in "A" you made a program to calculate sinc(x), press "XEQ 0" to calculate the error function, "XEQ A" to calculate sinc. Using XEQ does not change the selected program (the one that gets edited with P/R, ran with R/S, or used by integral, solve, etc...). The SEL button does that.

Program Flow

The IF instruction requires entering an END instruction later, and optionally an ELSE instruction. It can be used for branches, based on a condition. The IF conditions checks the current value on screen. If it's 0, the part between ELSE and END is executed. Otherwise, the part between IF and ELSE is executed (and it jumps after the END afterwards). Nested IFs are supported. Anything can be used as the IF condition: e.g. the test operators give 0 or non-0 as answer, so does the "prime?" function, and anything else you create can be designed to put 0 or 1 on top of the stack to be used by an IF. The l.and, l.or, l.xor and l.not allow doing logical operations on such booleans, e.g. to combine multiple conditions for an IF.

The test instructions (equals, <, >, etc...) are binary operators that compare two numbers and give a boolean answer (0 or 1). This can then be used by the IF instruction.

The GTO instruction goes to a certain line number. Whenever you enter an instruction in a program, its line number is shown. The line number to go to is the current top stack value (the value on screen). Normally, when a program runs, it goes sequentially from beginning to end (sometimes skipping parts based on IF instructions). With GTO, you can go to any line number. This can cause an infinite loop, to avoid that a condition can be added by putting the GTO in an IF. Because you may not easily know the line numbers while entering a program, designing it on paper first can be a good idea.

GSB is the gosub instruction. It's similar to GTO, except that it remembers where it was. When later an RTN instruction is encountered, it goes back to where GSB was called. This allows creating functions. Up to 100 nested GSB calls are supported.

Integration

Summation and product

Derivatives

Solve

Matrices

Some matrix operators store the result overwriting the input matrix. That is: negate, conj, transpose, make zero/identity matrix.
Most other unary and binary matrix operators store the result in memory register 600 (F) and on.
Any unary matrix operator with two results stores one result overwriting the input matrix, the other in memory register 600 (F) and on.
Matrix operators that output a matrix display the memory address of the result screen (usually 600).
Matrix operators that output a scalar simply display the scalar on screen.

To use a matrix operator, instead of putting operands on the stack, you put a memory index pointing to each matrix on the stack.

That register in memory, and the successive ones, represent the matrix. The matrix result of a binary operation will be stored by default at memory register 600 (the one accessible with RCL F), while the result of an unary matrix operation that doesn't alter matrix size, will be stored at the same location as where the input matrix was (overwriting the original).

The user needs to make sure matrices are far apart enough in memory to not overlap (an NxN matrix consumes NxN+2 registers). For example to add two 2x2 matrices A and B, A can be stored at register 0 (to 5), B at register 6 (to 11), and the result will be by default in register 600 (to 605). However the convenient memory locations A-F (100, 200, 300, 400, 500, 600) can be used instead, these are far enough apart for most use cases.

The format of a matrix in memory at register N is: at register N itself is the height of the matrix, at register N+1 the width. At the NxN next registers are all the values of the matrix, row by row. Because using the Σ+ after STO or RCL allows easily storing/reading from successive registers, entering and viewing matrices is easy. Matrices support complex numbers since the most primitive number value is complex and a complex number is stored in one register. E.g. to view the output matrix, first use RCL F, to see the height of the matrix. Then RCL Σ+ to see the width. Then RCL Σ+ to see the first value, and so on to see the next values.

Here's an example of how to add the matrix [[1,2],[3,4]] and [[8,8],[8,8]] using nothing but keyboard shortcuts, in RPN or ALG mode (where s is STO, t is Σ+, r is RCL):
enter first matrix at memory 100-105: 2 s a 2 s t 1 s t 2 s t 3 s t 4 s t
enter second matrix at memory 200-205: 2 s b 2 s t 8 s t 8 s t 8 s t 8 s t
add them (RPN mode): m a enter m b m + --> it should now show "600" on screen (the memory index where the result matrix starts)
add them (ALG mode): m a m + m b enter --> it should now show "600" on screen
view the result at memory 600-605: r f r t r t r t r t r t --> it should have shown 2, 2, 9, 10, 11, 12 on screen

A column vector (e.g. for "solve") has a height of n and a width of 1, so to enter e.g. a 3D column vector [7,8,9] in memory address 100 (a), use: 3, STO, a, 1, STO, Σ+, 7, STO, Σ+, 8, STO, Σ+, 9, STO, Σ+.

autogenerated list of button tooltips

A: hex digit A. When in smaller base, directly XEQ program A. With MATRIX: get memory address of matrix A
x=y: test equals. With HYP: round to nearest integer
B: hex digit B. When in smaller base, directly XEQ program B. With MATRIX: get memory address of matrix B
x≠y: test not equals. With HYP: truncate towards zero
C: hex digit C. When in smaller base, directly XEQ program C. With MATRIX: get memory address of matrix C
<: test lesser than. With HYP: floor of fractional number (for programming)
bin: base 2. With HYP: custom base. Press this button first, then the base (2-9, A-F, for base 2-15).
and: bitwise AND. With HYP: logical AND
D: hex digit D. When in smaller base, directly XEQ program D. With MATRIX: get memory address of matrix D
>: test greater than. With HYP: ceil of fractional number (for programming)
oct: base 8. With HYP: custom base. Press this button first, then the base (2-9, A-F, for base 2-15).
or: bitwise OR. With HYP: logical OR
E: hex digit E. When in smaller base, directly XEQ program E. With MATRIX: get memory address of matrix E
≤: test lesser than or equal to. With HYP: bit shift left
dec: base 10. With HYP: custom base. Press this button first, then the base (2-9, A-F, for base 2-15).
xor: bitwise XOR. With HYP: logical XOR
F: hex digit F. When in smaller base, directly XEQ program F. With MATRIX: get memory address of matrix F
≥: test greater than or equal. With HYP: bit shift right
hex: base 16. The A-F buttons now allow entering those digits by default (instead of running programs, which is still available from XEQ). With HYP: custom base. Press this button first, then the base (2-9, A-F, for base 2-15).
not: bitwise NOT. With HYP: logical NOT
R/S: run/stop: run or continue the current program from its current instruction pointer. If running, pause it
P/R: program/run: Toggle to program mode to edit the current program. This can be used for simple macro programming: press P/R, (then optionally to clear current program press PCLR), then press the key sequence to use (e.g. HYP TAN ASIN to make it take the tanh followed by the arcsine, the Gudermannian function gd), then press P/R again to finish macro programming. Then press R/S at any time to repeat the programmed key sequence. For more advanced programming with conditions and loops, see the manual.
SEL: choose the currently selected program (press 0-9, A-F). This is the program that gets ran, edited, used for integrate, etc... With HYP: get selected program index
PCLR: clears the selected program.
XEQ: Eexecute a program of choice (0-9, A-F) starting from its first instruction. Does not permanently select the program (the program selected with SEL remains the one you will get when using P/R later). When used inside a program, XEQ can call another program (a "sub-program"). If in a base smaller than or equal to 10, you can press buttons A-F directly without XEQ to execute their corresponding programs.
RST: reset running program back to beginning. Same as GTO to line 0, and setting the sub-program of the instruction pointer back to the selected program that was chosen with SEL
IP: get instruction pointer. With MATRIX: For debugging: get a representation of the matrix as a single number: NM.xxxxxx where NM is the size and x is the first non-0 digit of each element. E.g. matrix [[1, 2][3, 4]] would output 22.1234
PCPY: Copy program. Press a chosen destination program (0-f, a-f). Copies currently selected program to the chosen program (overwrites what was originally in chosen program).
◀BST: while editing a program, step backwards one instruction.
GTO: goto: In a program, go to that line number. Only line numbers are supported, no labels, so it is advised to design complex programs on paper first. This operation also works when not programming or running, it still brings the instruction pointer there, and will display that line when going to edit program mode.
GSB: gosub: Like GTO, but allows using RTN to jump back to the current location
RTN: finish the program, or if XEQ or GSB was used, jump back (using the instruction pointer stack).
SST▶: while editing a program, step forward one instruction.
END: END instruction for IF and ELSE
IF: if: pops value from the stack. If it's 0, jump to the corresponding ELSE or END instruction. Otherwise, continue from here, but skip what's between the ELSE and END if there's an ELSE. With HYP: Ternary operator: takes 3 arguments. If the first argument is zero, outputs the third argument. Otherwise outputs the second argument. In ALG mode, enter three arguments as follows: a1 ?: a2 ENTER a3 ENTER.
ELSE: optional part of an if, if present, the part between this and the corresponding END is executed when the IF condition was 0
∫f: integrate. Uses the currently selected program as function. This is a two operand operation: start and end of the definite integral. With MATRIX: takes the FFT of the elements of a matrix, and outputs it as a complex matrix, 2D if the matrix is 2D
∂: derivative. Uses the currently selected program as function. With HYP: second derivative. Uses the currently selected program as function. With MATRIX: takes the IFFT of the elements of a matrix, and outputs it as a complex matrix, 2D if the matrix is 2D
solve: solve: find a zero. Uses the currently selected program as function. This is a two operand operation: start and end of range to search in. Returns NaN if no solution in this range. With HYP: like solve, but without requiring a range (uses Newton-Raphson method, and supports complex values). With MATRIX: solve linear system of equations with matrices
Σf: summation of a sequence. Uses the currently selected program as function. This is a two operand operation: start value and end value. The step is 1. With HYP: product of a sequence. Uses the currently selected program as function. This is a two operand operation: start value and end value. The step is 1.
matrix: Do matrix operation, e.g. +,-,*,1/x,abs for determinant,sto for copy,... Operator usually takes as much inputs as non-matrix counterpart, but each input is a number pointing to memory address. Output of binary operator will start at memory address 0. Use STO+Σ+ and RCL+Σ+ to easily store/read consecutive memory values. Matrix format is: first a number representing matrix size (e.g. real 3 for 3x3 matrix, or complex 2i4 for 2x4 matrix), then width*height elements. Of course elements may be complex. -- A: matrix A, B: matrix B, C: matrix C, D: matrix D, E: matrix E, F: matrix F, IP: mdbg, ∫f: FFT, ∂: IFFT, solve: matrix solve, elop: elementwise matrix-matrix operation, A_11: A_11, HYP+A_11: A_00, MxN: MxN, Σ+: add matrix elements to statistics, Σ-: remove matrix elements from statistics, SIN: sine of matrix, COS: cosine of matrix, e^x: matrix exponential, ln: matrix logarithm, y^x: matrix power, ENTER: matrix copy, √x: matrix square root, x²: matrix square, HYP+x²: matrix cube, x↔y: matrix swap, 1/x: matrix inverse, HYP+1/x: matrix pseudo inverse, 7: matrix rank, 8: trace of square matrix, ÷: matrix divide, HYP+÷: left matrix divide, +/-: negate matrix, conj: matrix complex conjugate, 4: 2-norm, 5: max absolute row sum norm, 6: condition number of matrix, ×: matrix multiply, 1: identity matrix, 2: frobenius norm, 3: max absolute column sum norm, -: matrix subtract, ||: ||, 0: null matrix, EE: eig, +: matrix add,
elop: Do elementwise matrix-scalar operation. Any scalar operation can be pressed after this, and it will be applied to each element. With HYP: elementwise matrix operation on diagonals of the svd. With MATRIX: Do elementwise matrix-matrix operation. Any scalar operation can be pressed after this, and it will be applied to corresponding elements of the two input matrices.
A₁₁: Get matrix element. Ternary operator with 1 output. Input is matrix address, y (1-based), x (1-based). There is a much more convenient way than this button to get many elements in a matrix: E.g. to get at memory address 100 (= A), press: RCL, A, (height shown), RCL, Σ+, (width shown), RCL, Σ+, RCL, Σ+, RCL, Σ+, RCL, Σ+ (this showed the 4 elements). This gets the values in the matrix memory structure: width, height, row-by-row elements, with "RCL Σ+" increasing memory location. With HYP: Get matrix element, 0-index based. Like a11, but the coordinates start at 0 instead of 1. With MATRIX: Set matrix element. Quaternary operation with 0 outputs. Inputs are matrix address, y (1-based), x (1-based), the value. There is a much more convenient way than this button to set many elements in a matrix: E.g. to set the 2x2 matrix [[1 2][3 4]] at memory address 100 (= A), press: 2, STO, A, 2, STO, Σ+, 1, STO, Σ+, 2, STO, Σ+, 3, STO, Σ+, 4, STO, Σ+. This stores the values in the matrix memory structure: width, height, row-by-row elements, with "STO Σ+" increasing memory location. With HYP+MATRIX: Set matrix element, 0-index based. Like a11, but the coordinates start at 0 instead of 1.
MxN: Get matrix size. Unary operator with 2 outputs. Input is matrix address, output is height followed by width (height shown first on screen, width seen by pressing x↔y). With MATRIX: Set matrix size. Ternary operator with 0 outputs. Inputs are matrix address, height, width. Note that the size of a matrix is stored in memory addresses starting at the matrix address value (e.g. A=100): first the height, then the width, then width*height elements. See the comment at the A11 (get/set element) button for a more convenient way to set an entire matrix.
STO: store value in memory. For registers 0-15, press button 0-9 after this, for matrix registers, press buttons a-f after this. For arbitrary register (indirect), press i after this. To use the register one higher than the last used one, press Σ+ after this. To use i to store value 5 in register 1000, in RPN type 5, enter, 1000, STO, i. In ALG mode, type 5, STO, i, 1000, enter. To cancel and stop selecting, press RCL after this.
M↔X: swap displayed value with memory (0-9, a-f)
MCLR: clear all memory
RCL: read value from memory. For registers 0-9, press button 0-9 after this, for matrix registers, press buttons a-f after this. For arbitrary register (indirect), press i after this. To use the register one higher than the last used one, press Σ+ after this. To use i to read the value from register 1000, in type 1000, RCL, i. To cancel and stop selecting, press RCL again.
Σx: sum of entered statistics x's. With RCL or STO, uses memory index -1, used as parameter for statistical distributions. With HYP: sum of entered statistics y's. With RCL or STO, uses memory index -2, used as second parameter for statistical distributions.
Σx²: sum of squares of entered statistics x's. With HYP: sum of squares of entered statistics y's
Σxy: sum of entered xy products
Σ+: add value to statistics register. When using STO or RCL before this, uses memory address one higher than the previous one used, this is handy for entering successive elements, e.g. a matrix. With MATRIX: add matrix elements to statistics
Σ-: remove value from statistics register, e.g. to undo an entered value. When using STO or RCL before this, uses memory address one lower than the previous one used. With MATRIX: remove matrix elements from statistics
Σn: get number of statistics values entered. When using RCL before this, puts the last accessed memory location on the stack (to see where you were after using RCL + Σ+ a lot). When using STO before this, stores in last used memory index without incrementing it.
Σclr: clear all statistics registers
W: Lambert W function, aka product log, branch 0. With HYP: branch -1 of LambertW.
x: average
s: sample standard deviation
σ: standard deviation with custom mean. Give mean as operand (uses same one for x and y). E.g. press the average button first, then this.
x!: factorial. With HYP: gamma function
ψ: digamma function
L.R.: linear regression
ŷ,r: linear estimation y and correlation coefficient r for x. Shows y on screen, to see r, press x↔y
pdf: probability density function or probability mass function of distribution (select with 0-9, A-F) -- 7: gamma pdf, 4: student t pdf, 5: chi square pdf, 6: logistic pdf, 1: normal pdf, 2: lognormal pdf, 3: cauchy pdf, 0: standard normal function,
qf: quantile function of distribution (select with 0-9, A-F) -- 7: gamma quantile function, 4: student t quantile function, 5: chi square quantile function, 6: logistic quantile function, 1: normal quantile function, 2: lognormal quantile function, 3: cauchy quantile function, 0: probit function,
cdf: cumulative distribution function of distribution (select with 0-9, A-F) -- 7: gamma cumulative function, 4: student t cumulative function, 5: chi square cumulative function, 6: logistic cumulative function, 1: normal cumulative function, 2: lognormal cumulative function, 3: cauchy cumulative function, 0: standard normal cumulative function,
erf: error function. With HYP: complimentary error function (erfc)
SIN: sine. BEWARE! If you are in an angle mode like degrees or gradians, you must add a ° symbol to the number (simple to do with the ° button) before using trigonometrics, else the input is always treated as radians even in non-radians angle modes. With HYP: hyperbolic sine. With MATRIX: sine of matrix
SIN^-1: arcsine. With HYP: hyperbolic arcsine
S_x,y: Stirling number of the second kind
sinc: normalized sinc: sinc(x)/(pi*x). With HYP: unnormalized sinc: sin(x)/x
COS: cosine. BEWARE! If you are in an angle mode like degrees or gradians, you must add a ° symbol to the number (simple to do with the ° button) before using trigonometrics, else the input is always treated as radians even in non-radians angle modes. With HYP: hyperbolic cosine. With MATRIX: cosine of matrix
COS^-1: arccosine. With HYP: hyperbolic arccosine
C_x,y: combinations (binomial coefficient)
TAN: tangent. BEWARE! If you are in an angle mode like degrees or gradians, you must add a ° symbol to the number (simple to do with the ° button) before using trigonometrics, else the input is always treated as radians even in non-radians angle modes. With HYP: hyperbolic tangent
TAN^-1: arctangent. With HYP: hyperbolic arctangent
P_x,y: permutations
atan2: atan2(y, x)
e^x: exponential. With HYP: exponential minus 1. With MATRIX: matrix exponential
10^x: decimal power. With HYP: golden ratio to the power of x
2^x: binary power
ln: natural logarithm. With HYP: natural logarithm of x plus 1. With MATRIX: matrix logarithm
log₁₀: decimal logarithm. With HYP: logarithm base φ
log₂: binary logarithm
y^x: power. With HYP: tetration x^^y: e.g. 2^^4 = 2^(2^(2^2)) = 65536. Well defined for integer height with any base, and Infinite height (power tower). Returns experimental results for real height with any base, or complex height with base e. With MATRIX: matrix raised to scalar power (any power, including complex or very high values)
^x√y: arbitrary root
log_xy: arbitrary logatirhm
rand: random value in range 0-1
ENTER: enter value in RPN mode, equals (result) in ALG mode. With HYP: 10x enter (fill up stack, or repeat 10x). With MATRIX: matrix copy
undo: undo last operation
lst.x: get last used top stack value back
lst.y: get second last used top stack value back
√x: square root. With HYP: cube root. With MATRIX: matrix square root
x²: square. With HYP: cube. With MATRIX: matrix square. With HYP+MATRIX: matrix cube
x↔y: swap top two stack values. Required to see Y or angle of result of rectangular<->polar operations. With HYP: mirror the top N stack values. With MATRIX: matrix swap
factor: smallest prime factor (factorize). Returns two values: smallest prime factor, and original number divided through that. Press X<->Y to see and use the latter. Repeated application until a prime is reached reveals all factors. If the number returns itself, it's prime. With HYP: Euler's Totient function: amount of smaller integers relatively prime to x
gcd: greatest common divisor. With HYP: least common multiplier
prime: check if number is prime. With HYP: next prime
R↓(: RPN: roll down. ALG: open parenthesis
R↑): RPN: roll up. ALG: close parenthesis
←: backspace/clear
HYP: toggle h / hyperbolic mode. Enables cosh for cos etc..., but also many other modifications to operators, e.g. square becomes cube, log10 becomes log2, x! becomes gamma function, Σx becomes Σy, etc... This can be considered the "h" mode, but unlike f and g, the h functions are not labeled on keys. Around half the keys has a h function, which is usually very similar to the corresponding labeled function. Due to the possibility to combine f, g and h, a key can have up to 8 functions.
1/x: inverse (reciproke). With HYP: matrix pseudo inverse. With MATRIX: matrix inverse. With HYP+MATRIX: matrix pseudo inverse
†: conjugate transpose of matrix. With HYP: transpose of matrix
%: divide through 100
Δ%: delta percent: how much percent bigger is the second operand than the first operand
7: digit 7. With MATRIX: matrix rank. With PDF: gamma pdf (mem -2: θ, mem -3: k). With CDF: gamma cumulative function. With QF: gamma quantile function
ε₀: get electric constant (vacuum perimttivity) in F/m. With HYP: get magnetic constant (vacuum permeability) in H/m
→km: convert mile to kilometer. With HYP: convert acres to hectares
→mi: convert kilometer to mile. With HYP: convert hectares to acres
8: digit 8. With MATRIX: trace of square matrix
q_e: get elementary charge of proton in C
→m: convert feet to meter. With HYP: convert sq.feet to sq.meter
→ft: convert meter to feet. With HYP: convert sq.meter to sq.feet
9: digit 9
k: get Boltzmann constant in J/K. With HYP: get gas constant in J/(K*mol)
→cm: convert inch to centimeter
→in: convert centimeter to inch
÷: divide. With MATRIX: matrix divide. With HYP+MATRIX: left matrix divide
mod: modulo division (result has sign of divisor). With HYP: remainder of division (result has sign of dividend).
g→: use top right function of button. When combined with f↓, use bottom right function. Only works in "mobile" mode, in non-mobile mode instead individual labels can be clicked.
+/-: negate / enter sign. With HYP: sign. With MATRIX: negate matrix
conj: complex conjugate. With MATRIX: matrix complex conjugate
4: digit 4. With MATRIX: 2-norm, aka spectral norm. With PDF: student t pdf (mem -3: ν). With CDF: student t cumulative function. With QF: student t quantile function
N_A: get Avogadro number in units per mole
→kg: convert pounds to kilogram
→lb: convert kilogram to pounds
5: digit 5. With MATRIX: max absolute row sum norm. With PDF: chi square pdf (mem -3: k). With CDF: chi square cumulative function. With QF: chi square quantile function
h: get Planck constant in J*s. With HYP: get Planck constant through 2 pi in J*s/rad
→l: convert gallons to liter. With HYP: convert fluid ounces to centiliter
→gal: convert liter to gallons. With HYP: convert centiliter to fluid ounces
6: digit 6. With MATRIX: condition number of matrix. With PDF: logistic pdf (mem -1: μ, mem -2: s). With CDF: logistic cumulative function. With QF: logistic quantile function
c: get light speed in m/s. With HYP: get gravitational constant in m^3/(kg*s^2)
→°C: convert degrees fahrenheit to celcius. With HYP: convert kelvin to degrees celcius
→°F: convert degrees celcius to fahrenheit. With HYP: convert degrees celcius to kelvin
×: multiply. With MATRIX: matrix multiply
→unix: time in format YYYYMMDD.HHMMSS to unix time (hours in 24h notation). With HYP: time in format YYYYMMDD.HHMMSS to seconds since 1 january 1. Does not take Julian calendar into account. This scheme is used by some databases and differs 62135596800 seconds from Unix time. Add or subtract 86400 to make it differ a day for some similar standards.
←unix: time in unix time to format YYYYMMDD.HHMMSS (hours in 24h notation). With HYP: seconds since 1 january 1 to time in format YYYYMMDD.HHMMSS. Does not take Julian calendar into account. This scheme is used by some databases and differs 62135596800 seconds from Unix time. Add or subtract 86400 to make it differ a day for some similar standards.
f↓: use bottom left function of button. When combined with g→, use bottom right function. Only works in "mobile" mode, in non-mobile mode instead individual labels can be clicked.
+i: start entering imaginary part of complex number. Entering complex numbers works as follows (different than in math notation): to enter mathematical 1 + 5i, press 1, i, 5 and it shows 1+i5 on screen. To enter mathematical -5i, press i, 5, +/- and it shows 0-i5 on screen (i serves as a separator rather than appendix at the end hence that form).
im: get imaginary part of complex number. With HYP: split complex number into real and imaginary part
re: get real part of complex number. With HYP: combines re and im from stack to complex number
re↔im: swap real and imaginary part of number. With HYP: nextroot(z, n): get next complex nth root solution: rotates complex argument by 2*pi/n radians.
1: digit 1. With MATRIX: replace matrix with identity matrix. With PDF: normal pdf (mem -1: μ, mem -2: σ). With CDF: normal cumulative function. With QF: normal quantile function
φ: get golden ratio
→DMS: fractional decimal number to base 60 degrees, minutes, seconds notation. Use fix 4 and base 10 to see the result as intended
→DD: base 60 degrees, minutes, seconds notation to ractional decimal number
2: digit 2. With MATRIX: frobenius norm. With PDF: lognormal pdf (mem -1: μ, mem -2: σ). With CDF: lognormal cumulative function. With QF: lognormal quantile function
e: get euler number
P→R: polar to rectangular. Angle value depends on angle mode. To use to calculate for R=1, angle=2: RPN mode: 2 enter 1 P→R (see X on screen) x↔y (see Y on screen). ALG mode: 1 P→R 2 enter (see X on screen) x↔y (see Y on screen). Note the opposite input order in RPN, not in ALG!. With HYP: spherical to rectangular. Angle values depend on angle mode. Takes 3 inputs r,θ,φ, has 3 outputs x,y,x. Physical convention dist,incl,azimuth is used. To use to calculate for R=1, incl.=2, azimuth=3: RPN mode: 3 enter 2 enter 1 HYP P→R (see X on screen) R↓ (see Y on screen) R↓ (see Z on screen). ALG mode: 1 HYP P→R 2 enter 3 enter (see X on screen) x↔y (see Y on screen) 3 HYP x↔y (see Z on screen, this weird trick is the only way to show the third value in ALG mode...). Note the opposite input order in RPN, not in ALG!
R→P: rectangular to polar. Angle value depends on angle mode. To use to calculate for X=1, Y=2: RPN mode: 2 enter 1 R→P (see R on screen) x↔y (see angle on screen). ALG mode: 1 R→P 2 enter (see R on screen) x↔y (see angle on screen). Note the opposite input order in RPN, not in ALG!. With HYP: spherical to polar. Angle values depend on angle mode. Takes 3 inputs x,y,x, has 3 outputs r,θ,φ. Physical convention dist,incl,azimuth is used. To use to calculate for X=1, Y=2, Z=3: RPN mode: 3 enter 2 enter 1 HYP R→P (see R on screen) R↓ (see inclination on screen) R↓ (see azimuth on screen). ALG mode: 1 HYP R→P 2 enter 3 enter (see R on screen) x↔y (see inclination on screen) 3 HYP x↔y (see azimuth on screen, this weird trick is the only way to show the third value in ALG mode...). Note the opposite input order in RPN, not in ALG!
3: digit 3. With MATRIX: max absolute column sum norm. With PDF: cauchy pdf (mem -1: x0. mem -2: γ). With CDF: cauchy cumulative function. With QF: cauchy quantile function
π: get pi. With HYP: get 2*pi
→rad: convert rad to deg (without changing mode, use HYP+°, or number with ° and the non-arrowed rad/deg/grad buttons, if you wish to convert using angle mode instead)
→deg: convert deg to rad (without changing mode, use HYP+°, or number with ° and the non-arrowed rad/deg/grad buttons, if you wish to convert using angle mode instead)
-: subtract. With HYP: minimum of two numbers. With MATRIX: matrix subtract
DoW: get weekday of date. Operand is date entered in format YYYYMMDD. Result meaning: 1=mon, 2=tue, 3=wed, 4=thu, 5=fri, 6=sat, 0=sun. The date system uses the current Gregorian calendar system, so dates before 1582 are not supported: 15 oktober 1582 was a friday and a Gregorian date, but the day right before that was the Julian date thursday 4 oktober 1582 and that is not supported here. With HYP: get day of year. Operand is date entered in format YYYYMMDD. E.g. first of january returns 1
date+: add days to date. First operand is date entered in format YYYYMMDD, result is a date. The date system uses the current Gregorian calendar system, so dates before 1582 are not supported
Δdate: difference between two dates. Dates are entered in format YYYYMMDD, result is number of days. The date system uses the current Gregorian calendar system, so dates before 1582 are not supported.
on/c: on / clear x (disabling stack lift)
off: off (does nothing)
show: show number with more precision if applicable
°,∠: Angle symbol, to set the number to the current angle mode instead of radians. Use during typing of a number (at the end) to add angle symbol to it. BEWARE! Only if you enter this symbol in a number, it is in the current angle mode, otherwise it is always radians! So if angle mode is degrees, you must enter 90°, not just 90, to actually compute trigonometric functions of 90 degrees. Similarly, inverse trigonometric functions will indicate their result with ° when it uses the angle mode, without ° the result is in radians. If the angle mode is radians, then this button has no effect other than entering polar part of complex numbers as described next. Press a second time or simply type a digit after the first to start entering angle part of complex number (e.g. to enter 2∠0.5, enter 2, this button, 0.5). This is indicated with "L" on the display. BEWARE: for the argument part, too, you must then use this key again to use the angle mode instead of radians for the argument. When not entering any number currently, it will toggle ° from the previous number of the stack instead, preserving the visible number rather than the mathematical value. While entering numbers, pressing the button multiple times cycles various options (when no arg yet entered, 3 options, when arg started, 4 options). When you a numbers with ° on screen, know that its mathematical value is not the one displayed since the ° implies a multiplier. Most mathematical operations will work on the underlying number (including, conveniently, COS/SIN/TAN of course). A few simple arithmetic operations, such as multiply with non-angle or adding two angles, will preserve the ° display. With HYP: Toggle between angle with ° and radians, preserving underlying mathematical value (so numeric display changes, unless angle mode itself is radians, then this is a no-op).
arg: argument of complex number. With HYP: split complex number into modulus and argument
||: absolute value (modulus of complex number). With HYP: combines abs and arg from stack into polar complex number. With MATRIX: matrix determinant
polar: toggle polar <-> rectangular notation for complex numbers
0: digit 0. With MATRIX: null matrix. With PDF: standard normal function. With CDF: standard normal cumulative function. With QF: probit function
∞: get infinity. With HYP: toggle RPN stack size between 8 and 4
rpn: toggle RPN <-> chain algebraic mode. In algebraic ('ALG') mode, to add 2 and 3 you type 2 + 3 enter. In RPN mode, you instead type 2 enter 3 +, and have a whole 8-level stack at your disposal. With HYP: toggle classical RPN vs entry RPN: with classical RPN, the enter key duplicates the value also when typing a new one, with entry RPN, the enter key only enters a new value once but still duplicates an existing value
.,/: decimal separator. Press twice in a row to enter a fraction (A period period B to enter A/B), or press A, period, B, period, C to enter mixed notation A+B/C
./,: display decimal separator as period or comma. With HYP: toggle thousand separators
F↔D: toggle display of numbers as fractions or floating point. In fraction mode, the max denominator is 999999 if no fix, eng or sci is used, or base^(fix/eng/sci digits) if such mode is used. With HYP: Decomposes the number into a fraction (rational approximation). Returns numerator and denominator. Shows the numerator first, press x↔y to see the denominator.
mix: toggle display of improper fractions in mixed or common mode
EE: enter exponent. With MATRIX: eigen decomposition
deg: set angle mode to degrees. BEWARE! You must use the ° button to actually input numbers in degrees before using trigonometrics, otherwise they are always in radians! See also the tooltip of the ° button. With HYP: custom angle mode. Enter value first, e.g. 1 for turns, 4 for quadrants, 2π for rad, 24 for hour angle, 32 for points, 256 for binary degrees, 360 for degrees, 400 for grad, 6000, 2000π, 6300 or 6400 for mil, 21600 for arcminutes, 1296000 for arcseconds, ... Then press this button.
rad: set angle mode to radians. This makes the ° symbol of numbers effectively a no-op (and it will not be displayed). Note that numbers without ° are already always in radians, and COS/SIN/TAN already operate in radians unless numbers have °, so rad mode only affects default display (derivatives and so on already work in radians in any angle mode). However, in rad mode, results of inverse trigonometrics and arguments of complex numbers are displayed in rad, and being in rad mode makes the "°" button slightly simpler for adding argument to complex number since it will not function as both "°" and "∠" but only as "∠". With HYP: custom angle mode. Enter value first, e.g. 1 for turns, 4 for quadrants, 2π for rad, 24 for hour angle, 32 for points, 256 for binary degrees, 360 for degrees, 400 for grad, 6000, 2000π, 6300 or 6400 for mil, 21600 for arcminutes, 1296000 for arcseconds, ... Then press this button.
grad: set angle mode to gradians. "°" will then mean gradians, not degrees. BEWARE! You must use the ° button to actually input numbers in gradians before using trigonometrics, otherwise they are always in radians! See also the tooltip of the ° button. With HYP: custom angle mode. Enter value first, e.g. 1 for turns, 4 for quadrants, 2π for rad, 24 for hour angle, 32 for points, 256 for binary degrees, 360 for degrees, 400 for grad, 6000, 2000π, 6300 or 6400 for mil, 21600 for arcminutes, 1296000 for arcseconds, ... Then press this button.
+: add. With HYP: maximum of two numbers. With MATRIX: matrix add
fix: set fixed precision to 0-9 or a-f digits after the point. Or press period or this button again to use automatic precision ("ALL"). In fixed mode, there will always be as many digits behind the decimal point as the precision, even if it are zeroes. In standard automatic mode, it doesn't show redundant zeroes, and always tries to show as large precision as the screen allows, only using exponential notation if the number wouldn't fit on screen otherwise.
sci: enable scientific mode with precision to 0-9 or a-f digits after the point. Or press period or this button again to use automatic precision ("ALL"). In scientific mode, exponential notation is always used, and the number is shown with a total number of digits (including before the point) matching the given precision.
eng: enable engineering mode with precision to 0-9 or a-f digits after the point. Or press period or this button again to use automatic precision ("ALL"). Engineering mode is like scientific mode except the exponent is always a multiple of 3

autogenerated list of special key codes

MATRIX+A: mtrxa

MATRIX+B: mtrxb

MATRIX+C: mtrxc

MATRIX+D: mtrxd

MATRIX+E: mtrxe

MATRIX+F: mtrxf

MATRIX+IP: mdbg

MATRIX+∫f: fft

MATRIX+∂: ifft

MATRIX+solve: msolve

MATRIX+elop: mmelop

MATRIX+A₁₁: seta11

MATRIX+MxN: mssize

MATRIX+Σ+: mstta

MATRIX+Σ-: msttr

MATRIX+SIN: msin

MATRIX+COS: mcos

MATRIX+e^x: mexp

MATRIX+ln: mln

MATRIX+y^x: mpow

MATRIX+ENTER: mcopy

MATRIX+√x: msqrt

MATRIX+x²: msqr

MATRIX+x↔y: mswap

MATRIX+1/x: minv

MATRIX+7: rank

MATRIX+8: trace

MATRIX+÷: mdiv

MATRIX++/-: mneg

MATRIX+conj: mconj

MATRIX+4: norm2

MATRIX+5: rnorm

MATRIX+6: condn

MATRIX+×: mmul

MATRIX+1: idmtrx

MATRIX+2: frob

MATRIX+3: cnorm

MATRIX+-: msub

MATRIX+||: det

MATRIX+0: nullm

MATRIX+EE: eig

MATRIX++: madd

HYP+x=y: round

HYP+x≠y: trunc

HYP+<: floor

HYP+bin: base

HYP+and: land

HYP+>: ceil

HYP+oct: base

HYP+or: lor

HYP+≤: lshift

HYP+dec: base

HYP+xor: lxor

HYP+≥: rshift

HYP+hex: base

HYP+not: lnot

HYP+SEL: getsel

HYP+IF: tern

HYP+∂: deriv2

HYP+solve: solva

HYP+Σf: prod

HYP+elop: evop

HYP+A₁₁: a00

HYP+Σx: sttsy

HYP+Σx²: sttsqy

HYP+W: wm

HYP+x!: gamma

HYP+erf: erfc

HYP+SIN: sinh

HYP+SIN^-1: asinh

HYP+sinc: usinc

HYP+COS: cosh

HYP+COS^-1: acosh

HYP+TAN: tanh

HYP+TAN^-1: atanh

HYP+e^x: exp1m

HYP+10^x: golpow

HYP+ln: ln1p

HYP+log₁₀: gollog

HYP+y^x: tet

HYP+ENTER: ent10

HYP+√x: curt

HYP+x²: cube

HYP+x↔y: mirror

HYP+factor: tot

HYP+gcd: lcm

HYP+prime: npr

HYP+1/x: pinv

HYP+†: transp

HYP+ε₀: magconst

HYP+→km: 2ha

HYP+→mi: 2ac

HYP+→m: 2m2

HYP+→ft: 2ft2

HYP+k: gasconstant

HYP+mod: rem

HYP++/-: sign

HYP+h: planck2

HYP+→l: 2cl

HYP+→gal: 2oz

HYP+c: gravconstant

HYP+→°C: k2cel

HYP+→°F: 2kel

HYP+→unix: 2j0

HYP+←unix: j02

HYP+im: split

HYP+re: ccomb

HYP+re↔im: nroot

HYP+P→R: sphr

HYP+R→P: rsph

HYP+π: 2pi

HYP+-: min

HYP+DoW: doy

HYP+°,∠: lconv

HYP+arg: psplit

HYP+||: pcomb

HYP+∞: ssize

HYP+rpn: entry

HYP+./,: thous

HYP+F↔D: decomp

HYP+deg: angle

HYP+rad: angle

HYP+grad: angle

HYP++: max

HYP+MATRIX+A₁₁: seta00

HYP+MATRIX+x²: mcube

HYP+MATRIX+1/x: pinv

HYP+MATRIX+÷: ldiv

PDF+7: pdfgam

PDF+4: pdfstt

PDF+5: pdfchq

PDF+6: pdflgs

PDF+1: pdfnor

PDF+2: pdflgn

PDF+3: pdfcau

PDF+0: pdfstd

CDF+7: cdfgam

CDF+4: cdfstt

CDF+5: cdfchq

CDF+6: cdflgs

CDF+1: cdfnor

CDF+2: cdflgn

CDF+3: cdfcau

CDF+0: cdfstd

QF+7: qfgam

QF+4: qfstt

QF+5: qfchq

QF+6: qflgs

QF+1: qfnor

QF+2: qflgn

QF+3: qfcau

QF+0: qfstd

This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.

Manual