Calculateur d'arcocoseno en ligne
L'arc cosinus de 0,5 vaut 60 degrés, soit 1,047197551197 radian. Saisissez une valeur entre -1 et 1 et obtenez l'unique angle compris entre 0 et 180 degrés qui a ce cosinus, en radians, en degrés ou les deux. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Valeur
- 0,5 both
- Radians
- 1,0471975512
- Degrés
- 60
Le calculateur d'arcocoseno calcule le cosinus inverse de toute valeur comprise entre -1 et 1 et renvoie l'angle correspondant en radians, en degrés ou les deux. Il répond à la question que la trigonométrie pose le plus souvent : le cosinus m'a donné ce nombre — quel angle l'a produit ? Le résultat se situe toujours sur la branche principale, de 0 à π radians (0 à 180 degrés), convention que tout manuel, toute formule de navigation et toute dérivation physique suppose.
Ce que l'arcocoseno calcule réellement
Le cosinus associe un angle à un nombre compris entre -1 et 1 ; l'arcocoseno fait le trajet inverse : il prend ce nombre et vous rend l'angle. Comme le cosinus n'est pas bijectif — une infinité d'angles partagent le même cosinus — l'inverse est définie sur une seule branche principale : arccos(x) renvoie toujours l'unique angle de [0, π] radians, c'est-à-dire de 0 à 180 degrés, dont le cosinus vaut x.
Ainsi arccos(1) vaut 0, arccos(0) vaut π/2 (90 degrés), arccos(0.5) vaut π/3 (60 degrés) et arccos(-1) vaut π (180 degrés). Ce calculateur renvoie cette valeur principale en pleine précision double et arrondit le résultat publié à douze décimales afin que les résultats soient stables à l'octet près d'une machine à l'autre.
Cette rigueur compte lorsque l'entrée provient d'un calcul plus long : une formule de distance ou un produit scalaire qui a dérivé d'un cheveu au-delà de 1 à cause des arrondis doit être détecté et borné délibérément par vous, pas masqué.
Radians, degrés ou les deux
Le paramètre unit contrôle la forme de la réponse. Passez 'radians' et vous obtenez uniquement la mesure en radians, celle qu'attendent l'analyse, la physique et la plupart des langages de programmation — Math.acos en JavaScript, math.acos en Python et acos en C parlent tous nativement en radians. Passez 'degrees' et vous obtenez l'angle en degrés, l'unité qu'utilisent réellement les géomètres, les navigateurs et la géométrie scolaire.
Passez 'both' — la valeur par défaut — et vous obtenez les deux représentations dans une seule réponse, converties par l'identité exacte degrees = radians × 180 / π, ce qui évite un second appel quand un rapport a besoin d'une unité et le code derrière de l'autre. Choisir l'unité à la source évite le bogue classique de double conversion, où une valeur en degrés arrondie est reconvertie en radians et dérive de la vraie réponse.
Si vous omettez entièrement le paramètre, la valeur par défaut 'both' s'applique, de sorte que la requête la plus simple possible — juste une valeur — renvoie déjà une réponse complète : l'écho de votre entrée plus l'angle dans chaque unité. Chaque réponse renvoie en écho la valeur envoyée, ce qui rend les résultats auto-descriptifs lorsqu'ils sont consignés ou archivés pour un audit.
Où il s'insère et combien il coûte
Le cosinus inverse apparaît partout où un angle doit être retrouvé à partir d'un rapport : transformer un produit scalaire en angle entre deux vecteurs, extraire l'angle au centre entre deux points d'une sphère avec la formule de haversine, résoudre des triangles avec la loi des cosinus, calculer des angles d'articulations en robotique, ou inverser une similarité cosinus dans un classement de recherche.
Dans tous ces cas, l'arithmétique est triviale mais la validation ne l'est pas : la dérive des flottants peut pousser une entrée mathématiquement valide jusqu'à 1.0000000002, et une bibliothèque qui renvoie NaN laisse cette erreur se propager silencieusement à chaque étape en aval. Ce point de terminaison échoue vite à la place, de sorte que l'erreur apparaît à la frontière où elle a été commise.
Cas d’usage
Angle entre deux vecteurs
Calculez le produit scalaire de deux vecteurs normalisés et passez-le à arccos pour retrouver l'angle entre eux en degrés ou en radians.
Distance orthodromique sur Terre
Appliquez la loi sphérique des cosinus entre deux points lat/lon et inversez le terme en cosinus pour obtenir l'angle au centre de l'itinéraire.
Questions fréquentes
Combien cela coûte-t-il ?
L'exécution dans votre navigateur sur cette page est également gratuite et illimitée.
Quelles entrées sont acceptées ?
Tout nombre fini de -1 à 1 inclus.
Pourquoi 1.2 est-il rejeté si arccos existe dans les nombres complexes ?
Parce que les angles réels ne produisent jamais |cos| > 1. Ce calculateur ne renvoie que des angles réels : une entrée hors domaine est donc une erreur, pas un résultat complexe.
Quel angle renvoie-t-il quand plusieurs partagent un cosinus ?
Toujours la valeur principale : l'unique angle de [0, π] radians, soit 0 à 180 degrés, ayant ce cosinus.
Quelles unités puis-je obtenir ?
Radians, degrés ou les deux à la fois. La valeur par défaut est 'both', et la valeur en degrés est dérivée exactement comme radians × 180 / π.
Mon entrée est-elle stockée ?
Non. La valeur sert au calcul puis est détruite ; seul l'angle calculé est renvoyé.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/math/arccos \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":0.5}'const res = await fetch("https://api.kit.forhosting.com/math/arccos", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 0.5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/arccos",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 0.5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/arccos", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":0.5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":0.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/arccos", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"value": 0.5
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.arccos",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Envoyez une valeur hors du domaine valide et l'API la rejette avec une erreur invalid_input explicite au lieu de renvoyer NaN, afin que les pipelines automatisés échouent bruyamment et tôt. Exactement le même code s'exécute gratuitement dans votre navigateur sur cette page ; vous ne payez $0.002 par requête que lorsque vous l'appelez via l'API.
Ce que l'arcocoseno calcule réellement
L'entrée doit être un nombre fini dans l'intervalle fermé [-1, 1] ; toute valeur en dehors n'a pas d'arcocoseno réel — le cosinus d'un angle réel ne peut jamais atteindre 1.1 ni -2 — et le calculateur le signale par une erreur invalid_input nommant la valeur fautive au lieu d'émettre silencieusement NaN.
Où il s'insère et combien il coûte
Il s'exécute comme un calcul pur sur notre edge mondial sans rien stocker après la réponse, et le module identique alimente le calculateur gratuit de cette page, de sorte que le navigateur et l'API ne peuvent jamais être en désaccord. L'usage dans le navigateur est gratuit et illimité ; les appels API coûtent $0.002 par requête sans surcoût par unité, ce qui rend pratique la validation de chaque appel d'un pipeline plutôt que l'échantillonnage de quelques-uns.
Cas d'intégration
Détecter tôt la dérive des flottants
Envoyez chaque cosinus calculé à l'API : les entrées qui dérivent juste au-delà de 1 sont rejetées bruyamment au lieu de propager NaN en aval.