Unary operation

Mathematical operation with only one operand

This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed.
Find sources: "Unary operation" – news · newspapers · books · scholar · JSTOR (March 2010) (Learn how and when to remove this message)

|

In mathematics, a unary operation is an operation with only one operand, i.e. a single input.[1] This is in contrast to binary operations, which use two operands.[2] An example is any function ⁠ f : A → A {\displaystyle f:A\rightarrow A} ⁠, where A is a set; the function ⁠ f {\displaystyle f} ⁠ is a unary operation on A.

Common notations are prefix notation (e.g. ¬, −), postfix notation (e.g. factorial n!), functional notation (e.g. sin x or sin(x)), and superscripts (e.g. transpose AT). Other notations exist as well, for example, in the case of the square root, a horizontal bar extending the square root sign over the argument can indicate the extent of the argument.

## Examples

[edit]

### Absolute value

[edit]

Obtaining the absolute value of a number is a unary operation. This function is defined as  | n | = { n , if  n ≥ 0 − n , if  n < 0 {\displaystyle |n|={\begin{cases}n,&{\mbox{if }}n\geq 0\\\\-n,&{\mbox{if }}n<0\end{cases}}} where  | n | {\displaystyle |n|} is the absolute value of  n {\displaystyle n} .

### Negation

[edit]

Negation is used to find the negative value of a single number. Here are some examples:

− ( 3 ) = − 3 {\displaystyle -(3)=-3}

− ( − 3 ) = 3 {\displaystyle -(-3)=3}

### Factorial

[edit]

For any positive integer n, the product of the integers less than or equal to n is a unary operation called factorial. In the context of complex numbers, the gamma function is a unary operation extension of factorial.

### Trigonometry

[edit]

In trigonometry, the trigonometric functions, such as  sin {\displaystyle \sin } ,  cos {\displaystyle \cos } , and  tan {\displaystyle \tan } , can be seen as unary operations. This is because it is possible to provide only one term as input for these functions and retrieve a result. By contrast, binary operations, such as addition, require two different terms to compute a result.

### Examples from programming languages

[edit]

Below is a table summarizing common unary operators along with their symbols, description, and examples:[3]

Operator | Symbol | Description | Example

|
|
|

Increment | `++` | Increases the value of a variable by 1 | `x = 2; ++x; // x is now 3`
Decrement | `--` | Decreases the value of a variable by 1 | `y = 10; --y; // y is now 9`
Unary Plus | `+` | Indicates a positive value | `a = -5; b = +a; // b is -5`
Unary Minus | `-` | Indicates a negative value | `c = 4; d = -c; // d is -4`
Logical NOT | `!` | Negates the truth value of a Boolean expression | `flag = true; result = !flag; // result is false`
Bitwise NOT | `~` | Bitwise negation, flips the bits of an integer | `num = 5; result = ~num; // result is -6`

#### JavaScript

[edit]

In JavaScript, these operators are unary:[4]

* Increment: `++x`, `x++`
* Decrement: `--x`, `x--`
* Positive: `+x`
* Negative: `-x`
* Ones' complement: `~x`
* Logical negation: `!x`

#### C family of languages

[edit]

In the C family of languages, the following operators are unary:[5][6]

* Increment: `++x`, `x++`
* Decrement: `--x`, `x--`
* Address: `&x`
* Indirection: `*x`
* Positive: `+x`
* Negative: `-x`
* Ones' complement: `~x`
* Logical negation: `!x`
* Sizeof: `sizeof x, sizeof(type-name)`
* Cast: `(type-name) cast-expression`

#### Unix shell (Bash)

[edit]

In the Unix shell (Bash/Bourne Shell), e.g., the following operators are unary:[7][8]

* Pre and Post-Increment: `++$x`, `$x++`
* Pre and Post-Decrement: `--$x`, `$x--`
* Positive: `+$x`
* Negative: `-$x`
* Logical negation: `!$x`
* Simple expansion: `$x`
* Complex expansion: `${#x}`

#### PowerShell

[edit]

In the PowerShell, the following operators are unary:[9]

* Increment: `++$x`, `$x++`
* Decrement: `--$x`, `$x--`
* Positive: `+$x`
* Negative: `-$x`
* Logical negation: `!$x`
* Invoke in current scope: `.$x`
* Invoke in new scope: `&$x`
* Cast: `[type-name] cast-expression`
* Cast: `+$x`
* Array: `,$array`

## See also

[edit]

* Unary function
* Binary operation
* Iterated binary operation
* Binary function
* Ternary operation
* Arity
* Operation (mathematics)
* Operator (programming)

## References

[edit]

1. ^ Weisstein, Eric W. "Unary Operation". mathworld.wolfram.com. Retrieved 2020-07-29.
2. ^ Weisstein, Eric W. "Binary Operation". mathworld.wolfram.com. Retrieved 2020-07-29.
3. ^ "Unary Operators in Programming". GeeksforGeeks. 20 March 2024. Retrieved 24 April 2024.
4. ^ "Unary Operators".
5. ^ "5. Expressions and Operators". C/C++ Language Reference. Version 6.0. p. 109\. Archived from the original on 2012-10-16.
6. ^ "Unary Operators - C Tutorials - Sanfoundry". www.sanfoundry.com. 2 March 2014.
7. ^ "Shell Arithmetic (Bash Reference Manual)". www.gnu.org. GNU Operating System. Retrieved 24 April 2024.
8. ^ Miran, Mohammad Shah (26 October 2023). "Unary Operators in Bash". LinuxSimply. Retrieved 24 April 2024.
9. ^ "Expressions - PowerShell". learn.microsoft.com. Microsoft. 3 September 2021. Retrieved 23 April 2024.

## External links

[edit]

* Media related to Unary operations at Wikimedia Commons