In general, functions or operators with a given arity follow the naming conventions of
n-based
numeral systems, such as
binary and
hexadecimal. A
Latin prefix is combined with the -ary suffix. For example: • A nullary function takes no arguments. • Example: f()=2 • A
unary function takes one argument. • Example: f(x)=2x • A
binary function takes two arguments. • Example: f(x,y)=2xy • A
ternary function takes three arguments. • Example: f(x,y,z)=2xyz • An
n-ary function takes
n arguments. • Example: f(x_1, x_2, \ldots, x_n)=2\prod_{i=1}^n x_i
Nullary A
constant can be treated as the output of an operation of arity 0, called a
nullary operation. Also, outside of
functional programming, a function without arguments can be meaningful and not necessarily constant (due to
side effects). Such functions may have some
hidden input, such as
global variables or the whole state of the system (time, free memory, etc.).
Unary Examples of
unary operators in mathematics and in programming include the
unary minus and plus, the increment and decrement operators in
C-style languages (not in logical languages), and the
successor,
factorial,
reciprocal,
floor,
ceiling,
fractional part,
sign,
absolute value,
square root (the principal square root),
complex conjugate (unary of "one"
complex number, that however has two parts at a lower level of abstraction), and
norm functions in mathematics. In programming the
two's complement,
address reference, and the
logical NOT operators are examples of unary operators. All functions in
lambda calculus and in some
functional programming languages (especially those descended from
ML) are technically unary, but see
n-ary below. According to
Quine, the Latin distributives being
singuli,
bini,
terni, and so forth, the term "singulary" is the correct adjective, rather than "unary".
Abraham Robinson follows Quine's usage. In philosophy, the adjective
monadic is sometimes used to describe a
one-place relation such as 'is square-shaped' as opposed to a
two-place relation such as 'is the sister of'.
Binary Most operators encountered in programming and mathematics are of the
binary form. For both programming and mathematics, these include the
multiplication operator, the radix operator, the often omitted
exponentiation operator, the
logarithm operator, the
addition operator, and the
division operator. Logical predicates such as
OR,
XOR,
AND,
IMP are typically used as binary operators with two distinct operands. In
CISC architectures, it is common to have two source operands (and store result in one of them).
Ternary Most modern
CPUs provide a ternary
fused multiply–add (FMA) instruction for floating-point numbers, which multiplies two numbers and adds the result to a third number, only rounding once at the end. This avoids the inaccuracy resulting from rounding the multiplication and addition operations separately. The computer programming language
C and its various descendants (including
C++,
C#,
Java,
Julia,
Perl, and others) provide the
ternary conditional operator ?:. The first operand (the condition) is evaluated, and if it is true, the result of the entire expression is the value of the second operand, otherwise it is the value of the third operand. This operator has a lazy or 'shortcut'
evaluation strategy that does not evaluate whichever of the second and third arguments is not used. Some functional programming languages, such as
Agda, have such an evaluation strategy for all functions and consequently implement as an ordinary function; several others, such as
Haskell, can do this but for syntactic, performance or historical reasons choose to define keywords instead. The
Python language has a ternary conditional expression, . In
Elixir the equivalent would be . The
Forth language also contains a ternary operator, */, which multiplies the first two (one-cell) numbers, dividing by the third, with the intermediate result being a double cell number. This is used when the intermediate result would overflow a single cell. The Unix
dc calculator has several ternary operators, such as |, which will pop three values from the stack and efficiently compute x^y \bmod z with
arbitrary precision. Many (
RISC)
assembly language instructions are ternary (as opposed to only two operands specified in CISC); or higher, such as MOV %AX, (%BX, %CX), which will load () into register the contents of a calculated memory location that is the sum (parenthesis) of the registers and .
n-ary The
arithmetic mean of
n real numbers is an
n-ary function: \bar{x}=\frac{1}{n}\left (\sum_{i=1}^n{x_i}\right) = \frac{x_1+x_2+\dots+x_n}{n} Similarly, the
geometric mean of
n positive real numbers is an
n-ary function: \left(\prod_{i=1}^n a_i\right)^\frac{1}{n} = \ \sqrt[n]{a_1 a_2 \cdots a_n} . Note that a
logarithm of the geometric mean is the arithmetic mean of the logarithms of its
n arguments From a mathematical point of view, a function of
n arguments can always be considered as a function of a single argument that is an element of some
product space. However, it may be convenient for notation to consider
n-ary functions, as for example
multilinear maps (which are not linear maps on the product space, if ). The same is true for programming languages, where functions taking several arguments could always be defined as functions taking a single argument of some
composite type such as a
tuple, or in languages with
higher-order functions, by
currying.
Varying arity In computer science, a function that accepts a variable number of arguments is called
variadic. In logic and philosophy, predicates or relations accepting a variable number of arguments are called
multigrade, anadic, or variably polyadic. == Terminology ==