QALC
Section: User Commands (1)
Updated: 13 July 2020
Page Index
NAME
qalc  Powerful and easy to use command line calculator
SYNOPSIS
qalc
[
options]
[
expression]
DESCRIPTION
Qalculate! is a multipurpose crossplatform desktop calculator. It is simple
to use but provides power and versatility normally reserved for complicated
math packages, as well as useful tools for everyday needs (such as currency
conversion and percent calculation). Features include a large library of
customizable functions, unit calculations and conversion, physical constants,
symbolic calculations (including integrals and equations), arbitrary precision,
uncertainty propagation, interval arithmetic, plotting, and a userfriendly
interface.
qalc is the command line interface of Qalculate!.
OPTIONS
 b, base base

set the number base for results and, optionally, expressions
 c, color

use colors to hightlight different elements of expressions and results
 e, exrates

update exchange rates
 f, file file

execute commands from a file first
 h, help

display this help and exits
 i, interactive

start in interactive mode
 l, list [search term]

displays a list of all userdefined or matching variables, functions, units, and prefixes.
 listfunctions [search term]

displays a list of all or matching functions.
 listprefixes [search term]

displays a list of all or matching prefixes.
 listunits [search term]

displays a list of all or matching units.
 listvariables [search term]

displays a list of all or matching variables.
 m, time milliseconds

terminate calculation and display of result after specified amount of time
 n, nodefs

do not load any functions, units, or variables from file
 nocurrencies

do not load any global currencies from file
 nodatasets

do not load any global data sets from file
 nofunctions

do not load any global functions from file
 nounits

do not load any global units from file
 novariables

do not load any global variables from file
 p [base]

start in programming mode (same as b "base base" s "xor^", with base
conversion)
 s, set "option value"

as set command in interactive program session (ex. set "base 16")
 t, terse

reduce output to just the result of the input expression
 /+u8

switch unicode support on/off
 v, version

show application version and exit
The program will start in interactive mode if no expression and no file is
specified (or interactive mode is explicitly selected).
COMMANDS
 approximate

Equivalent to set approximation try exact.
 assume assumptions

Set default assumptions for unknown variables (unknown, nonzero, positive, negative, nonpositive, nonnegative +
number, real, rational, integer).
 base base

Sets the result number base (equivalent to set base).
 delete name

Removes the userdefined variable or function with the specified name.
Example: delete var1.
 exact

Equivalent to set approximation exact.
 expand

Expands the current result.
 exrates

Downloads current exchange rates from the Internet.
 factor

Factorizes the current result.
 find, list [name]

Displays a list of variables, functions and units.
Enter with argument 'currencies', 'functions', 'variables', 'units', or 'prefixes' to show a list of all currencies, functions, variables, units, or prefixes. Enter a search term to find matching variables, functions, units, and/or prefixes. If command is called with no argument all userdefinied objects are listed.
Example: list functions.
Example: find dinar.
Example: find variables planck.
 function name expression

Creates a function with the specified name and expression. Use '\x', '\y', '\z', '\a', etc. for arguments in the expression.
Example: function func1 5*\x.
 help [command]

 info

Displays information about a function, variable, unit, or prefix.
Example: info sin.
 mode

Displays the current mode.
 partial fraction

Applies partial fraction decomposition to the current result.
 save, store name [category] [title]

Saves the current result in a variable with the specified name. You may optionally also provide a category (default "Temporary") and a title.
If name equals "mode" or "definitions", the current mode and definitions, respectively, will be saved.
Example: store var1.
 save definitions

 save mode

 set option value

 to, convert, > unit/tocommand

Converts the previous result. Equivalent to using "to" at the end of an expression.
Example: to m/s
Example: to bin
 variable name expression

Create a variables with the specified name and expression.
Example: variable var1 pi / 2.
 quit/exit

Terminates the program.
Commands for RPN mode:
 rpn state

(De)activates the Reverse Polish Notation stack and syntax. "syntax" activates only the RPN syntax and "stack" enables the RPN stack.
 stack

Displays the RPN stack.
 clear stack

Clears the entire RPN stack.
 copy [index]

Duplicates a value on the RPN stack to the top of the stack. If no index is specified, the top of the stack is duplicated. Index 1 is the top of stack and negative index values counts from the bottom of the stack.
 move index 1 index 2

Changes the position of a value on the RPN stack. Index 1 is the top of stack and negative index values counts from the bottom of the stack.
Example: move 2 4
 pop [index]

Removes the top of the RPN stack or the value at the specified index. Index 1 is the top of stack and negative index values counts from the bottom of the stack.
 rotate [direction]

Rotates the RPN stack up (default) or down.
 swap [index 1] [index 2]

Swaps position of values on the RPN stack. If no index is specified, the values on the top of the stack (index 1 and index 2) will be swapped and if only one index is specified, the value at this index will be swapped with the top value. Index 1 is the top of stack and negative index values counts from the bottom of the stack.
Example: swap 2 4
When a line begins with '/', the text that follows is always interpreted as a command.
SETTINGS
These settings are changed using the
set command (e.g. set base 16) or the
s, set command line option (e.g. qalc s "base 16"). Possible values are shown in parenthesis. 1 and 0 can be used instead of on and off. If the value is left out, a value of 1 is generally assumed. The default value is marked with '*'.
Algebraic mode:
 algebra mode, alg (1* = expand, 2 = factorize)

Determines if the expression is factorized or not after calculation.
 assume nonzero denominators, nzd (on*, off)

Determines if unknown values will be assumed nonzero (x/x=1).
 warn nonzero denominators, warnnzd (on*, off)

Display a message after a value has been assumed nonzero.
 assumptions, ass (unknown*, nonzero, positive, negative, nonpositive, nonnegative + number, real*, rational, integer)

Default assumptions for unknown variables.
Calculation:
 angle unit, angle (0 = none, 1* = radians, 2 = degrees, 3 = gradians)

Default angle unit for trigonometric functions.
 approximation, appr (0 = exact, 1* = try exact, 2 = approximate)

How approximate variables and calculations are handled. In exact mode approximate values will not be calculated.
 interval arithmetic, ia (on*, off)

If activated, interval arithmetic determines the final precision of calculations (avoids wrong results after loss of significance) with
approximate functions and/or irrational numbers.
 interval calculation, ic (1* = variance formula, 2 = interval arithmetic)

Determines the method used for interval calculation / uncertainty propagation.
 precision, prec (> 0) 10*

Specifies the default number of significant digits displayed and determines the precision used for approximate calculations.
Enabled Objects
 calculate functions, calcfunc (on*, off)

 calculate variables, calcvar (on*, off)

 complex numbers, cplx (on*, off)

 functions, func (on*, off)

 infinite numbers, inf (on*, off)

 units (on*, off)

 unknowns (on, off*)

Interprete undefined symbols in expressions as unknown variables.
 variables, var (on*, off)

 variable units, varunit (on*, off)

If activated physical constants include units (e.g. c = 299 792 458 m∕s).
Generic Display Options.PP
 abbreviations, abbr (on*, off)

Use abbreviated names for units and variables.
 color (0 = off, 1* = default, 2 = light)

Use colors to highlight different elements of expressions and results.
 division sign, divsign (0* = /, 1 = division slash, 2 = division sign)

 excessive parentheses, expar (on, off*)

 minus last, minlast (on, off*)

Always place negative values last.
 multiplication sign, mulsign (0 = *, 1 = multiplication dot, 2* = multiplication x, 3 = middle dot)

 short multiplication, shortmul (on*, off)

 spacious, space (on*, off)

Add extra space around operators.
 spell out logical, spellout (on*, off)

 unicode, uni (on*, off)

Display Unicode characters.
Numerical Display
 base (1114112  1114112, bin, oct, dec*, hex, sexa, time, roman)

 base display, basedisp (0 = none, 1* = normal, 2 = alternative)

 complex form, cplxform (0* = rectangular, 1 = exponential, 2 = polar, 3 = cis, 4 = angle)

 decimal comma (locale*, off, on)

Determines the default decimal separator.
 digit grouping, group (0* = off, 1 = standard, 2 = locale)

 fractions, fr (0* = off, 1 = exact, 2 = on, 3 = mixed, 4 = long)

Determines how rational numbers are displayed (e.g. 5/4 = 1 + 1/4 = 1.25). 'long' removes limits on the size of the numerator and denonimator.
 hexadecimal two's, hextwos (on, off*)

Enables two's complement representation for display of negative hexadecimal numbers.
 imaginary j, imgj (on, off*)

Use 'j' (instead of 'i') as default symbol for the imaginary unit.
 interval display, ivdisp (0* = adaptive, 1 = significant, 2 = interval, 3 = plusminus, 4 = midpoint, 5 = upper, 6 = lower)

 lowercase e, lowe (on, off*)

Use lowercase e for Enotation (5e2 = 5 * 10^2).
 lowercase numbers, lownum (on, off*)

Use lowercase letters for number bases > 10.
 max decimals, maxdeci (off*, >= 0)

 min decimals, mindeci (off*, >= 0)

 round to even, rndeven (on, off*)

Determines whether halfway numbers are rounded upwards or towards the nearest even integer.
 scientific notation, exp (0 = off, 1 = auto*, 3 = engineering, 1 = pure, 3 = scientific, >= 0)

Determines how scientific notation are used (e.g. 5 543 000 = 5.543E6).
 show ending zeroes, zeroes (on*, off)

If actived, zeroes are kept at the end of approximate numbers.
 two's complement, twos (on*, off)

Enables two's complement representation for display of negative binary numbers.
Parsing
 caret as xor, xor^ (on, off*)

Use ^ as bitwise exclusive OR operator.
 decimal comma (locale*, off, on)

Determines the default decimal separator.
 ignore comma (on, off*)

Allows use of ',' as thousands separator.
 ignore dot (on, off*)

Allows use of '.' as thousands separator.
 imaginary j, imgj (on, off*)

Use 'j' (instead of 'i') as default symbol for the imaginary unit.
 input base, inbase (1114112  1114112, bin, oct, dec*, hex, roman)

 limit implicit multiplication, limimpl (on, off*)

 parsing mode, parse (0* = adaptive, 1 = implicit first, 2 = conventional)

 read precision, readprec (0* = off, 1 = always, 2 = when decimals)

If activated, numbers be interpreted as approximate with precision equal to the number of significant digits (3.20 = 3.20+/0.005).
rpn syntax, rpnsyn
Units
 all prefixes, allpref (on, off*)

Enables automatic use of hecto, deca, deci, and centi.
 autoconversion, conv (none, optimal*, base, optimalsi, mixed)

Controls automatic unit conversion of the result. 'optimalsi' always converts nonSI units, while 'optimal' only converts to more optimal unit
expressions, with less units and exponents.
 binary prefixes, binpref (on, off*)

If activated, binary prefixes are used by default for information units.
 currency conversion, curconv (on*, off)

Enables automatic conversion to the local currency when optimal unit conversion is enabled.
 denominator prefixes, denpref (on*, off)

Enables automatic use of prefixes in the denominator of unit expressions.
 place units separately, unitsep (on*, off)

If activated, units are separated from variables at the end of the result.
 prefixes, pref (on*, off)

Enables automatic use of prefixes in the result.
 show negative exponents, negexp (on, off*)

Use negative exponents instead of division for units in result (m/s = m*s^1).
 sync units, sync (on*, off)

 update exchange rates, upxrates (1 = ask*, 0 = never, > 0 = days)

Other
 ignore locale (yes, no*)

Ignore system language and use English (requires restart).
 rpn (on, off*)

Activates the Reverse Polish Notation stack.
 save definitions (yes*, no)

Save functions, units, and variables on exit.
 save mode (yes*, no)

Save settings on exit.
SYNTAX
Mathematical entities:

Numbers
These are the regular numbers composed by digits 09 and a decimal sign — a dot, or a comma if it is the default decimal point in the locale/language used. If comma is used as decimal sign, the dot is still kept as an alternative decimal sign, if not explicitely deactivated. Numbers include integers, real numbers, and complex numbers. The imaginary part of complex numbers are written with as regular number followed by the special variable "i" (can be changed to a "j"), which represents the square root of 1. Spaces between digits are ignored ("5 5 = 55"). "E" (or "e") can be considered as a shortcut for writing many zeroes and is equivalent to multiplication by 10 raised to the power of the righthand value (e.g. "5E3 = 5000"). Sexagesimal numbers (and time) can be entered directly using colons (e.g. "5:30 = 5.5"). A number immediately preceeded "0b", "0o", "0d" or "0x" are interpreted as a number with base 2, 8, 12 or 16, respectively (e.g. "0x3f = 63").
Intervals
A number interval can be entered using the interval() function, the uncertainty() function, or using "±" or "+/" (e.g. 5±1 = uncertainty(5, 0.2) = interval(4, 6)). If the read precision option is activated, decimal numbers are interpreted as an interval between the numbers that are normally rounded to the entered number (e.g. 1.1 = 1.1±0.05). If interval calculation using variance formula is activated (default), the interval represents the standard uncertainty (deviation) of the value.
Vectors and Matrices
A matrix is a twodimensional rectangular array of mathematical objects. Vectors are matrices with only one row or column, and thus onedimensional sequences of objects. Vectors and matrices are generated by various functions, or using syntax in the form of [1, 2, 3, 4] and [[1, 2], [3, 4]].
Variables/Constants
See the list of variables in the GUI manual or using the command .I list variables
Functions
See the list of functions in the GUI manual or using the command .I list functions
Units and Prefixes
See the list of units and prefixes in the GUI manual or using the command .I list units.
Abbreviated, plural and singular forms of unit names and prefixes are generally allowed. Prefixes must be put immediately before the unit to be interpreted as prefixes (eg. 5 mm = 0.005 m, but 5 m m = 5 m^2). For convenience units allow the power operator to be left out (e.g. 5 m2 = 5 m^2), with currencies excluded.
Unknowns
Unknowns are text strings without any associated value. These are temporary unknown variables with default assumptions. Unknowns can also be explicitly entered by placing a backslash (\) before a single character (e.g. 5\a + 2\b) or using quotation mark before and after a text string (e.g. 5 "apples" + 2 "bananas"). If unknowns are activated characters without any associated variable, function or unit in an expression, will be regarded as an unknown variable.
Date and Time
Date/time values are specified using quoted text string (quotation marks are not needed for function arguments), using standard date and time format (YYYYMMDDTHH:MM:SS). Some local formats are also supported, but not recommended. The local time zone are used, unless a time zone is specified at the end of the time string (Z/UTC/GMT or +/HH:MM). Date/time supports a small subset of arithmetic operations. The time units represents calender time, instead of average values, when added or subtracted to a date.
Text
This category represent a number of different function argument types, such as regular text and file names. They can, but do not need to be put in quotes except when containing the argument separator.
Comments
All text after a hashtag (e.g. (5*2)/2 #calculating triangle area) is treated as a comment, which are added to the history.
Operations and operators (word operators such as AND must be surrounded by space):

Addition (+)
Subtraction ()
Multiplication (*)
Division (/)
Modulo (%, mod)
Returns the remainder after division.
Integer Division (//, div)
Rounds the result of division towards zero.
Exponentiation (^, **)
Note that x^y^z equals x^(y^z), and not (x^y)^z. Note also that for noninteger exponents with negative bases, the principal root is returned and not the real root ((8)^(1/3) equals 1 + 1.73i, and not 2). To calculate the real root for negative values, use the cbrt() and root() functions.
10^x (E)
Parenthesis ((, ))
Logical operators (!, , OR, &&, AND)
Primarily used in conjunction with comparisons.
Bitwise operators (~, , &, <<, >>, XOR)
Comparison operators (=, !=, <, <=, >, >=)
Returns 1 if expression is true and 0 if false. The x variable is isolated if the expression does not evaluate as true or false. Primarily used for equations and inequalities.
Evaluation priority order:
parenthesis, 10^x, exponentiation, functions, bitwise NOT, logical NOT, multiplication/division/modulo, addition/subtraction, bitwise NOT, bitwise shift, comparisons, bitwise AND, bitwise XOR, bitwise OR, logical AND, logical OR.
The evaluation of short/implicit multiplication without any multiplication sign (e.g. 5x, 5(2+3)), differs depending on the parsing mode. In the conventional mode implicit multiplication does not differ from explicit multiplication (12/2(1+2) = 12/2*3 = 18, 5x/5y = 5 * x/5 * y = xy). In the parse implicit multiplication first mode, implicit multiplication is parsed before explicit multiplication (12/2(1+2) = 12/(2 * 3) = 2, 5x/5y = (5 * x)/(5 * y) = x/y). The default adaptive mode works as the parse implicit multiplication first mode, unless spaces are found (1/5x = 1/(5 * x), but 1/5 x = (1/5) * x). In the adaptive mode unit expressions are parsed separately (5 m/5 m/s = (5 * m)/(5 * (m/s)) = 1 s). Function arguments without parentheses are an exception, where implicit multiplication in front of variables and units is parsed first regardless of mode (sqrt 2x = sqrt(2x)).
The "to"operator is used for unit conversion and manipulation of how the result is presented. Place " to " or a right arrow (e.g. ">") followed by one of expressions/commands the below, at the end of an expression.
 Unit conversion

 a unit or unit expression (e.g. meter or km/h)
prepend with ? to request the optimal prefix
prepend with b? to request the optimal binary prefix
prepend with + or  to force/disable use of mixed units
 a variable or physical constant (e.g. c)
 base (convert to base units)
 optimal (convert to optimal unit)
 mixed (convert to mixed units, e.g. hours + minutes)
 Number base conversion

 bin, binary (show as binary number)
 bin# (show as binary number with specified number of bits)
 oct, octal (show as octal number)
 duo, duodecimal (show as duodecimal number)
 hex, hexadecimal (show as hexadecimal number)
 hex# (show as hexadecimal number with specified number of bits)
 sex, sexagesimal (show as sexagesimal number)
 bijective (shown in bijective base26)
 fp16, fp32, fp64, fp80, fp128 (show in binary floatingpoint format)
 roman (show as roman numerals)
 time (show in time format)
 unicode
 base # (show in specified number base)
 bases (show as binary, octal, decimal and hexadecimal number)
 Complex format

 rectangular, cartesian (show complex numbers in rectangular form)
 exponential (show complex numbers in exponential form)
 polar (show complex numbers in polar form)
 cis (show complex numbers in cis form)
 angle, phasor (show complex numbers in angle/phasor notation)
 Time and date conversion

 UTC (show date and time in UTC time zone)
 UTC+/hh[:mm] (show date and time in specified time zone)
 calendars
 Other conversion commands

 fraction (show result as mixed fraction)
 factors (factorize result)
Similarily where (or alternatively "/.") can be used at the end (but before "to"), for variable assignments, function replacements, etc. (e.g. "x+y where x=1 and y=2", "x^2=4 where x>0", and "sin(5) where sin()=cos()").
EXAMPLES
Note that semicolon can be replaced with comma, if comma is not used as decimal or thousands separator.
Basic functions and operators
 sqrt 4

= sqrt(4)
= 4^(0.5)
= 4^(1/2)
= 2
 sqrt(25; 16; 9; 4)

= [5; 4; 3; 2]
 sqrt(32)

= 4 * sqrt(2) (in exact mode)
 cbrt(27)

= root(27; 3)
= 3 (real root)
 (27)^(1/3)

= 1.5 + 2.5980762i (principal root)
 ln 25

= log(25; e)
= 3.2188758
 log2(4)/log10(100)

= log(4; 2)/log(100; 10)
= 1
 5!

= 1 * 2 * 3 * 4 * 5
= 120
 5\2 (integer division)

= 5//2
= trunc(5/2)
= 2
 5 mod 3

= mod(5; 3)
= 2
 52 to factors

= 2^2 * 13
 25/4 * 3/5 to fraction

= 3 + 3/4
 gcd(63; 27)

= 9
 sin(pi/2)  cos(pi)

= sin(90 deg)  cos(180 deg)
= 2
 sum(x; 1; 5)

= 1 + 2 + 3 + 4 + 5 = 15
 sum(i^2+sin(i); 1; 5; i)

= 1^2 + sin(1) + 2^2 + sin(2) + ... = 55.176162
 product(x; 1; 5)

= 1 * 2 * 3 * 4 * 5 = 120
 var1:=5

store value 5 in variable var1
 5^2 #this is a comment

= 25
 sinh(0.5) where sinh()=cosh()

= cosh(0.5) = 1.1276260
 plot(x^2; 5; 5)

plots the function y=x^2 from 5 to 5
Units
 5 dm3 to L

= 25 dm^3 to L
= 5 L
 20 miles / 2h to km/h

= 16.09344 km/h
 1.74 to ft = 1.74 m to ft

= 5 ft + 8.5039370 in
 1.74 m to ft

= 5.7086614 ft
 100 lbf * 60 mph to hp

= 16 hp
 50 Ω * 2 A

= 100 V
 50 Ω * 2 A to base

= 100 kg*m^2*s^3*A^1
 10 N / 5 Pa

= (10 N)/(5 Pa) = 2 m^2
 5 m/s to s/m

= 0.2 s/m
 500 EUR  20% to USD

= 451.04 USD
 500 megabit/s * 2 h to b?byte

= 419.09516 gibibytes
Physical constants
 k_e / G * a_0

= (coulombs_constant / newtonian_constant) * bohr_radius
= 7.126e9 kg*H*m^1
 planck ∕ (compton_wavelength * c)

= 9.1093837e31 kg
 5 ns * rydberg to c

= 6.0793194E8c
 atom(Hg; weight) + atom(C; weight) * 4 to g

= 4.129e22 g
 (G * planet(earth; mass) * planet(mars; mass))/(54.6e6 km)^2

= 8.58e16 N (gravitational attraction between earth and mars)
Uncertainty and interval arithmetic
result with interval arithmetic activated is shown in parenthesis
 sin(5+/0.2)^2/2+/0.3

= 0.460±0.088 (0.46+/0.12)
 (2+/0.02 J)/(523+/5 W)

= 3.824+/0.053 ms (3.82+/±0.075 ms)
 interval(2; 5)^2

= intervall(8.2500000; 12.750000) (intervall(0; 25))
Algebra
 (5x^2 + 2)/(x  3)

= 5x + 15 + 47/(x  3)
 (\a + \b)(\a  \b) = ("a" + "b")("a"  "b")

= 'a'^2  'b'^2
 (x + 2)(x  3)^3

= x^4  7x^3 + 9x^2 + 27x  54
 factorize x^4  7x^3 + 9x^2 + 27x  54

= x^4  7x^3 + 9x^2 + 27x  54 to factors
= (x + 2)(x  3)^3
 cos(x)+3y^2 where x=pi and y=2

= 11
 gcd(25x; 5x^2)

= 5x
 1/(x^2+2x3) to partial fraction

= 1/(4x  4)  1/(4x + 12)
 x+x^2+4 = 16

x = 3 or x = 4
 x^2/(5 m)  hypot(x; 4 m) = 2 m where x>0

x = 7.1340411 m
 cylinder(20cm; x) = 20L

x = (1 / (2pi)) m
x = 16 cm (height of 20 L cylinder with radius 20 cm)
 asin(sqrt(x)) = 0.2

x = sin(0.2)^2
x = 0.039469503
 x^2 > 25x

= x > 25 or x < 0
 solve(x = y+ln(y); y)

= lambertw(e^x)
 solve2(5x=2y^2; sqrt(y)=2; x; y)

= 32/5
 multisolve([5x=2y+32; y=2z; z=2x]; [x; y; z])

= [32/3; 128/3; 64/3]
 dsolve(diff(y; x)  2y = 4x; 5)

= 6e^(2x)  2x  1
Calculus
 diff(6x^2)

= 12x
 diff(sinh(x^2)/(5x) + 3xy/sqrt(x))

= (2/5) * cosh(x^2)  sinh(x^2)/(5x^2) + (3y)/(2 * sqrt(x))
 integrate(6x^2)

= 2x^3 + C
 integrate(6x^2; 1; 5)

= 248
 integrate(sinh(x^2)/(5x) + 3xy/sqrt(x))

= 2x * sqrt(x) * y + Shi(x^2) / 10 + C
 integrate(sinh(x^2)/(5x) + 3xy/sqrt(x); 1; 2)

= 3.6568542y + 0.87600760
 limit(ln(1 + 4x)/(3^x  1); 0)

= 4 / ln(3)
Matrices and vectors
 ((1; 2; 3); (4; 5; 6))

= [[1; 2; 3]; [4; 5; 6]] (2x3 matrix)
 (1; 2; 3) * 2  2

= [1 * 2  2; 2 * 2  2; 3 * 2  2]
= [0; 2; 4]
 (1; 2; 3) * (4; 5; 6)

= 32 (dot product)
 cross((1; 2; 3); (4; 5; 6))

= [3; 6; 3] (cross product)
 ((1; 2; 3); (4; 5; 6)) * ((7; 8); (9; 10); (11; 12))

= [[58; 64]; [139; 154]]
 hadamard([[1; 2; 3]; [4; 5; 6]]; [[7; 8; 9]; [10; 11; 12]])

= [[7; 16; 27]; [40; 55; 72]] (hadamard product)
 ((1; 2); (3; 4))^1

= inverse([[1; 2]; [3; 4]])
= [[2; 1]; [1.5; 0.5]]
Statistics
 mean(5; 6; 4; 2; 3; 7)

= 4.5
 stdev(5; 6; 4; 2; 3; 7)

= 1.87
 quartile((5; 6; 4; 2; 3; 7); 1)

= percentile([5; 6; 4; 2; 3; 7]; 25)
= 2.9166667
 normdist(7; 5)

= 0.053990967
 spearman(column(load(test.csv); 1); column(load(test.csv); 2))

= 0.33737388 (depends on the data in the CSV file)
Time and date
 10:31 + 8:30 to time

= 19:01
 10h 31min + 8h 30min to time

= 19:01
 now to utc

= "20200710T07:50:40Z"
 "20200710T07:50CET" to utc+8

= "20200710T14:50:00+08:00"
 "20200520" + 523d

= addDays(20200520; 523)
= "20211025"
 today  5 days

= "20200705"
 "20201005"  today

= days(today; 20201005)
= 87
 timestamp(20200520)

= 1 589 925 600
 stamptodate(1 589 925 600)

= "20200520T00:00:00"
 "20200520" to calendars

returns date in Hebrew, Islamic, Persian, Indian, Chinese, Julian, Coptic, and Ethiopian calendars
Number bases
 52 to bin

= 0011 0100
 52 to bin16

= 0000 0000 0011 0100
 52 to oct

= 064
 52 to hex

= 0x34
 0x34

= hex(34)
= base(34; 16)
= 52
 523<<2&250 to bin

= 0010 1000
 52.345 to float

= 0100 0010 0101 0001 0110 0001 0100 1000
 float(01000010010100010110000101001000)

= 1715241/32768
= 52.345001
 flaotError(52.345)

= 1.2207031e6
 52.34 to sexa

= 52°20'24"
 1978 to roman

= MCMLXXVIII
 52 to base 32

= 1K
 sqrt(32) to base sqrt(2)

= 100000
SEE ALSO
The manual of the graphical user interface at
https://qalculate.github.io/manual/index.html
(includes more details about the syntax and elements supported in mathematical expressions, and various options, and
includes a complete list of functions, variables, and units)
BUGS
Please report any bugs at
https://github.com/Qalculate/libqalculate/issues
AUTHORS
Hanna Knutsson <
hanna.knutsson@protonmail.com>.