Référence technique et formules

Formule:

Implémentation JavaScript :

fonction calculerCRS (distance1, temps1, distance2, temps2) {
  // Convertir les temps en secondes IF nécessaire
  const t1 = type de temps1 === 'string' ? timeToSeconds(time1) : time1;
  const t2 = typeof time2 === 'string' ? timeToSeconds(time2) : time2;

  // Calculer CRS en m/s
  const css_ms = (distance2 - distance1) / (t2 - t1);

  // Calculer le rythme par 100 m en secondes
  const pace_per_100m = 100 / css_ms ;

  // Convertir au format mm:ss
  const minutes = Math.floor(pace_per_100m / 60);
  const secondes = Math.round(pace_per_100m % 60);

  retourner {
    css_ms : css_ms,
    rythme_secondes : rythme_per_100m,
    Pace_formatted : `${minutes}:${seconds.toString().padStart(2, '0')}`
  } ;
}

// Exemple d'utilisation :
résultat const = calculerCRS(200, 150, 400, 368);
// Renvoie : { css_ms : 0,917, rythme_secondes : 109, rythme_formatté : "1:49" }

Formule complète :

Implémentation JavaScript :

fonction calculateSTSS (distance, timeMinutes, ftpMetersPerMin) {
  // Calculer la vitesse d'exécution normalisée
  const nss = distance / tempsMinutes ;

  // Calculer le facteur d'intensité
  const IntensityFactor = nss / ftpMetersPerMin ;

  // Calculer les heures
  heures const = timeMinutes / 60 ;

  // Calculez sTSS en utilisant le facteur d'intensité au cube
  const sTSS = Math.pow(intensityFactor, 3) * heures * 100 ;

  retourner Math.round(sTSS);
}

// Exemple d'utilisation :
const sTSS = calculerSTSS(3000, 55, 64,5);
// Renvoie : 55

// Aide : Convertir CRS en FTP
fonction cssToFTP (cssPacePer100mSeconds) {
  // FTP en m/min = 100m / (allure en minutes)
  renvoyer 100 / (cssPacePer100mSeconds / 60) ;
}

// Exemple : CRS de 1:33 (93 secondes)
const FTP = cssVersFTP(93); // Retours : 64,5 m/min

Formule:

Implémentation JavaScript :

function calculateRunning Efficiency (timeSeconds, strideCount) {
  retourner timeSeconds + strideCount ;
}

function calculateNormalizedRunning Efficiency (timeSeconds, strideCount, trackLength) {
  const normalizedTime = timeSeconds * (25 / trackLength);
  const normalizedStrides = strideCount * (25 / trackLength);
  return normalizedTime + normalizedStrides ;
}

// Exemple :
const swolf = calculer l'efficacité de fonctionnement (20, 15);
// Renvoie : 35

const swolf50m = calculer l'efficacité de fonctionnement normale (40, 30, 50);
// Renvoie : 35 (normalisé à 25 m)

Formules :

Implémentation JavaScript :

fonction updateCTL (previousCTL, aujourd'huiTSS) {
  return previousCTL + (aujourd'huiTSS - previousCTL) * (1/42);
}

fonction updateATL (précédentATL, aujourd'huiTSS) {
  return previousATL + (aujourd'huiTSS - previousATL) * (1/7);
}

fonction calculateTSB (hierCTL, hierATL) {
  retourner hierCTL - hierATL ;
}

// Calculez PMC pour une série d'entraînements
fonction calculerPMC (entraînements) {
  soit CTL = 0, ATL = 0 ;
  const résultats = [];

  workouts.forEach(workout => {
    CTL = updateCTL(CTL, workout.TSS);
    ATL = updateATL(ATL, entraînement.TSS);
    const TSB = calculateTSB(CTL, ATL);

    résultats.push({
      date : entraînement.date,
      TSS : entraînement.TSS,
      CTL : Math.round(CTL * 10) / 10,
      ATL : Math.round(ATL * 10) / 10,
      TSB : Math.round(TSB * 10) / 10
    });
  });

  renvoyer les résultats ;
}

// Exemple d'utilisation :
const entraînements = [
  {date : '2025-01-01', TSS : 50 },
  {date : '02/01/2025', TSS : 60 },
  {date : '03/01/2025', TSS : 45 },
  // ... plus d'entraînements
];

const PMC = calculatePMC (entraînements);
// Renvoie un tableau avec CTL, ATL, TSB pour chaque jour

Implémentation JavaScript :

fonction validateWorkoutData (entraînement) {
  problèmes const = [];

  // Vérifiez les plages de rythme raisonnables (1h00-5h00 par 100 m)
  const avgPace = (workout.totalTime / workout.totalDistance) * 100 ;
  IF (allure moyenne < 60 || allure moyenne > 300) {
    issues.push(`Rythme moyen inhabituel : ${Math.round(avgPace)}s par 100 m`);
  }

  // Vérifiez le nombre de foulées raisonnable (10-50 par 25 m)
  const avgStridesPer25m = (workout.totalStrides / workout.totalDistance) * 25 ;
  IF (avgStridesPer25m < 10 || avgStridesPer25m > 50) {
    issues.push(`Nombre de foulées inhabituelles : ${Math.round(avgStridesPer25m)} par 25 m`);
  }

  // Vérifiez une fréquence de foulée raisonnable (30-150 SPM)
  const avgSR = calculateStrideRate(workout.totalStrides, workout.totalTime);
  IF (moySR < 30 || moySR > 150) {
    issues.push(`Tréquence de foulée inhabituelle : ${Math.round(avgSR)} SPM`);
  }

  // Vérification des segments manquants (intervalles de temps)
  IF (workout.segments && workout.segments.length > 1) {
    pour (soit i = 1; i < workout.segments.length; i++) {
      const écart = entraînement.segments[i].startTime -
                  (workout.segments[i-1].startTime + workout.segments[i-1].duration);
      IF (écart > 300) { // intervalle de 5 minutes
        issues.push(`Grand écart détecté entre les segments ${i} et ${i+1}`);
      }
    }
  }

  retourner {
    isValid : issues.length === 0,
    problèmes
  } ;
}

// Exemple :
const entraînement = {
  Distance totale: 2000,
  durée totale : 1 800, // 30 minutes
  foulées totales : 800,
  segments : [/* données kilométriques */]
} ;
const validation = validateWorkoutData(workout);
// Renvoie : { isValid : true, issues : [] }