Bases et Représentation de la Donnée

Découvrir comment les nombres, textes et fichiers sont codés en binaire et représentés en mémoire.

Une donnée est un fait brut mesurable — une observation élémentaire de la réalité attachée à une entité. Seule, elle ne dit rien. C’est la combinaison de sa nature, son type, son unité et son domaine qui lui confère sa valeur analytique.

Nature Mathématique

Classifier une variable est la première étape de toute analyse. Cette taxonomie dicte les opérations mathématiques autorisées et le mode d’encodage en mémoire.

Nominale Qualitative

motsNominal = ["Rouge", "France", "Standard", "69003", "Bleu", "Genre", "Directeur", "Italie", "Vert"]

renderNominale = {
  createWordCloud('plot-nominale', motsNominal, { radius: 80 })
}

Catégories ou étiquettes sans ordre naturel ni hiérarchie. Les chiffres ne servent que de codes d’identification.

Note

Exemples : Couleur des yeux, Pays, Genre, Code postal.

Ordinale Qualitative

renderOrdinale = {
  createPiramid("plot-ordinale", {
    text: ["Rang 3", "Rang 2", "Rang 1"],
    values: [20, 30, 50]
  }, {
    colors: [
      getThemeColor("--sol-yellow", "#b58900"),
      getThemeColor("--sol-cyan", "#2aa198"),
      getThemeColor("--sol-blue", "#268bd2")
    ]
  });
}

Catégories dotées d’une hiérarchie stricte. La distance mathématique entre rangs n’est pas mesurable.

Note

Exemples : Niveau (S/M/L), Mention bac, Satisfaction client.

Discrète Quantitative

dataDiscrete = {
  let vals = Array.from({length: 5}, () => 10 + Math.floor(Math.random() * 80));
  return { x: ["0", "1", "2", "3", "4+"], y: vals };
}

renderDiscrete = {
  createBar("plot-discrete", dataDiscrete, "", {
    marker: { color: getThemeColor("--sol-green", "#859900") },
    layout: { margin: { t: 10, b: 20, l: 30, r: 10 }, paper_bgcolor: 'transparent', plot_bgcolor: 'transparent' }
  });
}

Valeurs numériques entières dénombrables. On compte des unités distinctes (pas de demi-mesure possible).

Note

Exemples : Nombre d’enfants, graines dans un fruit, élèves par classe.

Continue Quantitative

dataContinuous = {
  let x = [], y = [];
  for(let i = 15; i <= 135; i += 2) {
    x.push(i);
    let dx = (i - 75) / 20;
    y.push(85 * Math.exp(-0.5 * dx * dx));
  }
  return { x, y };
}

renderContinuous = {
  createLine("plot-continuous", dataContinuous, "", {
    mode: "lines",
    line: { shape: "spline", color: getThemeColor("--sol-blue", "#268bd2"), width: 3 },
    markerSize: 0,
    layout: {
      margin: { t: 10, b: 20, l: 30, r: 10 },
      paper_bgcolor: 'transparent',
      plot_bgcolor: 'transparent',
      hovermode: "x unified"
    }
  });
}

Valeurs décimales sur une échelle infinie. Entre deux mesures, il existe une infinité de valeurs possibles.

Note

Exemples : Température °C, Salaire exact, Latitude, Poids.

La Nature Dépend du Contexte

La nature d’une variable n’est pas figée dans le marbre : elle dépend de votre objectif d’analyse.

Prenons l’âge d’un individu :

Contexte	Nature	Valeur typique
Étude clinique (dosage médicament)	Quantitative Continue	12,4 ans
Recensement administratif	Quantitative Discrète	12 ans
Médecine du travail (aptitude)	Qualitative Ordinale	Junior, Adulte, Senior

C’est toujours le but final de l’enquête qui dicte la nature de la variable.

Warning

Attention à la confusion de nature : Un code numérique (ISBN, code postal, numéro de téléphone) reste une donnée nominale. Y appliquer des opérations arithmétiques (moyenne, somme) est mathématiquement sans sens.

Classification des Données

Panneau de brassage des indices

id	label	match	feedback
postal	Code postal du suspect (ex: 75001)	nominale	Le code postal est nominal. Même s’il s’agit de chiffres, leur somme ou moyenne n’a aucun sens mathématique.
salaire	Salaire annuel en euros (ex: 45200.50)	continue	Le salaire est quantitatif continu. Il s’exprime sur une échelle infinie de valeurs décimales mesurables.
mention	Mention au bac (Passable, Bien, Très Bien)	ordinale	La mention est qualitative ordinale. Ce sont des catégories textuelles dotées d’une hiérarchie stricte indiscutable.
battements	Battements cardiaques par minute	discrete	Le nombre de battements est quantitatif discret. On dénombre des unités entières distinctes (pas de demi-battement).

Reliez chaque pièce à conviction de gauche à sa catégorie de données logique de droite.

ON

OFF

Circuit alimenté Circuit coupé

viewof powerOn = createLever("#power-lever", invalidation)

Diagnostic du signal

[!] SIGNAL BROUILLÉ : Brassage incomplet. L’analyse ne peut pas démarrer ({{score}}/{{total}} connectés).

[+] DIAGNOSTIC VALIDÉ : Excellent travail, le signal est pur ({{score}}/{{total}} corrects).

[-] CONFLIT DE SIGNAL : Des courts-circuits subsistent. Analysez la nature des variables ({{score}}/{{total}} corrects).

leftItems = parseTableData("#cabling-data table")
rightItems = Array.from(new Set(leftItems.map(item => item.match))).map(id => ({
  id: id,
  label: id.charAt(0).toUpperCase() + id.slice(1)
}))

engine = {
  const m = createCabling("#cabling-canvas", leftItems, rightItems, (state) => {
    if(state.score < leftItems.length) renderFeedbackUI("#cabling-feedback-panel", { status: "hidden" });
  });
  invalidation.then(() => m.destroy());
  return m;
}

uiLogic = {
  powerOn;
  let state = { status: "hidden" };

  if (powerOn === true) {
    state = engine.validate();
  } else {
    engine.clearValidation();
    renderFeedbackUI("#cabling-feedback-panel", { status: "hidden" });
    return;
  }

  let listData = [];
  if (state.status === "validated") {
    const isPerfect = state.score === leftItems.length;
    state.status = isPerfect ? "validated" : "error";

    listData = leftItems.map(item => {
      const isCorrect = state.connections[item.id] === item.match;
      const rMatch = rightItems.find(r => r.id === state.connections[item.id]);
      return {
        label: item.label,
        rightLabel: rMatch ? rMatch.label : "?",
        badgeClass: isCorrect ? "text-success" : "text-danger",
        badgeText: isCorrect ? "OK" : "Erreur",
        feedback: isCorrect ? item.feedback : "Incohérence détectée dans le choix de l'échelle."
      };
    });
  }

  renderFeedbackUI("#cabling-feedback-panel", state, listData);
}

L’Unité de Mesure

Un nombre sans unité n’a aucune signification concrète. Documenter et valider l’unité associée à chaque variable quantitative est une étape critique — souvent négligée avec des conséquences catastrophiques.

La Catastrophe de Mars Climate Orbiter (1999)

En 1999, la sonde de la NASA à 328 millions de dollars a été pulvérisée dans l’atmosphère martienne à cause d’une seule confusion d’unités.

Un sous-traitant calculait la poussée des moteurs en unités impériales (livre-force × seconde), tandis que l’ordinateur de bord attendait du système métrique (newton × seconde). Même chiffre, unité différente.

Règle d’or : Ne mélangez jamais des choux et des carottes. Validez et convertissez toujours vos unités avant toute opération mathématique ou échange de données entre systèmes.

Même chiffre, valeur physique différente

renderUnits = {
  createBar("plot-units", {
    x: ["450 N·s\n(NASA)", "450 lbf·s\n(Sous-traitant)"],
    y: [450, 2001]
  }, "", {
    marker: { color: [getThemeColor("--sol-green", "#859900"), getThemeColor("--sol-red", "#dc322f")] },
    layout: {
      margin: { t: 15, b: 50, l: 50, r: 10 },
      paper_bgcolor: 'transparent',
      plot_bgcolor: 'transparent',
      yaxis: { title: "Valeur en N·s", gridcolor: 'rgba(255,255,255,0.08)' },
      annotations: [{
        x: 1, y: 2001, text: "4,4× trop grand", showarrow: true, arrowhead: 2,
        font: { color: getThemeColor("--sol-red", "#dc322f"), size: 11 },
        arrowcolor: getThemeColor("--sol-red", "#dc322f")
      }]
    }
  });
}

Note

Types d’unités à documenter :

• Physique : Mètres (\(m\)), kilogrammes (\(kg\)), degrés Celsius (\(°C\))
• Monétaire : Euros (€), Dollars ($), avec l’année de référence pour les données historiques
• Temporelle : Millisecondes (\(ms\)), secondes (\(s\)), jours

Le Domaine de Définition

Le domaine représente l’ensemble des valeurs logiquement admissibles pour une variable. Définir des bornes strictes est la première ligne de défense contre les valeurs aberrantes avant tout traitement algorithmique.

Visualisation d’un domaine — Variable : Âge (années)

renderDomain = {
  const el = document.getElementById("plot-domain");
  if (!el) return;
  el.innerHTML = "";

  const totalWidth = el.clientWidth || 340;
  const height = 110;
  const ml = 20, mr = 20, mt = 35, mb = 20;
  const pw = totalWidth - ml - mr;

  const domMin = -25, domMax = 170;
  const validMin = 0, validMax = 120;
  const xScale = d3.scaleLinear().domain([domMin, domMax]).range([0, pw]);

  const validPoints = [8, 22, 45, 68, 103];
  const invalidPoints = [-12, 150];

  const svg = d3.create("svg")
    .attr("width", "100%")
    .attr("height", height)
    .attr("viewBox", `0 0 ${totalWidth} ${height}`)
    .style("overflow", "visible");

  const g = svg.append("g").attr("transform", `translate(${ml},${mt})`);

  // Axis
  g.append("line")
    .attr("x1", 0).attr("y1", 20).attr("x2", pw).attr("y2", 20)
    .attr("stroke", "var(--sol-base01, #657b83)").attr("stroke-width", 1.5);

  // Valid domain rect
  const rx = xScale(validMin), rw = xScale(validMax) - xScale(validMin);
  g.append("rect")
    .attr("x", rx).attr("y", 10).attr("width", rw).attr("height", 20)
    .attr("fill", "rgba(133, 153, 0, 0.15)")
    .attr("stroke", "var(--sol-green, #859900)").attr("stroke-width", 1.5).attr("rx", 4);

  // Domain label
  g.append("text")
    .attr("x", rx + rw / 2).attr("y", 3)
    .attr("text-anchor", "middle")
    .attr("fill", "var(--sol-green, #859900)").attr("font-size", "10px")
    .text("Domaine valide [0, 120]");

  // Ticks
  [0, 30, 60, 90, 120].forEach(v => {
    const cx = xScale(v);
    g.append("line").attr("x1", cx).attr("y1", 18).attr("x2", cx).attr("y2", 22)
      .attr("stroke", "var(--sol-base01, #657b83)");
    g.append("text").attr("x", cx).attr("y", 34).attr("text-anchor", "middle")
      .attr("fill", "var(--sol-base01, #657b83)").attr("font-size", "9px").text(v);
  });

  // Valid points
  validPoints.forEach(v => {
    const pt = g.append("g").attr("cursor", "pointer");
    pt.append("circle").attr("cx", xScale(v)).attr("cy", 20).attr("r", 6)
      .attr("fill", "var(--sol-cyan, #2aa198)").attr("opacity", 0.9);
    pt.append("title").text(`${v} ans ✓ (valeur valide)`);
  });

  // Invalid points (X marks)
  invalidPoints.forEach(v => {
    const cx = xScale(v), cy = 20, s = 6;
    const mk = g.append("g").attr("cursor", "pointer");
    mk.append("line")
      .attr("x1", cx - s).attr("y1", cy - s).attr("x2", cx + s).attr("y2", cy + s)
      .attr("stroke", "var(--sol-red, #dc322f)").attr("stroke-width", 2.5);
    mk.append("line")
      .attr("x1", cx + s).attr("y1", cy - s).attr("x2", cx - s).attr("y2", cy + s)
      .attr("stroke", "var(--sol-red, #dc322f)").attr("stroke-width", 2.5);
    mk.append("title").text(`${v} ans ✗ (hors domaine – valeur aberrante)`);
  });

  // Legend
  const lg = g.append("g").attr("transform", `translate(0, 50)`);
  lg.append("circle").attr("cx", 6).attr("cy", 0).attr("r", 5).attr("fill", "var(--sol-cyan, #2aa198)");
  lg.append("text").attr("x", 15).attr("y", 4).attr("font-size", "9px")
    .attr("fill", "var(--sol-base0, #839496)").text("Valeur valide");
  const lx2 = pw / 2;
  lg.append("line").attr("x1", lx2 - 5).attr("y1", -5).attr("x2", lx2 + 5).attr("y2", 5)
    .attr("stroke", "var(--sol-red, #dc322f)").attr("stroke-width", 2.5);
  lg.append("line").attr("x1", lx2 + 5).attr("y1", -5).attr("x2", lx2 - 5).attr("y2", 5)
    .attr("stroke", "var(--sol-red, #dc322f)").attr("stroke-width", 2.5);
  lg.append("text").attr("x", lx2 + 9).attr("y", 4).attr("font-size", "9px")
    .attr("fill", "var(--sol-base0, #839496)").text("Valeur aberrante");

  el.appendChild(svg.node());
}

Note

Exemples de domaines courants :

• Âge : \([0, 120]\) ans
• Probabilité : \([0, 1]\)
• Latitude : \([-90°, 90°]\)
• Note sur 20 : \([0, 20]\)

Toute valeur hors du domaine est soit une erreur de saisie, soit une anomalie à investiguer avant tout traitement.

Encodage en Mémoire (RAM)

Simulateur d’encodage physique

Caractéristique	Spécification
Type de donnée	Booléen (Logique)
Taille Physique	1 octet (8 bits)
Encodage RAM	00000001 (True / Vrai) \	00000000 (False / Faux)
Comportement	Bien que 1 bit suffise théoriquement, la mémoire est adressée par octets complets physiques.

Caractéristique	Spécification
Type de donnée	Entier 8 bits (Byte / Octet)
Taille Physique	1 octet (8 bits)
Plage de valeurs	de 0 à 255 (non signé) \	de -128 à 127 (signé)
Comportement	Encodage binaire direct. Les valeurs négatives sont stockées en complément à deux.

Caractéristique	Spécification
Type de donnée	Entier 32 bits (Mot Standard)
Taille Physique	4 octets (32 bits)
Plage de valeurs	de -2 147 483 648 à +2 147 483 647
Comportement	Découpé en 4 octets consécutifs en mémoire, respectant l’endianness (boutisme) de l’architecture.

Caractéristique	Spécification
Type de donnée	Réel double précision (Double / Float64)
Taille Physique	8 octets (64 bits)
Standard	Norme internationale IEEE 754
Structure	1 bit de signe, 11 bits d’exposant, 52 bits de mantisse
Comportement	Représentation scientifique précise, découpée sur 8 octets consécutifs.

Caractéristique	Spécification
Type de donnée	Chaîne de caractères (String)
Taille Physique	Variable (1 octet par caractère en ASCII / UTF-8 standard)
Encodage RAM	Code numérique de chaque caractère (Table ASCII / Points de code Unicode)
Comportement	Séquence contiguë d’octets. Les caractères spéciaux hors ASCII peuvent prendre plusieurs octets.

mutable dataType = "int32"

_ramTabWatcher = {
  const w = createTabsetWatcher(
    ".ram-tabset",
    { "bool": "bool", "int8": "int8", "int32": "int32", "float64": "float64", "string": "string" },
    (val) => { mutable dataType = val; }
  );
  invalidation.then(() => w.destroy());
  return null;
}

rawInput = Generators.input(document.getElementById('rawInput'))

{{hex}}

Octet {{index}}

ramData = getRamData(rawInput, dataType)
updateRamUI = renderRam(ramData)