Programmation C/Courbe de Bézier
Ce code permet de tracer une définie par 4 points de contrôle. C'est donc une courbe cubique. Cet algorithme est une implémentation de l'.
Pour adapter ce code C à votre système, il vous suffit de remplacer la procédure de tracé de segment (ici en ).
La structure Global_Bezier contient les 4 points de contrôle de la courbe de Bézier à tracer. level contient le nombre d'appel récursif.
 typedef struct {
 float x, y;
 } point;
 typedef struct {
 point P[4];
 } Bezier;
 /* Variables globales */
 Bezier Global_Bezier;
 int level=1;
 // Draw a line with color (r,v,b)
 void DrawLine(int x1, int y1, int x2, int y2,float r, float v, float b)
 glColor3f(r,v,b);
 glBegin(GL_LINES);
 glVertex2i(x1,y1);
 glVertex2i(x2,y2);
 glEnd();
 glFlush();
 void DrawBezierBase(Bezier p,float r,float v,float b)
 DrawLine(p.P[0].x,p.P[0].y,p.P[1].x,p.P[1].y,r,v,b);
 DrawLine(p.P[1].x,p.P[1].y,p.P[2].x,p.P[2].y,r,v,b);
 DrawLine(p.P[2].x,p.P[2].y,p.P[3].x,p.P[3].y,r,v,b);
 void DrawBezierRecursive (Bezier b, int level) 
 if (level <= 0) {
 /* draw a line segment */
 DrawLine((int) (b.P[0].x + 0.5), (int) (b.P[0].y + 0.5),
 (int) (b.P[3].x + 0.5), (int) (b.P[3].y + 0.5),1,1,1);
 } else {
 Bezier left, right; 
 /* subdivide into 2 Bezier segments */
 left.P[0].x = b.P[0].x;
 left.P[0].y = b.P[0].y;
 left.P[1].x = (b.P[0].x + b.P[1].x) / 2;
 left.P[1].y = (b.P[0].y + b.P[1].y) / 2;
 left.P[2].x = (b.P[0].x + 2*b.P[1].x + b.P[2].x) / 4;
 left.P[2].y = (b.P[0].y + 2*b.P[1].y + b.P[2].y) / 4;
 left.P[3].x = (b.P[0].x + 3*b.P[1].x + 3*b.P[2].x + b.P[3].x) / 8;
 left.P[3].y = (b.P[0].y + 3*b.P[1].y + 3*b.P[2].y + b.P[3].y) / 8;
 DrawBezierBase(left,0,1,0);
 right.P[0].x = left.P[3].x;
 right.P[0].y = left.P[3].y;
 right.P[1].x = (b.P[1].x + 2*b.P[2].x + b.P[3].x) / 4;
 right.P[1].y = (b.P[1].y + 2*b.P[2].y + b.P[3].y) / 4;
 right.P[2].x = (b.P[2].x + b.P[3].x) / 2;
 right.P[2].y = (b.P[2].y + b.P[3].y) / 2;
 right.P[3].x = b.P[3].x;
 right.P[3].y = b.P[3].y;
 DrawBezierBase(right,0,0,1);
 /* draw the 2 segments recursively */
 DrawBezierRecursive (left, level -1);
 DrawBezierRecursive (right, level -1);
 void DrawBezier()
 DrawBezierBase(Global_Bezier,1,0,0);
 DrawBezierRecursive(Global_Bezier,level);

Photographie/Fabricants/Canon/Canon EF 80-200 mm f/2,8 L

Programmation Java/Générer un triangle de Sierpiński

Le programme ci-dessous dessine un triangle de Sierpiński dans une fenêtre en utilisant la bibliothèque Swing pour l'interface utilisateur.
La méthode récursive private void drawSierpinskiTriangle(Graphics g, int[] x, int[] y, int d) accepte des coordonnées de trois points (coins du triangle principal) plus ou moins arbitraires.
Pour compiler (vous devez disposez du JDK Java) : codice_1
Source de "SierpinskiTriangle.java" :
/* Nom du fichier : SierpinskiTriangle.java */
package org.wikibooks.fr.swing;
import java.awt.*;
import javax.swing.*;
 * Triangle de Sierpiński
 * @author fr.wikibooks.org
public class SierpinskiTriangle extends JComponent
 private final int size;
 private final int d_min = 8;
 public SierpinskiTriangle(int size)
 this.size = size;
 Dimension d = new Dimension(size, size);
 setPreferredSize(d);
 setMinimumSize(d);
 @Override
 protected void paintComponent(Graphics g)
 g.setColor(getBackground());
 g.clearRect(0, 0, size, size);
 g.setColor(getForeground());
 int x0 = 0; // distance de gauche
 int y0 = 0; // distance du haut
 int h = (int) (size * Math.sqrt(3) / 2); // hauteur
 // adapté à un triangle équilatéral
 // spécification du triangle principal: points A, B, C
 int xA = x0, yA = y0 + h; // (bas-gauche)
 int xB = x0 + size, yB = y0 + h; // (bas-droite)
 // int xB=x0, yB=y0; // (haut-gauche)
 // int xB=x0+d, yB=y0; // (haut-droite)
 int xC = x0 + size / 2, yC = y0; // triangle équilatéral (haut-milieu)
 // int xC=x0, yC=y0; // (haut-gauche)
 // triangle perpendiculaire, angle droit près A
 // int xC=x0+d, yC=y0; // (haut-droite)
 // triangle perpendiculaire, angle droit près B
 int[] x = { xA, xB, xC };
 int[] y = { yA, yB, yC };
 drawSierpinskiTriangle(g, x, y, size / 2); // démarrer la récursion
 private void drawSierpinskiTriangle(Graphics g, int[] x, int[] y, int d)
 if (d < d_min)
 g.fillPolygon(x, y, 3); // fin de la récursion
 else
 // milieux des côtés du triangle:
 int xMc = (x[0] + x[1]) / 2, yMc = (y[0] + y[1]) / 2;
 int xMb = (x[0] + x[2]) / 2, yMb = (y[0] + y[2]) / 2;
 int xMa = (x[1] + x[2]) / 2, yMa = (y[1] + y[2]) / 2;
 int[] xNouveau1 =
 { x[0], xMc, xMb };
 int[] yNouveau1 =
 { y[0], yMc, yMb };
 drawSierpinskiTriangle(g, xNouveau1, yNouveau1, d / 2); // récursion
 int[] xNouveau2 =
 { x[1], xMc, xMa };
 int[] yNouveau2 =
 { y[1], yMc, yMa };
 drawSierpinskiTriangle(g, xNouveau2, yNouveau2, d / 2); // récursion
 int[] xNouveau3 =
 { x[2], xMb, xMa };
 int[] yNouveau3 =
 { y[2], yMb, yMa };
 drawSierpinskiTriangle(g, xNouveau3, yNouveau3, d / 2); // récursion
 public static void main(String[] args)
 JFrame f = new JFrame("Triangle de Sierpiński");
 f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 f.getContentPane().add(new SierpinskiTriangle(1024));
 f.pack();
 f.setVisible(true);

Hiéroglyphes/Exercice 1
1.
Consigne:
2.
Consigne:

Hiéroglyphes/Dieux
Voici des noms de dieux égyptiens en hiéroglyphes :

Grec ancien/Numération
Il existe en grec ancien plusieurs manières d'écrire des nombres :
Nous connaissons également un système de numération "scientifique", inspiré des mathématiques babyloniennes. Il n'en sera pas fait état ici.
Numération acrophonique.
Dès le V siècle avant l'ère chrétienne, en Attique, région d'Athènes, apparaissent des chiffres dont chaque signe (à l'exception de celui pour 1) n'est autre que la première lettre du nom du nombre, tracé dans l'alphabet local athénien , à savoir :
C'est pour cette raison qu'on parle d'une numération acrophonique. La notation des nombres suivait le principe additif que l'on retrouve dans les chiffres romains. Ainsi, 3 s'exprimait par "ΙΙΙ", 9 par "ΓΙΙΙΙ", 400 par "ΗΗΗΗ", etc.
Il existait des signes notant des valeurs intermédiaires, représentés par une ligature des deux chiffres fondamentaux pour : 
Chacun de ces chiffres est composé de celui pour 5 auquel on a souscrit celui du multiplicateur.
Presque exclusivement épigraphique, ce système numéral s'est surtout utilisé pour indiquer des prix et des mesures. Bien que s'étant étendu, en raison du rayonnement d'Athènes, à d'autres cités grecques (avec de nombreuses variantes locales, selon les alphabets épichoriques), il a été détrôné par le système alphabétique.
Numération alphabétique.
Ce système existe encore aujourd'hui en Grèce, à la manière des chiffres romains dans les pays de langues romanes. Elle utilise, outre les lettres courantes de l'alphabet grec, trois lettres archaïques, "digamma" (tracé le plus souvent comme un "stigma"), "koppa" (distinct du "koppa" littéral ancien) et "sampi" (évolution d'une lettre plus ancienne). Purement additive, cette numération ne nécessite pas l'utilisation du zéro. Cependant, le calcul basé sur ces écritures est impossible : les anciens Grecs utilisaient des jetons placés sur des abaques, de bois ou de marbre, partagés en colonnes.
Histoire.
La numération alphabétique est plus récente que la numération acrophonique. Elle a été introduite à Athènes en même temps que l'adoption du modèle ionien de Milet, en −403. Elle est cependant bien plus ancienne puisqu'on en trouve des attestations à Milet vers −700. On la nomme pour cette raison aussi « numération milésienne » ; l'alphabet de Milet, devenu « classique » grâce à Athènes, n'utilisait pas les trois lettres supplémentaires mentionnées dans l'écriture des mots : leur maintien dans la numération est donc un archaïsme qui s'explique par la nécessité d'avoir à disposition trois fois neuf signes différents.
Ces signes, évoluant avec le temps, se sont transmis à d'autres écritures ayant emprunté le reste des lettres grecques : l'alphabet copte, l'alphabet gotique et l'alphabet cyrillique.