The topic you requested is included in another documentation set. For convenience, it's displayed below. Choose Switch to see the topic in its original location.
We recommend using Visual Studio 2017

# acos, acosf, acosl

Visual Studio 2015

The latest version of this topic can be found at acos, acosf, acosl.

Calculates the arccosine.

## Syntax

```double acos(
double x
);
float acos(
float x
);   // C++ only
long double acos(
long double x
);   // C++ only
float acosf(
float x
);
long double acosl(
long double x
);

```

#### Parameters

`x`
Value between –1 and 1, for which to calculate the arccosine (the inverse cosine).

## Return Value

The `acos` function returns the arccosine of `x` in the range 0 to π radians.

By default, if `x` is less than –1 or greater than 1, `acos` returns an indefinite.

InputSEH ExceptionMatherr Exception
± ∞`INVALID``_DOMAIN`
± QNAN,INDnone`_DOMAIN`
|x|>1`INVALID``_DOMAIN`

## Remarks

Because C++ allows overloading, you can call overloads of `acos` that take and return `float` and `long double` types. In a C program, `acos` always takes and returns a `double`.

## Requirements

`acos`, `acosf`, `acosl`<math.h><errno.h>

## Example

This program prompts for a value in the range -1 to 1. Input values outside this range produce `_DOMAIN` error messages. If a valid value is entered, the program prints the arcsine and the arccosine of that value.

```// crt_asincos.c
// arguments: 0

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main( int ac, char* av[] )
{
double  x,
y;
errno_t err;

// argument checking
if (ac != 2)
{
fprintf_s( stderr, "Usage: %s <number between -1 and 1>\n",
av[0]);
return 1;
}

// Convert argument into a double value
if ((err = sscanf_s( av[1], "%lf", &x )) != 1)
{
fprintf_s( stderr, "Error converting argument into ",
"double value.\n");
return 1;
}

// Arcsine of X
y = asin( x );
printf_s( "Arcsine of %f = %f\n", x, y );

// Arccosine of X
y = acos( x );
printf_s( "Arccosine of %f = %f\n", x, y );
}

```
```Arcsine of 0.000000 = 0.000000
Arccosine of 0.000000 = 1.570796

```

## .NET Framework Equivalent

System::Math::Acos