ឯកសារយោង និងរូបមន្ត

រូបមន្ត៖

ការអនុវត្ត JavaScript៖

មុខងារគណនាCSS(ចម្ងាយ1,ពេលវេលា1,ចម្ងាយ2,ពេលវេលា2) {
  // បំលែងពេលវេលាទៅជាវិនាទីប្រសិនបើចាំបាច់
  const t1 = typeof time1 === 'string' ? timeToSeconds(time1): time1;
  const t2 = typeof time2 === 'string' ? timeToSeconds(time2): time2;

  // គណនា CSS ក្នុង m/s
  const css_ms = (ចម្ងាយ 2 - ចម្ងាយ1) / (t2 - t1);

  // គណនាល្បឿនក្នុង 100 ម៉ែត្រក្នុងមួយវិនាទី
  const pace_per_100m = 100 / css_ms;

  // បំលែងទៅជាទម្រង់ mm:ss
  const នាទី = Math.floor(pace_per_100m / 60);
  const វិនាទី = Math.round(pace_per_100m % 60);

  ត្រឡប់ {
    css_ms៖ css_ms,
    ល្បឿន_វិនាទី៖ pace_per_100m,
    pace_formatted៖ `${minutes}:${seconds.toString().padStart(2, '0')}`
  };
}

// ឧទាហរណ៍ការប្រើប្រាស់៖
លទ្ធផល const = គណនា CSS(200, 150, 400, 368);
// ត្រឡប់៖ { css_ms: 0.917, pace_seconds: 109, pace_formatted: "1:49" }

រូបមន្តពេញលេញ៖

ការអនុវត្ត JavaScript៖

មុខងារគណនាSTSS(ចម្ងាយ ពេលវេលានាទី ftpMetersPerMin) {
  // គណនាល្បឿនហែលទឹកធម្មតា។
  const nss = ចម្ងាយ / ម៉ោងនាទី;

  // គណនាកត្តាអាំងតង់ស៊ីតេ
  const intensityFactor = nss / ftpMetersPerMin;

  // គណនាម៉ោង
  ម៉ោង const = timeminutes / 60;

  // គណនា sTSS ដោយប្រើកត្តាអាំងតង់ស៊ីតេគូប
  const stss = Math.pow(អាំងតង់ស៊ីតេកត្តា, 3) * ម៉ោង * 100;

  ត្រឡប់ Math.round(stss);
}

// ឧទាហរណ៍ការប្រើប្រាស់៖
const stss = គណនាSTSS(3000, 55, 64.5);
// ត្រឡប់ៈ ៥៥

// អ្នកជំនួយ៖ បំប្លែង CSS ទៅ FTP
មុខងារ cssToFTP(cssPacePer100mSeconds) {
  // FTP ក្នុង m/min = 100m / (ល្បឿនក្នុងមួយនាទី)
  ត្រឡប់ 100 / (cssPacePer100mSeconds / 60);
}

// ឧទាហរណ៍៖ CSS នៃ 1:33 (93 វិនាទី)
const ftp = cssToFTP(93); // ត្រឡប់: 64.5 m/min

រូបមន្ត៖

ការអនុវត្ត JavaScript៖

មុខងារគណនាSWOLF(timeSeconds, strokeCount) {
  ពេលវេលាត្រឡប់វិនាទី + ចំនួន stroke;
}

មុខងារគណនាNormalizedSWOLF(timeSeconds, strokeCount, poolLength) {
  const normalizedTime = timeSeconds * (25 / poolLength);
  const normalizedStrokes = strokeCount * (25 / poolLength);
  ត្រឡប់ normalizedTime + normalizedStrokes;
}

// ឧទាហរណ៍៖
const swolf = គណនា SWOLF(20, 15);
// ត្រឡប់៖ ៣៥

const swolf50m = គណនាNormalizedSWOLF(40, 30, 50);
// ត្រលប់មកវិញ៖ 35 (ធម្មតាដល់ 25 ម)

រូបមន្ត៖

ការអនុវត្ត JavaScript៖

មុខងារអាប់ដេតCTL(ពីមុនCTL, todayTSS) {
  ត្រឡប់ PreviousCTL + (ថ្ងៃនេះTSS - PreviousCTL) * (1/42);
}

មុខងារអាប់ដេតATL(ពីមុនATL, todayTSS) {
  ត្រឡប់ PreviousATL + (ថ្ងៃនេះTSS - PreviousATL) * (1/7);
}

មុខងារគណនាTSB(ម្សិលមិញCTL, ម្សិលមិញATL) {
  ត្រឡប់ម្សិលមិញCTL - ម្សិលមិញATL;
}

// គណនា PMC សម្រាប់ស៊េរីនៃការហាត់ប្រាណ
មុខងារគណនាPMC(ការហាត់ប្រាណ) {
  អនុញ្ញាតឱ្យ ctl = 0, atl = 0;
  លទ្ធផល const = [];

  workouts.forEach(ហាត់ប្រាណ => {
    ctl = updateCTL(ctl, workout.tss);
    atl = updateATL(atl, workout.tss);
    const tsb = គណនាTSB(ctl, atl);

    results.push({
      កាលបរិច្ឆេទ៖ workout.date,
      tss: workout.tss,
      ctl: Math.round(ctl * 10) / 10,
      atl: Math.round(atl * 10) / 10,
      tsb: Math.round(tsb * 10) / 10
    });
  });

  លទ្ធផលត្រឡប់មកវិញ;
}

// ឧទាហរណ៍ការប្រើប្រាស់៖
លំហាត់ const = [
  { កាលបរិច្ឆេទ៖ '2025-01-01', tss: 50 },
  { កាលបរិច្ឆេទ៖ '2025-01-02', tss: 60 },
  {កាលបរិច្ឆេទ៖ '2025-01-03', tss: 45 },
  // ... លំហាត់ច្រើនទៀត
];

const pmc = គណនាPMC(ការហាត់ប្រាណ);
// ត្រឡប់អារេជាមួយ CTL, ATL, TSB សម្រាប់មួយថ្ងៃៗ

ការអនុវត្ត JavaScript៖

មុខងារ validateWorkoutData (ហាត់ប្រាណ) {
  បញ្ហា const = [];

  // ពិនិត្យ​មើល​ជួរ​ល្បឿន​សមរម្យ (1:00-5:00 ក្នុង 100m)
  const avgPace = (workout.totalTime / workout.totalDistance) * 100;
  ប្រសិនបើ (avgPace < 60 || avgPace > 300) {
    issue.push(`ល្បឿនមធ្យមមិនធម្មតា៖ ${Math.round(avgPace)}s ក្នុង 100m`);
  }

  // ពិនិត្យ​មើល​ចំនួន​ដាច់​សរសៃឈាម​ខួរក្បាល​សម​ហេតុផល (10-50 ក្នុង 25m)
  const avgStrokesPer25m = (workout.totalStrokes / workout.totalDistance) * 25;
  ប្រសិនបើ (avgStrokesPer25m < 10 || avgStrokesPer25m > 50) {
    issues.push(`ការរាប់ការដាច់សរសៃឈាមខួរក្បាលមិនធម្មតា៖ ${Math.round(avgStrokesPer25m)} ក្នុង 25m`);
  }

  // ពិនិត្យមើលអត្រាដាច់សរសៃឈាមខួរក្បាលដែលសមហេតុផល (30-150 SPM)
  const avgSR = គណនាStrokeRate(workout.totalStrokes, workout.totalTime);
  ប្រសិនបើ (avgSR < 30 || avgSR > 150) {
    issue.push(`អត្រាដាច់សរសៃឈាមខួរក្បាលមិនធម្មតា៖ ${Math.round(avgSR)} SPM`);
  }

  // ពិនិត្យមើលការខកខាន (ចន្លោះពេល)
  ប្រសិនបើ (workout.laps && workout.laps.length > 1) {
    សម្រាប់ (អនុញ្ញាតឱ្យ i = 1; i < workout.laps.length; i++) {
      const gap = workout.laps[i].startTime -
                  (workout.laps[i-1].startTime + workout.laps[i-1].duration);
      ប្រសិនបើ (គម្លាត> 300) { // គម្លាត 5 នាទី។
        issue.push(`គម្លាតធំត្រូវបានរកឃើញរវាង laps ${i} និង ${i+1}`);
      }
    }
  }

  ត្រឡប់ {
    isValid: issues.length === 0,
    បញ្ហា
  };
}

// ឧទាហរណ៍៖
const workout = {
  ចម្ងាយសរុប៖ ២០០០,
  ពេលវេលាសរុប: 1800, // 30 នាទី។
  សរុប៖ ៨០០,
  laps: [/* laps data */]
};
const validation = validateWorkoutData(ការហាត់ប្រាណ);
// ត្រឡប់៖ { ត្រឹមត្រូវ៖ ពិត បញ្ហា៖ [] }