<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Separable Differential Equation: dy/dx = 3x²y</title>
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      background: #ffffff;
      color: #1e293b;
      padding: 10px;
      display: flex;
      flex-direction: column;
      gap: 10px;
      max-width: 700px;
      margin: 0 auto;
    }

    .main-grid {
      display: grid;
      grid-template-columns: 1fr 1.15fr;
      gap: 10px;
      align-items: stretch;
    }

    @media (max-width: 540px) {
      .main-grid {
        grid-template-columns: 1fr;
      }
    }

    /* Steps Column */
    .steps-container {
      display: flex;
      flex-direction: column;
      gap: 6px;
      justify-content: space-between;
    }

    .step-item {
      background: #f8fafc;
      border: 1.5px solid #e2e8f0;
      border-radius: 8px;
      padding: 7px 10px;
      cursor: pointer;
      transition: border-color 0.2s, background-color 0.2s, box-shadow 0.2s;
      display: flex;
      align-items: center;
      justify-content: space-between;
      gap: 8px;
    }

    .step-item:hover {
      background: #f1f5f9;
      border-color: #cbd5e1;
    }

    .step-item.active {
      background: #f0f9ff;
      border-color: #0284c7;
      box-shadow: 0 0 0 1px #0284c7;
    }

    .step-badge {
      font-size: 11px;
      font-weight: 700;
      color: #64748b;
      letter-spacing: 0.2px;
      white-space: nowrap;
    }

    .step-item.active .step-badge {
      color: #0284c7;
    }

    /* Clean HTML Math Styling */
    .math-expr {
      font-family: "Cambria Math", "STIX Two Math", "Times New Roman", serif;
      font-size: 14px;
      display: inline-flex;
      align-items: center;
      gap: 3px;
      white-space: nowrap;
    }

    .frac {
      display: inline-flex;
      flex-direction: column;
      vertical-align: middle;
      text-align: center;
      line-height: 1;
      font-size: 0.88em;
      padding: 0 1px;
    }

    .frac .num {
      border-bottom: 1.2px solid currentColor;
      padding-bottom: 1px;
    }

    .frac .den {
      padding-top: 1px;
    }

    var {
      font-style: italic;
      font-family: "Cambria Math", "Times New Roman", serif;
    }

    sup, sub {
      font-size: 0.75em;
      line-height: 0;
      position: relative;
    }

    sup { top: -0.45em; }
    sub { bottom: -0.25em; }

    /* Graph Column */
    .graph-panel {
      background: #f8fafc;
      border: 1.5px solid #e2e8f0;
      border-radius: 8px;
      padding: 8px;
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 6px;
      position: relative;
      overflow: hidden;
    }

    .graph-header {
      width: 100%;
      display: flex;
      justify-content: space-between;
      align-items: center;
      font-size: 12px;
      font-weight: 600;
      flex-wrap: wrap;
      gap: 4px;
    }

    .curve-pills {
      display: flex;
      gap: 4px;
      flex-wrap: wrap;
    }

    .pill {
      font-size: 10.5px;
      font-weight: 700;
      padding: 2px 6px;
      border-radius: 10px;
      border: 1px solid transparent;
      cursor: pointer;
      transition: opacity 0.2s, background-color 0.2s;
    }

    .pill.c2 { background: #dbeafe; color: #1d4ed8; border-color: #bfdbfe; }
    .pill.c1 { background: #dcfce7; color: #15803d; border-color: #bbf7d0; }
    .pill.cm1 { background: #fef3c7; color: #b45309; border-color: #fde68a; }
    .pill.cm2 { background: #f3e8ff; color: #7e22ce; border-color: #e9d5ff; }

    .pill.dimmed {
      opacity: 0.35;
    }

    .svg-container {
      width: 100%;
      border-radius: 4px;
      background: #ffffff;
      border: 1px solid #e2e8f0;
      overflow: hidden;
    }

    svg {
      width: 100%;
      height: auto;
      display: block;
    }

    .axis-line { stroke: #64748b; stroke-width: 1.2; }
    .grid-line { stroke: #f1f5f9; stroke-width: 1; }
    .tick-line { stroke: #94a3b8; stroke-width: 1; }
    .axis-text { font-size: 9.5px; fill: #64748b; font-family: system-ui, sans-serif; }
    
    .curve {
      fill: none !important;
      stroke-width: 2.2px;
      stroke-linecap: round;
      stroke-linejoin: round;
      transition: stroke-width 0.2s, opacity 0.2s;
    }

    .curve.highlight {
      stroke-width: 3.6px;
      filter: drop-shadow(0 0 2px rgba(0,0,0,0.25));
    }

    .curve.dimmed {
      opacity: 0.2;
      stroke-width: 1.4px;
    }

    .c2-color { stroke: #2563eb; }
    .c1-color { stroke: #16a34a; }
    .cm1-color { stroke: #d97706; }
    .cm2-color { stroke: #9333ea; }

    .point-marker {
      stroke: #ffffff;
      stroke-width: 1px;
      transition: r 0.2s, opacity 0.2s;
    }
    .point-marker.c2-color { fill: #2563eb; }
    .point-marker.c1-color { fill: #16a34a; }
    .point-marker.cm1-color { fill: #d97706; }
    .point-marker.cm2-color { fill: #9333ea; }

    .point-marker.dimmed { opacity: 0.2; }
    .point-marker.highlight { r: 4.5; }

    .stepper-nav {
      display: flex;
      justify-content: center;
      align-items: center;
      gap: 8px;
      padding-top: 2px;
    }

    .nav-btn {
      background: #f1f5f9;
      border: 1px solid #cbd5e1;
      border-radius: 6px;
      padding: 5px 14px;
      font-size: 12px;
      font-weight: 600;
      cursor: pointer;
      color: #334155;
      transition: background 0.15s;
    }
    .nav-btn:hover { background: #e2e8f0; }
  </style>
</head>
<body>

  <div class="main-grid">
    
    <div class="steps-container" id="stepsGroup">
      <div class="step-item active" data-step="0">
        <span class="step-badge">1. Given</span>
        <span class="math-expr">
          <span class="frac"><span class="num">d<var>y</var></span><span class="den">d<var>x</var></span></span>
          = 3<var>x</var><sup>2</sup><var>y</var>
        </span>
      </div>
      <div class="step-item" data-step="1">
        <span class="step-badge">2. Separate</span>
        <span class="math-expr">
          <span class="frac"><span class="num">1</span><span class="den"><var>y</var></span></span>
          d<var>y</var> = 3<var>x</var><sup>2</sup> d<var>x</var>
        </span>
      </div>
      <div class="step-item" data-step="2">
        <span class="step-badge">3. Integrate</span>
        <span class="math-expr">
          ln|<var>y</var>| = <var>x</var><sup>3</sup> + <var>C</var><sub>1</sub>
        </span>
      </div>
      <div class="step-item" data-step="3">
        <span class="step-badge">4. Exponentiate</span>
        <span class="math-expr">
          <var>y</var> = <var>C</var><var>e</var><sup><var>x</var><sup>3</sup></sup>
        </span>
      </div>
    </div>

    
    <div class="graph-panel">
      <div class="graph-header">
        <span>Family: <span class="math-expr"><var>y</var> = <var>C</var><var>e</var><sup><var>x</var><sup>3</sup></sup></span></span>
        <div class="curve-pills">
          <span class="pill c2" data-c="2">C = 2</span>
          <span class="pill c1" data-c="1">C = 1</span>
          <span class="pill cm1" data-c="-1">C = -1</span>
          <span class="pill cm2" data-c="-2">C = -2</span>
        </div>
      </div>
      
      <div class="svg-container">
        <svg id="plotSvg" viewBox="0 0 300 180">
          <defs>
            <clipPath id="graphBounds">
              <rect x="0" y="0" width="300" height="180" />
            </clipPath>
          </defs>
          <g id="gridLayer"></g>
          <g id="axesLayer"></g>
          <g id="curvesLayer" clip-path="url(#graphBounds)"></g>
          <g id="pointsLayer" clip-path="url(#graphBounds)"></g>
        </svg>
      </div>
    </div>
  </div>

  <div class="stepper-nav">
    <button class="nav-btn" id="prevBtn">◀ Prev</button>
    <button class="nav-btn" id="playBtn">▶ Auto</button>
    <button class="nav-btn" id="nextBtn">Next ▶</button>
  </div>

  <script>
    // Coordinate Mapping
    const width = 300;
    const height = 180;
    const xMin = -1.4, xMax = 1.4;
    const yMin = -4.5, yMax = 4.5;

    function toScreenX(x) {
      return ((x - xMin) / (xMax - xMin)) * width;
    }
    function toScreenY(y) {
      return height - ((y - yMin) / (yMax - yMin)) * height;
    }

    const gridLayer = document.getElementById('gridLayer');
    const axesLayer = document.getElementById('axesLayer');
    const curvesLayer = document.getElementById('curvesLayer');
    const pointsLayer = document.getElementById('pointsLayer');

    // Grid & Axes
    let gridSvg = '';
    for (let y = -4; y <= 4; y += 2) {
      if (y === 0) continue;
      const sy = toScreenY(y);
      gridSvg += `<line x1="0" y1="${sy}" x2="${width}" y2="${sy}" class="grid-line" />`;
    }
    for (let x = -1; x <= 1; x += 0.5) {
      if (x === 0) continue;
      const sx = toScreenX(x);
      gridSvg += `<line x1="${sx}" y1="0" x2="${sx}" y2="${height}" class="grid-line" />`;
    }
    gridLayer.innerHTML = gridSvg;

    const originX = toScreenX(0);
    const originY = toScreenY(0);

    // Ticks and labels (shifted left of axis to avoid collision with (0, C) intercept markers)
    let axesSvg = `
      <line x1="0" y1="${originY}" x2="${width}" y2="${originY}" class="axis-line" />
      <line x1="${originX}" y1="0" x2="${originX}" y2="${height}" class="axis-line" />
      <text x="${width - 8}" y="${originY - 5}" class="axis-text" font-weight="bold" text-anchor="end">x</text>
      <text x="${originX + 7}" y="11" class="axis-text" font-weight="bold">y</text>
      
      
      <line x1="${toScreenX(1)}" y1="${originY - 2.5}" x2="${toScreenX(1)}" y2="${originY + 2.5}" class="tick-line" />
      <text x="${toScreenX(1)}" y="${originY + 12}" class="axis-text" text-anchor="middle">1</text>
      
      <line x1="${toScreenX(-1)}" y1="${originY - 2.5}" x2="${toScreenX(-1)}" y2="${originY + 2.5}" class="tick-line" />
      <text x="${toScreenX(-1)}" y="${originY + 12}" class="axis-text" text-anchor="middle">-1</text>
      
      
      <line x1="${originX - 2.5}" y1="${toScreenY(2)}" x2="${originX + 2.5}" y2="${toScreenY(2)}" class="tick-line" />
      <text x="${originX - 6}" y="${toScreenY(2) + 3.5}" class="axis-text" text-anchor="end">2</text>
      
      <line x1="${originX - 2.5}" y1="${toScreenY(4)}" x2="${originX + 2.5}" y2="${toScreenY(4)}" class="tick-line" />
      <text x="${originX - 6}" y="${toScreenY(4) + 3.5}" class="axis-text" text-anchor="end">4</text>

      <line x1="${originX - 2.5}" y1="${toScreenY(-2)}" x2="${originX + 2.5}" y2="${toScreenY(-2)}" class="tick-line" />
      <text x="${originX - 6}" y="${toScreenY(-2) + 3.5}" class="axis-text" text-anchor="end">-2</text>

      <line x1="${originX - 2.5}" y1="${toScreenY(-4)}" x2="${originX + 2.5}" y2="${toScreenY(-4)}" class="tick-line" />
      <text x="${originX - 6}" y="${toScreenY(-4) + 3.5}" class="axis-text" text-anchor="end">-4</text>
    `;
    axesLayer.innerHTML = axesSvg;

    // Curves: y = C * e^(x^3)
    const curves = [
      { c: 2, colorClass: 'c2-color', stroke: '#2563eb' },
      { c: 1, colorClass: 'c1-color', stroke: '#16a34a' },
      { c: -1, colorClass: 'cm1-color', stroke: '#d97706' },
      { c: -2, colorClass: 'cm2-color', stroke: '#9333ea' }
    ];

    let curvesSvg = '';
    let pointsSvg = '';

    curves.forEach(item => {
      const step = 0.01;
      let segments = [];
      let currentSegment = [];

      for (let x = xMin - 0.1; x <= xMax + 0.1; x += step) {
        const y = item.c * Math.exp(Math.pow(x, 3));
        const sx = toScreenX(x);
        const sy = toScreenY(y);

        // Keep points within extended bounds
        if (sy >= -25 && sy <= height + 25) {
          currentSegment.push(`${sx.toFixed(1)} ${sy.toFixed(1)}`);
        } else {
          if (currentSegment.length > 0) {
            segments.push(currentSegment);
            currentSegment = [];
          }
        }
      }
      if (currentSegment.length > 0) {
        segments.push(currentSegment);
      }

      segments.forEach(seg => {
        if (seg.length > 1) {
          const d = 'M ' + seg.join(' L ');
          curvesSvg += `<path d="${d}" fill="none" stroke="${item.stroke}" class="curve ${item.colorClass}" data-c="${item.c}" />`;
        }
      });

      // y-intercept point (0, C)
      const px = toScreenX(0);
      const py = toScreenY(item.c);
      pointsSvg += `<circle cx="${px}" cy="${py}" r="3" class="point-marker ${item.colorClass}" data-c="${item.c}" />`;
    });

    curvesLayer.innerHTML = curvesSvg;
    pointsLayer.innerHTML = pointsSvg;

    // Interaction: Curve Highlighting
    let activeC = null;
    function highlightCurve(c) {
      if (activeC === c) {
        activeC = null;
      } else {
        activeC = c;
      }

      document.querySelectorAll('.pill').forEach(p => {
        const pc = parseInt(p.dataset.c, 10);
        if (activeC === null) {
          p.classList.remove('dimmed');
        } else {
          p.classList.toggle('dimmed', pc !== activeC);
        }
      });

      document.querySelectorAll('.curve, .point-marker').forEach(el => {
        const ec = parseInt(el.dataset.c, 10);
        if (activeC === null) {
          el.classList.remove('dimmed', 'highlight');
        } else if (ec === activeC) {
          el.classList.add('highlight');
          el.classList.remove('dimmed');
        } else {
          el.classList.add('dimmed');
          el.classList.remove('highlight');
        }
      });
    }

    document.querySelectorAll('.pill').forEach(pill => {
      pill.addEventListener('click', () => {
        highlightCurve(parseInt(pill.dataset.c, 10));
      });
    });

    // Step Navigation
    let currentStep = 0;
    const stepItems = document.querySelectorAll('.step-item');
    const totalSteps = stepItems.length;

    function setStep(idx) {
      currentStep = (idx + totalSteps) % totalSteps;
      stepItems.forEach((el, i) => {
        el.classList.toggle('active', i === currentStep);
      });
      if (currentStep === 3) {
        highlightCurve(null);
      }
    }

    stepItems.forEach((item, i) => {
      item.addEventListener('click', () => setStep(i));
    });

    document.getElementById('prevBtn').addEventListener('click', () => setStep(currentStep - 1));
    document.getElementById('nextBtn').addEventListener('click', () => setStep(currentStep + 1));

    // Auto Play Stepper
    let autoInterval = null;
    const playBtn = document.getElementById('playBtn');

    function toggleAuto() {
      if (autoInterval) {
        clearInterval(autoInterval);
        autoInterval = null;
        playBtn.textContent = '▶ Auto';
      } else {
        playBtn.textContent = '⏸ Pause';
        autoInterval = setInterval(() => {
          setStep(currentStep + 1);
        }, 2800);
      }
    }
    playBtn.addEventListener('click', toggleAuto);
  </script>
</body>
</html>

Solving Separable Differential Equations: General Solutions

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="1:1">
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, sans-serif;
      background: #ffffff;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      width: 100%;
      height: 100%;
      user-select: none;
      padding: 10px;
    }
    .header {
      display: flex;
      align-items: center;
      justify-content: space-between;
      width: 100%;
      max-width: 440px;
      margin-bottom: 8px;
    }
    .eq-tag {
      font-size: 15px;
      font-weight: 700;
      color: #1e2945;
      background: #f1f5f9;
      padding: 4px 10px;
      border-radius: 6px;
    }
    .sol-tag {
      font-size: 14px;
      font-weight: 600;
      color: #64748b;
    }
    .graph-container {
      position: relative;
      width: 100%;
      max-width: 440px;
      aspect-ratio: 1 / 1;
      touch-action: none;
      cursor: crosshair;
    }
    svg {
      width: 100%;
      height: 100%;
      display: block;
      overflow: visible;
    }
    .grid-line {
      stroke: #e2e8f0;
      stroke-width: 1;
    }
    .axis {
      stroke: #94a3b8;
      stroke-width: 1.5;
    }
    .axis-label {
      font-size: 11px;
      fill: #94a3b8;
      font-weight: 500;
      text-anchor: middle;
      dominant-baseline: central;
    }
    .slope-segment {
      stroke: #64748b;
      stroke-width: 2.2;
      stroke-linecap: round;
      transition: stroke 0.2s;
    }
    .circle-sol {
      fill: none;
      stroke-width: 3;
      transition: opacity 0.3s, stroke-dashoffset 0.6s ease;
    }
    .interactive-circle {
      fill: none;
      stroke: #f59e0b;
      stroke-width: 2.5;
      stroke-dasharray: 5, 4;
      pointer-events: none;
    }
    .interactive-dot {
      fill: #f59e0b;
      stroke: #ffffff;
      stroke-width: 2;
      pointer-events: none;
    }
    .c1 { stroke: #0284c7; }
    .c4 { stroke: #8b5cf6; }
    .c9 { stroke: #10b981; }
    .controls {
      display: flex;
      gap: 6px;
      margin-top: 10px;
      flex-wrap: wrap;
      justify-content: center;
      max-width: 440px;
      width: 100%;
    }
    .btn {
      appearance: none;
      border: 1px solid #cbd5e1;
      background: #ffffff;
      color: #475569;
      font-size: 13px;
      font-weight: 600;
      padding: 6px 12px;
      border-radius: 6px;
      cursor: pointer;
      display: flex;
      align-items: center;
      gap: 5px;
      transition: all 0.2s;
    }
    .btn.active {
      background: #1e2945;
      color: #ffffff;
      border-color: #1e2945;
    }
    .badge {
      width: 8px;
      height: 8px;
      border-radius: 50%;
      display: inline-block;
    }
  </style>
</head>
<body>

  <div class="header">
    <div class="eq-tag">dy/dx = −x/y</div>
    <div class="sol-tag" id="currentC">x² + y² = C</div>
  </div>

  <div class="graph-container" id="graphArea">
    <svg id="svgGraph" viewBox="-200 -200 400 400">
      
      <g id="gridGroup"></g>
      
      
      <line x1="-190" y1="0" x2="190" y2="0" class="axis" />
      <line x1="0" y1="-190" x2="0" y2="190" class="axis" />
      <g id="axisLabelsGroup"></g>

      
      <g id="slopeGroup"></g>

      
      <circle id="circle1" cx="0" cy="0" r="48" class="circle-sol c1" opacity="0.95" />
      <circle id="circle2" cx="0" cy="0" r="96" class="circle-sol c4" opacity="0.95" />
      <circle id="circle3" cx="0" cy="0" r="144" class="circle-sol c9" opacity="0.95" />

      
      <circle id="dynCircle" cx="0" cy="0" r="0" class="interactive-circle" opacity="0" />
      <circle id="dynDot" cx="0" cy="0" r="4.5" class="interactive-dot" opacity="0" />
    </svg>
  </div>

  <div class="controls">
    <button class="btn active" id="btnAll" onclick="setMode('all')">All</button>
    <button class="btn" id="btn1" onclick="setMode('1')"><span class="badge" style="background:#0284c7"></span>C = 1</button>
    <button class="btn" id="btn4" onclick="setMode('4')"><span class="badge" style="background:#8b5cf6"></span>C = 4</button>
    <button class="btn" id="btn9" onclick="setMode('9')"><span class="badge" style="background:#10b981"></span>C = 9</button>
  </div>

  <script>
    const SCALE = 48; // 48px = 1 math unit
    const svg = document.getElementById('svgGraph');
    const gridGroup = document.getElementById('gridGroup');
    const labelsGroup = document.getElementById('axisLabelsGroup');
    const slopeGroup = document.getElementById('slopeGroup');
    const dynCircle = document.getElementById('dynCircle');
    const dynDot = document.getElementById('dynDot');
    const currentCText = document.getElementById('currentC');

    // 1. Draw Grid Lines and Axis Numbers (-3 to 3)
    for (let i = -3; i <= 3; i++) {
      if (i === 0) continue;
      const pos = i * SCALE;
      // Vertical grid line
      const vLine = document.createElementNS('http://www.w3.org/2000/svg', 'line');
      vLine.setAttribute('x1', pos);
      vLine.setAttribute('y1', -190);
      vLine.setAttribute('x2', pos);
      vLine.setAttribute('y2', 190);
      vLine.setAttribute('class', 'grid-line');
      gridGroup.appendChild(vLine);

      // Horizontal grid line
      const hLine = document.createElementNS('http://www.w3.org/2000/svg', 'line');
      hLine.setAttribute('x1', -190);
      hLine.setAttribute('y1', pos);
      hLine.setAttribute('x2', 190);
      hLine.setAttribute('y2', pos);
      hLine.setAttribute('class', 'grid-line');
      gridGroup.appendChild(hLine);

      // X label
      const xLbl = document.createElementNS('http://www.w3.org/2000/svg', 'text');
      xLbl.setAttribute('x', pos);
      xLbl.setAttribute('y', 12);
      xLbl.setAttribute('class', 'axis-label');
      xLbl.textContent = i;
      labelsGroup.appendChild(xLbl);

      // Y label
      const yLbl = document.createElementNS('http://www.w3.org/2000/svg', 'text');
      yLbl.setAttribute('x', -10);
      yLbl.setAttribute('y', -pos);
      yLbl.setAttribute('class', 'axis-label');
      yLbl.textContent = i;
      labelsGroup.appendChild(yLbl);
    }

    // 2. Generate 8x8 Slope Field for dy/dx = -x/y
    // Off-axis grid ensures no division-by-zero singularities
    const coords = [-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5];
    const SEG_LEN = 13;

    coords.forEach(x => {
      coords.forEach(y => {
        // Tangent direction to circle at (x,y): vector (-y, x)
        const r = Math.sqrt(x * x + y * y);
        const vx = -y / r;
        const vy = x / r;

        // Screen mapping: Screen X = x * SCALE, Screen Y = -y * SCALE
        const cx = x * SCALE;
        const cy = -y * SCALE;

        const dx = (SEG_LEN / 2) * vx;
        const dy = (SEG_LEN / 2) * (-vy); // Invert vy for SVG downward y-axis

        const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
        line.setAttribute('x1', cx - dx);
        line.setAttribute('y1', cy - dy);
        line.setAttribute('x2', cx + dx);
        line.setAttribute('y2', cy + dy);
        line.setAttribute('class', 'slope-segment');
        slopeGroup.appendChild(line);
      });
    });

    // 3. Interactive controls and tap/drag tracing
    let activeMode = 'all';

    function setMode(mode) {
      activeMode = mode;
      document.querySelectorAll('.controls .btn').forEach(b => b.classList.remove('active'));
      
      const c1 = document.getElementById('circle1');
      const c2 = document.getElementById('circle2');
      const c3 = document.getElementById('circle3');

      dynCircle.setAttribute('opacity', '0');
      dynDot.setAttribute('opacity', '0');

      if (mode === 'all') {
        document.getElementById('btnAll').classList.add('active');
        c1.setAttribute('opacity', '0.95');
        c2.setAttribute('opacity', '0.95');
        c3.setAttribute('opacity', '0.95');
        currentCText.textContent = 'x² + y² = C';
      } else {
        document.getElementById('btn' + mode).classList.add('active');
        c1.setAttribute('opacity', mode === '1' ? '0.95' : '0.12');
        c2.setAttribute('opacity', mode === '4' ? '0.95' : '0.12');
        c3.setAttribute('opacity', mode === '9' ? '0.95' : '0.12');
        currentCText.textContent = `x² + y² = ${mode}`;
      }
    }

    function handlePointer(evt) {
      const rect = svg.getBoundingClientRect();
      const px = evt.clientX - rect.left;
      const py = evt.clientY - rect.top;
      
      // Convert to SVG coordinates (-200 to 200)
      const svgX = (px / rect.width) * 400 - 200;
      const svgY = (py / rect.height) * 400 - 200;

      const radPx = Math.sqrt(svgX * svgX + svgY * svgY);
      if (radPx < 5 || radPx > 185) return;

      const mathR = radPx / SCALE;
      const cVal = (mathR * mathR).toFixed(1);

      dynCircle.setAttribute('r', radPx);
      dynCircle.setAttribute('opacity', '1');
      dynDot.setAttribute('cx', svgX);
      dynDot.setAttribute('cy', svgY);
      dynDot.setAttribute('opacity', '1');

      currentCText.textContent = `x² + y² = ${cVal}`;
    }

    const container = document.getElementById('graphArea');
    let isPointerDown = false;

    container.addEventListener('pointerdown', e => {
      isPointerDown = true;
      handlePointer(e);
    });

    window.addEventListener('pointermove', e => {
      if (isPointerDown) handlePointer(e);
    });

    window.addEventListener('pointerup', () => {
      isPointerDown = false;
    });
  </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <style>
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
      font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
    }

    body {
      color: #1e2945;
      background: transparent;
      padding: 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      min-height: 100%;
    }

    .main-wrap {
      width: 100%;
      max-width: 580px;
      display: flex;
      flex-direction: column;
      gap: 12px;
    }

    /* Legend */
    .legend-row {
      display: flex;
      justify-content: center;
      align-items: center;
      gap: 16px;
      font-size: 13px;
      font-weight: 600;
    }

    .legend-tag {
      display: inline-flex;
      align-items: center;
      gap: 6px;
      padding: 4px 10px;
      border-radius: 20px;
    }

    .legend-y {
      background: #fef3c7;
      color: #b45309;
      border: 1px solid #fde68a;
    }

    .legend-x {
      background: #dbeafe;
      color: #1d4ed8;
      border: 1px solid #bfdbfe;
    }

    .dot-pill {
      width: 8px;
      height: 8px;
      border-radius: 50%;
    }
    .legend-y .dot-pill { background: #d97706; }
    .legend-x .dot-pill { background: #2563eb; }

    /* Steps Stack */
    .steps-container {
      display: flex;
      flex-direction: column;
      gap: 8px;
      position: relative;
    }

    .step-card {
      background: #ffffff;
      border: 1.5px solid #e2e8f0;
      border-radius: 12px;
      padding: 12px 16px;
      display: flex;
      align-items: center;
      justify-content: space-between;
      transition: all 0.3s ease;
      cursor: pointer;
      user-select: none;
    }

    .step-card.active {
      border-color: #3b82f6;
      box-shadow: 0 4px 16px rgba(37, 99, 235, 0.12);
      background: #f8fafc;
    }

    .step-header {
      display: flex;
      align-items: center;
      gap: 10px;
      min-width: 120px;
    }

    .step-num {
      width: 24px;
      height: 24px;
      border-radius: 50%;
      background: #f1f5f9;
      color: #64748b;
      font-size: 12px;
      font-weight: 700;
      display: flex;
      align-items: center;
      justify-content: center;
      transition: all 0.3s ease;
    }

    .step-card.active .step-num {
      background: #2563eb;
      color: #ffffff;
    }

    .step-label {
      font-size: 13px;
      font-weight: 600;
      color: #64748b;
      transition: color 0.3s ease;
    }

    .step-card.active .step-label {
      color: #1e2945;
    }

    /* Math Expressions */
    .math-expr {
      font-family: 'Cambria Math', 'Times New Roman', serif;
      font-size: 20px;
      font-weight: 500;
      display: flex;
      align-items: center;
      justify-content: center;
      gap: 6px;
    }

    .frac {
      display: inline-flex;
      flex-direction: column;
      align-items: center;
      vertical-align: middle;
      font-size: 0.9em;
      padding: 0 2px;
    }

    .num {
      border-bottom: 1.5px solid currentColor;
      width: 100%;
      text-align: center;
      padding-bottom: 1px;
    }

    .den {
      text-align: center;
      padding-top: 1px;
    }

    .var-y {
      color: #d97706;
      background: #fffbeb;
      padding: 2px 5px;
      border-radius: 6px;
      border: 1px solid #fef3c7;
      font-weight: 600;
      display: inline-flex;
      align-items: center;
    }

    .var-x {
      color: #2563eb;
      background: #eff6ff;
      padding: 2px 5px;
      border-radius: 6px;
      border: 1px solid #dbeafe;
      font-weight: 600;
      display: inline-flex;
      align-items: center;
    }

    .op-integral {
      font-size: 28px;
      line-height: 1;
      color: #059669;
      font-weight: 400;
      margin-right: -2px;
    }

    /* Connecting arrows between cards */
    .flow-arrow {
      display: flex;
      justify-content: center;
      align-items: center;
      color: #94a3b8;
      font-size: 14px;
      height: 6px;
      margin: -2px 0;
    }

    /* Controls */
    .controls {
      display: flex;
      justify-content: center;
      align-items: center;
      gap: 12px;
      margin-top: 2px;
    }

    .btn-play {
      background: #ffffff;
      border: 1.5px solid #cbd5e1;
      color: #1e2945;
      padding: 6px 14px;
      border-radius: 20px;
      font-size: 13px;
      font-weight: 600;
      cursor: pointer;
      display: inline-flex;
      align-items: center;
      gap: 6px;
      transition: all 0.2s ease;
    }

    .btn-play:hover {
      background: #f8fafc;
      border-color: #94a3b8;
    }

    .indicator-dots {
      display: flex;
      gap: 6px;
    }

    .dot-btn {
      width: 10px;
      height: 10px;
      border-radius: 50%;
      background: #cbd5e1;
      border: none;
      cursor: pointer;
      padding: 0;
      transition: all 0.3s ease;
    }

    .dot-btn.active {
      background: #2563eb;
      width: 22px;
      border-radius: 10px;
    }

    @media (max-width: 440px) {
      .step-card {
        padding: 10px 12px;
        flex-direction: column;
        gap: 6px;
        align-items: flex-start;
      }
      .math-expr {
        font-size: 18px;
        align-self: center;
      }
      .step-header {
        min-width: auto;
      }
    }
  </style>
</head>
<body>
  <div class="main-wrap">
    
    <div class="legend-row">
      <span class="legend-y"><span class="dot-pill"></span>y-terms (left)</span>
      <span class="legend-x"><span class="dot-pill"></span>x-terms (right)</span>
    </div>

    
    <div class="steps-container">
      
      <div class="step-card active" id="stepCard0" onclick="goToStep(0)">
        <div class="step-header">
          <div class="step-num">1</div>
          <div class="step-label">Mixed Form</div>
        </div>
        <div class="math-expr">
          <span class="frac"><span class="num var-y">dy</span><span class="den var-x">dx</span></span>
          <span>=</span>
          <span class="var-x">f(x)</span>
          <span class="var-y">g(y)</span>
        </div>
      </div>

      <div class="flow-arrow">↓</div>

      
      <div class="step-card" id="stepCard1" onclick="goToStep(1)">
        <div class="step-header">
          <div class="step-num">2</div>
          <div class="step-label">Separated</div>
        </div>
        <div class="math-expr">
          <span class="frac"><span class="num">1</span><span class="den var-y">g(y)</span></span>
          <span class="var-y">dy</span>
          <span>=</span>
          <span class="var-x">f(x)</span>
          <span class="var-x">dx</span>
        </div>
      </div>

      <div class="flow-arrow">↓</div>

      
      <div class="step-card" id="stepCard2" onclick="goToStep(2)">
        <div class="step-header">
          <div class="step-num">3</div>
          <div class="step-label">Integrate</div>
        </div>
        <div class="math-expr">
          <span class="op-integral">∫</span>
          <span class="frac"><span class="num">1</span><span class="den var-y">g(y)</span></span>
          <span class="var-y">dy</span>
          <span>=</span>
          <span class="op-integral">∫</span>
          <span class="var-x">f(x)</span>
          <span class="var-x">dx</span>
        </div>
      </div>
    </div>

    
    <div class="controls">
      <button class="btn-play" id="playBtn" onclick="toggleAutoPlay()">
        <span id="playIcon">⏸</span>
        <span id="playText">Pause</span>
      </button>
      <div class="indicator-dots">
        <button class="dot-btn active" id="dot0" onclick="goToStep(0)" aria-label="Step 1"></button>
        <button class="dot-btn" id="dot1" onclick="goToStep(1)" aria-label="Step 2"></button>
        <button class="dot-btn" id="dot2" onclick="goToStep(2)" aria-label="Step 3"></button>
      </div>
    </div>
  </div>

  <script>
    let currentStep = 0;
    const totalSteps = 3;
    let isPlaying = true;
    let timer = null;

    function updateUI() {
      for (let i = 0; i < totalSteps; i++) {
        const card = document.getElementById('stepCard' + i);
        const dot = document.getElementById('dot' + i);
        if (i === currentStep) {
          card.classList.add('active');
          dot.classList.add('active');
        } else {
          card.classList.remove('active');
          dot.classList.remove('active');
        }
      }
    }

    function goToStep(idx) {
      currentStep = idx;
      updateUI();
      if (isPlaying) {
        restartTimer();
      }
    }

    function nextStep() {
      currentStep = (currentStep + 1) % totalSteps;
      updateUI();
    }

    function startTimer() {
      timer = setInterval(nextStep, 3500);
    }

    function stopTimer() {
      if (timer) {
        clearInterval(timer);
        timer = null;
      }
    }

    function restartTimer() {
      stopTimer();
      startTimer();
    }

    function toggleAutoPlay() {
      isPlaying = !isPlaying;
      const icon = document.getElementById('playIcon');
      const text = document.getElementById('playText');
      if (isPlaying) {
        icon.textContent = '⏸';
        text.textContent = 'Pause';
        startTimer();
      } else {
        icon.textContent = '▶';
        text.textContent = 'Play';
        stopTimer();
      }
    }

    startTimer();
  </script>
</body>
</html>

OGM.12.CAL.6

Aligned learning resources

Related diagrams