Skip to content

Giant Reference Page

Here's an all-in-one feature list (ctrl+f is your friend!). Each section header opens a live demo.

Basic Commands (click for demo)

Arithmetic (Add, Subtract, Multiply, Divide)
2 + 2            = 4
(3 * 5) / 2      = 7.5
sqrt(9)          = 3
5^2              = 25

Percentages
5%               = 5%
100 * 17%        = 17
20 + 50%         = 30

Number shorthand
3.3 k            = 3,300
200 million      = 200,000,000
6.6 billion      = 6,600,000,000

Scientific
1.234e3          = 1,234
1e-3             = 0.001

Dollar formatting
$5 / 3           = $1.67

Comments
30 + 40          = 70 new total

Click result column to show/hide details
x = 3            = 3 hidden row

Variables and Rows

x = 9               = 9
y = x + 3           = 12
sqrt(x)             = 3
x + y               = 21
r1                  = 9
r2                  = 12
sum(r1:r3)          = 24
average(r1:r3)      = 8

Unit Conversions

Convert units: to, into, as, ->
15 feet into inches                                = 180 inches

Unit rates: /, per, every, until
15 miles/hour into feet/second                     = 22 feet/second
15 pounds per year in pounds per month             = 1.25 pounds/month

Custom units: plurals handled
15 sales/day in minutes per sale                   = 96 minutes/sale
15 sales/day in minutes until 5 sales              = 480 minutes/5 sales

Autoconversion: @, at, with, for, using
15 mph @ 10 hours                                  = 150 miles
15 mph @ 100 miles                                 = 6.6667 hour
150 dollars/sale @ 10 sales/day @ 10 days          = 15,000 dollars
150 dollars/sale @ 10 sales/day @ 750 dollars      = 0.5 day

Implied Conversion
15 mph in min                                      = 0.25 miles/min
15 mph in /min                                     = 0.25 miles/min
15 mph in km                                       = 24.1402 km/hour

SI units and prefixes (m, s, kg, newton, Pa, kWh...)
10 N -> base                                       = 10 kg m/s² in SI base units
10 kg m/s^2                                        = 10 newton automatically merged into compound unit

Weight: oz, lb, g, kg, ug (microgram), ton...
150 lbs in kg                                      = 68.0389 kg

Length: mile, yard (yd), foot (ft), inch (in), km, m...
15 feet in inches                                  = 180 inches

Area (square, ^2): acre, square mile, yd^2, in^2, cm^2, cm2...
2 acres in m^2                                     = 8,093.7128 m²

Volume (cubic, ^3): gallon (gal), quart (qt), pint (pt), cup (cp), fl oz, tbsp, tsp, cubic inch, ft^3, L, mL, cm^3, cc
1500 cc in cubic inches                            = 91.5356 inches³

Time: second (s/sec), minute (min), hour (hr), day, month, year, decade, century
3 days in minutes = 4320 minutes                   = 1,440 minutes/days_in_minute

Currency (3-letter code): USD, CAD, AUD, CNY, EUR, JPY, BRL, GBP, IRL, CNY, MXN, HKD...
15 USD in EUR                                      = 13.82 EUR updated weekly

Stock price lookup
STOCK(AAPL)                                        last closing price

Construction / Tape Measure
3' 4" x 2                                          = 6' 8"
180 cm as tape measure                             = 5' 10 55/64"

Cell and Row formatting

Currency formatting
$5 / 3                          = $1.67

Add comment with double backslash
30 + 40                         = 70 new total

Click result to toggle row
Variables get textboxes
x =10                           = 10
calculations (like 1 + 2) get hidden
1 + 2                           = 3
comments get hidden

Row formatting
0x123 as decimal                = 291
.15 as percent                  = 15%
.15 as fraction                 = 3/20
.15 as fraction over 5          = 1/5
15000 as money                  = 15K
15000 as scientific             = 1.5e4
15000 as engineering            = 15e3
3.5 inches as tape measure      = 3 1/2"
100 as hex                      = 0x0064
100 as bin                      = 0b01100100
100 cm as value                 = 100
100 cm as unit                  = 1 cm
100 cm as tape measure          = 3' 3 3/8"

123 as roman                    = CXXIII roman numerals
1234567 cm as scaled            = 12.3457 km better units
1234567 as nearest 1k           = 1,235,000
pi to 2 decimals                = 3.14
1234 seconds as time            = 20m 34s
123 as finance as noformat      = 123

Other number features

random                     = 0.82876105
random(10)                 = 7.89385073
round(3.51)                = 4
roundup(3.01)              = 4
rounddown(3.99)            = 3
abs(-2)                    = 2
3!                         = 6
sum(r6:r7)                 = 8
max(r3:r7)                 = 6
average(r3:r7)             = 3.8

fractions and decimal
1/2 + 1/3 as fraction      = 5/6
pi as fraction             = 355/113

percentages
15% of 200                 = 30
15% off 200                = 170 (discount)
15 as a % of 200           = 7.5%

greek letter shortcuts (\pi), superscript exponents
r = 2                      = 2
πr²                        = 12.56637061

plain english
fifteen plus five          = 20
15 squared                 = 225

Scientific (Trig, logs, etc.)

PI                 = 3.14159265 constants
E                  = 2.71828183

sin(30)            = 0.5 degrees
sin(PI/4 rad)      = 0.70710678 radians
exp(2)             = 7.3890561 e^x
E^2                = 7.3890561 alternative
ln(2)              = 0.69314718 "ln" is natural log
log(2)             = 0.30103 "log" is base 10
log_2(16)          = 4 "log_2" is log base 2

x = 3              = 3
log_x(100)         = 4.19180655 use any base you like
6.022e23           = 6.022e23 scientific notation

Programming

hex and binary
0xff                                                  = 0x00ff
0b1001                                                = 0b00001001
255 as hex                                            = 0x00ff conversion-style
hex(255)                                              = 0x00ff function-style
bin(9)                                                = 0b00001001
15 mod 2                                              = 1

binary operators
bin(19)                                               = 0b00010011
bin(7)                                                = 0b00000111
bin(19 and 7)                                         = 0b00000011
bin(19 or 7)                                          = 0b00010111
bin(19 xor 7)                                         = 0b00010100

data sizes assume bytes (write GB vs Gbit)
hex(1MB)                                              = 0x00100000
60GB / 700MB                                          = 87.77142857
10 mbit/s in minutes per gigabyte                     = 13.6533 minutes/gigabyte

More examples
0x56ef xor 0x123a                                     = 0x44d5
bin(0x56ef xor 0x123a)                                = 0b0100010011010101
x = 3                                                 = 3
x > 5                                                 = false
15 == x * 5                                           = true
if (x >= 3) {"at least as big"} else {"smaller"}      = at least as big

y = x + 3; y + 10                                     = 16 multiple statements

Computer Units

data sizes
1kb                                = 1 kb
10 gb / 5mb                        = 2,048
15MB * 3                           = 45 MB
data rates
1.5 mbps                           = 1.5 mbps
time(1gb / 1.5 mbps)               = 1h 35m 26s

operations
15 MFLOPS * 10 mins                = 9,000,000,000 ops

Hz (cycles/sec)
15 Ghz * 10 bytes/cycle in MB      = 143,051.1475 MB/sec

Excel Financial Functions

loan: 5% interest, 120 payments (10 years x 12 mo), 100k current value
PMT(5%/12, 10 * 12, 100k)                                         = -1,060.66
payment ending with positive 50k cash balance
PMT(5%/12, 10 * 12, 100k, 50k)                                    = -1,382.65

use friendly inline conversions
PMT(5% per year in per month, 10 years in months, 100k, 50k)      = -1,382.65

IRR(-70k, 12k, 15k, 18k, 21k, 26k)                                = 8.6631%
RATE(4*12, -200, 8000)                                            = 0.7701%
IPMT(10%/12, 1, 3*12, 8k)                                         = -66.67
PPMT(10%/12, 1, 2*12, 2k)                                         = -75.62
NPER(12% / 12, -100, -1k, 10k, 1)                                 = 59.67386567
ISPMT(10%/4, 1, 12*4, 10000)                                      = -244.79
PV(8%/12, 12*20, 500)                                             = -59,777.15

-1k                                                               = -1,000
1.1k                                                              = 1,100
2k                                                                = 2,000
NPV(10%, r17:r19)                                                 = 1,502.63

Excel Stats Functions

1                           = 1
2                           = 2
3                           = 3
4                           = 4
5                           = 5

sum(r1:r5)                  = 15
product(r1:r5)              = 120
avg(r1:r5)                  = 3 or mean()
mode(r1:r5)                 = 5
max(r1:r5)                  = 5
min(r1:r5)                  = 1

var(r1:r5)                  = 2
stddev(r1:r5)               = 1.41421356
range(r1:r5)                = 4
count(r1:r5)                = 5
percentile(r1:r5, 20%)      = 1.8

COMBINATION(10, 2)          = 45 or COMBIN
PERMUTATION(10, 2)          = 90 or PERMUT

Date/Time

Dates
today                             = Sun, May 26, 2024
tomorrow                          = Mon, May 27, 2024
yesterday                         = Sat, May 25, 2024
today + 5                         = Fri, May 31, 2024
today + 5 weeks                   = Sun, Jun 30, 2024
May 25 - Dec 31                   = 220 days date difference

Date formats
2024/12/05                        = Thu, Dec 5, 2024 YYYY/MM/DD
2024.12.05                        = Thu, Dec 5, 2024 YYYY.MM.DD
5/12/2024                         = Sun, May 12, 2024 MM/DD/YYYY
5.12.2024                         = Thu, Dec 5, 2024 German style: MM.DD.YYYY
2023-08-08T13:15:30Z              = Tue, Aug 8, 2023 6:15:30 AM ISO

Timezones
3pm PST in EST                    = 6:00 PM EDT

Date math
200 miles / (sept 1 - jun 1)      = 2.1739 miles/day
any order (absolute value)
200 miles / (jun 1 - sept 1)      = 2.1739 miles/day

Times: HH:MM by defau
2:15                              = 2:15
2:15 + 3 hours                    = 5:15

To get seconds (MM:SS)
2:15.0                            = 00:02:15 use decimal point
2m15s                             = 2m 15s use "Xm Ys"
00:02:15                          = 00:02:15 use leading 00: or 0:

Time calculations
3:45 * 2                          = 7:30
26.2 miles / 3:30 in mph          = 7.4857 miles/hour no decimal, hh:mm
100m / 0:9.8 in mph               = 22.8259 miles/hour with a decimal, mm:ss

Adding times keeps original format
3:45 + 2:15                       = 6:00
3h 45m + 2h 15m                   = 6h

The following are extracted from the config data file.

Number shorthand

    k: 1e3,
    hundred: 1e2,
    thousand: 1e3,

    M: 1e6, // capital
    million: 1e6,
    mln: 1e6,
    mio: 1e6, // german, somehow getting more commmon

    // TODO: have language packs which can add new units/scales? 

    b: 1e9,
    billion: 1e9,
    bil: 1e9,
    bn: 1e9,
    bln: 1e9,
    milliard: 1e9,

    t: 1e12,
    trillion: 1e12,

    quadrillion: 1e15,
    quintillion: 1e18,
    sextillion: 1e21,
    septillion: 1e24,

    rad: 180 / Math.PI,
    radian: 180 / Math.PI,
    radians: 180 / Math.PI,

    googol: 1e100,
    googolplex: 1e1000,

Formatting Options

Demo: https://instacalc.com/57432

Name of formatterDescriptionExample
percent, pct, %Formats the result as a percentage.666 as percent = 66.6%
fraction, fracFormats the result as a fraction.6666666 as fraction = 2/3
fraction / NFormats the result as a fraction with a specific denominator.666 as fraction/10 = 7/10
decimal, decFormats the result as a decimal number2/3 as decimal = 0.66666667
hexadecimal, hexFormats the result as a hexadecimal number255 as hexadecimal = 0x00ff
octal, octFormats the result as an octal number255 as octal = 0o377
binary, binFormats the result as a binary number255 as binary = 0b11111111
roman numeral, romanFormats the result as a Roman numeral255 as roman = CCLV
scientific, sciFormats the result in scientific notation12345 as scientific = 1.2345e4
engineering, engFormats the result in engineering notation12345 as engineering = 12.345e3
SICombines base units into compound SI unit15 kg m/s^2 as si = 15 newton
SIbase, base, metricSeparates compound unit into base SI units15 newton -> sibase = 15 kg m/s^2
finance, moneyFormats the result in financial notation (K/M/B)1234567 as finance = 1.2M
scaledScales the result to the best unit1234567 cm as scaled = 12.3457 km
unitExtracts unit from result12 cm as unit = 1 cm
value, val, number, numExtracts raw number from result12 cm as value = 12
nearest XRounds the result to the nearest X1234567 as nearest 100000 = 1,200,000
N decimal placesRounds the result to N decimal places1.2345 to 2 decimal places = 1.23
tape measure, tapeFormats the result as a tape measure (feet and inches)1.5 feet as tape = 1' 6"
timeFormats a time result in unit format (Xh Ym Zs)3661 seconds as time = 1h 1m 1s
noformatRemoves any formatting from the result1.23 as finance as noformat = 1.23

Predefined variables


    TAU: 2 * Math.PI,
    PI: Math.PI,
    E: Math.E,
    LOG10E: Math.LOG10E,
    LOG2E: Math.LOG2E,
    LN10: Math.LN10,
    LN2: Math.LN2,
    SQRT1_2: Math.SQRT1_2,
    PHI: (1 + Math.sqrt(5)) / 2,
    RAD: 180 / Math.PI, // acts like a constant as well
    RADIAN: 180 / Math.PI,
    RADIANS: 180 / Math.PI,
    RANDOM: () => Math.random(),

    // phystics constants
    GRAVITY: () => IC.makeICObject(9.8, "m/s^2"),
    SPEED_OF_LIGHT: () => IC.makeICObject(299792458, "m/s"),
    C_LIGHT: () => IC.makeICObject(299792458, "m/s"),
    SMALLG: () => IC.makeICObject(9.8, "m/s^2"),
    BIGG: () => IC.makeICObject(6.67408e-11, "m^3/kg/s^2"),
    PLANCK: () => IC.makeICObject(6.62607015e-34, "J s"),
    PLANCK_REDUCED: () => IC.makeICObject(6.62607015e-34 / (2 * Math.PI), "J*s"),
    HBAR: () => IC.makeICObject(6.62607015e-34 / (2 * Math.PI), "J s"),
    ELECTRON_CHARGE: () => IC.makeICObject(1.602176634e-19, "coulomb"),
    ELECTRON_MASS: () => IC.makeICObject(9.1093837015e-31, "kg"),
    PROTON_MASS: () => IC.makeICObject(1.67262192369e-27, "kg"),
    NEUTRON_MASS: () => IC.makeICObject(1.67492749804e-27, "kg"),
    R_GAS: () => IC.makeICObject(8.31446261815324, "J/K/mol"),
    F_FARADAY: () => IC.makeICObject(96485.33212331001, "coulomb/mol"),
    AVOGADRO_CONST: () => IC.makeICObject(6.02214076e23, "1/mol"),
    K_BOLTZMANN: () => IC.makeICObject(1.380649e-23, "J/K"),
  • 15 kg * gravity => 147 newton
  • Underscores can be swapped with spaces: speed_of_light or speed of light

Function Help Reference


    "hex": "hex(x) | convert x to hexadecimal, hex(255) = 0xff",
    "oct": "oct(x) | convert x to octal, oct(255) = 0377",
    "bin": "bin(x) | convert x to binary, bin(255) = 0b11111111",
    "dec": "dec(x) | convert x to decimal, dec(0xFF) = 255",

    if: "if (condition) { result } else { result } | if (age >= 18) { \"adult\" } else { \"child\" } \n IF(condition, true result, false result) | IF(age >= 18, \"adult\", \"child\") // excel-style",

    sin: "sin(x) | sine of x (degrees) | sin(2pi rad) for radians",
    cos: "cos(x) | cosine of x (degrees) | cos(2pi rad) for radians",
    tan: "tan(x) | tangent of x (degrees) | tan(2pi rad) for radians",
    sec: "sec(x) | secant of x (degrees) | sec(2pi rad) for radians",
    csc: "csc(x) | cosecant of x (degrees) | csc(2pi rad) for radians",
    cot: "cot(x) | cotangent of x (degrees) | cot(2pi rad) for radians",

    asin: "asin(x) | arcsine of x (result in degrees)",
    acos: "acos(x) | arccosine of x (result in degrees)",
    atan: "atan(x) | arctangent of x (result in degrees)",
    atan2: "atan2(y, x) | arctangent of y/x (result in degrees)",
    asec: "asec(x) | arcsecant of x (result in degrees)",
    acsc: "acsc(x) | arccosecant of x (result in degrees)",
    acot: "acot(x) | arccotangent of x (result in degrees)",

    sinh: "sinh(x) | hyperbolic sine",
    cosh: "cosh(x) | hyperbolic cosine",
    tanh: "tanh(x) | hyperbolic tangent",
    sech: "sech(x) | hyperbolic secant",
    csch: "csch(x) | hyperbolic cosecant",
    coth: "coth(x) | hyperbolic cotangent",
    asinh: "asinh(x) | hyperbolic arcsine of x",
    acosh: "acosh(x) | hyperbolic arccosine of x",
    atanh: "atanh(x) | hyperbolic arctangent of x",
    asech: "asech(x) | hyperbolic arcsecant of x",
    acsch: "acsch(x) | hyperbolic arccosecant of x",
    acoth: "acoth(x) | hyperbolic arccotangent of x",

    abs: "abs(x) | absolute value of x",
    ceil: "ceil(x) | ceiling of x",
    floor: "floor(x) | floor of x",
    round: "round(x, [decimal places]) | rounds number: round(pi) = 3, round(pi, 2) = 3.14, round(pi, .01) = 3.14",
    roundup: "roundup(x) | round up to nearest integer",
    rounddown: "rounddown(x) | round down to nearest integer",
    trunc: "trunc(x) | truncate to integer",
    int: "int(x) | truncate to integer",
    integer: "integer(x) | truncate to integer",

    hypot: "hypot(x, y) | sqrt(x^2 + y^2)",
    exp: "exp(x) | e^x",
    ln: "ln(x) | natural log of x",
    log: "log(x) | log base 10 of x",
    log2: "log2(x) | log base 2 of x",
    log_2: "log2(x) | log base 2 of x",
    log10: "log10(x) | log base 10 of x",
    log_10: "log10(x) | log base 10 of x",
    sqrt: "sqrt(x) | square root of x",
    cuberoot: "cuberoot(x) | cube root of x",
    pow: "pow(x, y) | x to power y: x^y",
    root: "root(x) | square root of x",

    time: "time(seconds) | convert seconds to HMS, time(10000) = 2h 46m 40s",

    mod: "mod(x, y) | x modulo (remainder) y",
    gcd: "gcd(x, y) | greatest common divisor of x and y",
    lcm: "lcm(x, y) | least common multiple of x and y",
    sign: "sign(x) | sign of x (-1, 0, or 1)",
    clamp: "clamp(x, min, max) | min <= x <= max",
    erf: "erf(x) | error function",
    erfinverse: "erfinverse(x) | inverse error function",
    gamma: "gamma(x) | gamma function",

    square: "square(x) | x^2",
    cube: "cube(x) | x^3",

    max: "max(r1:r3) or max(x, y, ...) | maximum of values",
    min: "min(r1:r3) or min(x, y, ...) | minimum of values",
    avg: "avg(r1:r3) or avg(x, y, ...) | average of values",
    sum: "sum(r1:r3) or sum(x, y, ...) | sum of values",
    total: "total(r1:r3) or total(x, y, ...) | sum of values",
    average: "average(r1:r3) or average(x, y, ...) | average of values",
    product: "product(r1:r3) or product(x, y, ...) | product of values",
    sub: "sub(x, y) | subtract y from x",
    subtract: "subtract(x, y) | subtract y from x",
    divide: "divide(x, y) | divide x by y",
    quotient: "quotient(x, y) | divide x by y",

    mean: "mean(r1:r3) or mean(x, y, ...) | mean of values",
    mode: "mode(r1:r3) or mode(x, y, ...) | mode of values",
    median: "median(r1:r3) or median(x, y, ...) | median of values",
    geomean: "geomean(r1:r3) or geomean(x, y, ...) | geometric mean of values",

    var: "var(r1:r3) or var(x, y, ...) | sample variance of values",
    variance: "variance(r1:r3) or variance(x, y, ...) | sample variance of values",

    "var.s": "var.s(r1:r3) or var.s(x, y, ...) | sample variance of values",
    "var.p": "var.p(r1:r3) or var.p(x, y, ...) | population variance of values",

    covar: "covar(r1:r3) or var(x, y, ...) | population covariance of values",
    covariance: "covariance(r1:r3) or variance(x, y, ...) | population covariance of values",

    "covar.s": "var.s(r1:r3) or var.s(x, y, ...) | sample variance of values",
    "covar.p": "var.p(r1:r3) or var.p(x, y, ...) | population variance of values",
    "covariance.s": "var.s(r1:r3) or var.s(x, y, ...) | sample variance of values",
    "covariance.p": "var.p(r1:r3) or var.p(x, y, ...) | population variance of values",

    slope: "slope(known_y's, known_x's) | slope of the linear regression line (Excel)",
    intercept: "intercept(known_y's, known_x's) | y-intercept of the linear regression line (Excel)",
    correl: "correl(array1, array2) | correlation coefficient between two data sets (Excel)",
    linest: "linest(known_y's, known_x's, [const], [stats]) | linear regression line (Excel)",
    forecast: "forecast(x, known_y's, known_x's) | forecast value on the linear regression line (Excel)",
    confidence: "confidence(alpha, standard_dev, size) | confidence interval for population mean (Excel)",

    stddev: "stddev(r1:r3) or stddev(x, y, ...) | sample standard deviation of values",
    stdev: "stdev(r1:r3) or stddev(x, y, ...) | sample standard deviation of values",

    "stdev.s": "stdev.s(r1:r3) or stdev.s(x, y, ...) | sample standard deviation of values",
    "stdev.p": "stdev.p(r1:r3) or stdev.p(x, y, ...) | population standard deviation of values",

    kurt: "kurtosis(r1:r3) | sample kurtosis of values (Excel)",
    kurtosis: "kurtosis(r1:r3) | sample kurtosis of values (Excel)",
    skewness: "skew(array) | sample skewness of values (Excel)",
    skew: "skew(array) | sample skewness of values (Excel)",

    "norm.s.inv": "norm.s.inv(p) | inverse of standard normal cumulative distribution function (Excel)",
    "normsinv": "norm.s.inv(p) | inverse of standard normal cumulative distribution function (Excel)",
    "norminv": "norm.inv(p) | inverse of normal cumulative distribution function (Excel)",
    "norm.dist": "norm.dist(x, mean, standard_dev, cumulative) | normal distribution function (Excel)",
    "normdist": "norm.dist(x, mean, standard_dev, cumulative) | normal distribution function (Excel)",
    "norm.s.dist": "norm.s.dist(z, cumulative) | standard normal distribution function (Excel)",
    "normsdist": "norm.s.dist(z, cumulative) | standard normal distribution function (Excel)",
    "t.inv": "t.inv(probability, degrees_freedom) | inverse of Student's t-distribution (Excel)",
    "tinv": "t.inv(probability, degrees_freedom) | inverse of Student's t-distribution (Excel)",
    "t.dist": "t.dist(x, degrees_freedom, cumulative) | Student's t-distribution function (Excel)",
    "tdist": "t.dist(x, degrees_freedom, cumulative) | Student's t-distribution function (Excel)",
    "chisq.dist": "chisq.dist(x, degrees_freedom, cumulative) | chi-square distribution function (Excel)",
    "chisqdist": "chisq.dist(x, degrees_freedom, cumulative) | chi-square distribution function (Excel)",
    "f.dist": "f.dist(x, degrees_freedom1, degrees_freedom2, cumulative) | F-distribution function (Excel)",
    "fdist": "f.dist(x, degrees_freedom1, degrees_freedom2, cumulative) | F-distribution function (Excel)",
    "z.test": "z.test(array, x, [sigma]) | z-test for mean (Excel)",
    "ztest": "z.test(array, x, [sigma]) | z-test for mean (Excel)",
    "t.test": "t.test(array1, array2, [tails], [type]) | t-test for means (Excel)",
    "ttest": "t.test(array1, array2, [tails], [type]) | t-test for means (Excel)",

    "t.dist.2t": "t.dist.2t(x, degrees_freedom) | two-tailed Student's t-distribution function (Excel)",
    "tdist2t": "t.dist.2t(x, degrees_freedom) | two-tailed Student's t-distribution function (Excel)",
    "t.dist.rt": "t.dist.rt(x, degrees_freedom) | right-tailed Student's t-distribution function (Excel)",
    "tdistrt": "t.dist.rt(x, degrees_freedom) | right-tailed Student's t-distribution function (Excel)",
    "t.inv.2t": "t.inv.2t(probability, degrees_freedom) | two-tailed inverse of Student's t-distribution (Excel)",
    "tinv2t": "t.inv.2t(probability, degrees_freedom) | two-tailed inverse of Student's t-distribution (Excel)",
    "chisq.dist.rt": "chisq.dist.rt(x, degrees_freedom) | right-tailed chi-square distribution function (Excel)",
    "chisqdistrt": "chisq.dist.rt(x, degrees_freedom) | right-tailed chi-square distribution function (Excel)",
    "chisq.inv": "chisq.inv(probability, degrees_freedom) | inverse of chi-square distribution function (Excel)",
    "chisqinv": "chisq.inv(probability, degrees_freedom) | inverse of chi-square distribution function (Excel)",
    "chisq.inv.rt": "chisq.inv.rt(probability, degrees_freedom) | right-tailed inverse of chi-square distribution function (Excel)",
    "chisqinvrt": "chisq.inv.rt(probability, degrees_freedom) | right-tailed inverse of chi-square distribution function (Excel)",
    "f.dist.rt": "f.dist.rt(x, degrees_freedom1, degrees_freedom2) | right-tailed F-distribution function (Excel)",
    "fdistrt": "f.dist.rt(x, degrees_freedom1, degrees_freedom2) | right-tailed F-distribution function (Excel)",
    "f.inv": "f.inv(probability, degrees_freedom1, degrees_freedom2) | inverse of F-distribution function (Excel)",
    "finv": "f.inv(probability, degrees_freedom1, degrees_freedom2) | inverse of F-distribution function (Excel)",
    "f.inv.rt": "f.inv.rt(probability, degrees_freedom1, degrees_freedom2) | right-tailed inverse of F-distribution function (Excel)",
    "finvrt": "f.inv.rt(probability, degrees_freedom1, degrees_freedom2) | right-tailed inverse of F-distribution function (Excel)",

    "binom.dist": "binom.dist(x, trials, probability_s, cumulative) | binomial distribution function (Excel)",
    "binomdist": "binom.dist(x, trials, probability_s, cumulative) | binomial distribution function (Excel)",
    "negbinom.dist": "negbinom.dist(x, r, p, cumulative) | negative binomial distribution function (Excel)",
    "negbinomdist": "negbinom.dist(x, r, p, cumulative) | negative binomial distribution function (Excel)",
    "weibull.dist": "weibull.dist(x, alpha, beta, cumulative) | Weibull distribution function (Excel)",
    "weibulldist": "weibull.dist(x, alpha, beta, cumulative) | Weibull distribution function (Excel)",
    "poisson.dist": "poisson.dist(x, mean, cumulative) | Poisson distribution function (Excel)",
    "poissondist": "poisson.dist(x, mean, cumulative) | Poisson distribution function (Excel)",
    "gamma.dist": "gamma.dist(x, alpha, beta, cumulative) | gamma distribution function (Excel)",
    "gammadist": "gamma.dist(x, alpha, beta, cumulative) | gamma distribution function (Excel)",

    range: "range(r1:r3) or range(x, y, ...) | range of values",
    count: "count(r1:r3) or count(x, y, ...) | count of values",
    percentile: "percentile(r1:r3, p) or percentile(x, y, ..., p) | pth percentile of values",
    percentrank: "percentrank(r1:r3, x, [sig (optional)]) or percentrank(x, y, ..., x) | percent rank of x in values, to [sig] digits (Excel)",

    combin: "combination(n, k) | n choose k",
    combination: "combination(n, k) | n choose k",
    c: "combination(n, k) | n choose k",
    permut: "permutation(n, k) | n permute k",
    permutation: "permutation(n, k) | n permute k",
    p: "permutation(n, k) | n permute k",

    // excel functions
    pmt: "PMT(rate, nper, pv, [fv (optional)], [type]) | loan payment (Excel)",
    ipmt: "IPMT(rate, per, nper, pv, [fv (optional)], [type]) | interest payment (Excel)",
    ppmt: "PPMT(rate, per, nper, pv, [fv (optional)], [type]) | payment on the principal (Excel)",

    ispmt: "ISPMT(rate, per, nper, pv) | interest payment specific period (Excel)",

    pv: "PV(rate, nper, pmt, [fv (optional)], [type]) | present value of an investment (Excel)",
    fv: "FV(rate, nper, pmt, [pv (optional)], [type]) | future value of an investment (Excel)",
    irr: "IRR(values, [guess (optional]) | internal rate of return (Excel)",
    npv: "NPV(rate, r1:r5) or NPV(rate, val1, val2...) | net present value (Excel)",

    rate: "RATE(nper, pmt, pv, [fv (optional)], [type], [guess]) | interest rate per period of an annuity (Excel)",
    nper: "NPER(rate, pmt, pv, [fv (optional)], [type]) | number of periods for an annuity (Excel)",

    rri: "RRI(nper, pv, fv) | interest rate per period of an annuity (Excel)",
    pduration: "PDURATION(rate, pv, fv) | number of periods for an annuity (Excel)",

    loan: "loan(amount, rate, term) | loan payment: loan(400k, 5%, 30y)",
    invest: "invest(amount, rate, term) | future value of investment: invest(200/month, 5%, 30y)",
    interest: "interest(amount, rate, term) | interest cost of loan: interest(200/month, 5%, 30y)",

    stock: "stock(symbol) | stock price: STOCK(AAPL)",
    import: "import(json_url) | import data from public URL to object",
    fib: "fib(n) | returns the nth Fibonacci number",
    fibonacci: "fibonacci(n) | returns the nth Fibonacci number",
    fac: "fac(n) | returns the factorial of n",
    factorial: "factorial(n) | returns the factorial of n",
    nchoosek: "nchoosek(n, k) | returns the binomial coefficient of n and k",

    sigfig: "sigfig(x, n) | round to n significant figures, sigfig(123.456, 2) = 120",

Function help appears below your input as you type (details).

Plain English Operations

    add: "+",
    "added to": "+",
    plus: "+",
    minus: "-",
    times: "*",
    "multiply by": "*",
    "by": "*",
    mul: "*",
    multiply: "*",
    "multiplied by": "*",
    div: "/",
    "divide by": "/",
    "divided by": "/",
    "out of": "/",
    "over": "/",
    "subtracted from": "* -1 +",
    "take away": "-",
    "to the power of": "^",
    "to the power": "^",
    "raised to the power of": "^",
    "raised to the power": "^",
    "raised to": "^",
    "power": "^",
    "pow": "^",
    "half of": "0.5 *",

    "is": " = ",
    "are": " = ",
    "equals": " = ",

    sub: "-",
    subtract: "-",
    negative: "-", // three plus negative two: 3+ -2
    modulo: " mod",

    // full names for math functions
    cosine: "cos ",
    sine: "sin ",
    tangent: "tan ",
    cotangent: "cot ",
    secant: "sec ",
    cosecant: "csc ",

    // remember: longest match first
    "is what percentage of": " :pctof: ",
    "is what percent of": " :pctof: ",
    "is what pct of": " :pctof: ",
    "is what % of": " :pctof: ",
    "is what of": " :pctof: ",
    "as a percentage of": " :pctof: ",
    "as a percent of": " :pctof: ",
    "as a pct of": " :pctof: ",
    "as a % of": " :pctof: ",

    "% of what is": "% inverse *", // 20% of what is 30 => 20% inverse * 30

    "choose": ":choose:",
    "pick": ":choose:", // wolfram alpha uses pick as choose
    "permute": ":permute:",

    "percentage of": "% of ",
    "percent of": "% of ",
    "pct of": "% of ",

    // conversion words
    "into a": " -> ",
    "to a": " -> ",
    "as a": " -> ",
    "in a": " -> ",

    "convert to": " -> ",
    "convert": " -> ",
    "as": " -> ",
    "into": " -> ",
    "to": " -> ",
    // no "in" because it could be "inch"

    // typesolve words
    "using": " @ ",
    "with": " @ ",
    "at": " @ ",
    "for": " @ ",

    "per": "/",
    "every": "/",
    "until": "/",
  • 15 times 3
  • half of 27
  • 13 is what percent of 25
  • 15 lbs convert to kg
  • 15 mph for 3 hours
  • 15 feet per day in feet per year

Alternate symbols

    "×": "*",
    "✕": "*", // multiplication X
    "÷": "/",
    "⁄": "/",
    "\u2212": "-",
    "–": "-",       // en dash
    "—": "-",       // em dash

    "**": "^",      // treat ** as ^ for all conversions, units, etc.

    "•": "*", // bullet
    "·": "*", // middot

    "√": "sqrt",
    "∛": "cbrt",

    "≠": "!=",
    "≤": "<=",
    "≥": ">=",

    "°": "deg", // degree

    // constants
    "\u03C0": "(PI)",
    "\u03C6": "(PHI)",
    "\u03C4": "(TAU)",
  • Usually not typed, these may come in via copy-paste of text

Currency shorthand

    yen: "(JPY, Japanese Yen)",
    euro: "(EUR, Euro)",
    yuan: "(CNY, Chinese Yuan)",
    rupee: "(INR, Indian Rupee)",
    peso: "(MXN, Mexican Peso)",
    ruble: "(RUB, Russian Ruble)",
    ringgit: "(MYR, Malaysian Ringgit)",
    won: "(KRW, South Korean Won)",
    loonie: "(CAD, Canadian Dollar)",
    aussie: "(AUD, Australian Dollar)",
    baht: "(THB, Thai Baht)",
    dirham: "(AED, United Arab Emirates Dirham)",
    lira: "(TRY, Turkish Lira)",
    riyal: "(SAR, Saudi Riyal)",
    lev: "(BGN, Bulgarian Lev)",
    zloty: "(PLN, Polish Zloty)",
    krona: "(SEK, Swedish Krona)",
    franc: "(CHF, Swiss Franc)",
    quetzal: "(GTQ Guatemalan Quetzal)",
    shekel: "(ILS, Israeli Shekel)",
    dong: "(VND, Vietnamese Dong)",
    dinar: "(KWD, Kuwaiti Dinar)",
    kuna: "(HRK, Croatian Kuna)",
    birr: "(ETB, Ethiopian Birr)",
    taka: "(BDT, Bangladeshi Taka)",
    forint: "(HUF, Hungarian Forint)",
    rupiah: "(IDR, Indonesian Rupiah)",
    kyat: "(MMK, Burmese Kyat)",
    naira: "(NGN, Nigerian Naira)",
    bolivar: "(VES, Venezuelan Bolivar)",
  • 15 dollars in loonie
  • 200 yen in USD

Symbol insertion: "\symbol", like \Alpha

    // operators - https://www.classe.cornell.edu/~dms79/LectureNotes/formulae/list-of-math-symbols-extended.htm 
    plus: "\u002B",
    minus: "\u2212",
    times: "\u00D7",
    mult: "\u00D7",
    div: "\u00F7",

    lt: "<",
    gt: ">",
    ne: "≠",
    "!=": "≠",
    eq: "=",
    le: "≤",
    "<=": "≤",
    ge: "≥",
    ">=": "≥",

    root: "\u221A",
    sqrt: "\u221A",
    cbrt: "\u221B",

    // exponents
    "0": "\u2070",
    "1": "\u00B9", // ¹
    "2": "\u00B2", // ² 
    "3": "\u00B3", // ³ 
    "4": "\u2074",
    "5": "\u2075",
    "6": "\u2076",
    "7": "\u2077",
    "8": "\u2078",
    "9": "\u2079",

    // neg exponents
    "-0": "\u207B\u2070",
    "-1": "\u207B\u00B9", // ¹
    "-2": "\u207B\u00B2", // ² 
    "-3": "\u207B\u00B3", // ³ 
    "-4": "\u207B\u2074",
    "-5": "\u207B\u2075",
    "-6": "\u207B\u2076",
    "-7": "\u207B\u2077",
    "-8": "\u207B\u2078",
    "-9": "\u207B\u2079",

    // subscripts
    "_0": "\u2080",
    "_1": "\u2081",
    "_2": "\u2082",
    "_3": "\u2083",
    "_4": "\u2084",
    "_5": "\u2085",
    "_6": "\u2086",
    "_7": "\u2087",
    "_8": "\u2088",
    "_9": "\u2089",

    // latex symbols
    dot: "·",
    bullet: "\u2022",
    cdot: "·",
    deg: "\u00B0",

    // calc symbols
    del: "∂",
    partial: "∂",
    grad: "∇",
    nabla: "∇",
    angle: "∠",
    triangle: "△",
    star: "★",
    sum: "\u03A3", // sigma
    int: "∫",
    oint: "∮",
    prop: "∝",
    propto: "∝",
    approx: "≈",

    // greeks - http://www.javascripter.net/faq/greekletters.htm
    Alpha: "\u0391", // Α,
    Beta: "\u0392", // Β,
    Gamma: "\u0393", // Γ,
    Delta: "\u0394", // Δ,
    Epsilon: "\u0395", // Ε,
    Zeta: "\u0396", // Ζ,
    Eta: "\u0397", // Η,
    Theta: "\u0398", // Θ,
    Iota: "\u0399", // Ι,
    Kappa: "\u039A", // Κ,
    Lambda: "\u039B", // Λ,
    Mu: "\u039C", // Μ,
    Nu: "\u039D", // Ν,
    Xi: "\u039E", // Ξ,
    Omicron: "\u039F", // Ο,
    Pi: "\u03A0", // Π,
    Rho: "\u03A1", // Ρ,
    Sigma: "\u03A3", // Σ,
    Tau: "\u03A4", // Τ,
    Upsilon: "\u03A5", // Υ,
    upsih: "\u03D2", // ϒ,
    Phi: "\u03A6", // Φ,
    Chi: "\u03A7", // Χ,
    Psi: "\u03A8", // Ψ,
    Omega: "\u03A9", // Ω,
    alpha: "\u03B1", // α,
    beta: "\u03B2", // β,
    gamma: "\u03B3", // γ,
    delta: "\u03B4", // δ,
    epsilon: "\u03B5", // ε,
    zeta: "\u03B6", // ζ,
    eta: "\u03B7", // η,
    theta: "\u03B8", // θ,
    thetasym: "\u03D1", // ϑ,
    iota: "\u03B9", // ι,
    kappa: "\u03BA", // κ,
    lambda: "\u03BB", // λ,
    mu: "\u03BC", // μ,
    nu: "\u03BD", // ν,
    xi: "\u03BE", // ξ,
    omicron: "\u03BF", // ο,
    pi: "\u03C0", // π,
    piv: "\u03D6", // ϖ,
    rho: "\u03C1", // ρ,
    sigmaf: "\u03C2", // ς,
    sigma: "\u03C3", // σ,
    tau: "\u03C4", // τ,
    upsilon: "\u03C5", // υ,
    phi: "\u03C6", // φ,
    chi: "\u03C7", // χ,
    psi: "\u03C8", // ψ,
    omega: "\u03C9", // ω,

    // other symbols
    rightarrow: "→",
    infty: "∞",

    micro: "µ",

    // curisve script
    // https://www.w3.org/TR/xml-entity-names/1D4.html
    // Idea: let people enter variables, constants, etc. that don't interfere
    // with built-in units (c), etc.
    A: "𝓐",
    B: "𝓑",
    C: "𝓒",
    D: "𝓓",
    E: "𝓔",
    F: "𝓕",
    G: "𝓖",
    H: "𝓗",
    I: "𝓘",
    J: "𝓙",
    K: "𝓚",
    L: "𝓛",
    M: "𝓜",
    N: "𝓝",
    O: "𝓞",
    P: "𝓟",
    Q: "𝓠",
    R: "𝓡",
    S: "𝓢",
    T: "𝓣",
    U: "𝓤",
    V: "𝓥",
    W: "𝓦",
    X: "𝓧",
    Y: "𝓨",
    Z: "𝓩",

    a: "𝒂",
    b: "𝒃",
    c: "𝒄",
    d: "𝒅",
    e: "𝒆",
    f: "𝒇",
    g: "𝒈",
    h: "𝒉",
    i: "𝒊",
    j: "𝒋",
    k: "𝒌",
    l: "𝒍",
    m: "𝒎",
    n: "𝒏",
    o: "𝒐",
    p: "𝒑",
    q: "𝒒",
    r: "𝒓",
    s: "𝒔",
    t: "𝒕",
    u: "𝒖",
    v: "𝒗",
    w: "𝒘",
    x: "𝒙",
    y: "𝒚",
    z: "𝒛"
  • Insert a symbol by writing \symbol and then pressing space, such as \pi or \alpha