RPNcalculator screenshot

Catalogue of large integer⁄ Bigint RPN calculator functions.

{button caption}
function description,
registers in/out.

Framewise from left to right: 1 2 3 4 5 6

{confrc}
Continued fraction representation of rational a ⁄ b, truncated at
the first convergent p ⁄ q for which q ≥ n.
In: Z(a), Y(b), X(n); out: Y(p), X(q), Textbox(partial quotients).

{farey}
Find the successor of rational a ⁄ b in the Farey series of order n:
the ascending series of irreducible fractions between 0 and 1 with
denominators ≤ n.
In: Z(a), Y(b), X(n); out: Y(p), X(q).

{bezout}
Find the smallest solution of indeterminate equation a · x − b · y = c
(aka. Bézout's identity), equivalent to the congruence a · x ≡ c (mod b).
This fails if the gcd(a, b) does not divide c. Input c = 0 to compute
a · x − b · y = gcd(a, b).
In: Z(a), Y(b), X(c); out: Y(x), X(y).

{gcd}
Greatest common divisor of integers a and b: the largest positive integer
which divides both a and b.
In: Y(a), X(b); out: X(gcd).

{lcm}
Least common multiple of integers a and b: the smallest positive integer
which is divisible by both a and b.
In: Y(a), X(b); out: X(lcm).

{modpwr}
Modular exponentiation: raise base a to the k-th power and reduce modulo m.
In: Z(a), Y(k), X(m); out: Y(power), X(m).

{modord}
Calculate the Euler totient function φ(m) and the order of a modulo m:
the smallest positive value of x for which a^x ≡ 1 (mod m).
This fails if a and m are not coprime or if the calculator cannot factorize m.
Press F1 to break off, repeat if necessary.
If base a = 1, then the order is set to φ(m).
If φ(m) is equal to the Carmichael λ-function for m,
then the least positive primitive root of m is also given.
In: Y(a), X(m);
out: Z(a), Y(x), X(m), Textbox(φ(m) and either λ(m) or the root).

{modinv}
Multiplicative inverse or associate of a to modulus m: x such that
a · x ≡ 1 (mod m). This fails if a and m are not coprime.
In: Y(a), X(m); out: Y(x), X(m).

{modsqr}
Calculate Kronecker's symbol for a and m, and solve quadratic congruence
x^2 ≡ a (mod m). This fails if a is a quadratic nonresidue modulo m
or if m is composite and cannot be factorized by the calculator.
In: Y(a), X(m); out: Y(x), X(m), Textbox((a ⁄ m)).

{chinese}
Find the solution of simultaneous congruences x ≡ a (mod m) and x ≡ b (mod n)
with the Chinese remainder theorem. This fails if the gcd(m, n) does not
divide b − a.
In: S(a), Z(m), Y(b), X(n); out: Y(x), X(modulus).

Basic operations

This frame may be switched into different calculation modes by clicking it.

Default mode (colour black, caption Z)
Operations are done on signed integer numbers (ring Z).
Rational mode (colour blue, caption Q)
Operations are done on rational integers (field Q).
The numbers in registers S, Z, Y and X are interpreted pairwise as
rationals a ⁄ b.
Complex mode (colour green, caption K)
Operations are done on integers in quadratic ring K = Z[i].
the numbers in registers S, Z, Y and X are interpreted pairwise as
Gaussian integers a + bi.

{mod}
Residue of a to modulus m: positive solution of x ≡ a (mod m).
In: Y(a), X(m); out: X(x).
In: S(a), Z(b), Y(p), X(q); out: Y(0), X(1).
In: S(a), Z(b), Y(u), X(v); out: Y(x), X(y),
with x + yi = w − round(w ⁄ z) × z, w = a + bi, z = u + vi.

{a^k}
Exponentiation: raise base a to the k-th power.
In: Y(a), X(k); out: X(power).
In: Z(a), Y(b), X(k); out: Y(a^k), X(b^k), k ∈ N.
In: Z(a), Y(b), X(k); out: Y(x), X(y),
with x + yi = (a + bi)^k, k ∈ N.

{a^2}
The square of a.
In: X(a); out: X(square).
In: Y(a), X(b); out: Y(a^2), X(b^2).
In: Y(a), X(b); out: Y(x), X(y),
with x + yi = (a^2 + b^2) + 2abi.

{sqrt}
Integer square root of a ≥ 0.
In: X(a); out: X(root).
In: Y(a), X(b); out: Y(√a), X(√b).
In: Y(a), X(b); out: Y(x), X(y),
with x + yi = (a + bi)^½.

{÷}
Integer division.
In: Y(a), X(b); out: X(a ⁄ b).
In: S(a), Z(b), Y(p), X(q); out: Y(aq), X(bp).
In: S(a), Z(b), Y(u), X(v); out: Y(x), X(y),
with x + yi = (au + bv) ⁄ t + i(bu − av) ⁄ t, t = u^2 + v^2.

{×}
Multiplication.
In: Y(a), X(b); out: X(a × b).
In: S(a), Z(b), Y(p), X(q); out: Y(ap), X(bq).
In: S(a), Z(b), Y(u), X(v); out: Y(x), X(y),
with x + yi = (au - bv) + i(bu + av).

{+}
Addition.
In: Y(a), X(b); out: X(a + b).
In: S(a), Z(b), Y(p), X(q); out: Y(aq + bp), X(bq).
In: S(a), Z(b), Y(u), X(v); out: Y(a + u), X(b + v).

{−}
Subtraction.
In: Y(a), X(b); out: X(a − b).
In: S(a), Z(b), Y(p), X(q); out: Y(aq − bp), X(bq).
In: S(a), Z(b), Y(u), X(v); out: Y(a − u), X(b − v).

{shr}
Shift a one bit to the right.
In: X(a); out: X(a ⁄ 2).
In: Y(a), X(b); out: Y(a), X(b × 2).
In: Y(a), X(b); out: Y(a ⁄ 2), X(b ⁄ 2).

{shl}
Shift a one bit to the left.
In: X(a); out: X(a × 2).
In: Y(a), X(b); out: Y(a × 2), X(b).
In: Y(a), X(b); out: Y(a × 2), X(b × 2).

{inc}
Increment a by one.
In: X(a); out: X(a + 1).
In: Y(a), X(b); out: Y(a + 1), X(b).
In: Y(a), X(b); out: Y(a + 1), X(b).

{dcr}
Decrement a by one.
In: X(a); out: X(a − 1).
In: Y(a), X(b); out: Y(a − 1), X(b).
In: Y(a), X(b); out: Y(a − 1), X(b).

Memory buttons

{sto}
Store the contents of registers X (display) and Y (stack bottom) into memory.

{rcl}
Recall the memory contents and put them into registers X and Y.

Stack manipulation

[Enter] (has no button equivalent)
Save the value in the display (copy register X to Y and lift the stack).

{last} or [Up Arrow]
Exchange the current stack with the stack before the last operation.

{clear} or [Insert]
Clear the current stack.

{clx} or numeric .[Del]
Cancel entry (clear the display).

{roll} or [Page Up]
Roll the stack one level up.

{drop} or [Page Down]
Drop the stack one level down.

{x«»y} or [Down Arrow]
Swap the X (display) and Y (stack bottom) registers.

{bino}
Binomial coefficient or combination n choose k: the coefficient of
x^k in (1 + x)^n, also the number of k-subsets possible out of a set of
n distinct items. Positive k ≤ abs(n) < 10^9.
In: Y(n), X(k); out: X(binomial coefficient).

{n!}
Factorial of integer abs(n) < 10^4: the number of ways in which n objects
can be permuted, defined as n · (n − 1) · · · 2 · 1.
In: X(n); out: X(factorial).

{rnd}
Random positive integer a with length abs(l) < 10^4.
In: X(l); out: X(random a).

{chs}
Change the sign of integer a.
In: X(a); out: X(-a).

{fibo}
Fibonacci number Fn, defined by the recurrence relation Fn+1 = Fn + Fn-1,
with F1 = F2 = 1 and index abs(n) < 2^16.
In: X(n); out: X(Fn).

{10^k}
Exponentiation: raise base 10 to the k-th power, abs(k) < 10^4.
In: X(k); out: X(power).

{prim}
Find the next probable prime ≥ abs(a) with the 1980 Miller-Rabin strong
pseudoprime test. Press F1 to break off.
In: X(a); out: X(next prime).

{split}
Attempt to split abs(a) in two factors. Press F1 to break off.
If a is prime and a ≡ 1 (mod 4) then abs(a) is factored into conjugate
Gaussian primes x ± yi in the quadratic ring K = Z(√−1).
The continued fraction expansion of a ⁄ r, with r² ≡ −1 (mod a) is also given.
In: X(a); out: Y(f or x), X(a ⁄ f or y), Textbox(partial quotients).

{a ⁄ b}
Decimal expansion of rational number a ⁄ b.
In: Y(a), X(b); out: Textbox(decimal fraction).

{1 ⁄ a}
Decimal expansion of the reciprocal of nonzero integer a.
In: X(a); out: Textbox(decimal fraction).

{funit}
Power basis representation of the fundamental unit (p + q√d) ⁄ 2
for the quadratic ring K = Z(√d), with positive d < 10^9.
Also given are the continued fraction expansion of the irrational
and a decimal approximation of the real square root.
In: X(d); out: Y(p), X(q), Textbox(partial quotients, decimal root).

{divf}
Divisor functions μ(a), ω(a), Ω(a), δ(a) and σ(a) of nonzero integer abs(a).
This fails if the calculator cannot factorize a. Press F1 to break off.
In: X(a); out: Y(σ(a)), Textbox(prime factors and function values).

{bits}
Hexadecimal, binary representation and population count of integer abs(a).
In: X(a); out: Textbox(hexstring, bitstring and popcount).

Note on factorization