Vitesse angulaire finale
Une roue qui tourne à 10 rad/s et gagne 2 rad/s chaque seconde atteint 20 rad/s au bout de 5 secondes : la calculatrice ajoute αt à ω₀ et détaille chaque étape. Un α négatif décrit un freinage. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Vitesse angulaire ω0
- 10
- Alpha
- 2
- T
- 5
- Oméga
- 20
- Vitesse angulaire finale
- 20
- Équation
- ω = 10 + (2) · (5) = 20
Un calculateur de vitesse angulaire finale applique la première équation de la cinématique rotationnelle à accélération angulaire constante : la vitesse angulaire finale ω est égale à la vitesse angulaire initiale ω₀ plus l’accélération angulaire α multipliée par le temps écoulé t.
Ce que ω = ω₀ + αt signifie en cinématique rotationnelle
Sous accélération angulaire constante, la vitesse angulaire d’un corps rigide change à un rythme fixe. Si la vitesse angulaire au début d’un intervalle est ω₀ et que l’accélération angulaire reste α pendant une durée t, la vitesse angulaire à la fin de cet intervalle est exactement ω égal à ω₀ plus α fois t. C’est l’analogue rotationnel de l’équation linéaire SUVAT v égal à u plus a fois t : elle ne relie que la vitesse angulaire, l’accélération angulaire et le temps, sans exiger de connaître le déplacement angulaire.
La vitesse angulaire initiale ω₀ peut être positive ou négative selon le sens positif de rotation choisi ; l’accélération angulaire α peut de même être positive (accélération du spin dans le sens positif) ou négative (freinage ou accélération opposée à l’axe positif). Le temps t est la durée écoulée de l’intervalle et doit être non négatif pour ce calculateur — un t négatif inverserait la lecture causale de « après le temps t » que les apprenants recherchent lorsqu’ils consultent un calculateur de vitesse angulaire finale.
Lorsque t est nul, il n’y a pas d’intervalle, donc ω est égal à ω₀ par définition. Lorsque α est nul, la rotation est uniforme et la vitesse angulaire ne change jamais. L’outil ne convertit pas les unités : si ω₀ est en radians par seconde et α en radians par seconde carrée, t doit être en secondes pour que α fois t ait la même unité que ω₀ et que leur somme soit une vitesse angulaire cohérente.
La même règle s’applique dans tout système cohérent — tours par seconde avec l’accélération angulaire correspondante, ou degrés par seconde après conversion cohérente — afin que les appelants conservent un seul système de bout en bout plutôt que de mélanger rad/s et RPM au milieu de l’équation sans conversion.
Cas d’usage
Contrôles de devoirs de cinématique rotationnelle
Les étudiants saisissent ω₀, α et t issus de problèmes de manuel à accélération angulaire constante et comparent ω écrite à la main et les étapes de substitution à un résultat déterministe avant de rendre.
Tests unitaires pour aides à la rotation dans les simulateurs
Générez des cas connus d’accélération du spin, de freinage angulaire et de temps nul, plus des rejets délibérés d’entrée non numérique et de temps négatif, comme valeurs attendues de katas de code pour jeux ou moteurs physiques.
Précontrôle de laboratoire avant modèles de spin multi-segments
Les pipelines valident d’abord la vitesse angulaire finale à partir de ω₀, α et t, puis ne branchent vers le déplacement angulaire ou des trajectoires multi-intervalles que lorsque le contrôle d’intervalle unique concorde avec les notes de laboratoire.
Questions fréquentes
Comment calculer la vitesse angulaire finale à partir de ω₀, α et t ?
Gardez les trois dans un seul système d’unités cohérent (p. ex. rad/s, rad/s², s).
Que se passe-t-il si j’envoie une entrée non numérique ?
Les champs manquants, chaînes vides, mots et valeurs non finies sont rejetés et ne sont pas facturés.
Pourquoi le temps négatif est-il rejeté ?
La durée écoulée ne peut pas revenir en arrière dans ce modèle « après le temps t ». Utilisez un t non négatif ; un temps nul renvoie correctement ω égal à ω₀.
α ou ω₀ peuvent-ils être négatifs ?
Seul le temps est contraint à être non négatif.
Faut-il connaître l'angle parcouru ?
Non. Cette relation ne lie que la vitesse angulaire, l'accélération angulaire et le temps : l'angle balayé n'est pas nécessaire. Si c'est cet angle que vous cherchez, utilisez le calculateur de déplacement angulaire.
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/mech/angular-velocity-final \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"omega0":10,"alpha":2,"t":5}'const res = await fetch("https://api.kit.forhosting.com/mech/angular-velocity-final", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"omega0": 10,
"alpha": 2,
"t": 5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/mech/angular-velocity-final",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"omega0": 10,
"alpha": 2,
"t": 5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/mech/angular-velocity-final", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"omega0":10,"alpha":2,"t":5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"omega0":10,"alpha":2,"t":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/mech/angular-velocity-final", 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
{
"omega0": 10,
"alpha": 2,
"t": 5
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "mech.angular_velocity_final",
"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.
Limites
max_abs | 1000000000000 |
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
Saisissez trois nombres finis —omega0 (taux angulaire initial), alpha (accélération angulaire constante) et t (temps non négatif)— et l’outil renvoie la vitesse angulaire finale arrondie, une équation de substitution lisible, un court message de physique et une liste ordonnée d’étapes que vous pouvez coller dans des contrôles de devoirs ou des tests automatisés. Une entrée non numérique et un temps négatif sont rejetés avec une erreur claire invalid_input car le modèle exige des nombres finis et la durée écoulée ne peut pas revenir en arrière ; un temps nul renvoie correctement ω égal à ω₀. Le freinage angulaire (alpha négatif), le sens de rotation inverse et la rotation uniforme (alpha égal à zéro) sont pris en charge via des valeurs signées de omega0 et alpha. Étudiants, tuteurs et ingénieurs qui travaillent déjà dans un système d’unités cohérent —radians par seconde et radians par seconde carrée, ou tout ensemble parallèle— obtiennent le même JSON déterministe depuis l’exécuteur gratuit du navigateur et depuis l’API prépayée, sans appels réseau, sans graines aléatoires et sans dépendance à l’horloge système. Le tarif est un forfait de $0.002 par requête API réussie ; une validation échouée n’est jamais facturée.
Comment appeler l’API et ce qu’elle renvoie
Envoyez un corps JSON avec trois nombres finis obligatoires : omega0 (alias omega_i, omega_initial, w0 et initial_angular_velocity), alpha (alias angular_acceleration et ang_accel) et t (alias time et duration). Les valeurs absolues de omega0 et alpha doivent rester dans la limite publiée d’un billion ; t doit être compris entre zéro et un billion inclus. Une validation échouée — champs manquants, valeurs non finies ou non numériques, valeurs hors limites absolues, produit non fini, vitesse angulaire finale hors plafond absolu, ou t négatif — renvoie invalid_input et n’est jamais facturée. Le tarif est un forfait de $0.002 par requête réussie, avec l’unité item. Préférez envoyer des nombres JSON lorsque vous contrôlez le client ; les nombres en chaîne ne sont acceptés que s’ils correspondent à un motif numérique fini strict, ce qui conserve les chemins de collage de formulaires de devoirs sans accepter de texte arbitraire comme des mots ou des chaînes vides.
Conseils pratiques, limites et recherches associées
Utilisez un système d’unités cohérent pour les trois entrées avant d’appeler ; cette page ne convertit pas les unités entre rad/s et RPM. Cette page vise les personnes qui recherchent un calculateur de vitesse angulaire finale, omega égal à omega zéro plus alpha t, ou la cinématique rotationnelle en ligne ; ce n’est pas une suite SUVAT rotationnelle complète qui résout aussi le déplacement angulaire ou le temps avec des inconnues mixtes, ni un intégrateur d’accélération variable, ni un outil de vitesse finale linéaire (utilisez le calculateur linéaire v égal à u plus a t pour la translation). Préférez cette capacité lorsque vous connaissez déjà la vitesse angulaire initiale, l’accélération angulaire constante et le temps écoulé et n’avez besoin que du taux angulaire final ; si le problème source donne le déplacement angulaire au lieu du temps, réarrangez d’abord une autre équation cinématique rotationnelle. Gardez omega0, alpha et t dans la plage absolue publiée afin que le produit alpha fois t et la somme omega0 plus alpha t restent finis en double précision IEEE, tant sur le Worker que dans le navigateur. Associez délibérément des exemples de cours : omega0 égal à dix, alpha égal à deux, t égal à cinq donne omega égal à vingt ; omega0 égal à vingt, alpha égal à moins quatre, t égal à trois produit un freinage angulaire jusqu’à huit ; omega0 égal à cinq, alpha égal à zéro, t égal à douze illustre la rotation uniforme ; et un alpha non numérique ou t égal à moins un montre le chemin strict invalid_input. En enseignant les conventions de sens, alignez le signe de alpha sur le sens positif de rotation choisi pour omega0 plutôt que de traiter « ralentir » comme toujours négatif sans définir les axes. Les tâches en échec qui renvoient invalid_input ne consomment pas le solde prépayé, ce qui maintient les scripts exploratoires peu coûteux lorsque les apprenants passent délibérément une entrée incorrecte. Les vérifications aller-retour sont simples : recalculez omega0 plus alpha fois t à la main et confirmez l’égalité avec l’omega publiée dans le même arrondi à douze décimales utilisé dans la réponse.
Questions techniques
Combien coûte le calculateur de vitesse angulaire finale ?
L’outil du navigateur est gratuit. Les requêtes API utilisent le solde KIT prépayé à $0.002 par appel réussi ; une entrée invalide n’est pas facturée.