Unary operation

Short description: Mathematical operation with only one operand

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, where A is a set. The function 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.

## Contents

* 1 Examples
* 1.1 Absolute value
* 1.2 Negation
* 1.3 Unary negative and positive
* 1.4 Trigonometry
* 1.5 Examples from programming languages
* 1.5.1 JavaScript
* 1.5.2 C family of languages
* 1.5.3 Unix shell (Bash)
* 1.5.4 PowerShell
* 2 See also
* 3 References
* 4 External links

## Examples

### Absolute value

Obtaining the absolute value of a number is a unary operation. This function is defined as [math]\displaystyle{ |n| = \begin{cases} n, & \mbox{if } n\geq0 \\\ -n, & \mbox{if } n\lt 0 \end{cases} }[/math][3] where [math]\displaystyle{ |n| }[/math] is the absolute value of [math]\displaystyle{ n }[/math].

### Negation

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

[math]\displaystyle{ -(3) = -3 }[/math]

[math]\displaystyle{ -( -3) = 3 }[/math]

### Unary negative and positive

As unary operations have only one operand they are evaluated before other operations containing them. Here is an example using negation:

[math]\displaystyle{ 3 }[/math][math]\displaystyle{ - }[/math][math]\displaystyle{ - }[/math][math]\displaystyle{ 2 }[/math]

Here, the first '−' represents the binary subtraction operation, while the second '−' represents the unary negation of the 2 (or '−2' could be taken to mean the integer −2). Therefore, the expression is equal to:

[math]\displaystyle{ 3 }[/math][math]\displaystyle{ - }[/math][math]\displaystyle{ (- }[/math][math]\displaystyle{ 2) }[/math][math]\displaystyle{ = 5 }[/math]

Technically, there is also a unary + operation but it is not needed since we assume an unsigned value to be positive:

[math]\displaystyle{ +2 = 2 }[/math]

The unary + operation does not change the sign of a negative operation:

[math]\displaystyle{ + }[/math][math]\displaystyle{ (- }[/math][math]\displaystyle{ 2) }[/math][math]\displaystyle{ = }[/math] [math]\displaystyle{ -2 }[/math]

In this case, a unary negation is needed to change the sign:

[math]\displaystyle{ -(-2)=+2 }[/math]

### Trigonometry

In trigonometry, the trigonometric functions, such as [math]\displaystyle{ \sin }[/math], [math]\displaystyle{ \cos }[/math], and [math]\displaystyle{ \tan }[/math], 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

#### JavaScript

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

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)

In the Unix/Linux shell (bash/sh), '$' is a unary operator when used for parameter expansion, replacing the name of a variable by its (sometimes modified) value. For example:

* Simple expansion: `$x`
* Complex expansion: `${#x}`

#### PowerShell

* 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

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

## References

1. ↑ Weisstein, Eric W.. "Unary Operation" (in en). https://mathworld.wolfram.com/UnaryOperation.html.
2. ↑ Weisstein, Eric W.. "Binary Operation" (in en). https://mathworld.wolfram.com/BinaryOperation.html.
3. ↑ "Absolute value". https://en.wikipedia.org/wiki/Absolute_value#:~:text=For any real,as[8].
4. ↑ "Unary Operators". https://www.javascripttutorial.net/javascript-unary-operators/.
5. ↑ "Chapter 5. Expressions and Operators". C/C++ Language Reference. p. 109. http://www-01.ibm.com/support/docview.wss?uid=swg27002103&aid=1.
6. ↑ "Unary Operators - C Tutorials - Sanfoundry". http://www.sanfoundry.com/c-tutorials-different-unary-operators-operate-operands/.

## External links

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Unary operation. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Unary_operation&oldid=3358989"