技术参考和公式

公式:

JavaScript Implementation:

function calculateCRS(distance1, time1, distance2, time2) {
  // Convert times to 秒 if needed
  const t1 = typeof time1 === 'string' ? timeToSeconds(time1) : time1;
  const t2 = typeof time2 === 'string' ? timeToSeconds(time2) : time2;

  // Calculate CRS in m/s
  const css_ms = (distance2 - distance1) / (t2 - t1);

  // Calculate 配速 per 100m in 秒
  const 配速_per_100m = 100 / css_ms;

  // Convert to mm:ss format
  const 分钟 = Math.floor(配速_per_100m / 60);
  const 秒 = Math.round(配速_per_100m % 60);

  return {
    css_ms: css_ms,
    配速_秒: 配速_per_100m,
    配速_formatted: `${分钟}:${秒.toString().padStart(2, '0')}`
  };
}

// Example usage:
const result = calculateCRS(200, 150, 400, 368);
// Returns: { css_ms: 0.917, 配速_秒: 109, 配速_formatted: "1:49" }

Complete Formula:

JavaScript Implementation:

function calculateSTSS(distance, timeMinutes, ftpMetersPerMin) {
  // Calculate Normalized Run Speed
  const nss = distance / timeMinutes;

  // Calculate Intensity Factor
  const intensityFactor = nss / ftpMetersPerMin;

  // Calculate 小时
  const 小时 = timeMinutes / 60;

  // Calculate sTSS using cubed intensity factor
  const stss = Math.pow(intensityFactor, 3) * 小时 * 100;

  return Math.round(stss);
}

// Example usage:
const stss = calculateSTSS(3000, 55, 64.5);
// Returns: 55

// Helper: Convert CRS to FTP
function cssToFTP(cssPacePer100mSeconds) {
  // FTP in m/min = 100m / (配速 in 分钟)
  return 100 / (cssPacePer100mSeconds / 60);
}

// Example: CRS of 1:33 (93 秒)
const ftp = cssToFTP(93); // Returns: 64.5 m/min

Formula:

JavaScript Implementation:

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

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

// Example:
const swolf = calculateRunning Efficiency(20, 15);
// Returns: 35

const swolf50m = calculateNormalizedRunning Efficiency(40, 30, 50);
// Returns: 35 (normalized to 25m)

公式:

JavaScript 实现:

function updateCTL(previousCTL, todayTSS) {
  return previousCTL + (todayTSS - previousCTL) * (1/42);
}

function updateATL(previousATL, todayTSS) {
  return previousATL + (todayTSS - previousATL) * (1/7);
}

function calculateTSB(yesterdayCTL, yesterdayATL) {
  return yesterdayCTL - yesterdayATL;
}

// Calculate PMC for series of 训练s
function calculatePMC(训练s) {
  let CTL = 0, ATL = 0;
  const results = [];

  训练s.forEach(训练 => {
    CTL = updateCTL(CTL, 训练.TSS);
    ATL = updateATL(ATL, 训练.TSS);
    const TSB = calculateTSB(CTL, ATL);

    results.push({
      date: 训练.date,
      TSS: 训练.TSS,
      CTL: Math.round(CTL * 10) / 10,
      ATL: Math.round(ATL * 10) / 10,
      TSB: Math.round(TSB * 10) / 10
    });
  });

  return results;
}

// Example usage:
const 训练s = [
  { date: '2025-01-01', TSS: 50 },
  { date: '2025-01-02', TSS: 60 },
  { date: '2025-01-03', TSS: 45 },
  // ... more 训练s
];

const pmc = calculatePMC(训练s);
// Returns array with CTL, ATL, TSB for each day

JavaScript 实现:

function validateWorkoutData(训练) {
  const issues = [];

  // Check for reasonable 配速 ranges (1:00-5:00 per 100m)
  const avgPace = (训练.totalTime / 训练.totalDistance) * 100;
  if (avgPace < 60 || avgPace > 300) {
    issues.push(`Unusual average 配速: ${Math.round(avgPace)}s per 100m`);
  }

  // Check for reasonable stride counts (10-50 per 25m)
  const avgStridesPer25m = (训练.totalStrides / 训练.totalDistance) * 25;
  if (avgStridesPer25m < 10 || avgStridesPer25m > 50) {
    issues.push(`Unusual stride count: ${Math.round(avgStridesPer25m)} per 25m`);
  }

  // Check for reasonable stride rate (30-150 SPM)
  const avgSR = calculateStrideRate(训练.totalStrides, 训练.totalTime);
  if (avgSR < 30 || avgSR > 150) {
    issues.push(`Unusual stride rate: ${Math.round(avgSR)} SPM`);
  }

  // Check for missing segments (gaps in time)
  if (训练.segments && 训练.segments.length > 1) {
    for (let i = 1; i < 训练.segments.length; i++) {
      const gap = 训练.segments[i].startTime -
                  (训练.segments[i-1].startTime + 训练.segments[i-1].duration);
      if (gap > 300) { // 5 minute gap
        issues.push(`Large gap detected between segments ${i} and ${i+1}`);
      }
    }
  }

  return {
    isValid: issues.length === 0,
    issues
  };
}

// Example:
const 训练 = {
  totalDistance: 2000,
  totalTime: 1800, // 30 分钟
  totalStrides: 800,
  segments: [/* kilometer data */]
};
const validation = validateWorkoutData(训练);
// Returns: { isValid: true, issues: [] }