QALC(1) General Commands Manual QALC(1)
NAME
qalc - Powerful and easy to use command line calculator
SYNOPSIS
qalc [options] [expression]
DESCRIPTION
Qalculate! is a multi-purpose cross-platform 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 user-friendly 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 highlight different elements of expressions and
results
--defaults
load default settings
-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 user-defined or matching variables,
functions, units, and prefixes.
--list-functions [search term]
displays a list of all or matching functions.
--list-prefixes [search term]
displays a list of all or matching prefixes.
--list-units [search term]
displays a list of all or matching units.
--list-variables [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, non-
zero, positive, negative, non-positive, non-negative + number,
real, rational, integer, boolean).
base base
Sets the result number base (equivalent to set base).
clear Clears the screen
clear history
Clears the expression history
delete name
Removes the user-defined 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 user-definied 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.
keep name
Make the temporary user-defined variable or function with the
specified name non-temporary.
Example: keep var1.
MC/MS/M+/M-
Memory operations (memory clear, memory store, memory plus,
memory minus). Recall the memory using the MR/MRC variable.
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/"to"-command
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 variable 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 count
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 count 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
count 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 count
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.
KEYBINDINGS
Tab shows a list of functions, variables, and units that matches
the last object in the current expression
Ctrl+D terminates the program
Ctrl+E switches between approximation modes (exact, try exact, auto)
Ctrl+F switches between fraction modes (simple, decimal, auto)
Ctrl+A saves the current result in a temporary variable
Ctrl+L clears the screen
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, yes and no. 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 non-zero (x/x=1).
warn nonzero denominators, warnnzd (on*, off)
Display a message after a value has been assumed non-zero.
assumptions, asm (unknown*, non-zero, positive, negative, non-positive,
non-negative + number, real*, rational, integer, boolean)
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 (-1* = auto, 0 = exact, 1 = try exact, 2 =
approximate, 3 = dual)
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*)
Interpret undefined symbols in expressions as unknown
variables.
variables, var (on*, off)
variable units, varunits (on*, off)
If activated physical constants include units (e.g. c =
299>792>458 m>s).
Generic display options:
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.
unicode exponents, uniexp (0 = off, 1* = on, 2 = units)
Display exponents 0-9 using Unicode superscript characters.
vertical space, vspace (on*, off)
Add empty lines before and after result.
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)
exp display, edisp (E*, e, 10)
Determines how scientific notation are displayed (e.g. 3E6,
3e6, or 3 * 10^6).
fractions, fr (-1* = auto, 0 = off, 1 = exact, 2 = on, 3 = mixed, 4 =
long, 5 = dual, 1/n)
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 = lower, 6 = upper, 7 = concise, 8 =
relative)
lowercase numbers, lownum (on, off*)
Use lowercase letters for number bases > 10.
max decimals, maxdeci (-1* = off, >= 0)
min decimals, mindeci (-1* = off, >= 0)
repeating decimals, repdeci (on, off*)
If activated, 1/6 is displayed as '0.1 666...', otherwise as
'0.166667'.
rounding (0* = half away from zero, 1 = half to even, 2 = toward zero,
3 = half to odd, 4 = half toward zero, 5 = half up, 6 = half down, 7 =
half random, 8 = away from zero, 9 = up, 10 = down)
Determines how approximate numbers are rounded.
scientific notation, exp (0 = off, -1* = auto, -3 = engineering, 1 =
pure, 3 = scientific, >= 0)
Determines how scientific notation is 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.
duodecimal symbols, duosyms (on, off*)
Use special symbols for digits 10 and 11 in numbers with base
12.
Parsing:
caret as xor, xor^ (on, off*)
Use ^ as bitwise exclusive OR operator.
concise uncertainty, concise (on, off*)
Allow input of uncertainty using concise notation.
decimal comma (locale*, off, on)
Determines the default decimal separator.
hexadecimal two's input, hextwosin(on, off*)
Enables two's complement representation for input of negative
hexadecimal numbers. All hexadecimal numbers starting with 8 or
higher are negative, unless binary bits is set.
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, syntax (0* = adaptive, 1 = implicit first, 2 =
conventional, 3 = chain, 4 = rpn)
See syntax section.
read precision, readprec (0* = off, 1 = always, 2 = when decimals)
If activated, numbers are interpreted as approximate with
precision equal to the number of significant digits (3.20 =
3.20+/-0.005).
simplified percentage, percent (on*, off)
Interpret addition/subtraction of percentage as percentage
increase/decrease of the first term (100 + 10% = 110).
two's input, twosin (on, off*)
Enables two's complement representation for input of negative
binary numbers. All binary numbers starting with 1 are
negative, unless binary bits is set.
Units:
all prefixes, allpref (on, off*)
Enables automatic use of hecto, deca, deci, and centi.
autoconversion, conv (0 = none, 1* = optimal, 2 = base, 3 = optimalsi,
4 = mixed)
Controls automatic unit conversion of the result. 'optimalsi'
always converts non-SI 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)
temperature units, temp (0* = hybrid, 1 = absolute, 2 = relative)
Determines how expressions with temperature units are
calculated (hybrid acts as absolute if the expression contains
different temperature units, otherwise as relative).
update exchange rates, upxrates (-1* = ask, 0 = never, > 0 = days)
Other:
clear history (yes, no*)
Do not save expression history on exit.
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.
sigint action, sigint (0 = kill, 1* = exit, 2 = interrupt)
Determines how the SIGINT signal (Ctrl+C) is handled.
SYNTAX
Mathematical entities:
Numbers
These are the regular numbers composed by digits 0-9 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 explicitly 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 right-hand value (e.g. "5E3 = 5000").
Sexagesimal numbers (and time) can be entered directly using
colons (e.g. "5:30 = 5.5"). A number immediately preceded "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 two-dimensional rectangular array of mathematical
objects. Vectors are matrices with only one row or column, and
thus one-dimensional 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], with columns separated by space or
comma and rows separated by semi-colon, or (1, 2, 3, 4) and ((1,
2), (3, 4)). A vector with sequence of numbers can be created
using "..." (e.g. "1...4"), or colon (e.g. "[1:4]", or "[1:1:4]"
where the second value specifies the increment).
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 (YYYY-MM-DDTHH: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
calendar 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.
Operations and operators (word operators such as AND must be surrounded
by space):
Addition (+)
Subtraction (-)
Multiplication (*)
Division (/)
Remainder (%, rem) and 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 non-integer 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 ((, ))
Parellel sum (>, ||)
Returns the the reciprocal value of a sum of reciprocal values.
|| is interpreted as parallel if units are used, otherwise as
logical OR.
Logical operators (!, NOT, ||, OR, &&, AND, XOR, NOR, NAND)
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.
Dot product (.)
Element-wise operators (.*, ./, .^)
Save operator (:=, =)
Saves the expression to the right of the operator as a variable
or function (e.g. var1:=5, func1():=x+y, var1=ln(5)+2). If the
colon is omitted the expression is calculated before it is
assigned to the variable.
Evaluation priority order: parenthesis, 10^x, exponentiation,
functions, bitwise NOT, logical NOT, multiplication/division/remainder,
parallel sum, 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)).
In chain mode, expressions are calculated from left to right, ignoring
standard order of operations, like the immediate execution mode of a
traditional calculator (1+2*3 = (1+2)*3 = 9).
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 listed 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)
- prefix (convert to optimal prefix)
- 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, sexa2, sexa3, sexagesimal (show as sexagesimal number;
sexa2 hides and sexa3 rounds arcseconds)
- latitude, latitude2, longitude, longitude2 (show as
sexagesimal latitude/longitude; latitude2 and longitude2 hide
arcseconds)
- bijective (shown in bijective base-26)
- fp16, fp32, fp64, fp80, fp128 (show in binary floating-point
format)
- bcd (show as binary-coded decimal)
- 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
Fractions
- fraction (show result as mixed, or simple if prepended with
'-', fraction) show as mixed fraction with specified
denominator
- 1/# (show as mixed, or simple if prepended with '-', fraction
with specified denominator)
prepend with - to show as simple fraction
Other conversion commands
- factors (factorize result)
Similarly 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()"). Variables assignments can also be placed before the
expression, separated by comma, e.g. x=1, y=2, x+y
, but
this syntax is more strict.
Note that to and where can only be applied to the whole expression.
Everything before the operator is always treated as the expression to
convert (or apply replacement to), and everything after as the
conversion/replacement expression, regardless of any parentheses.
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 = 5 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.1093837e-31 kg
5 ns * rydberg to c
= 6.0793194E-8c
atom(Hg; weight) + atom(C; weight) * 4 to g
= 4.129e-22 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+2x-3) 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))
= [1 2 3; 4 5 6] (2x3 matrix)
1...5 = (1:5) = (1:1:5)
= [1 2 3 4 5]
(1; 2; 3) * 2 - 2
= [(1 * 2 - 2), (2 * 2 - 2), (3 * 2 - 2)]
= [0 2 4]
[1 2 3].[4 5 6]
= dot([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]
= 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 5 6] * [7 8; 9 10; 11 12]
= [58 64; 139 154] (matrix multiplication)
[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
= "2020-07-10T07:50:40Z"
"2020-07-10T07:50CET" to utc+8
= "2020-07-10T14:50:00+08:00"
"2020-05-20" + 523d
= addDays(2020-05-20; 523)
= "2021-10-25"
today - 5 days
= "2020-07-05"
"2020-10-05" - today
= days(today; 2020-10-05)
= 87
timestamp(2020-05-20)
= 1 589 925 600
stamptodate(1 589 925 600)
= "2020-05-20T00:00:00"
"2020-05-20" 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
floatError(52.345)
= 1.2207031e-6
52.34 to sexa
= 5220'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 .
13 July 2020 QALC(1)