ForHosting KIT · Ingénierie et construction

Déplacement angulaire

Un corps qui tourne à 10 rad/s avec une accélération angulaire de 2 rad/s² balaie 75 radians en 5 secondes : la calculatrice additionne ω₀t et ½αt² et montre chaque étape. Elle gère aussi freinage et rotation uniforme. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Exemple résolu

Si vous saisissez

Vitesse angulaire ω0: 10
Alpha: 2
T: 5

Vous obtenez

Thêta: 75
Déplacement angulaire: 75
Équation: θ = (10) · (5) + ½ · (2) · (5)² = 75

Un calculateur de déplacement angulaire applique l'équation de la cinématique rotationnelle à accélération angulaire constante : le déplacement angulaire θ est égal à la vitesse angulaire initiale ω₀ multipliée par le temps t plus la moitié de l'accélération angulaire α multipliée par t au carré.

Ce que signifie θ = ω₀t + ½αt² en cinématique rotationnelle

Sous accélération angulaire constante, la position angulaire d'un corps rigide évolue selon une loi quadratique en temps. Si la vitesse angulaire au début d'un intervalle est ω₀ et que l'accélération angulaire reste α pendant une durée t, le déplacement angulaire sur cet intervalle est exactement θ égal à ω₀ fois t plus la moitié de α fois t au carré.

C'est l'analogue rotationnel de l'équation linéaire SUVAT s égal à u t plus la moitié de a t au carré : elle relie déplacement angulaire, vitesse angulaire initiale, accélération angulaire et temps sans exiger la vitesse angulaire finale. La vitesse angulaire initiale ω₀ peut être positive ou négative selon le sens positif de rotation choisi ; l'accélération angulaire α peut également être positive (accélération 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 déplacement angulaire. Lorsque t vaut zéro, il n'y a pas d'intervalle, donc θ vaut zéro par définition. Lorsque α vaut zéro, la rotation est uniforme et le déplacement angulaire se réduit à ω₀ fois t.

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 ω₀ t et α t au carré partagent une unité angulaire et que leur somme soit un déplacement angulaire cohérent.

La même règle s'applique dans tout système cohérent —tours par seconde avec accélération angulaire correspondante, ou degrés par seconde après conversion cohérente— de sorte 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.

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 s'adresse à ceux qui recherchent un calculateur de déplacement angulaire, theta égal à omega zéro t plus demi alpha t au carré, ou de la cinématique rotationnelle en ligne ; ce n'est pas une suite SUVAT rotationnelle complète qui résout aussi la vitesse angulaire finale ou le temps avec des inconnues mixtes, ni un intégrateur d'accélération variable, ni un outil de déplacement linéaire (utilisez le calculateur linéaire s égal à u t plus demi a t au carré 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 déplacement angulaire ; si votre problème source donne la vitesse angulaire finale au lieu du temps, réarrangez d'abord une autre équation cinématique rotationnelle. Les contrôles aller-retour sont simples : recalculez ω₀ t plus la moitié de α t au carré à la main et confirmez l'égalité avec la theta publiée dans le même arrondi à douze décimales utilisé dans la réponse.

Cas d’usage

Contrôle des devoirs de cinématique rotationnelle

Les étudiants saisissent ω₀, α et t issus de problèmes d'accélération angulaire constante du manuel et comparent la θ é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 corrects d'accélération de rotation, de freinage angulaire et de temps nul, ainsi que des rejets délibérés pour entrée non numérique et temps négatif, comme valeurs attendues pour des katas de code dans les jeux ou moteurs physiques.

Précontrôle de laboratoire avant modèles de spin multi-segments

Les pipelines valident d'abord le déplacement angulaire à partir de ω₀, α et t, puis n'enchaînent vers la vitesse angulaire finale ou des trajectoires multi-intervalles que lorsque le contrôle à intervalle unique concorde avec les notes de labo.

Questions fréquentes

Comment calculer le déplacement angulaire à 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 à zéro.

α ou ω₀ peuvent-ils être négatifs ?

Seul le temps est contraint à être non négatif.

Dans quelle unité le résultat est-il donné ?

Dans l'unité d'angle qu'impliquent vos valeurs. Avec ω₀ en radians par seconde, α en radians par seconde carrée et le temps en secondes, le résultat est en radians. La calculatrice ne convertit rien : ne mélangez pas rad/s et tr/min.

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

POSThttps://api.kit.forhosting.com/mech/angular-displacement

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-displacement \
  -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-displacement", {
  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-displacement",
    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-displacement", 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-displacement", 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_displacement",
  "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

par requête$0.002

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 le déplacement angulaire arrondi, 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. Les entrées non numériques et le 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 à zéro. 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. Les é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 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, déplacement angulaire au-delà du 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 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 maintient les collages de formulaires de devoirs sans accepter de texte arbitraire comme des mots ou des chaînes vides.

Conseils pratiques, limites et recherches associées

Gardez omega0, alpha et t dans la plage absolue publiée afin que les produits ω₀ t et la moitié de α t au carré et leur somme restent finis en double précision IEEE sur le Worker et dans le navigateur. Associez des exemples de cours de façon délibérée : omega0 égal à dix, alpha égal à deux, t égal à cinq donne theta égal à soixante-quinze ; omega0 égal à vingt, alpha égal à moins quatre, t égal à trois produit un déplacement net avec un terme demi-alpha négatif ; omega0 égal à cinq, alpha égal à zéro, t égal à douze illustre un déplacement de rotation uniforme de soixante ; et un alpha non numérique ou t égal à moins un montre le chemin strict invalid_input. Lors de l'enseignement des 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 garde les scripts exploratoires peu coûteux lorsque les apprenants passent volontairement une entrée incorrecte.

Questions techniques

Combien coûte le calculateur de déplacement angulaire ?

L'outil navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; une entrée invalide n'est pas facturée.

Consulter la documentation complète du KIT →

Lancer gratuitement

Exemple résolu

Ce que signifie θ = ω₀t + ½αt² en cinématique rotationnelle

Conseils pratiques, limites et recherches associées

Cas d’usage

Contrôle des devoirs de cinématique rotationnelle

Tests unitaires pour aides à la rotation dans les simulateurs

Précontrôle de laboratoire avant modèles de spin multi-segments

Questions fréquentes

Outils associés

Pour les développeurs — accès API

Endpoint

Appeler depuis votre stack

Exemple de requête

Exemple de réponse

Tarifs

Limites

Erreurs

Notes techniques

Comment appeler l'API et ce qu'elle renvoie

Conseils pratiques, limites et recherches associées

Questions techniques

merci