OpenLLM-France/wikimedia huggingface dataset:
# Mkd (Extracteur de documents)/Internationalisation des manuels

Cette page est susceptible de subir des modifications occasionnelles

## Internationalisation des manuels

Les manuels pour UNIX sont écrits en standard au format nroff Les manuels traduits doivent être compressés mkd.1.gz avant d'être transférés dans les répertoires des langues: Les manuels de la version de mai 2012 existent en allemand, anglais et français. Vous pouvez envisager de les traduire dans d'autres langues à partir des références ci-dessous.

## Exemple d'installation des manuels (Fichier de commandes)

Pour d'autres langues que que anglais et français voir aussi le chapitre #Autres_langues
Installation des manuels

## Manuels de référence

* (anglais) Mkd-Manual (english reference manual)
* (français) Mkd, manuel de référence en français

## Manuels traduits

Votre participation pour corriger ces traductions est souhaitée.
* allemand Mkd-Handbuch
* espagnol Mkd-Manual

## Manuels souhaités (à traduire)

* italien Mkd-Manuale italiano Votre participation est souhaitée.

## Mises à jour des manuels internationalisés

* (man1) :
    - Téléchargez la mise à jour des manuels
    - Download the latest multi-lang Installer:
* Attention : Vérifiez les dates de publication de ces pages de manuels en bas de page.
* ↑ Manuels anglais allemand français
* ↑ Translations anglais allemand français
# Mkd (Extracteur de documents)/Exercices/cpp.c pour exercices

* Surlignez le contenu du cadre ci-dessous.
* Appuyez simultanément sur les touches CTRL et C,
* Ensuite faites la même chose avec CTRL et V dans votre éditeur afin d'y coller ce texte.
* Enfin sauvegardez votre fichier avec le nom cpp.c
* Dans ce fichier les tabulation habituelles ont été remplacées par 3 espaces pour faciliter la lecture.
* Les tabulations peuvent jouer de mauvais tours à l'édition.
* Prendre connaissance des bugs.

## Fichiers de la fonction cpp_

* Testé: (4 mai 2013)
    cpp.c pour Konsole
* Non testé:
    cpp.cc pour version c++ indépendante
    cpp.inc.c pour inclusion dans le source avec gtkmm pour mkdcppw

## Fichier de commande des tests Konsole

* Fichier MAKE_Tests_U:
* Fichier CLEAN_Tests_U:

## Fichiers sources des tests

* Fichier Test_cpp_U.cc
* Fichier Test_cpp_U.c2
* Fichier Test_cpp_U.c3
* Fichier Test_cpp_U.c4
# Mkd (Extracteur de documents)/Internationalisation des manuels/mkd-Handbuch

Cette page est susceptible de subir des modifications occasionnelles Votre aide est la bienvenue.

## Traduction du manuel mkd en langue allemande Deutschsprache Übersetzung

Sehen Sie auch das deutsche Dokument Mkd (Kommandozeile)

### Installieren

Copier le contenu du cadre ci-dessous dans votre éditeur de texte.
Enregistrez le fichier sous mkd_de.1 puis suivrez les indications d'Exemple d'installation des manuels.
Datei : Deutschsprache.mak
Datei : mkd_de.1
# Programmation mIRC/Droits d'auteurs et autorisations

Les travaux placés dans ce wikibook sont, dans la mesure du possible, en respect avec les copyright référencés et autorisations de leurs auteurs. Néanmoins, n'étant pas des surhommes, nous pouvons faire des erreurs et corrigerons dès que possible.

## Autorisations

* Tous travaux de ClickHeRe.
    son courriel : clickhere@scriptsdb.org
    ses articles recopiés :
      * DLL Ultradock
* Tous travaux de Artwerks (articles/tutoriaux)
    son courriel : ppnadeau@hotmail.com
       Ses articles recopiés :
* Tutorial de Raynor (Tokens)
    son courriel : raynor2706@hotmail.com
       Ses articles recopiés :
Revenir en page principale
# Programmation mIRC/DLL mIRC

Modèle:DLL's mIRC
# Programmation mIRC/Identifieurs

Les identifieurs retournent des valeurs spécifiques. Par exemple, $time retourne l'heure en cours. A chaque fois que mIRC trouve un identifieur dans une commande ou un script, il le remplace par sa valeur actuelle de cet identifieur. Beaucoup d'identifieurs accomplissent également des fonctions aux informations de que vous fournissez et retournent alors un résultat.
Les identifieurs qui ne peuvent pas être évalués ou ne retournent aucune valeur retournent la valeur $null. La valeur $null ne peut pas être utilisée dans des comparaisons d'expressions if-then-else pour contrôler le branchement, etc. Vous pouvez également placer les identifieurs ou variables à l'intérieur des parenthèses ou autres identifieurs et ils seront évalués.
Les identifieurs sont organisés par groupes comme suit :
* Identifieurs Temps et Date
* Identifieurs Fichiers et Dossiers
* Identifieurs Pseudonyme et adresse
* Identifieurs Texte et Numéro
* Identifieurs Token
* Identifieurs Fenêtre
* Autres Identifieurs
Il y a également des identifieurs spécialisés pour les Agents, Contrôle DDE, Fenêtres personnalisées, Fenêtres Image, Sockets, Scripts remote, Dialogues, Fichiers Binaires, Hash Tables, Expressions Régulières, Objets COM, Signaux, Multiserveur, Liste d'adresses interne, Sons, et Manipulation de fichiers.
# Programmation mIRC/Alias

Une Alias permet définir des raccourcis pour les commandes fréquemment utilisées (par exemple /join) ou n’importe quelles commandes jugées utiles.
D'une manière générale, tout ce qui est tapé sur la ligne de commande peut être mis dans une alias. Elle peuvent également exécuter plusieurs commandes d’un seul coup. Il est même possible de définir des alias qui seront lancées par les touches de fonctions, F1 - F2 etc. Dans mIRC, les alias peuvent être applée depuis la section « Alias », « Popups » ou « Remote. ». Toutefois, dans les versions rècentes de mIRC, il est possible d’avoir plusieurs fichiers d’alias. « alias.ini » est join au logiciel et il est possible d'ajouter des alias ou décider d’ajouter un fichier entier avec des alias.
# Programmation Java Swing/Arbre

* Introduction
* Composants
** Arbre
* Fenêtres
* Menus
* Actions
* Types de données et constantes
* Gestion de la disposition des composants
* Gestion des évènements
* Gestion des actions asynchrones
* Apparence de l'interface
* Contenu en HTML
* Créer un composant
** Une case à cocher à trois états
** Dessin d'un composant
** Dessin d'une étoile
** Dessin de texte et effets
* Créer une image
* Introduction
* Composants
** Arbre
* Fenêtres
* Menus
* Actions
* Types de données et constantes
* Gestion de la disposition des composants
* Gestion des évènements
* Gestion des actions asynchrones
* Apparence de l'interface
* Contenu en HTML
* Créer un composant
** Une case à cocher à trois états
** Dessin d'un composant
** Dessin d'une étoile
** Dessin de texte et effets
* Créer une image
[ Modifier le sommaire ]
Swing possède une classe de composant graphique permettant l'affichage d'une arborescence de données, de manière similaire à un explorateur de répertoires, nommée JTree.

## Modèle

Le modèle de l'arbre est géré par une classe implémentant l'interface javax.swing.tree.TreeModel. Cette interface permet d'obtenir l'arborescence des objets à afficher, la notification de modification des objets, et d'enregistrer un écouteur d'évènement de changement d'arborescence. Elle est implémentée par la classe javax.swing.tree.DefaultTreeModel gérant des nœuds implémentant l'interface javax.swing.tree.TreeNode.
Cette interface est implémentée par la classe javax.swing.tree.DefaultMutableTreeNode.

## Liens

* (anglais) How to Use Trees : http://docs.oracle.com/javase/tutorial/uiswing/components/tree.html
# Programmation Java Swing/Créer une image

* Introduction
* Composants
** Arbre
* Fenêtres
* Menus
* Actions
* Types de données et constantes
* Gestion de la disposition des composants
* Gestion des évènements
* Gestion des actions asynchrones
* Apparence de l'interface
* Contenu en HTML
* Créer un composant
** Une case à cocher à trois états
** Dessin d'un composant
** Dessin d'une étoile
** Dessin de texte et effets
* Créer une image
* Introduction
* Composants
** Arbre
* Fenêtres
* Menus
* Actions
* Types de données et constantes
* Gestion de la disposition des composants
* Gestion des évènements
* Gestion des actions asynchrones
* Apparence de l'interface
* Contenu en HTML
* Créer un composant
** Une case à cocher à trois états
** Dessin d'un composant
** Dessin d'une étoile
** Dessin de texte et effets
* Créer une image
[ Modifier le sommaire ]
Une application peut avoir besoin de créer une image, soit pour réutiliser cette image et l'afficher plusieurs fois en évitant de tout redessiner à nouveau, soit pour créer un fichier externe utilisable dans une autre application.
La création d'une image peut se faire aussi simplement que le dessin d'un composant, en utilisant un contexte graphique.

## Créer une image

La classe java.awt.image.BufferedImage permet de créer une nouvelle image. Le type d'image et sa taille en pixels doit être spécifié au constructeur.
Exemple :

## Dessiner le contenu

Le contenu est ensuite dessiné en obtenant un contexte graphique, comme celui utilisé pour dessiner un composant :
Comme le contexte graphique est de la même classe que celui utilisé pour le dessin d'un composant, les mêmes méthodes s'appliquent, donc notamment la méthode addRenderingHints pour améliorer la qualité de l'image.

## Enregistrer l'image

Enregistrer l'image se fait en utilisant la classe javax.imageio.ImageIO, en appelant la méthode statique write et en lui passant l'image, le nom du format d'image, et le chemin du fichier (de type java.io.File):

## Capture d'écran

La classe java.awt.Robot permet d'automatiser certaines actions de l'utilisateur (déplacer le curseur de souris, générer des touches, ...) et de réaliser des captures d'écrans. Son but principal est de pouvoir tester des applications automatiquement.
La classe possède deux constructeurs :

### Robot

    Constructeur d'instance pour l'écran principal.

### Robot(GraphicsDevice device)

    Constructeur d'instance pour l'écran spécifié.
Ensuite, il suffit d'appeler la méthode createScreenCapture(Rectangle bounds) pour créer une image de capture de la zone spécifiée de l'écran. L'image retournée est de type java.awt.image.BufferedImage.
Le code suivant réalise une capture de l'écran principal :
La capture est réalisée de manière asynchrone, ce qui explique l'utilisation de la classe java.awt.MediaTracker dans l'exemple précédent pour attendre que l'image soit prête à être utilisée.
# Structures de données/Dates

Ceci est un projet, c'est à dire un regroupement de problématiques connexes.

## Problématique

Nous souhaitons effectuer des opérations sur les dates de la forme « jour, mois, année ».
À cette fin, nous avons déclaré le type suivant :
Il est demandé de proposer des algorithmes pour les fonctions suivantes :

### le constructeur creerDate : entier, entier, entier → date

    fonction qui renvoie une date donnée par les trois entiers passés en paramètres.

### les 3 observateurs jour, mois, année toutes de types date → entier

    ces trois fonctions donnant accès respectivement au jour, au mois et à l'année de la date passée en paramètre. On aura donc jour(creerDate(a,b,c))=a, mois(creerDate(a,b,c))=b et année(creerDate(a,b,c))=c

### un prédicat EstBissextile : entier → booléen

    ce prédicat renvoie VRAI si l'année passée en paramètre est bissextile. FAUX sinon.

### un prédicat EstDateValide : date → booléen

    ce prédicat renvoie VRAI si la date passée en paramètre est valide et FAUX sinon. à expliciter

### une fonction NbJourMois : date → entier

    cette fonction renvoie le nombre de jour du mois de l'année de la date passée en paramètre. Gérer les années bissextiles.

### une fonction DiffDate : date, date → entier

    fonction qui donne en nombre de jours l'écart entre deux dates. On considère que le temps entre un jour et ce même jour est 0 et 1 entre un jour et son lendemain.

### une fonction JourDeLaSemaine : date → chaîne

    qui renvoie le jour (au sens "lundi", "mardi", ..., "dimanche") de la date passée en paramètre.
# Structures de données/Enregistrements

Cette page est considérée comme une ébauche à compléter . Si vous possédez quelques connaissances sur le sujet, vous pouvez les partager en éditant dès à présent cette page (en cliquant sur le lien « »).
Ressources suggérées : Aucune (vous pouvez indiquer les ressources que vous suggérez qui pourraient aider d'autres personnes à compléter cette page dans le paramètre « ressources » du modèle engendrant ce cadre)
Vous devez déjà être familier avec la notion de type enregistrement qui a du être abordée lors de l'étude de l'algorithmique impérative. Voici néanmoins un rappel :

## Première approche

L'enregistrement est une façon de créer un nouveau type, ou encore un méta-type c'est-à-dire un type qui contient d'autres variables (appelées champs) de types déjà définis.
Toute variable déclarée avec ce nouveau type utilise alors une zone mémoire suffisante pour y stocker tous les champs de l'enregistrement.

## Spécification

On déclare un nouveau type dans la partie Types comme suit :
on peut ensuite déclarer les variables de ce nouveau type enregistrement normalement :
Pour accéder à un champ de la variable enregistrement, nous utiliserons l'expression :
Cette expression est du type de identifiant_champ soit type_champ.

## Exemple

Supposons que nous voulons un nouveau type couple (de deux entiers). Nous allons déclarer le type couple comme suit :
Supposons maintenant que nous avons le lexique suivant :
Si nous assignons :

## Un exemple d'implémentation : les rationnels

Nous souhaitons implémenter le type rationnel. Pour cela, nous allons utiliser un type enregistrement composé de deux champs de types entier : numérateur et dénominateur.
Ensuite, nous réaliserons :
* un constructeur, permettant de créer un rationnel à partir de son numérateur et de son dénominateur,
* deux "accesseurs" c'est à dire des fonctions retournant la valeur des champs d'un enregistrement. Elles renvoient le numérateur ou le dénominateur d'un rationnel passé en paramètre,
* prédicat de nullité d'un rationnel, d'égalité de deux rationnels,
* somme, différence, produit et quotient de deux rationnels,
* réduction renvoyant sous sa forme réduite un rationnel donné.
# Statistiques/Probabilité
## Objectifs

- Calcul de base des probabilités

## Prérequis

- Notion d'ensembles
# Structures de données

* Une version imprimable du livre « Structures de données » est disponible. (voir/ modifier)
En informatique, une structure de données est une structure logique destinée à contenir des données, afin de leur donner une organisation permettant leur traitement. Une structure de données implémente concrètement un type abstrait.
* Introduction, problématique et prérequis
* Les types enregistrements
* Les pointeurs
* L'utilisation dynamique de la mémoire
* Les listes chaînées
* Piles et files
* Généricité
# Structures de données/Introduction
## Introduction

L'étude des structures de données fait suite à celle de l'algorithmique impérative. Une bonne connaissance stable de l'algorithmique impérative est une base essentielle à l'étude menée ici. L'étude de l'algorithmique fonctionnelle est d'une aide non-négligeable.
Nous n'avons donc utilisé jusqu'ici qu'une structure de données, le tableau. Cette structure de données pose un problème : elle occupe la mémoire en fonction de sa déclaration. Ce qui signifie que si on ignore combien l'utilisateur va nécessiter d'indice, il va falloir réserver le tableau le plus grand possible afin d'être sûr qu'il puisse contenir autant d'élément que l'utilisateur souhaitera. Il serait plus judicieux de réserver l'espace au fur et à mesure de la demande. C'est ce que l'on appelle la gestion dynamique de la mémoire (par opposition à statique).
Nous avons également vu que les tableaux sont génériques : c'est à dire qu'au moment de sa déclaration, nous pouvons dire que tous ses éléments sont d'un type donné et choisir ce type.
Nous avons vu que les tableaux sont homogènes : c'est à dire qu'un tableau donné ne peut contenir qu'un seul type d'élément (celui précisé dans la déclaration du tableau). Nous pourrions avoir besoin d'un tableau dont certain élément serait des entiers, d'autres des chaînes, d'autres encore des booléens. Il s'agit là de la problématique de l'hétérogénéité.
Note : attention à ne pas confondre la notion de généricité avec celle d'hétérogénéité. La première désigne la capacité à contenir des éléments d'un même type que l'on peut choisir en le fixant au moment de la déclaration. La seconde désigne la capacité à contenir des éléments de types différents.
Supposons maintenant que nous devions utiliser des formes d'information qui ne font pas partie de type de bases : les listes chaînées, les matrices, rationnels, les arbres, de l'génome, les couleurs, etc. Comment créer les éléments nécessaires au stockage de tel information quand un simple tableau ou un simple enregistrement ne suffisent plus ?
Dynamicité, généricité, hétérogénéité et la création de nouveau types non-élémentaires sont autant de problèmes traités dans ce wikilivre.

## Problématique

* Comment stocker des données en mémoire en prenant de la mémoire de façon dynamique, en fonction du besoin. Ceci afin d'éviter les dépassements de mémoire et de ne pas mobiliser des ressources machines (parfois précieuses) inutilement.
* Comment stocker en mémoire une donnée si aucun type n'est intégré dans le langage ? Les langages ne peuvent intégrer toutes les structures de données possibles. Il faut parfois les implémenter soi-même.
* Comment, au sein d'une structure, gérer sa généricité, son hétérogénéité.

## Pré-requis

* Algorithmique impérative : indispensable
* Algorithmique fonctionnelle : facultatif mais fortement conseillé (notamment pour l'implémentation de structures dynamiques)
* Architecture des ordinateurs : au moins les notions élémentaires sur la mémoire : mémoire statique/dynamique, représentation de valeurs en mémoire, codage sur un (entiers, caractères) ou plusieurs octets (chaînes de caractères), adressage (sur n bits)...
# Statistiques

Consultez également ces pages dans d’autres projets Wikimedia :
* Article encyclopédique sur Wikipédia.
* Définition sur Wiktionnaire.
* Ressources éducatives sur Wikiversité.

## Chapitres

* Généralités
* Probabilité
# Programmation Python/Programmer en deux minutes/Bas de page

       Pour aller plus loin : Catégorie:Programmation.
          ... en deux minutes avec Python :
         * une messagerie instantanée,
         * un programme en interface avec Wikipédia,
         * un serveur Web pour partager des fichiers et mettre en ligne un site statique en HTML.
       Voir aussi le livre : Programmer en deux minutes
# Programmation Python/Les threads
## Partie 1 - Introduction

* Avant-propos à l'attention des non-programmeurs
* Introduction
* Installation
* Éditeurs
* Programmer en deux minutes
** une messagerie instantanée
** un programme interfacé avec Wikipédia
** un serveur Web

## Partie 2 - Le langage

* Afficher un texte
* Structure d'un programme
* Variables
* Opérateurs
* Structures de contrôle
* Instructions répétitives
* Types
** Numériques
** Booléens
** Chaines de caractères
** Listes
** Tuples
** Dictionnaires
** Dates
** Ensembles
* Fonctions
* Modules
* Exercices
** Palindrome
* Regex
* Programmation orientée objet pour les non-programmeurs
* Classes
* Classes et Interfaces graphiques
* Fichiers
* Exceptions
* Bases de données
** Gestion
* L'interface CGI
* Applications web
* Réseau
* Threads

## Partie 3 - Les bibliothèques

* Bibliothèques pour Python
* L'interface graphique
* Utilisation de fenêtres et de graphismes
** Tkinter
** Widgets
** Turtle
* Les threads
* XML
* JSON
* Tests
* Analyse statique de programmes
* Fabric
* Le Web
** Django
** Karrigell
** Aiohttp

## Partie 1 - Introduction

* Avant-propos à l'attention des non-programmeurs
* Introduction
* Installation
* Éditeurs
* Programmer en deux minutes
** une messagerie instantanée
** un programme interfacé avec Wikipédia
** un serveur Web

## Partie 2 - Le langage

* Afficher un texte
* Structure d'un programme
* Variables
* Opérateurs
* Structures de contrôle
* Instructions répétitives
* Types
** Numériques
** Booléens
** Chaines de caractères
** Listes
** Tuples
** Dictionnaires
** Dates
** Ensembles
* Fonctions
* Modules
* Exercices
** Palindrome
* Regex
* Programmation orientée objet pour les non-programmeurs
* Classes
* Classes et Interfaces graphiques
* Fichiers
* Exceptions
* Bases de données
** Gestion
* L'interface CGI
* Applications web
* Réseau
* Threads

## Partie 3 - Les bibliothèques

* Bibliothèques pour Python
* L'interface graphique
* Utilisation de fenêtres et de graphismes
** Tkinter
** Widgets
** Turtle
* Les threads
* XML
* JSON
* Tests
* Analyse statique de programmes
* Fabric
* Le Web
** Django
** Karrigell
** Aiohttp
[ Modifier le sommaire ]
Les threads Python sont utilisés pour lancer de multiples processus légers (tâches, appels de fonction) en même temps (mais cela ne veut pas forcément dire sur plusieurs processeurs). Les threads Python n'accélèreront donc pas un programme qui utilise déjà 100 % du temps d'un CPU (voir la programmation parallèle pour cela).
Les threads Python sont utilisés si une tâche fait attendre les autres. C'est le cas par exemple, des interactions avec un serveur web, ou lors de l'utilisation de la fonction sleep.

## Exemples
### Appel de fonction

Pour afficher les nombres de 1 à 10, en attendant une seconde entre chaque :

### Objet

Résultat :
Note : cet exemple diminue l'IDLE (temps d'inactivité) dans Windows XP, alors que cela fonctionne dans WING IDE, Netbeans, et Eclipse. Cela peut poser problème en remplaçant sleep(1) par (2), et range(4) par range(10). Le Thread-2 finit alors en première ligne (avant d'avoir commencé).

## Références

* ↑ http://wiki.python.org/moin/ParallelProcessing
# Architecture/Techniques de représentation/Perspective/Perspective conique
## Définitions

Nous devons commencer par définir une fois pour toutes les principaux termes qui seront utilisés par la suite :
* le point de vue O correspond à la position de l'œil qui observe la scène.
* le tableau est le plan (pour l'instant vertical) dans lequel on dessine.
* le sol ou géométral est un plan de référence, dont on peut choisir la hauteur à volonté, et sur lequel les architectes vont tracer la projection verticale des objets à représenter.
* le plan d'horizon est le plan horizontal qui passe par l'œil.
* le point principal P est le projeté orthogonal de l'œil sur le tableau.
* la ligne de terre est l'intersection du tableau et du sol.
* la ligne d'horizon est l'intersection du tableau et du plan d'horizon, elle passe évidemment par le point principal.
* le plan neutre (non représenté ici) est parallèle au tableau et passe par l'œil. Tout ce qu'il contient est projeté à l'infini et seuls les objets ou parties d'objets qui se trouvent devant lui peuvent être représentés sur l'épure.

## Bibliographie

* HENNEBICQ, Daniel et MOLLE, Georges .- La mise en perspective .- Paris, Eyrolles, 1983, 107 p.