Calculateur de cofonction
Obtenez une fonction trigonométrique par sa partenaire à l'angle complémentaire : sin(30) vaut cos(60), soit 0,5, avec la cofonction et le complément indiqués en clair. Les six fonctions sont couvertes. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Fonction
- sin
- Angle
- 30
- Valeur
- 0,5
- Cofonction
- cos
- Angle (°)
- 30
- Angle complémentaire (degrés)
- 60
Envoyez un nom de fonction et un angle, et vous obtenez la cofonction utilisée, l'angle complémentaire et la valeur numérique arrondie à douze décimales.
Qu'est-ce qu'une cofonction
Les fonctions trigonométriques se présentent par paires complémentaires : sinus et cosinus, tangente et cotangente, sécante et cosécante. Le préfixe « co » signifie littéralement complémentaire : le cosinus est le sinus de l'angle complémentaire. Ce sont des identités exactes, pas des approximations : elles découlent directement de la géométrie du triangle rectangle, où les deux angles aigus sont toujours complémentaires et où le côté opposé à l'un est adjacent à l'autre.
Ainsi sin(30) vaut exactement cos(60), soit 0.5, et tan(75) vaut exactement cot(15). Ce calculateur prend un nom de fonction et un angle en degrés, calcule l'angle complémentaire 90 moins l'angle, y évalue la cofonction associée et renvoie la valeur arrondie à douze décimales, afin que le résultat publié soit stable à l'octet près d'une machine à l'autre. La réponse reprend la fonction, sa cofonction, votre angle et le complément, ce qui rend chaque résultat auto-descriptif dans un journal ou une piste d'audit.
Entrées, validation et cas limites
Deux familles de cas limites reçoivent une attention particulière. D'abord, les fonctions qui explosent : la tangente et la sécante sont indéfinies aux multiples impairs de 90 degrés, car le cosinus s'y annule, et la cotangente et la cosécante sont indéfinies aux multiples de 180 degrés, car le sinus s'y annule. Le calculateur détecte ces angles explicitement et les rejette avec un message indiquant que la fonction y est indéfinie, plutôt que de renvoyer un flottant énorme, Infinity ou NaN qui empoisonnerait tous les calculs en aval.
Ensuite, les angles ne sont pas bornés à 0-90 : les identités de cofonction valent pour tout angle réel, donc sin(120) est correctement traité comme cos(-30), et les deux sens passent par le même chemin de code. La validation a lieu une seule fois, à la frontière, exactement là où un pipeline automatisé en a besoin.
Pourquoi calculer via le complément
Si l'on peut calculer sin(theta) directement, pourquoi passer par cos(90 - theta) ? Trois raisons pratiques. D'abord, la pédagogie : les identités de cofonction sont un sujet d'examen classique, et voir sin(53) renvoyé comme cos(37) avec le complément explicité rend l'identité concrète au lieu de l'apprendre par cœur.
Ensuite, la simplification : réécrire une expression pour que toutes ses fonctions partagent une même famille — tout en sinus, ou tout en tangentes — est une étape standard pour résoudre des équations trigonométriques et démontrer des identités, et ce point de terminaison effectue cette réécriture numériquement à la demande.
Enfin, les contraintes matérielles et historiques : certaines bibliothèques embarquées et anciennes tables ne mettent en œuvre qu'une fonction par paire, et vérifier qu'une table de sinus seuls produit le bon cosinus via le complément est exactement le contrôle qu'effectue ce calculateur. Le calcul en lui-même est trivial, mais le faire via un point de terminaison strict et validé garantit la même réponse à chaque fois : déterministe, sans appel réseau, sans aléa ni état conservé.
Cas d’usage
Réécrire une expression dans une seule famille
Convertissez les cosinus en sinus pour simplifier une équation trigonométrique : cos(42) revient comme sin(48) avec la valeur numérique associée.
Questions fréquentes
Combien cela coûte-t-il ?
Son exécution est aussi gratuite et illimitée dans votre navigateur sur cette page.
Quelles fonctions sont prises en charge ?
Les six fonctions standard : sin, cos, tan, cot, sec et csc, insensibles à la casse.
Qu'est-ce que la valeur de cofonction exactement ?
Chaque fonction est évaluée via son identité complémentaire : sin(theta) = cos(90 - theta), tan(theta) = cot(90 - theta), sec(theta) = csc(90 - theta), et les trois mêmes paires en sens inverse.
L'angle doit-il être compris entre 0 et 90 ?
Non. Les identités valent pour tout angle fini en degrés, donc sin(120) est correctement calculé comme cos(-30).
Mes données sont-elles conservées ?
Non. Le nom de la fonction et l'angle servent au calcul puis sont écartés ; seul le résultat 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/cofunction \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"function":"sin","angle":30}'const res = await fetch("https://api.kit.forhosting.com/math/cofunction", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"function": "sin",
"angle": 30
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/cofunction",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"function": "sin",
"angle": 30
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/cofunction", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"function":"sin","angle":30}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"function":"sin","angle":30}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/cofunction", 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
{
"function": "sin",
"angle": 30
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.cofunction",
"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
Le calculateur de cofonction évalue une fonction trigonométrique pour tout angle en degrés en passant par sa cofonction associée à l'angle complémentaire : sin(theta) égale cos(90 - theta), tan(theta) égale cot(90 - theta), et sec(theta) égale csc(90 - theta) — chaque paire fonctionnant dans les deux sens. Les noms de fonction non pris en charge et les angles non finis sont rejetés avec une erreur invalid_input claire, et les angles où la fonction est indéfinie — tan à 90 degrés, csc à 0 — échouent explicitement au lieu de renvoyer Infinity ou NaN. Le même module s'exécute gratuitement dans votre navigateur sur cette page ; vous ne payez que $0.002 par requête via l'API.
Qu'est-ce qu'une cofonction
Deux angles sont complémentaires lorsque leur somme vaut 90 degrés, et les identités de cofonction affirment que chaque fonction d'un angle égale sa cofonction associée du complément — sin(theta) = cos(90 - theta), cos(theta) = sin(90 - theta), tan(theta) = cot(90 - theta), cot(theta) = tan(90 - theta), sec(theta) = csc(90 - theta) et csc(theta) = sec(90 - theta).
Entrées, validation et cas limites
L'API accepte deux champs : 'function', l'un des six noms sin, cos, tan, cot, sec ou csc (insensible à la casse, avec les alias fn et func), et 'angle', un nombre fini de degrés (avec les alias theta et degrees). Tout le reste est rejeté avant tout calcul : un nom de fonction inconnu, un champ manquant, un angle NaN ou Infinity produisent une erreur invalid_input qui nomme le champ fautif et la valeur attendue, de sorte qu'une erreur côté client ne se transforme jamais en silencieuses données numériques erronées.
Pourquoi calculer via le complément
Le module identique alimente le calculateur gratuit de cette page, donc le navigateur et l'API ne peuvent jamais diverger, et les appels API coûtent $0.002 par requête sans supplément à l'unité — assez bon marché pour valider chaque appel d'un pipeline plutôt que d'en échantillonner quelques-uns.
Cas d'intégration
Vérifier une identité de cofonction
Vérifiez numériquement que sin(30) égale cos(60) : envoyez function=sin et angle=30, puis lisez la valeur calculée via l'angle complémentaire.
Valider des angles dans un pipeline
Faites passer chaque angle calculé par l'API : les cas indéfinis comme tan(90) sont rejetés explicitement au lieu de propager Infinity en aval.
Questions techniques
Que se passe-t-il aux angles où la fonction est indéfinie ?
Les angles comme tan(90) ou csc(0) sont rejetés avec une erreur invalid_input indiquant que la fonction y est indéfinie — jamais Infinity ou NaN.