Aller au contenu principal
Recette numéro 185

Recettes · Chapitre 2 · Caractères et texte

Signes de logique et d’ensembles par une police des symboles

Un manuel de logique dans des polices sans ∀, ∈ ni ℵ : symbolFont désigne Noto Sans Math, qui dessine ces signes et le grec sur le canevas et dans le PDF.

Sur cette page
  • Exemple en anglais : pas encore d’édition française
  • Format 155 × 235 mm
  • 1 colonne
  • Crimson Pro 11/15
  • Cormorant Garamond
  • IBM Plex Sans Condensed
  • 4 pages
  • Niveau
  • Postext 1.73.0
  • Mis en page en 17 ms
  • 163 lignes de code

En bref

Un court chapitre qui apprend à lire les signes de la logique et de la théorie des ensembles. Les polices du livre n’ont pas ces signes : une seconde police les fournit, à l’écran et dans le PDF imprimé.

Ce que vous allez composer

Le premier chapitre d’un petit manuel de logique, sur une page de 155 × 235 mm : un bandeau grenat où les signes du chapitre sont composés en grand, puis quatre sections qui lisent à voix haute ∀, ∃, ∈, ∪, ∅ et ℵ, avec les formules dans le texte courant et détachées entre les paragraphes. Le livre est composé en Crimson Pro, ses titres en Cormorant Garamond et ses étiquettes en IBM Plex Sans Condensed. Aucune des trois n’a ∀, ∈ ni de lettre grecque dans les fichiers que sert Fontsource. Un seul réglage, symbolFont, place Noto Sans Math derrière chacune : tous les signes viennent de la même police dans le texte, les titres, les titres courants et les cellules des tableaux, et le PDF les imprime tous.

Cette recette répond à

  • Comment imprimer les signes de logique et d’ensembles (∀, ∈, ℵ) et le grec que ma police de texte n’a pas, sans cases vides dans le PDF ?

La réponse courte

script.js · lignes 34–47dans le code complet
// None of the three faces has ∀, ∈, ℵ or Greek. config.symbolFont (below) lists Noto Sans
// Math after every family the document names: what a face lacks is drawn from it, at the
// face's size and colour, in the canvas, the PDF, the HTML and the EPUB.
const SYMBOLS = 'Noto Sans Math';
// Fontsource serves Noto Sans Math whole in its "latin" file, and the kit would declare
// that file for the Latin range only. The screen and the PDF take it here with no range,
// so every glyph in it can be used.
const symbolFile = async () =>
  `${await fontsourceAt('noto-sans-math')}files/noto-sans-math-latin-400-normal.woff2`;
const resolve = async (family, ...face) =>
  (family === SYMBOLS ? [{ source: await symbolFile() }] : fontsourceResolver(family, ...face));
const pdfFonts = async (family, ...face) => (family !== SYMBOLS
  ? fontsourceProvider(family, ...face)
  : decompressWoff2(new Uint8Array(await (await fetch(await symbolFile())).arrayBuffer())));

Ingrédients

Typographie
Crimson Pro, Cormorant Garamond, IBM Plex Sans Condensed, Noto Sans Math (SIL OFL 1.1)
Ressources
Aucune : chaque image est dessinée en code

Préparation

#1 · Une police des symboles derrière toutes les autres

Le code de cette étape est la réponse courte, plus haut. symbolFont: 'Noto Sans Math' (police des symboles) place cette famille derrière toutes celles que nomme la configuration : un caractère absent de la police est dessiné en Noto Sans Math, au corps et dans la couleur de la police, et le reste de la ligne garde la sienne. Fontsource sert Noto Sans Math entière dans son fichier latin, soit 3 033 caractères, mais le kit déclare ce fichier pour la seule plage latine, et le navigateur ne lui demanderait pas ∀. Le resolve et le pdfFonts de la recette transmettent le même fichier sans plage, à l’écran et à renderToPdf. Seuls les caractères manquants changent de police : Crimson Pro a ¬, la négation du texte reste donc en Crimson Pro.

#2 · Une première composition sans elle montre ce qui manque

script.js · lignes 243–250dans le code complet
// Each paragraph that sets a character its face lacks is a glyphFallbackAt warning with its
// page; with no symbol font it names no family that draws them, and the PDF would print
// empty boxes. The pages shown are the second build's.
const fonts = { ...kitFonts(FONTS), resolve }; // the kit's resolver, with the symbol file
const bare = await buildDocumentWithFonts({ markdown, resources }, { ...config, symbolFont: '' },
  fonts);
console.info((bare.contentWarnings ?? []).filter((w) => w.kind === 'glyphFallbackAt')
  .map(formatWarning).join('\n'));

La première composition laisse symbolFont vide et affiche ses avertissements glyphFallbackAt, un par paragraphe, titre ou tableau qui contient des caractères sans glyphe dans sa police, avec la page et les caractères. L’édition anglaise en compte dix-huit : quatorze paragraphes en Crimson Pro, trois titres en Cormorant Garamond et la ligne d’en-tête du tableau 1.1 en IBM Plex Sans Condensed gras. Sans famille pour les dessiner, le canevas prend les signes dans une police du système du lecteur et le PDF imprime une case vide pour chacun. La seconde composition, avec la police des symboles, est celle qu’on voit sur la page ; ses avertissements nomment "Noto Sans Math" comme la famille qui les dessine.

#3 · Les signes de l’ouverture sont du texte

script.js · lignes 51–67dans le code complet
const BAND = 78; // mm from the trim to the foot of the band
const onBand = { color: col('paper'), align: 'left' };
const below = (id, y, width) => ({ anchor: { to: `#${id}`, edge: 'below' }, offset: { y: mm(y) },
  size: { width: mm(width) } });
const opener = { enabled: true, minHeight: mm(BAND - TOP + 2), slot: { elements: [
  { kind: 'box', id: 'band', style: { backgroundColor: col('accent') },
    placement: { anchor: { to: 'bleed', edge: 'top-left' }, size: { height: mm(BAND) } } },
  { kind: 'text', id: 'kicker', content: '{attr.kicker}', ...onBand, fontFamily: LABEL,
    fontWeight: 600, fontSize: pt(8.5), letterSpacing: pt(1.8), textTransform: 'uppercase',
    placement: { anchor: { to: 'container', edge: 'top-left' }, offset: { y: mm(2) } } },
  { kind: 'text', id: 'title', content: '{titleText}', ...onBand, fontFamily: DISPLAY,
    fontWeight: 600, fontSize: pt(38), lineHeight: 1.02, placement: below('kicker', 3, 110) },
  // The signs are text in Cormorant Garamond, which has none of them: Noto Sans Math draws
  // every one, at 30 pt, in the band's white.
  { kind: 'text', id: 'signs', content: '{attr.signs}', ...onBand, fontFamily: DISPLAY,
    fontSize: pt(30), lineHeight: 1, letterSpacing: pt(9), placement: below('title', 7, 114) },
] } };

La ligne de sept signes sous le titre est un texte de maquette en Cormorant Garamond à 30 pt, nourri par l’attribut signs du titre. Cormorant Garamond n’en a aucun : les sept viennent de la police des symboles, dans le blanc du bandeau. Une approche de 9 pt les répartit sur la justification.

#4 · Cellules et titres courants prennent la même police

script.js · lignes 212–230dans le code complet
const [T, F] = t({ en: ['T', 'F'], es: ['V', 'F'] });
const connectives = [['¬*p*', (p) => !p], ['*p* ∧ *q*', (p, q) => p && q],
  ['*p* ∨ *q*', (p, q) => p || q], ['*p* → *q*', (p, q) => !p || q],
  ['*p* ↔ *q*', (p, q) => p === q]];
const cell = (content, isHeader = false) => ({ content, align: 'center', isHeader });
const truth = [[true, true], [true, false], [false, true], [false, false]].map(([p, q]) =>
  [p, q, ...connectives.map(([, f]) => f(p, q))].map((v) => cell(v ? T : F)));
const table = (id, rows, columnWidths, caption, position) => ({ id, typeId: 'table',
  kind: 'table', caption, createdAt: 0, updatedAt: 0, placement: { position },
  table: { model: { headerRowCount: 1, columnWidths, rows } } });
const resources = [
  table('truth', [['*p*', '*q*', ...connectives.map(([s]) => s)].map((s) => cell(s, true)),
    ...truth],
    [1, 1, 1.3, 1.6, 1.6, 1.6, 1.6], t({ en: 'The five connectives, row by row.',
      es: 'Las cinco conectivas, fila a fila.' }), 'top'), // to the head of a page
  table('signs', parseTSV(signs.trim()).rows.map((row, r) => row.map(({ content }, c) => ({
    content, align: c === 0 ? 'center' : 'left', isHeader: r === 0 }))), [0.8, 2.1, 5.3],
  t({ en: 'Where the signs come from.', es: 'De dónde vienen los signos.' }), 'here'),
];

La table de vérité est construite à partir des connecteurs eux-mêmes : l’en-tête de chaque colonne est la formule, et chaque cellule ce que la formule donne pour cette ligne. Les cellules d’en-tête sont en IBM Plex Sans Condensed gras italique et celles du corps en Crimson Pro ; la police des symboles sert les deux. Son unique style romain dessine pour toutes les graisses et toutes les pentes : le ∧ de l’en-tête en gras et le ∈ d’une formule en italique sont le même signe droit. Le titre courant de la belle page imprime la section en cours, {firstMark.h2}, et SETS: ∈, ∪, ∩ AND ∅, page 3, prend lui aussi ses signes dans Noto Sans Math.

Page 3 : les formules d’ensembles, en Crimson Pro italique, tous les signes venant de Noto Sans Math.

La recette complète

Sandbox
// ═══ Postext Cookbook · Nº 185 · Logic signs from a symbol font ═════════════════════
// https://postext.dev/en/cookbook/symbol-font-for-logic
// Code: MIT · Text: original (CC BY 4.0) · Pictures: none
// Fonts: Crimson Pro, Cormorant Garamond, IBM Plex, Noto Sans Math (OFL) · Needs postext ≥ 1.73.0
// A primer of logical notation set in faces that have no ∀, no ∈, no ℵ and no Greek:
// symbolFont names Noto Sans Math, which draws those characters on the canvas and in the PDF.
import {
  buildDocumentWithFonts, renderPageToCanvas, defaultResourceTypes, parseTSV, formatWarning,
} from 'https://esm.sh/postext';
import { renderToPdf, decompressWoff2 } from 'https://esm.sh/postext-pdf';

const LANG = 'en'; // @lang: the language of the sample document ('en' | 'es')
const RECIPE = 'symbol-font-for-logic';

// ─── 1 · Design ─────────────────────────────────────────────────────────────
const palette = {
  ink: '#1f1c22', // text: a cool near-black
  accent: '#7b2a3b', // claret: the opener band, labels, the table heads
  tint: '#f4ece9', // the even rows of the truth table
  rule: '#c3b4b2', // hairlines
  muted: '#6a6064', // running heads, the colophon
  paper: '#ffffff',
};
const col = (id) => ({ hex: palette[id], model: 'hex', paletteId: id });
const colorPalette = [
  ...Object.entries(palette).map(([id, hex]) => ({ id, name: id, value: { hex, model: 'hex' } })),
  { id: 'main-color', name: 'accent (defaults)', value: { hex: palette.accent, model: 'hex' } },
];
const TEXT = 'Crimson Pro', DISPLAY = 'Cormorant Garamond', LABEL = 'IBM Plex Sans Condensed';
const TRIM = [155, 235], INNER = 20, OUTER = 21, TOP = 23; // mm: a trade-size primer
const LEAD = 15; // pt: the body leading

// #region answer: one symbol font behind every face, on the canvas and in the PDF
// None of the three faces has ∀, ∈, ℵ or Greek. config.symbolFont (below) lists Noto Sans
// Math after every family the document names: what a face lacks is drawn from it, at the
// face's size and colour, in the canvas, the PDF, the HTML and the EPUB.
const SYMBOLS = 'Noto Sans Math';
// Fontsource serves Noto Sans Math whole in its "latin" file, and the kit would declare
// that file for the Latin range only. The screen and the PDF take it here with no range,
// so every glyph in it can be used.
const symbolFile = async () =>
  `${await fontsourceAt('noto-sans-math')}files/noto-sans-math-latin-400-normal.woff2`;
const resolve = async (family, ...face) =>
  (family === SYMBOLS ? [{ source: await symbolFile() }] : fontsourceResolver(family, ...face));
const pdfFonts = async (family, ...face) => (family !== SYMBOLS
  ? fontsourceProvider(family, ...face)
  : decompressWoff2(new Uint8Array(await (await fetch(await symbolFile())).arrayBuffer())));
// #endregion

Le script.js composé s’exécute tel quel : collez-le dans le script de module de n’importe quelle page, ou ouvrez la recette sur CodePen. Dossier de la recette sur GitHub ↗ (s’ouvre dans un nouvel onglet)

Variantes

#Supprimer la première composition

Une fois les avertissements lus, une seule composition suffit.

-const bare = await buildDocumentWithFonts({ markdown, resources }, { ...config, symbolFont: '' },
-  fonts);
-console.info((bare.contentWarnings ?? []).filter((w) => w.kind === 'glyphFallbackAt')
-  .map(formatWarning).join('\n'));

Erreurs fréquentes

Avertissement de mise en page · glyphFallbackAt

Caractères absents de la police, ici

Pourquoi. Un paragraphe contient des caractères absents de la police de son texte : lettres et opérateurs mathématiques (∪, ℵ), grec dans une police latine, flèches (glyphFallback nomme la police, celui-ci le paragraphe). supplier est la famille qui les dessine, en général la symbolFont ; sans elle, le PDF les imprime comme des cases vides.

Correction. Indiquez une symbolFont qui les contient (Noto Sans Math couvre presque toutes les mathématiques), ou choisissez une famille de texte qui les a. Si le caractère est faux (un aleph hébreu là où l’auteur voulait un complémentaire), corrigez le texte. Docs →

  • Une police dont les fichiers Fontsource comprennent le grec (Source Serif 4, Alegreya) compose elle-même φ et Γ, et le kit charge ce fichier quand le texte contient du grec : seuls les signes passent alors à la police des symboles. Crimson Pro n’a pas de fichier grec, son grec vient donc de Noto Sans Math.
  • La police des symboles n’a qu’un style, romain et normal. Un titre en gras ou une formule en italique compose ses signes dans ce style, comme les imprime l’usage mathématique.

Crédits

Texte
  • The primer of logical notation, in English and Spanish · Ignacio Ferro · CC BY 4.0
Polices
Crimson Pro (SIL OFL 1.1) · Cormorant Garamond (SIL OFL 1.1) · IBM Plex Sans Condensed (SIL OFL 1.1) · Noto Sans Math (SIL OFL 1.1)
SandboxPDF