OpenLLM-France/wikimedia huggingface dataset:
# Livre de cuisine/Forêt noire

La forêt noire, en allemand Schwarzwälder Kirschtorte, est un gâteau d'origine allemande.

## Ingrédients

* 500 g de cerises noires,
* 50 g de farine,
* 75 g de poudre d'amande,
* 5 g (un demi sachet) de levure chimique,
* 100 g de cacao en poudre,
* ¼ cuillère à café de sel,
* 6 œufs séparés,
* 100 g de beurre fondu,
* 40 cl de crème fraîche liquide,
* 25 g de sucre glace,
* 200 g de sucre en poudre,
* 10 cl de kirsch,
* 3 cuillères à café d'extrait de vanille,
* 200 g de chocolat noir,
* copeaux de chocolat.

## Préparation

* Dénoyauter les cerises et les faire macérer dans le kirsch pendant deux heures, les égoutter et conserver le jus ;
* Mélanger la farine, la poudre d'amandes, le cacao en poudre, le sel et la levure ;
* Séparer les blancs des jaunes d'œufs ;
* Mélanger les jaunes et 50 g de sucre en poudre ;
* Travailler l'ensemble jusqu'à ce que le mélange blanchisse, ajouter une cuillère à café d'extrait de vanille et mélanger ;
* Ajouter le farine en veillant à ne pas dégonfler le mélange jusqu'à obtention d'une pâte homogène, puis le beurre fondu ;
* Monter les blancs en neige ferme, les incorporer à la pâte délicatement.
* Répartir la pâte dans trois moules à gâteau de même diamètre, beurrés et farinés ;
* Enfourner pour 20 min à 180°C. Démouler et laissez refroidir ;
* Réaliser un sirop avec le reste de sucre en poudre, une cuillère à café d'extrait de vanille et 25 cl d'eau, hors du feu, ajouter le jus des cerises et le kirsch ;
* Imbiber les biscuits du sirop, les arroser fréquemment ;
* Battre la crème fraîche liquide jusqu'à obtention d'une crème chantilly, ajouter le sucre glace et l'extrait de vanille ;
* Napper un biscuit avec un quart de la crème chantilly, disposer la moitié des cerises égouttées ;
* Couvrir d'un biscuit, napper avec un quart de chantilly et les cerises ;
* Couvrir du biscuit, napper les dessus et côtés du gâteau avec la crème chantilly ;
* Poser les copeaux sur le gâteau pour le recouvrir intégralement ;
* Placer la forêt noire au réfrigérateur 3 heures avant de la servir.

## Note

La pâte peut être cuite dans un seul moule, la cuisson dure 40 min et le gâteau froid coupé en trois parties égales.
* Wikipédia propose un article sur : « Forêt noire ».
# Livre de cuisine/Fouée

La fouée est une boule de pain. C'est une recette traditionnelle des régions rurales de l'ouest de la France.

## Ingrédients

* 500 g de farine,
* 10 g de sel,
* 15 g de levure de boulanger,
* 30 cl d'eau tiède.

## Préparation

* Mettre la farine dans une bassine avec le sel ;
* Mélanger la levure avec de l'eau tiède dans une tasse à café ;
* Verser la levure dans la bassine en brassant la farine ;
* Ajouter l'eau progressivement, sans arrêter de brasser, jusqu'à ce que la pâte soit homogène ;
* Laisser reposer la pâte pendant 4 heures ;
* Faire des boules qui seront aplaties avec la paume de la main puis, avec un rouleau ;
* Enfourner à 220°C 35 min ;
* Servir chaud.
# Livre de cuisine/Fougasse

La fougasse, ou fougace, est un pain provençal.

## Ingrédients

* 500 g de farine,
* 10 g de levure de boulanger,
* 10 cl d'huile d'olive,
* 1 jaune d'œuf,
* 5 g de sel,
* 1/2 citron vert.

## Préparation

* Mettre dans un bol une poignée de farine, ajouter la levure et suffisamment d'eau pour avoir une bouillie lisse. Laisser reposer 1 heure.
* Ajouter le sel au reste de farine et la verser en tas sur le plan de travail (on peut au préalable réchauffer légèrement la farine dans le four, elle sera plus facile à travailler). Faire un puits au milieu et y verser le levain, rajouter de l'eau tiède et le jus de citron vert pour obtenir ensuite une pâte souple.
* Pétrir le mélange pendant 10 min, mettre la pâte obtenue dans une grande terrine farinée, couvrir d'un torchon et laisser lever jusqu'à ce qu'elle ait doublé de volume, la couper en quatre.
* Former une boule et la faire lever à nouveau. Diviser en deux portions et les aplatir sur le plan de travail. Les entailler en 9 ou 10 incisions bien nettes de 2 cm de long, disposées en oblique (3 d'un côté, 3 de l'autre et 3 au milieu). Écarter légèrement ces ouvertures (pour éviter qu'elles ne se referment à la cuisson).
* Préchauffer le four à 220°C. Poser les fougasses sur la tôle du four bien chaude. Glisser un bol d'eau dans le four et enfourner les fougasses. Cuire pendant 35 min jusqu'à ce qu'elles soient dorées et croustillantes.

## Variante

* Wikipédia propose un article sur : « Fougasse ».
Il existe un pain sucré homonyme spécialité de l'Aubrac aveyronnais et lozérien. Le Rouergue a gardé le nom de Fouace pour désigner cette fougace de l'Aubrac.
* Fougasse aux olives noires.
* Fougasse à la fleur d'oranger.
* Fougasse aux oignons.
* Fougasses façon pizza.
* Fougasse de Foix
# Livre de cuisine/Fondue épicée
## Ingrédients

pour 4 personnes
* 800 g de gruyère râpé ou en lamelles
* 1 cuillerée à soupe d'huile
* 1 petit oignon haché, 2 gousses d'ail pressées
* 1 poivron vert et 1 poivron rouge coupés en deux, épépinés et hachés
* 2 piments rouges épépinés, coupés en rondelles et brièvement blanchis (piments en bocal éventuellement).
* 3,5 dl de vin blanc, 1 petit verre de grappa
* 1 cuillerée à café de jus de citron frais
* 4 cuillerées à café de Maïzena
* poivre moulu, poivre de Cayenne, noix de muscade râpée

## Préparation

* Dans le caquelon, cuire l'oignon et l'ail dans l'huile chaude jusqu'à ce qu'ils deviennent transparents, ajouter les poivrons et laisser étuver environ 6 minutes.
* Mouiller avec le vin blanc additionné de jus de citron. Mélanger le gruyère et la Maïzena, ajouter au mélange vin/poivrons et porter à ébullition en remuant constamment.
* Quand le fromage est fondu, incorporer la grappa et épicer. Saupoudrer de piment et servir immédiatement.
# Livre de cuisine/Foufou sauce claire

Le foufou est un plat d'origine africaine fait à base de bananes plantains mûres et/ou non mûres. En pays Adjoukrou (sud de la Côte d'Ivoire), il est traditionnellement accompagné de sauce claire.

### Ingrédients

Foufou sauce claire pour 10 personnes :
Ingrédients pour le Foufou :
* Un régime de bananes plantains,
* De l'huile rouge,
* Du sel.
Ingrédients pour la sauce claire :
* Du poisson bien fumé (du requin et/ou du brochet),
* Cinq piments africains,
* Trois gousses d'oignon,
* Dix tomates fraîches,
* Du Sel,
* Un cube d’assaisonnement,
* Cinq aubergines,
* Une poignée d'akpi,
* Cinq gombos frais.

### Ustensiles

* Un mortier,
* Une casserole,
* Une cuvette,
* Un mixeur.

### Préparation du Foufou

Temps de préparation : 1 heure
Temps de cuisson : 45 minutes
* Laver puis éplucher les bananes.
* Mettre les bananes dans une casserole, ajouter de l'eau et du sel puis laisser cuire à feu moyen au moins 15 minutes.
* Retirer les bananes cuites et les écraser en ajoutant de l'huile rouge et du sel (au besoin).
* Après avoir obtenu une forme homogène, faire des formes de votre choix, des boules, des pyramides ou servir simplement dans une assiette creuse..

### Préparation de la sauce claire

Temps de préparation : 1 heure
* Mettre dans une casserole un peu d'eau.
* À l'ébullition, ajouter les poissons, le sel et l'huile rouge.
* Nettoyer les tomates, les aubergines,les gombos,les oignons et les piments puis les ajouter à la sauce avec un peu d'eau.
* Une fois les ingrédients cuits, les retirer sauf les aubergines et les gombos.
* Les faire mixer, puis les remettre dans la sauce en ajoutant l'akpi réduit en poudre et le cube d'assaisonnement.
# Programmation Java/Sommaire

* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
# Programmation Java/Swing/Boutons sur image

* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
[ Modifier le sommaire ]
# Programmation Java/Swing/Somme

* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
[ Modifier le sommaire ]

## Interfaces graphiques avec swing
### Calculer la somme de 2 entiers

Le fichier Somme.java
# Programmation Java/Swing

* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
[ Modifier le sommaire ]
Swing est une bibliothèque graphique Java fournissant des composants légers.
Pour apprendre à utiliser Swing, lire le livre consacré à la programmation Swing.
# Programmation Java/Swing/Distance

* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
[ Modifier le sommaire ]

## Interfaces graphiques avec swing
### Calculer la distance entre 2 points

Le fichier Distance.java
Le fichier Point.java
Le fichier PointDialog.java
# Programmation Java/Swing/Hello

* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
* Introduction
* La notion de machine virtuelle
* Installation
** NetBeans
** Eclipse
** Visual Studio Code
* Bases du langage
** Premier programme
** Commentaires
** Types de base
** Opérateurs
** Conditions
** Bloc de portée
** Itérations
** Tableaux
* Les classes en Java
** Membres
** Modificateurs d'accès
** Héritage
** Encapsulation
** Polymorphisme
** Classes abstraites
** Interfaces
** Classes internes
** Transtypage
** Types génériques
** Instanciation et cycle de vie
** « this »
** Objets comparables et clés
** Énumérations
** Exceptions
** Packages
* Classes de base
** Collections
** Nombre de taille arbitraire
** Tags Javadoc
** Annotations
** Entrées sorties
** Threads et synchronisation
** Méthodes natives
** Réflexion
** Regex
** JUnit
* Conclusion
* Exemples en Java
** Générer un carré magique
** Générer un triangle de Sierpiński
** XML
** Swing
*** Un premier exemple
*** Formulaire avec boutons sur image
*** Calcul de somme
*** Calcul de distance
* Annexes
** Les outils de base fournis avec le Java Development Kit
** Créer une archive Java
** Paramétrer la JVM
** Liste des mots réservés
** Débogage
** Java et les autres langages
[ Modifier le sommaire ]

## Interfaces graphiques avec swing
### Un premier exemple

Le premier programme de tout informaticien.
Le fichier Hello.java
# Programmation objet et géométrie/Objets Python sous Blender

Le logiciel Blender possède une console Python avec laquelle on peut créer et modifier des objets tridimensionnels.
Pour ouvrir la console, il suffit de changer une des vues 3D en vue "texte", puis d'écrire dedans après avoir créé un texte vide par new. On peut sauvegarder le script avec le raccourci Alt+S et l'exécuter avec le raccourci Alt+P.
Une fois la console ouverte, on doit commencer par y taper le texte suivant:
pour y utiliser les fonctionnalités de Blender (bpy est une abréviation de Blender Python).
# Programmation objet et géométrie/Objets Python sous Blender/Création de fractales avec bpy

Pour créer des surfaces fractales, avec bpy sous Blender comme ailleurs, il est nécessaire de faire appel à la récursivité. À part ça, l'objet créé (un tétraèdre de Sierpinski) sera un polyèdre et la technique de création sera la même que précédemment.

# Fonctions Python

Comme précédemment, pour pouvoir utiliser les méthodes de bpy, on doit les importer:
Les tableaux sommets et faces sont des variables globales; Python va les modifier au fur et à mesure des appels récursifs à la fonction sierpin ci-dessous.

## Milieu

Pour simplifier le code ci-dessous, on crée une fonction milieu qui, à deux tableaux de trois coordonnées (deux points dans l'espace) associe un troisième tableau du même genre:

## Récursivité

La fonction sierpin met dans le tableau sommets la liste des sommets du polyèdre, et dans faces la liste de ses faces, au fur et à mesure. Son code est relativement court grâce à la récursivité et à une variable auxiliaire n appelée ordre du tétraèdre:
* Si n=0, on se contente de créer un tétraèdre, à partir des 4 sommets donnés à sierpin;
* Sinon, on construit sur chaque sommet, un tétraèdre de Sierpinski deux fois plus petit, dont les autres sommets sont les milieux des arêtes qui passent par lui:
La variable ns contient le nombre actuel de sommets, en effet elle est calculée comme longueur du tableau contenant la liste des sommets, qui est donc bien égale au nombre de sommets. Mais comme ceux-ci sont numérotés à partir de 0, les 4 derniers sommets sont les numéros ns-4 à ns-1 (il n'y a pas de numéro ns).
Un appel à sierpin(a,b,c,d,0) donne les sommets et faces d'un tétraèdre (de sommets a, b, c et d),
un appel à sierpin(a,b,c,d,1) donne les sommets et faces de 4 tétraèdres,
etc.

# Création de l'objet
## Appel de la fonction récursive

Grâce à ce qui précède, il suffit pour avoir les sommets et faces de l'approximation polyédrale de l'objet fractal, d'une seule ligne:
Cet appel remplit les tableaux sommets et faces qu'il suffit de fournir à un objet polyèdre pour créer celui-ci:

## création du tétraèdre de Sierpinski

Comme à chaque fois, il reste à
* instancier un objet héritant de la classe meshes (nommé sierp);
* Lui fournir ses sommets;
* lui fournir ses faces;
* activer la scène Blender;
* y placer l'objet en question (un si comme Sierpinski):
Ensuite, après avoir texturé l'objet 3D, il suffit d'un appui sur le bouton F12 du clavier pour effectuer un rendu: