---
name: abs
signature: 'abs VALUE'
since: 5.0
status: documented
categories: ["Numeric functions"]
---

```{index} single: abs; Perl built-in
```

*[Numeric functions](../perlfunc-by-category)*

# abs

Return the absolute value of a number.

`abs` takes a single scalar, forces it to numeric context, and returns
its magnitude — the value with any sign stripped. Non-numeric strings
are converted using the same rules as arithmetic (leading whitespace
and an optional sign, followed by digits; the rest is discarded, with
a warning under `use warnings`). If `VALUE` is omitted, `abs` operates
on [`$_`](../perlvar).

## Synopsis

```perl
abs VALUE
abs
abs($x)
```

## What you get back

A non-negative number. The result is an integer if the input was an
integer within the platform's integer range, otherwise a floating-point
number. `abs` never changes its argument — the result is a fresh
scalar, so `abs $x` leaves `$x` alone.

## Global state it touches

With no argument, `abs` reads [`$_`](../perlvar). It neither writes nor reads any
other special variable. Under `use warnings`, a non-numeric argument
triggers the standard `Argument "…" isn't numeric` warning via the
normal numeric-conversion path.

## Examples

Strip the sign from an integer:

```perl
print abs(-7);              # 7
print abs(7);               # 7
```

Floating-point magnitude — the result keeps the full precision of the
input:

```perl
print abs(-3.14159);        # 3.14159
print abs(-1e-10);          # 1e-10
```

Use the default argument form inside a loop over [`$_`](../perlvar):

```perl
for (-3, -1, 0, 2, 4) {
    print abs, "\n";        # 3, 1, 0, 2, 4 on separate lines
}
```

Distance between two points on a number line:

```perl
sub distance { abs($_[0] - $_[1]) }
print distance(10, 3);      # 7
print distance(3, 10);      # 7
```

String that looks like a negative number — `abs` parses the leading
numeric prefix and strips the sign:

```perl
print abs("-42");           # 42
print abs("  -3.5xyz");     # 3.5  (warning under use warnings)
```

## Edge cases

- **`abs(undef)`** returns `0`. Under `use warnings` it emits
  `Use of uninitialized value in abs`.
- **Non-numeric string**: `abs("hello")` returns `0` and warns under
  `use warnings` that the argument isn't numeric.
- **Integer overflow boundary**: `abs` of the most-negative
  platform integer (`PERL_INT_MIN`, e.g. `-2**63` on 64-bit builds)
  promotes to a floating-point result, because the positive
  counterpart does not fit in a signed integer:

  ```perl
  use Config;
  my $min = -(2 ** ($Config{ivsize} * 8 - 1));
  print abs($min);            # 9.22337203685478e+18 on 64-bit
  ```

- **IEEE 754 special values**: `abs(-0.0)` returns `0` (a positive
  zero). `abs("-Inf")` returns `Inf`. `abs("NaN")` returns `NaN` —
  `NaN` has no sign that `abs` can meaningfully remove.
- **Complex numbers and big integers** are not handled by the
  built-in. `use Math::Complex` overloads `abs` to compute the
  modulus; {ext}`Math::BigInt` and {ext}`Math::BigFloat` provide their own
  sign-stripping on blessed objects via operator overloading.
- **No in-place form**: `abs` always returns a new scalar. To replace
  a variable's value with its magnitude, assign back:

  ```perl
  $x = abs $x;
  ```

- **Parser note**: the unary form `abs $x` binds tighter than `,` but
  looser than most arithmetic operators, so `abs $x + 1` parses as
  `abs($x) + 1`, not `abs($x + 1)`. Parenthesise when in doubt:

  ```perl
  print abs $x + 1;           # abs($x) + 1
  print abs($x + 1);          # abs of the sum
  ```

## Differences from upstream

Fully compatible with upstream Perl 5.42.

## See also

- [`sqrt`](sqrt) — square root; like `abs` it is a pure numeric
  unary with a default-to-[`$_`](../perlvar) form
- [`int`](int) — truncate toward zero; pairs with `abs` when you want
  the integer magnitude of a float
- [`sprintf`](sprintf) — formatted numeric output; use `%d` or `%g`
  together with `abs` to render unsigned magnitudes
- [`$_`](../perlvar) — the default argument when `abs` is called
  without one