---
title: sass:math
---

{% render 'documentation/snippets/built-in-module-status' %}

{% markdown %}
## Variables
{% endmarkdown %}

{% function 'math.$e' %}
{% compatibility '1.25.0', false, null, false %}{% endcompatibility %}

{% markdown %}
The closest 64-bit floating point approximation of the [mathematical constant
*e*][].

[mathematical constant *e*]: https://en.wikipedia.org/wiki/E_(mathematical_constant)
{% endmarkdown %}

{% codeExample 'math-e', false %}
@debug math.$e; // 2.7182818285
===
@debug math.$e  // 2.7182818285
{% endcodeExample %}
{% endfunction %}

{% function 'math.$epsilon' %}
{% compatibility '1.55.0', false, null, false %}{% endcompatibility %}

{% markdown %}
The difference between 1 and the smallest 64-bit floating point number greater
than 1 according to floating-point comparisons. Because of Sass numbers' [10
digits of precision](/documentation/values/numbers), in many cases this will appear to
be 0.
{% endmarkdown %}
{% endfunction %}

{% function 'math.$max-number' %}
{% compatibility '1.55.0', false, null, false %}{% endcompatibility %}

{% markdown %}
The maximum finite number that can be represented as a 64-bit floating point
number.
{% endmarkdown %}

{% codeExample 'math-max-number', false %}
@debug math.$max-number; // 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
===
@debug math.$max-number  // 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
{% endcodeExample %}
{% endfunction %}

{% function 'math.$max-safe-integer' %}
{% compatibility '1.55.0', false, null, false %}{% endcompatibility %}

{% markdown %}
The maximum integer `n` such that both `n` and `n + 1` can be precisely
represented as a 64-bit floating-point number.
{% endmarkdown %}

{% codeExample 'math-max-safe-integer', false %}
@debug math.$max-safe-integer; // 9007199254740991
===
@debug math.$max-safe-integer  // 9007199254740991
{% endcodeExample %}
{% endfunction %}

{% function 'math.$min-number' %}
{% compatibility '1.55.0', false, null, false %}{% endcompatibility %}

{% markdown %}
The smallest positive number that can be represented as a 64-bit floating
point number. Because of Sass numbers' [10 digits of
precision](/documentation/values/numbers), in many cases this will appear to be 0.
{% endmarkdown %}
{% endfunction %}

{% function 'math.$min-safe-integer' %}
{% compatibility '1.55.0', false, null, false %}{% endcompatibility %}

{% markdown %}
The minimum integer `n` such that both `n` and `n - 1` can be precisely
represented as a 64-bit floating-point number.
{% endmarkdown %}

{% codeExample 'math-min-safe-integer', false %}
@debug math.$min-safe-integer; // -9007199254740991
===
@debug math.$min-safe-integer  // -9007199254740991
{% endcodeExample %}
{% endfunction %}

{% function 'math.$pi' %}
{% compatibility '1.25.0', false, null, false %}{% endcompatibility %}

{% markdown %}
The closest 64-bit floating point approximation of the [mathematical constant *π*][].

[mathematical constant *π*]: https://en.wikipedia.org/wiki/Pi
{% endmarkdown %}

{% codeExample 'math-pi', false %}
@debug math.$pi; // 3.1415926536
===
@debug math.$pi  // 3.1415926536
{% endcodeExample %}
{% endfunction %}

{% markdown %}
## Bounding Functions
{% endmarkdown %}

{% function 'math.ceil($number)', 'ceil($number)', 'returns:number' %}
{% markdown %}
Rounds `$number` up to the next highest whole number.
{% endmarkdown %}

{% codeExample 'math-ceil', false %}
@debug math.ceil(4); // 4
@debug math.ceil(4.2); // 5
@debug math.ceil(4.9); // 5
===
@debug math.ceil(4)  // 4
@debug math.ceil(4.2)  // 5
@debug math.ceil(4.9)  // 5
{% endcodeExample %}
{% endfunction %}

{% function 'math.clamp($min, $number, $max)', 'returns:number' %}
{% compatibility '1.25.0', false, null, false %}{% endcompatibility %}

{% markdown %}
Restricts `$number` to the range between `$min` and `$max`. If `$number` is
less than `$min` this returns `$min`, and if it's greater than `$max` this
returns `$max`.

`$min`, `$number`, and `$max` must have compatible units, or all be unitless.
{% endmarkdown %}

{% codeExample 'math-clamp', false %}
@debug math.clamp(-1, 0, 1); // 0
@debug math.clamp(1px, -1px, 10px); // 1px
@debug math.clamp(-1in, 1cm, 10mm); // 10mm
===
@debug math.clamp(-1, 0, 1) // 0
@debug math.clamp(1px, -1px, 10px) // 1px
@debug math.clamp(-1in, 1cm, 10mm) // 10mm
{% endcodeExample %}
{% endfunction %}

{% function 'math.floor($number)', 'floor($number)', 'returns:number' %}
{% markdown %}
Rounds `$number` down to the next lowest whole number.
{% endmarkdown %}

{% codeExample 'math-floor', false %}
@debug math.floor(4); // 4
@debug math.floor(4.2); // 4
@debug math.floor(4.9); // 4
===
@debug math.floor(4)  // 4
@debug math.floor(4.2)  // 4
@debug math.floor(4.9)  // 4
{% endcodeExample %}
{% endfunction %}

{% function 'math.max($number...)', 'max($number...)', 'returns:number' %}
{% markdown %}
Returns the highest of one or more numbers.
{% endmarkdown %}

{% codeExample 'math-max', false %}
@debug math.max(1px, 4px); // 4px

$widths: 50px, 30px, 100px;
@debug math.max($widths...); // 100px
===
@debug math.max(1px, 4px)  // 4px

$widths: 50px, 30px, 100px
@debug math.max($widths...)  // 100px
{% endcodeExample %}
{% endfunction %}

{% function 'math.min($number...)', 'min($number...)', 'returns:number' %}
{% markdown %}
Returns the lowest of one or more numbers.
{% endmarkdown %}

{% codeExample 'math-min', false %}
@debug math.min(1px, 4px); // 1px

$widths: 50px, 30px, 100px;
@debug math.min($widths...); // 30px
===
@debug math.min(1px, 4px)  // 1px

$widths: 50px, 30px, 100px
@debug math.min($widths...)  // 30px
{% endcodeExample %}
{% endfunction %}

{% function 'math.round($number)', 'round($number)', 'returns:number' %}
{% markdown %}
Rounds `$number` to the nearest whole number.
{% endmarkdown %}

{% codeExample 'math-round', false %}
@debug math.round(4); // 4
@debug math.round(4.2); // 4
@debug math.round(4.9); // 5
===
@debug math.round(4)  // 4
@debug math.round(4.2)  // 4
@debug math.round(4.9)  // 5
{% endcodeExample %}
{% endfunction %}

{% markdown %}
## Distance Functions
{% endmarkdown %}

{% function 'math.abs($number)', 'abs($number)', 'returns:number' %}
{% markdown %}
Returns the [absolute value][] of `$number`. If `$number` is negative, this
returns `-$number`, and if `$number` is positive, it returns `$number` as-is.

[absolute value]: https://en.wikipedia.org/wiki/Absolute_value
{% endmarkdown %}

{% codeExample 'math-abs', false %}
@debug math.abs(10px); // 10px
@debug math.abs(-10px); // 10px
===
@debug math.abs(10px) // 10px
@debug math.abs(-10px) // 10px
{% endcodeExample %}
{% endfunction %}

{% function 'math.hypot($number...)', 'returns:number' %}
{% compatibility '1.25.0', false, null, false %}{% endcompatibility %}

{% markdown %}
Returns the length of the *n*-dimensional [vector][] that has components equal
to each `$number`. For example, for three numbers *a*, *b*, and *c*, this
returns the square root of *a² + b² + c²*.

The numbers must either all have compatible units, or all be unitless. And
since the numbers' units may differ, the output takes the unit of the first
number.

[vector]: https://en.wikipedia.org/wiki/Euclidean_vector
{% endmarkdown %}

{% codeExample 'math-hypot', false %}
@debug math.hypot(3, 4); // 5

$lengths: 1in, 10cm, 50px;
@debug math.hypot($lengths...); // 4.0952775683in
===
@debug math.hypot(3, 4) // 5

$lengths: 1in, 10cm, 50px
@debug math.hypot($lengths...) // 4.0952775683in
{% endcodeExample %}
{% endfunction %}

{% markdown %}
## Exponential Functions
{% endmarkdown %}

{% function 'math.log($number, $base: null)', 'returns:number' %}
{% compatibility '1.25.0', false, null, false %}{% endcompatibility %}

{% markdown %}
Returns the [logarithm][] of `$number` with respect to `$base`. If `$base` is
`null`, the [natural log][] is calculated.

`$number` and `$base` must be unitless.

[logarithm]: https://en.wikipedia.org/wiki/Logarithm
[natural log]: https://en.wikipedia.org/wiki/Natural_logarithm
{% endmarkdown %}

{% codeExample 'math-log', false %}
@debug math.log(10); // 2.302585093
@debug math.log(10, 10); // 1
===
@debug math.log(10) // 2.302585093
@debug math.log(10, 10) // 1
{% endcodeExample %}
{% endfunction %}

{% function 'math.pow($base, $exponent)', 'returns:number' %}
{% compatibility '1.25.0', false, null, false %}{% endcompatibility %}

{% markdown %}
Raises `$base` [to the power of][] `$exponent`.

`$base` and `$exponent` must be unitless.

[to the power of]: https://en.wikipedia.org/wiki/Exponentiation
{% endmarkdown %}

{% codeExample 'math-pow', false %}
@debug math.pow(10, 2); // 100
@debug math.pow(100, math.div(1, 3)); // 4.6415888336
@debug math.pow(5, -2); // 0.04
===
@debug math.pow(10, 2) // 100
@debug math.pow(100, math.div(1, 3)) // 4.6415888336
@debug math.pow(5, -2) // 0.04
{% endcodeExample %}
{% endfunction %}

{% function 'math.sqrt($number)', 'returns:number' %}
{% compatibility '1.25.0', false, null, false %}{% endcompatibility %}

{% markdown %}
Returns the [square root][] of `$number`.

`$number` must be unitless.

[square root]: https://en.wikipedia.org/wiki/Square_root
{% endmarkdown %}

{% codeExample 'math-sqrt', false %}
@debug math.sqrt(100); // 10
@debug math.sqrt(math.div(1, 3)); // 0.5773502692
@debug math.sqrt(-1); // NaN
===
@debug math.sqrt(100) // 10
@debug math.sqrt(math.div(1, 3)) // 0.5773502692
@debug math.sqrt(-1) // NaN
{% endcodeExample %}
{% endfunction %}

{% markdown %}
## Trigonometric Functions
{% endmarkdown %}

{% function 'math.cos($number)', 'returns:number' %}
{% compatibility '1.25.0', false, null, false %}{% endcompatibility %}

{% markdown %}
Returns the [cosine][] of `$number`.

`$number` must be an angle (its units must be compatible with `deg`) or
unitless. If `$number` has no units, it is assumed to be in `rad`.

[cosine]: https://en.wikipedia.org/wiki/Trigonometric_functions#Right-angled_triangle_definitions
{% endmarkdown %}

{% codeExample 'math-cos', false %}
@debug math.cos(100deg); // -0.1736481777
@debug math.cos(1rad); // 0.5403023059
@debug math.cos(1); // 0.5403023059
===
@debug math.cos(100deg) // -0.1736481777
@debug math.cos(1rad) // 0.5403023059
@debug math.cos(1) // 0.5403023059
{% endcodeExample %}
{% endfunction %}

{% function 'math.sin($number)', 'returns:number' %}
{% compatibility '1.25.0', false, null, false %}{% endcompatibility %}

{% markdown %}
Returns the [sine][] of `$number`.

`$number` must be an angle (its units must be compatible with `deg`) or
unitless. If `$number` has no units, it is assumed to be in `rad`.

[sine]: https://en.wikipedia.org/wiki/Trigonometric_functions#Right-angled_triangle_definitions
{% endmarkdown %}

{% codeExample 'math-sin', false %}
@debug math.sin(100deg); // 0.984807753
@debug math.sin(1rad); // 0.8414709848
@debug math.sin(1); // 0.8414709848
===
@debug math.sin(100deg) // 0.984807753
@debug math.sin(1rad) // 0.8414709848
@debug math.sin(1) // 0.8414709848
{% endcodeExample %}
{% endfunction %}

{% function 'math.tan($number)', 'returns:number' %}
{% compatibility '1.25.0', false, null, false %}{% endcompatibility %}

{% markdown %}
Returns the [tangent][] of `$number`.

`$number` must be an angle (its units must be compatible with `deg`) or
unitless. If `$number` has no units, it is assumed to be in `rad`.

[tangent]: https://en.wikipedia.org/wiki/Trigonometric_functions#Right-angled_triangle_definitions
{% endmarkdown %}

{% codeExample 'math-tan', false %}
@debug math.tan(100deg); // -5.6712818196
@debug math.tan(1rad); // 1.5574077247
@debug math.tan(1); // 1.5574077247
===
@debug math.tan(100deg) // -5.6712818196
@debug math.tan(1rad) // 1.5574077247
@debug math.tan(1) // 1.5574077247
{% endcodeExample %}
{% endfunction %}

{% function 'math.acos($number)', 'returns:number' %}
{% compatibility '1.25.0', false, null, false %}{% endcompatibility %}

{% markdown %}
Returns the [arccosine][] of `$number` in `deg`.

`$number` must be unitless.

[arccosine]: https://en.wikipedia.org/wiki/Inverse_trigonometric_functions#Basic_properties
{% endmarkdown %}

{% codeExample 'math-acos', false %}
@debug math.acos(0.5); // 60deg
@debug math.acos(2); // NaNdeg
===
@debug math.acos(0.5) // 60deg
@debug math.acos(2) // NaNdeg
{% endcodeExample %}
{% endfunction %}

{% function 'math.asin($number)', 'returns:number' %}
{% compatibility '1.25.0', false, null, false %}{% endcompatibility %}

{% markdown %}
Returns the [arcsine][] of `$number` in `deg`.

`$number` must be unitless.

[arcsine]: https://en.wikipedia.org/wiki/Inverse_trigonometric_functions#Basic_properties
{% endmarkdown %}

{% codeExample 'math-asin', false %}
@debug math.asin(0.5); // 30deg
@debug math.asin(2); // NaNdeg
===
@debug math.asin(0.5) // 30deg
@debug math.asin(2) // NaNdeg
{% endcodeExample %}
{% endfunction %}

{% function 'math.atan($number)', 'returns:number' %}
{% compatibility '1.25.0', false, null, false %}{% endcompatibility %}

{% markdown %}
Returns the [arctangent][] of `$number` in `deg`.

`$number` must be unitless.

[arctangent]: https://en.wikipedia.org/wiki/Inverse_trigonometric_functions#Basic_properties
{% endmarkdown %}

{% codeExample 'math-atan', false %}
@debug math.atan(10); // 84.2894068625deg
===
@debug math.atan(10) // 84.2894068625deg
{% endcodeExample %}
{% endfunction %}

{% function 'math.atan2($y, $x)', 'returns:number' %}
{% compatibility '1.25.0', false, null, false %}{% endcompatibility %}

{% markdown %}
Returns the [2-argument arctangent][] of `$y` and `$x` in `deg`.

`$y` and `$x` must have compatible units or be unitless.

[2-argument arctangent]: https://en.wikipedia.org/wiki/Atan2
{% endmarkdown %}

{% funFact %}
`math.atan2($y, $x)` is distinct from `atan(math.div($y, $x))` because it preserves the
quadrant of the point in question. For example, `math.atan2(1, -1)` corresponds
to the point `(-1, 1)` and returns `135deg`. In contrast, `math.atan(math.div(1, -1))` and
`math.atan(math.div(-1, 1))` resolve first to `atan(-1)`, so both return `-45deg`.
{% endfunFact %}

{% codeExample 'math-atan2', false %}
@debug math.atan2(-1, 1); // 135deg
===
@debug math.atan2(-1, 1) // 135deg
{% endcodeExample %}
{% endfunction %}

{% markdown %}
## Unit Functions
{% endmarkdown %}

{% function 'math.compatible($number1, $number2)', 'comparable($number1, $number2)', 'returns:boolean' %}
{% markdown %}
Returns whether `$number1` and `$number2` have compatible units.

If this returns `true`, `$number1` and `$number2` can safely be [added][],
[subtracted][], and [compared][]. Otherwise, doing so will produce errors.

[added]: /documentation/operators/numeric
[subtracted]: /documentation/operators/numeric
[compared]: /documentation/operators/relational
{% endmarkdown %}

{% headsUp %}
The global name of this function
is <code>compa<strong>ra</strong>ble</code>, but when it was added to the
`sass:math` module the name was changed
to <code>compa<strong>ti</strong>ble</code> to more clearly convey what the
function does.
{% endheadsUp %}

{% codeExample 'math-compatible', false %}
@debug math.compatible(2px, 1px); // true
@debug math.compatible(100px, 3em); // false
@debug math.compatible(10cm, 3mm); // true
===
@debug math.compatible(2px, 1px)  // true
@debug math.compatible(100px, 3em)  // false
@debug math.compatible(10cm, 3mm)  // true
{% endcodeExample %}
{% endfunction %}

{% function 'math.is-unitless($number)', 'unitless($number)', 'returns:boolean' %}
{% markdown %}
Returns whether `$number` has no units.
{% endmarkdown %}

{% codeExample 'math-is-unitless', false %}
@debug math.is-unitless(100); // true
@debug math.is-unitless(100px); // false
===
@debug math.is-unitless(100)  // true
@debug math.is-unitless(100px)  // false
{% endcodeExample %}
{% endfunction %}

{% function 'math.unit($number)', 'unit($number)', 'returns:quoted string' %}
{% markdown %}
Returns a string representation of `$number`'s units.
{% endmarkdown %}

{% headsUp %}
This function is intended for debugging; its output format is not guaranteed
to be consistent across Sass versions or implementations.
{% endheadsUp %}

{% codeExample 'math-unitless', false %}
@debug math.unit(100); // ""
@debug math.unit(100px); // "px"
@debug math.unit(5px * 10px); // "px*px"
@debug math.unit(math.div(5px, 1s)); // "px/s"
===
@debug math.unit(100)  // ""
@debug math.unit(100px)  // "px"
@debug math.unit(5px * 10px)  // "px*px"
@debug math.unit(math.div(5px, 1s))  // "px/s"
{% endcodeExample %}
{% endfunction %}

{% markdown %}
## Other Functions
{% endmarkdown %}

{% function 'math.div($number1, $number2)', 'returns:number' %}
{% compatibility '1.33.0', false, null, false %}{% endcompatibility %}

{% markdown %}
Returns the result of dividing `$number1` by `$number2`.

Any units shared by both numbers will be canceled out. Units in `$number1`
that aren't in `$number2` will end up in the return value's numerator, and
units in `$number2` that aren't in `$number1` will end up in its denominator.
{% endmarkdown %}

{% headsUp %}
For backwards-compatibility purposes, this returns the *exact same result*
as [the deprecated `/` operator], including concatenating two strings with a
`/` character between them. However, this behavior will be removed
eventually and shouldn't be used in new stylesheets.

[the deprecated `/` operator]: /documentation/breaking-changes/slash-div
{% endheadsUp %}

{% codeExample 'math-div', false %}
@debug math.div(1, 2); // 0.5
@debug math.div(100px, 5px); // 20
@debug math.div(100px, 5); // 20px
@debug math.div(100px, 5s); // 20px/s
===
@debug math.div(1, 2)  // 0.5
@debug math.div(100px, 5px)  // 20
@debug math.div(100px, 5)  // 20px
@debug math.div(100px, 5s)  // 20px/s
{% endcodeExample %}
{% endfunction %}

{% function 'math.percentage($number)', 'percentage($number)', 'returns:number' %}
{% markdown %}
Converts a unitless `$number` (usually a decimal between 0 and 1) to a
percentage.
{% endmarkdown %}

{% funFact %}
This function is identical to `$number * 100%`.
{% endfunFact %}

{% codeExample 'math-percentage', false %}
@debug math.percentage(0.2); // 20%
@debug math.percentage(math.div(100px, 50px)); // 200%
===
@debug math.percentage(0.2)  // 20%
@debug math.percentage(math.div(100px, 50px))  // 200%
{% endcodeExample %}
{% endfunction %}

{% function 'math.random($limit: null)', 'random($limit: null)', 'returns:number' %}
{% markdown %}
If `$limit` is `null`, returns a random decimal number between 0 and 1.
{% endmarkdown %}

{% codeExample 'math-random', false %}
@debug math.random(); // 0.2821251858
@debug math.random(); // 0.6221325814
===
@debug math.random()  // 0.2821251858
@debug math.random()  // 0.6221325814
{% endcodeExample %}

{% markdown %}
* * *

If `$limit` is a number greater than or equal to 1, returns a random whole
number between 1 and `$limit`.
{% endmarkdown %}

{% headsUp false %}
{% markdown %}
`random()` ignores units in `$limit`. [This behavior is deprecated] and
`random($limit)` will return a random integer with the same units as the
`$limit` argument.

[This behavior is deprecated]: /documentation/breaking-changes/random-with-units
{% endmarkdown %}

{% codeExample 'math-random-warning', false %}
@debug math.random(100px); // 42
===
@debug math.random(100px)  // 42
{% endcodeExample %}
{% endheadsUp %}

{% codeExample 'math-random-limit', false %}
@debug math.random(10); // 4
@debug math.random(10000); // 5373
===
@debug math.random(10)  // 4
@debug math.random(10000)  // 5373
{% endcodeExample %}
{% endfunction %}