Learn C++

Computer Science

Returns the absolute value of the floating point argument.

Returns the absolute value of the floating point argument.

## Syntax

```cpp
std:fabs(n)
```

## Example 1

Use `fabs()` to return the absolute value of `-6.5`:

```cpp
#include <iostream>
#include <cmath>

int main () {
  std::cout << std::fabs(-6.5) << "\n";
}

// Output: 6.5
```


Returns the absolute value of the argument.

abs()

Returns the absolute value of the argument.

## Syntax

```py
abs(n)
```

## Example 1

Use `abs()` to return the absolute value of `-6.5`:

```cpp
#include <iostream>
#include <cmath>

int main () {
  std::cout << std::abs(-6.5) << "\n";
}

// Output: 6.5
```


Returns the inverse cosine of the argument in radians.

acos()

Returns the inverse cosine of the argument in radians.

## Syntax

```py
acos(n)
```

## Example 1

Use `acos()` to return the inverse cosine of `0.0`:

```cpp
#include <iostream>
#include <cmath>

int main() {
  double x = 0.0;
  double result;

  result = std::acos(x);

  std::cout << result << " radians" << "\n";
  // Output: 1.5708 radians
}
```


Returns the inverse sine of the argument in radians.

asin()

Returns the inverse sine of the argument in radians.

## Syntax

```py
asin(n)
```

## Example 1

Use `asin()` to return the inverse sine of `0.0`:

```cpp
#include <iostream>
#include <cmath>

int main() {
  double x = 0.0;
  double result;

  result = std::asin(x);

  std::cout << result << " radians" << "\n";
  // Output: 1.5708 radians
}
```


Returns the inverse tangent of the argument in radians.

atan()

Returns the inverse tangent of the argument in radians.

## Syntax

```py
atan(n)
```

## Example 1

Use `atan()` to return the inverse tangent of `0.0`:

```cpp
#include <iostream>
#include <cmath>

int main() {
  double x = 0.0;
  double result;

  result = std::atan(x);

  std::cout << result << " radians" << "\n";
  // Output: 1.5708 radians
}
```


cbrt()

Returns the cube root of the argument.

## Syntax

```cpp
std::cbrt(n)
```

## Example 1

Use `cbrt()` to return the cube root of `27`:

```cpp
#include <iostream>
#include <cmath>

int main() {
  double x = 27;
  double result;

  result = std::cbrt(x);

  std::cout << "The cube root of " << x << " is " << result << "\n";
  // Output: The cube root of 27 is 3
}
```


Returns the next whole number that is greater than or equal to the argument.

ceil()

Returns the next whole number that is greater than or equal to the argument.

## Syntax

```cpp
std::ceil(n);
```

Argument must be a `double`/`float`/`long double`, and the return value will be same type.

## Example

Use `ceil()` function to round up the double `12.3456`:

```cpp
#include <iostream>
#include <cmath>

int main() {
  double n = 12.3456;
  double result;

  result = std::ceil(n);

  std::cout << "The result is " << result << "!\n";
  // Output: The result is 13!
}
```


Returns the cosine of an argument given in radians.

cos()

Returns the cosine of an argument given in radians.

## Syntax

```cpp
std::cos(n)
```

## Example 1

Use `cos()` to return the cosine of `3.1416` radians:

```cpp
#include <iostream>
#include <cmath>

int main() {
  double x = 3.1416;
  double result;

  result = std::cos(x);

  std::cout << "The cosine of " << x << " radians is " << result << "\n";
  // Output: The cosine of 3.1416 radians is -1
}
```


Returns the hyperbolic cosine of an argument given in radians.

cosh()

Returns the hyperbolic cosine of an argument given in radians.

## Syntax

```cpp
std::cosh(n)
```

## Example 1

Use `cosh()` to return the hyperbolic cosine of `0.0` radians:

```cpp
#include <iostream>
#include <cmath>

int main() {
  double x = 0.0;
  double result;

  result = std::cosh(x);

  std::cout << "The hyperbolic cosine of " << x << " radians is " << result << "\n";
  // Output: The hyperbolic cosine of 0 radians is 1
}
```


Returns e raised to the power of the argument.

exp()

`exp()` returns the base-_e_ exponential function of the argument, which is _e_ raised to the power of the argument.

The number _e_, also known as Euler's number, is a mathematical constant approximately equal to 2.71828 and the base of the natural logarithm.

The `cmath` library must be added to the top of the file with `#include <cmath>`.

## Syntax

Returns *e*ⁿ:

```cpp
std::exp(n)
```

## Example

Use `exp()` to return the value of *e*³):

```cpp
double result;

result = std::exp(3);
```

## Codebyte Example

Use `exp()` to return the value of _e_ (*e*¹):

```codebyte/cpp
#include <iostream>
#include <cmath>

int main() {
  double x = 1;
  double result;

  result = std::exp(x);

  std::cout << "e^" << x << " = " << result << "\n";
  // Output: e^1 = 2.71828
}
```


Returns e raised to the power of the argument minus 1.

expm1()

Returns _e_ raised to the power of the argument minus 1. For small magnitudes of x `expm1(x)` may be more accurate than `exp(x)-1`.

The number _e_, also known as Euler's number, is a mathematical constant approximately equal to 2.71828 and the base of the natural logarithm.

The `cmath` library must be added to the top of the file with `#include <cmath>`.

## Syntax

Returns *e*ⁿ - 1:

```cpp
std::expm1(n)
```

## Example

Use `expm1()` to return the value of *e*³-1:

```cpp
double result;

result = std::expm1(3);
```

## Codebyte Example

Use `expm1()` to return the value of _e_-1 (*e*¹-1):

```codebyte/cpp
#include <iostream>
#include <cmath>

int main() {
  double x = 1;
  double result;

  result = std::expm1(x);

  std::cout << "e^" << x << "-1 = " << result << "\n";
  // Output: e^1-1 = 1.71828
}
```


fabs()

Returns the positive difference between two arguments.

fdim()

Returns the positive difference between two arguments.

## Syntax

`cmath` library must be added at the top of the file.

```cpp
std:fdim(x, y)
```

If the first argument is greater than the second argument `fdim()` returns the first argument minus the second argument, otherwise it returns zero.

## Example

```cpp
double result1;
double result2;

result1 = std::fdim(6, 2); // 4
result2 = std::fdim(4, 8); // 0
```

## Codebyte Example

Use `fdim()` to return the positive difference between `8` and `5`:

```codebyte/cpp
#include <iostream>
#include <cmath>

int main () {
  double x = 8;
  double y = 5;
  double result1;
  double result2;

  result1 = std::fdim(x, y);
  result2 = std::fdim(y, x);

  std::cout << result1 << "\n";
  std::cout << result2 << "\n";
}
```


Returns the first whole number that is less than or equal to the argument.

floor()

The `floor()` function returns the first whole number that is less than or equal to the argument.

## Syntax

The `cmath` library must be added at the top of the file.

```cpp
std::floor(n);
```

Argument must be a `double`/`float`/`long double`, and the return value will be the same type.

## Example

```cpp
double result;

result = std::floor(n);
```

## Codecademy Example

Use `floor()` to round down the double `12.3456`:

```codebyte/cpp
#include <iostream>
#include <cmath>

int main() {
  double n = 12.3456;
  double result;

  result = std::floor(n);

  std::cout << "The result is " << result << "!\n";
  // Output: The result is 12!
}
```


fabs()

Syntax

Example 1

Contributors

Learn C++ on Codecademy

Learn C++

Computer Science

Contributors

Languages

Subjects

Languages