Advanced

Tutor model

i62 💰:9.4

i52 💰:7.9

🏆 i67 💰:62.5

i70 💰:125.0

i68 💰:125.0

🏆 i66 💰:75.0

i65 💰:125.0

i63 💰:62.5

i61 💰:75.0

i60 💰:9.4

i60 💰:37.5

i58 💰:62.5

i57 💰:22.5

i57 💰:37.5

i56 💰:45.0

⚡ i55 💰:11.25

i55 💰:37.5

i54 💰:62.5

i52 💰:35.0

i51 💰:37.5

i49 💰:15.0

i49 💰:62.5

i48 💰:11.3

i47 💰:7.5

i44 💰:25.0

i43 💰:37.5

i42 💰:187.5

i40 💰:5.0

i39 💰:100.0

i38 💰:37.5

i37 💰:11.0

i36 💰:187.5

i34 💰:12.5

i33 💰:37.5

i30 💰:1.0

i29 💰:1.5

i28 💰:150.0

i23 💰:20.0

i20 💰:4.0

i18 💰:1.0

i16 💰:25.0

i13 💰:1.5

Keep session private

What would you like to learn?

Override for the tutor's lesson content generation calls. Auto uses the system default (Claude Sonnet 5 for lesson text, Opus 5 for diagrams).

Lesson generation model

System default

i58 💰:18.8

i31 💰:11.0

i25 💰:31.3

Tutoring abilities

Imagine a friend calls and says, "I hiked 4 miles from our campsite! Come meet me!"

Even with a map, you have no idea where they are because 4 miles could mean north, south, up a mountain, or straight into a lake.

To pinpoint their location, you need two pieces of information: how far they went and which way they headed.

A **scalar** is a quantity fully described by just a single numerical value, known as its **magnitude** (or size), along with units.

A **vector** is a quantity that requires both a **magnitude** and a specific **direction** to be completely understood.

In the 1840s, Irish mathematician William Rowan Hamilton coined the word *vector*—from the Latin word for "carrier"—to describe quantities that carry an object from one point to another.

<!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;
      user-select: none;
      -webkit-user-select: none;
    }

    body {
      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      background: #f8f9fa;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      width: 100%;
      min-height: 100%;
      padding: 12px;
      gap: 10px;
    }

    .hud {
      display: flex;
      gap: 12px;
      width: 100%;
      max-width: 440px;
      justify-content: center;
    }

    .badge {
      flex: 1;
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      padding: 6px 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      box-shadow: 0 1px 3px rgba(0,0,0,0.04);
    }

    .badge-label {
      font-size: 11px;
      text-transform: uppercase;
      letter-spacing: 0.5px;
      font-weight: 700;
      color: #64748b;
    }

    .badge-val {
      font-size: 18px;
      font-weight: 700;
      color: #2563eb;
    }

    .badge-val.dir {
      color: #059669;
    }

    .canvas-wrap {
      width: 100%;
      max-width: 440px;
      aspect-ratio: 4 / 3;
      background: #ffffff;
      border-radius: 12px;
      border: 1px solid #e2e8f0;
      box-shadow: 0 2px 8px rgba(0,0,0,0.04);
      position: relative;
      touch-action: none;
    }

    svg {
      width: 100%;
      height: 100%;
      overflow: visible;
      display: block;
    }

    .grid-line {
      stroke: #f1f5f9;
      stroke-width: 1;
    }

    .axis {
      stroke: #cbd5e1;
      stroke-width: 1.5;
      stroke-linecap: round;
    }

    .angle-arc {
      fill: rgba(5, 150, 105, 0.12);
      stroke: #059669;
      stroke-width: 1.5;
    }

    .vec-line {
      stroke: #2563eb;
      stroke-width: 4;
      stroke-linecap: round;
    }

    .mag-label {
      fill: #2563eb;
      font-size: 13px;
      font-weight: 700;
      text-anchor: middle;
      paint-order: stroke;
      stroke: #ffffff;
      stroke-width: 4px;
      stroke-linejoin: round;
    }

    .term-label {
      font-size: 11px;
      font-weight: 600;
      fill: #64748b;
      text-anchor: middle;
    }

    .handle {
      fill: #2563eb;
      stroke: #ffffff;
      stroke-width: 3;
      cursor: grab;
      filter: drop-shadow(0 2px 4px rgba(37,99,235,0.3));
    }

    .handle:active {
      cursor: grabbing;
      fill: #1d4ed8;
    }

    .tail-dot {
      fill: #1e2945;
    }

    .presets {
      display: flex;
      gap: 6px;
      width: 100%;
      max-width: 440px;
      justify-content: center;
      flex-wrap: wrap;
    }

    .btn-preset {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      padding: 5px 10px;
      border-radius: 6px;
      font-size: 12px;
      font-weight: 600;
      color: #475569;
      cursor: pointer;
      box-shadow: 0 1px 2px rgba(0,0,0,0.03);
    }

    .btn-preset:hover {
      background: #f8fafc;
      border-color: #cbd5e1;
    }
  </style>
</head>
<body>

  <div class="hud">
    <div class="badge">
      <span class="badge-label">Magnitude</span>
      <span class="badge-val" id="magVal">5.0 u</span>
    </div>
    <div class="badge">
      <span class="badge-label">Direction</span>
      <span class="badge-val dir" id="dirVal">37°</span>
    </div>
  </div>

  <div class="canvas-wrap" id="stage">
    <svg viewBox="0 0 400 300" id="svgCanvas">
      <defs>
        <marker id="arrow" viewBox="0 0 10 10" refX="6" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">
          <path d="M 0 1.5 L 8 5 L 0 8.5 z" fill="#2563eb" />
        </marker>
      </defs>

      
      <g id="grid"></g>

      
      <line x1="40" y1="230" x2="360" y2="230" class="axis" />
      <line x1="80" y1="270" x2="80" y2="30" class="axis" />

      
      <path id="angleArc" class="angle-arc" d="" />
      <text id="angleLabel" x="0" y="0" font-size="11" font-weight="700" fill="#059669" text-anchor="middle"></text>

      
      <line id="vecLine" x1="80" y1="230" x2="240" y2="110" class="vec-line" marker-end="url(#arrow)" />

      
      <text id="magText" class="mag-label" x="160" y="160">5.0</text>

      
      <circle cx="80" y="230" r="5" class="tail-dot" />
      <text x="80" y="248" class="term-label">Tail</text>

      
      <text id="headLabel" x="240" y="96" class="term-label">Head</text>
      <circle id="handle" cx="240" y="110" r="10" class="handle" />
    </svg>
  </div>

  <div class="presets">
    <button class="btn-preset" onclick="setVec(3, 4)">3, 4 (5.0 u @ 53°)</button>
    <button class="btn-preset" onclick="setVec(5, 2)">5, 2 (5.4 u @ 22°)</button>
    <button class="btn-preset" onclick="setVec(2, 4.5)">2, 4.5 (4.9 u @ 66°)</button>
    <button class="btn-preset" onclick="setVec(6, 0)">6, 0 (6.0 u @ 0°)</button>
  </div>

  <script>
    const ORIGIN = { x: 80, y: 230 };
    const SCALE = 36; // 36px per unit

    const svg = document.getElementById('svgCanvas');
    const handle = document.getElementById('handle');
    const vecLine = document.getElementById('vecLine');
    const angleArc = document.getElementById('angleArc');
    const angleLabel = document.getElementById('angleLabel');
    const magText = document.getElementById('magText');
    const headLabel = document.getElementById('headLabel');
    const magVal = document.getElementById('magVal');
    const dirVal = document.getElementById('dirVal');
    const grid = document.getElementById('grid');

    // Draw Grid
    for (let x = 80 + SCALE; x <= 360; x += SCALE) {
      const l = document.createElementNS('http://www.w3.org/2000/svg', 'line');
      l.setAttribute('x1', x); l.setAttribute('y1', 30);
      l.setAttribute('x2', x); l.setAttribute('y2', 270);
      l.setAttribute('class', 'grid-line');
      grid.appendChild(l);
    }
    for (let y = 230 - SCALE; y >= 30; y -= SCALE) {
      const l = document.createElementNS('http://www.w3.org/2000/svg', 'line');
      l.setAttribute('x1', 40); l.setAttribute('y1', y);
      l.setAttribute('x2', 360); l.setAttribute('y2', y);
      l.setAttribute('class', 'grid-line');
      grid.appendChild(l);
    }

    let headX = 224; // 4 units
    let headY = 122; // 3 units

    function updateVector(hx, hy) {
      headX = Math.max(90, Math.min(350, hx));
      headY = Math.max(30, Math.min(250, hy));

      const dx = (headX - ORIGIN.x) / SCALE;
      const dy = (ORIGIN.y - headY) / SCALE;

      const mag = Math.sqrt(dx * dx + dy * dy);
      let deg = Math.atan2(dy, dx) * (180 / Math.PI);
      if (deg < 0) deg += 360;

      // Update Handle & Line
      handle.setAttribute('cx', headX);
      handle.setAttribute('cy', headY);

      // Shorten visible line slightly so arrow marker doesn't get covered by handle
      const rad = Math.atan2(headY - ORIGIN.y, headX - ORIGIN.x);
      const lineEndX = headX - Math.cos(rad) * 4;
      const lineEndY = headY - Math.sin(rad) * 4;

      vecLine.setAttribute('x2', lineEndX);
      vecLine.setAttribute('y2', lineEndY);

      headLabel.setAttribute('x', headX);
      headLabel.setAttribute('y', headY - 14);

      // Magnitude text along vector midpoint
      const midX = (ORIGIN.x + headX) / 2;
      const midY = (ORIGIN.y + headY) / 2;
      const perpX = -Math.sin(rad) * 16;
      const perpY = Math.cos(rad) * 16;
      magText.setAttribute('x', midX + perpX);
      magText.setAttribute('y', midY + perpY);
      magText.textContent = mag.toFixed(1);

      // Angle Arc
      const arcR = Math.min(38, Math.max(22, mag * SCALE * 0.4));
      if (mag > 0.3) {
        const startX = ORIGIN.x + arcR;
        const startY = ORIGIN.y;
        const endX = ORIGIN.x + arcR * Math.cos(rad);
        const endY = ORIGIN.y + arcR * Math.sin(rad);
        const largeArc = deg > 180 ? 1 : 0;
        const sweep = rad > 0 ? 1 : 0;

        angleArc.setAttribute('d', `M ${ORIGIN.x} ${ORIGIN.y} L ${startX} ${startY} A ${arcR} ${arcR} 0 ${largeArc} ${sweep} ${endX} ${endY} Z`);
        angleArc.style.display = 'block';

        const midAngle = -deg / 2 * (Math.PI / 180);
        const labelR = arcR + 14;
        angleLabel.setAttribute('x', ORIGIN.x + labelR * Math.cos(midAngle));
        angleLabel.setAttribute('y', ORIGIN.y + labelR * Math.sin(midAngle) + 4);
        angleLabel.textContent = `${Math.round(deg)}°`;
      } else {
        angleArc.style.display = 'none';
        angleLabel.textContent = '';
      }

      // HUD Badges
      magVal.textContent = `${mag.toFixed(1)} u`;
      dirVal.textContent = `${Math.round(deg)}°`;
    }

    function setVec(uX, uY) {
      updateVector(ORIGIN.x + uX * SCALE, ORIGIN.y - uY * SCALE);
    }

    // Drag Interaction
    let isDragging = false;

    function getSvgCoords(e) {
      const pt = svg.createSVGPoint();
      pt.x = e.clientX || (e.touches && e.touches[0].clientX);
      pt.y = e.clientY || (e.touches && e.touches[0].clientY);
      return pt.matrixTransform(svg.getScreenCTM().inverse());
    }

    function onPointerDown(e) {
      isDragging = true;
      const coords = getSvgCoords(e);
      updateVector(coords.x, coords.y);
    }

    function onPointerMove(e) {
      if (!isDragging) return;
      const coords = getSvgCoords(e);
      updateVector(coords.x, coords.y);
    }

    function onPointerUp() {
      isDragging = false;
    }

    const stage = document.getElementById('stage');
    stage.addEventListener('pointerdown', onPointerDown);
    window.addEventListener('pointermove', onPointerMove);
    window.addEventListener('pointerup', onPointerUp);
    window.addEventListener('pointercancel', onPointerUp);

    // Initial setup: 4 units right, 3 units up => 5.0u @ 37°
    setVec(4, 3);
  </script>
</body>
</html>

How do mathematicians draw and label a quantity that points in space?

On paper, we represent a vector as a **directed line segment**—an arrow connecting a starting point to an ending point.

The arrow starts at the **initial point** (the tail) and points toward the **terminal point** (the tip or arrowhead).

The arrow's length represents the vector's **magnitude**, while the way the arrowhead points shows its **direction**.

In textbooks and equations, vectors are written in bold ($\mathbf{v}$) or with a small arrow on top ($\vec{v}$), while the magnitude is written with vertical bars, like $|\vec{v}\|$ or $\|\vec{v}\|$. Magnitude is always a non-negative number.

<!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">
  <title>Vector: Magnitude and Direction</title>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.css">
  <script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.8/dist/katex.min.js"></script>
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; -webkit-tap-highlight-color: transparent; }
    body {
      font-family: system-ui, -apple-system, sans-serif;
      background: #f8f9fa;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      min-height: 100%;
      padding: 12px;
      user-select: none;
    }

    .readouts {
      display: flex;
      gap: 10px;
      width: 100%;
      max-width: 480px;
      justify-content: center;
      margin-bottom: 6px;
    }

    .badge {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      padding: 6px 12px;
      font-size: 14px;
      font-weight: 600;
      box-shadow: 0 1px 3px rgba(0,0,0,0.05);
      display: flex;
      align-items: center;
      gap: 6px;
      flex: 1;
      justify-content: center;
    }

    .badge-mag { color: #2563eb; border-left: 4px solid #2563eb; }
    .badge-dir { color: #7c3aed; border-left: 4px solid #7c3aed; }

    .svg-wrap {
      width: 100%;
      max-width: 480px;
      aspect-ratio: 4 / 3;
      background: #ffffff;
      border-radius: 12px;
      border: 1px solid #e2e8f0;
      position: relative;
      touch-action: none;
      box-shadow: 0 2px 6px rgba(0,0,0,0.04);
    }

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

    .grid-line { stroke: #f1f5f9; stroke-width: 1.5; }
    .axis-line { stroke: #cbd5e1; stroke-width: 2; }
    .axis-label { fill: #94a3b8; font-size: 11px; font-weight: 500; text-anchor: middle; }

    .vec-line { stroke: #2563eb; stroke-width: 4.5; stroke-linecap: round; }
    .vec-head { fill: #2563eb; }
    .angle-arc { fill: rgba(124, 58, 237, 0.12); stroke: #7c3aed; stroke-width: 2; }
    
    .handle {
      fill: #ffffff;
      stroke: #2563eb;
      stroke-width: 3.5;
      cursor: grab;
      filter: drop-shadow(0 2px 4px rgba(0,0,0,0.2));
      transition: r 0.15s ease;
    }
    .handle:active, .is-dragging .handle {
      cursor: grabbing;
      r: 12;
      stroke: #1d4ed8;
    }

    .controls {
      display: flex;
      gap: 8px;
      width: 100%;
      max-width: 480px;
      margin-top: 8px;
    }

    .btn {
      flex: 1;
      background: #ffffff;
      border: 1px solid #cbd5e1;
      border-radius: 8px;
      padding: 8px 4px;
      font-size: 13px;
      font-weight: 600;
      color: #334155;
      cursor: pointer;
      text-align: center;
      transition: background 0.2s, border-color 0.2s;
    }
    .btn:active {
      background: #e2e8f0;
      border-color: #94a3b8;
    }
  </style>
</head>
<body>

  <div class="readouts">
    <div class="badge badge-mag">
      <span id="mag-label"></span>
    </div>
    <div class="badge badge-dir">
      <span id="dir-label"></span>
    </div>
  </div>

  <div class="svg-wrap" id="canvas-container">
    <svg id="scene" viewBox="0 0 400 300">
      
      <g id="grid"></g>
      
      
      <line x1="40" y1="230" x2="370" y2="230" class="axis-line" />
      <line x1="70" y1="260" x2="70" y2="30" class="axis-line" />
      <text x="365" y="245" class="axis-label">+x</text>
      <text x="55" y="40" class="axis-label">+y</text>
      
      
      <path id="angle-arc" class="angle-arc" d="" />
      <text id="angle-text" x="0" y="0" fill="#7c3aed" font-size="13" font-weight="700" text-anchor="middle"></text>

      
      <line id="vec-line" x1="70" y1="230" x2="250" y2="95" class="vec-line" />
      <polygon id="vec-head" class="vec-head" points="" />

      
      <circle id="handle" class="handle" cx="250" cy="95" r="10" />
    </svg>
  </div>

  <div class="controls">
    <button class="btn" id="btn-turn">↻ Rotate (Same Mag)</button>
    <button class="btn" id="btn-grow">⇥ Extend (Same Dir)</button>
  </div>

  <script>
    const origin = { x: 70, y: 230 };
    const scale = 32; // pixels per unit
    let tip = { x: 260, y: 90 };
    let isDragging = false;

    const svg = document.getElementById('scene');
    const wrap = document.getElementById('canvas-container');
    const vecLine = document.getElementById('vec-line');
    const vecHead = document.getElementById('vec-head');
    const handle = document.getElementById('handle');
    const angleArc = document.getElementById('angle-arc');
    const angleText = document.getElementById('angle-text');
    const magLabel = document.getElementById('mag-label');
    const dirLabel = document.getElementById('dir-label');

    // Build Background Grid
    const gridG = document.getElementById('grid');
    for (let x = origin.x; x <= 370; x += scale) {
      gridG.innerHTML += `<line x1="${x}" y1="20" x2="${x}" y2="270" class="grid-line"/>`;
    }
    for (let y = origin.y; y >= 30; y -= scale) {
      gridG.innerHTML += `<line x1="30" y1="${y}" x2="380" y2="${y}" class="grid-line"/>`;
    }

    function update() {
      const dx = tip.x - origin.x;
      const dy = origin.y - tip.y; // SVG y is inverted
      
      const lengthPx = Math.hypot(dx, dy);
      const magUnits = (lengthPx / scale).toFixed(1);
      
      let rad = Math.atan2(dy, dx);
      if (rad < 0) rad += 2 * Math.PI;
      const deg = Math.round((rad * 180) / Math.PI);

      // Shorten line slightly so arrow head fits cleanly
      const headLen = 14;
      const angle = Math.atan2(tip.y - origin.y, tip.x - origin.x);
      
      const endX = tip.x - Math.cos(angle) * (headLen * 0.5);
      const endY = tip.y - Math.sin(angle) * (headLen * 0.5);

      vecLine.setAttribute('x2', endX);
      vecLine.setAttribute('y2', endY);

      // Arrow head points
      const p1x = tip.x;
      const p1y = tip.y;
      const p2x = tip.x - headLen * Math.cos(angle - Math.PI / 6);
      const p2y = tip.y - headLen * Math.sin(angle - Math.PI / 6);
      const p3x = tip.x - headLen * Math.cos(angle + Math.PI / 6);
      const p3y = tip.y - headLen * Math.sin(angle + Math.PI / 6);
      vecHead.setAttribute('points', `${p1x},${p1y} ${p2x},${p2y} ${p3x},${p3y}`);

      // Drag handle
      handle.setAttribute('cx', tip.x);
      handle.setAttribute('cy', tip.y);

      // Direction Arc
      const arcR = Math.min(48, lengthPx * 0.4);
      if (lengthPx > 25 && deg > 2) {
        const arcEndX = origin.x + arcR * Math.cos(angle);
        const arcEndY = origin.y + arcR * Math.sin(angle);
        const largeArc = deg > 180 ? 1 : 0;
        // SVG sweeps clockwise (y downwards), so sweep=0 goes counter-clockwise in math coords
        const d = `M ${origin.x + arcR} ${origin.y} A ${arcR} ${arcR} 0 ${largeArc} 0 ${arcEndX} ${arcEndY} L ${origin.x} ${origin.y} Z`;
        angleArc.setAttribute('d', d);
        angleArc.style.display = 'block';

        const midA = - (rad / 2);
        const textR = arcR + 18;
        angleText.setAttribute('x', origin.x + textR * Math.cos(midA));
        angleText.setAttribute('y', origin.y + textR * Math.sin(midA) + 4);
        angleText.textContent = `${deg}°`;
        angleText.style.display = 'block';
      } else {
        angleArc.style.display = 'none';
        angleText.style.display = 'none';
      }

      // Render math labels
      if (window.katex) {
        katex.render(`|\\vec{v}| = ${magUnits}`, magLabel);
        katex.render(`\\theta = ${deg}^\\circ`, dirLabel);
      } else {
        magLabel.textContent = `|v⃗| = ${magUnits}`;
        dirLabel.textContent = `θ = ${deg}°`;
      }
    }

    function setTipFromPoint(clientX, clientY) {
      const rect = svg.getBoundingClientRect();
      const x = ((clientX - rect.left) / rect.width) * 400;
      const y = ((clientY - rect.top) / rect.height) * 300;

      // Clamp within grid area
      const clampedX = Math.max(75, Math.min(365, x));
      const clampedY = Math.max(35, Math.min(225, y));
      tip = { x: clampedX, y: clampedY };
      update();
    }

    function onPointerDown(e) {
      isDragging = true;
      wrap.classList.add('is-dragging');
      setTipFromPoint(e.clientX || (e.touches && e.touches[0].clientX), e.clientY || (e.touches && e.touches[0].clientY));
    }

    function onPointerMove(e) {
      if (!isDragging) return;
      const cx = e.clientX || (e.touches && e.touches[0].clientX);
      const cy = e.clientY || (e.touches && e.touches[0].clientY);
      setTipFromPoint(cx, cy);
      e.preventDefault();
    }

    function onPointerUp() {
      isDragging = false;
      wrap.classList.remove('is-dragging');
    }

    handle.addEventListener('mousedown', onPointerDown);
    wrap.addEventListener('mousedown', onPointerDown);
    window.addEventListener('mousemove', onPointerMove);
    window.addEventListener('mouseup', onPointerUp);

    handle.addEventListener('touchstart', onPointerDown, { passive: false });
    wrap.addEventListener('touchstart', onPointerDown, { passive: false });
    window.addEventListener('touchmove', onPointerMove, { passive: false });
    window.addEventListener('touchend', onPointerUp);

    // Preset interactions
    document.getElementById('btn-turn').addEventListener('click', () => {
      const dx = tip.x - origin.x;
      const dy = origin.y - tip.y;
      const len = Math.hypot(dx, dy);
      let rad = Math.atan2(dy, dx) + (Math.PI / 6);
      if (rad > Math.PI * 0.45) rad = 0.2; // Keep in visible quadrant
      tip.x = origin.x + len * Math.cos(rad);
      tip.y = origin.y - len * Math.sin(rad);
      update();
    });

    document.getElementById('btn-grow').addEventListener('click', () => {
      const dx = tip.x - origin.x;
      const dy = origin.y - tip.y;
      let len = Math.hypot(dx, dy) * 1.35;
      if (len > 290) len = 110; // Wrap length
      const angle = Math.atan2(dy, dx);
      tip.x = origin.x + len * Math.cos(angle);
      tip.y = origin.y - len * Math.sin(angle);
      update();
    });

    window.addEventListener('load', update);
    update();
  </script>
</body>
</html>

What happens when an object keeps the same speed, but turns a corner?

**Distance** and **speed** are scalars: they only tell you how much ground was covered or how fast something is moving.

**Displacement** and **velocity** are vectors: displacement is the straight-line change in position from start to finish, and velocity is speed *in a given direction*.

If a racecar drives around a circular track at a steady $100\text{ mph}$, its speed is constant, but its velocity is constantly changing because its direction changes every millisecond.

<!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;
      user-select: none;
      -webkit-user-select: none;
    }

    body {
      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      background: #f8f9fa;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      height: 100%;
      min-height: 380px;
      padding: 12px;
      overflow: hidden;
    }

    .display-grid {
      display: grid;
      grid-template-columns: 1fr 1fr;
      gap: 10px;
      width: 100%;
      max-width: 440px;
    }

    .panel {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      padding: 8px 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      box-shadow: 0 1px 3px rgba(0,0,0,0.04);
    }

    .panel-title {
      font-size: 13px;
      font-weight: 700;
      letter-spacing: 0.3px;
      text-transform: uppercase;
      margin-bottom: 2px;
    }

    .scalar-title { color: #64748b; }
    .vector-title { color: #2563eb; }

    .panel-val {
      font-size: 16px;
      font-weight: 700;
      display: flex;
      align-items: center;
      gap: 6px;
    }

    .scalar-val { color: #0f172a; }
    .vector-val { color: #2563eb; }

    .badge {
      font-size: 11px;
      padding: 2px 6px;
      border-radius: 4px;
      font-weight: 600;
    }

    .badge-gray { background: #f1f5f9; color: #475569; }
    .badge-blue { background: #eff6ff; color: #2563eb; }

    .track-container {
      position: relative;
      width: 100%;
      max-width: 320px;
      aspect-ratio: 1 / 1;
      display: flex;
      align-items: center;
      justify-content: center;
      margin: 4px 0;
    }

    svg {
      width: 100%;
      height: 100%;
      overflow: visible;
      touch-action: none;
    }

    .track-road {
      fill: none;
      stroke: #e2e8f0;
      stroke-width: 24;
    }

    .track-center-line {
      fill: none;
      stroke: #cbd5e1;
      stroke-width: 2;
      stroke-dasharray: 6 6;
    }

    .vector-arrow {
      stroke: #2563eb;
      stroke-width: 3.5;
      stroke-linecap: round;
    }

    .car-marker {
      fill: #1e2945;
      stroke: #ffffff;
      stroke-width: 2;
      cursor: grab;
    }

    .car-marker:active {
      cursor: grabbing;
    }

    .controls {
      display: flex;
      align-items: center;
      gap: 12px;
    }

    .btn {
      background: #ffffff;
      border: 1px solid #cbd5e1;
      border-radius: 8px;
      padding: 6px 14px;
      font-size: 14px;
      font-weight: 600;
      color: #1e2945;
      cursor: pointer;
      display: flex;
      align-items: center;
      gap: 6px;
      box-shadow: 0 1px 2px rgba(0,0,0,0.05);
    }

    .btn:active {
      background: #f1f5f9;
    }
  </style>
</head>
<body>

  <div class="display-grid">
    <div class="panel">
      <div class="panel-title scalar-title">Speed (Scalar)</div>
      <div class="panel-val scalar-val">
        <span>100 mph</span>
        <span class="badge badge-gray">Constant</span>
      </div>
    </div>

    <div class="panel">
      <div class="panel-title vector-title">Velocity (Vector)</div>
      <div class="panel-val vector-val">
        <span id="headingText">100 mph →</span>
        <span class="badge badge-blue">Changing</span>
      </div>
    </div>
  </div>

  <div class="track-container">
    <svg viewBox="0 0 240 240" id="trackSvg">
      <defs>
        <marker id="arrowhead" viewBox="0 0 10 10" refX="6" refY="5" markerWidth="6" markerHeight="6" orient="auto">
          <path d="M 0 1.5 L 8 5 L 0 8.5 z" fill="#2563eb"/>
        </marker>
      </defs>

      
      <circle cx="120" cy="120" r="82" class="track-road" />
      <circle cx="120" cy="120" r="82" class="track-center-line" />

      
      <text x="120" y="117" text-anchor="middle" font-size="12" font-weight="600" fill="#94a3b8">Magnitude: 100</text>
      <text x="120" y="132" text-anchor="middle" font-size="11" font-weight="500" fill="#94a3b8">Direction: Changing</text>

      
      <line id="velocityVector" x1="120" y1="38" x2="175" y2="38" class="vector-arrow" marker-end="url(#arrowhead)" />

      
      <circle id="car" cx="120" cy="38" r="9" class="car-marker" />
    </svg>
  </div>

  <div class="controls">
    <button class="btn" id="playBtn">
      <span id="playIcon">⏸</span>
      <span id="playText">Pause</span>
    </button>
  </div>

  <script>
    const R = 82;
    const CX = 120;
    const CY = 120;
    const ARROW_LEN = 48;

    const car = document.getElementById('car');
    const vec = document.getElementById('velocityVector');
    const headingText = document.getElementById('headingText');
    const playBtn = document.getElementById('playBtn');
    const playIcon = document.getElementById('playIcon');
    const playText = document.getElementById('playText');
    const svg = document.getElementById('trackSvg');

    let angle = -Math.PI / 2; // Start at top
    let isPlaying = true;
    let isDragging = false;
    let lastTime = performance.now();

    const arrowSymbols = ['→', '↘', '↓', '↙', '←', '↖', '↑', '↗'];

    function getArrowSymbol(rad) {
      let deg = (rad * 180 / Math.PI) % 360;
      if (deg < 0) deg += 360;
      const idx = Math.round(deg / 45) % 8;
      return arrowSymbols[idx];
    }

    function updatePositions() {
      const carX = CX + R * Math.cos(angle);
      const carY = CY + R * Math.sin(angle);

      // Tangent vector direction (car moves clockwise: tangent angle = angle + pi/2)
      const tangentAngle = angle + Math.PI / 2;
      const targetX = carX + ARROW_LEN * Math.cos(tangentAngle);
      const targetY = carY + ARROW_LEN * Math.sin(tangentAngle);

      car.setAttribute('cx', carX);
      car.setAttribute('cy', carY);

      vec.setAttribute('x1', carX);
      vec.setAttribute('y1', carY);
      vec.setAttribute('x2', targetX);
      vec.setAttribute('y2', targetY);

      const sym = getArrowSymbol(tangentAngle);
      headingText.textContent = `100 mph ${sym}`;
    }

    function animate(currentTime) {
      const dt = (currentTime - lastTime) / 1000;
      lastTime = currentTime;

      if (isPlaying && !isDragging) {
        // Full loop in ~5 seconds
        angle += (2 * Math.PI / 5) * dt;
        if (angle > Math.PI * 2) angle -= Math.PI * 2;
        updatePositions();
      }

      requestAnimationFrame(animate);
    }

    function handlePointer(e) {
      const rect = svg.getBoundingClientRect();
      const x = (e.clientX || (e.touches && e.touches[0].clientX)) - rect.left;
      const y = (e.clientY || (e.touches && e.touches[0].clientY)) - rect.top;

      const scaleX = 240 / rect.width;
      const scaleY = 240 / rect.height;

      const svgX = x * scaleX;
      const svgY = y * scaleY;

      angle = Math.atan2(svgY - CY, svgX - CX);
      updatePositions();
    }

    function startDrag(e) {
      isDragging = true;
      handlePointer(e);
    }

    function stopDrag() {
      isDragging = false;
    }

    svg.addEventListener('mousedown', (e) => { startDrag(e); });
    window.addEventListener('mousemove', (e) => { if (isDragging) handlePointer(e); });
    window.addEventListener('mouseup', stopDrag);

    svg.addEventListener('touchstart', (e) => { startDrag(e); }, { passive: true });
    window.addEventListener('touchmove', (e) => { if (isDragging) handlePointer(e); }, { passive: true });
    window.addEventListener('touchend', stopDrag);

    playBtn.addEventListener('click', () => {
      isPlaying = !isPlaying;
      playIcon.textContent = isPlaying ? '⏸' : '▶';
      playText.textContent = isPlaying ? 'Pause' : 'Play';
    });

    updatePositions();
    requestAnimationFrame(animate);
  </script>
</body>
</html>

Can you always tell whether a real-world measurement is a scalar or a vector?

## Worked Example: Classifying Quantities

Let's classify three everyday quantities: (A) A wind gust blowing $35\text{ mph}$ due West, (B) A water bottle with a volume of $750\text{ mL}$, and (C) A downward gravitational pull of $9.8\text{ N}$.

For (A), $35\text{ mph}$ is magnitude and "due West" is direction, making this a **vector** (wind velocity).

For (B), $750\text{ mL}$ is an amount of space with no associated direction, so it is a **scalar**.

For (C), $9.8\text{ N}$ is magnitude and "downward" provides direction, making force a **vector**.

Next time you look at a weather map, ask yourself: is the meteorologist reporting a scalar like temperature, or a vector like wind velocity?

math

What Is a Vector? Magnitude and Direction. Define a vector as a quantity with both magnitude and direction and distinguish vectors from scalars.

Introduction to Vectors and Scalars

1-D Kinematics: Vectors and Scalars

Scalar and Vector Quantities

When introducing vectors to 9th-10th grade students, anchor the concept in tangible everyday experiences before formalizing algebraic symbols. Start with kinesthetic analogies (e.g., 'Take 3 steps' vs. 'Take 3 steps forward') to establish why direction is critical. Pair contrasting concepts side-by-side (Distance vs. Displacement, Speed vs. Velocity) and emphasize that vector magnitude $|\vec{v}|$ is always non-negative. Reinforce standard geometric representations (directed line segments with defined tail and head) alongside standard mathematical notations ($\vec{v}$, $\mathbf{v}$, $|\vec{v}|$) to build fluency across mathematics and introductory physics.

What Is a Vector? Magnitude and Direction

Scalars vs. Vectors

Anatomy of a Vector