OpenLLM-France/wikimedia huggingface dataset:
# Programmation GTK2 en Pascal/GtkFileSelection

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie

## Présentation

Le contrôle GtkFileSelection est une boîte de dialogue qui permet de demander à l'utilisateur de sélectionner un fichier particulier. Ce contrôle ne s'occupe de la récupération du nom du fichier.

### Hiérarchie

* Hiérarchie
* GObject
* └─GtkObject
* └─GtkWidget
* └─GtkContainer
* └─GtkBin
* └─GtkWindow
* └─GtkDialog
* └─GtkFileSelection

## Utilisation de base
### Création

La fonction de création est simple :
Le paramètre title est le titre de votre boîte de dialogue : vous pouvez ainsi l'appeler suivant vos besoins « Ouvrir... », « Sélectionner un fichier...», etc.

### Affichage

Puisque ce nouveau contrôle dérive directement du contrôle GtkDialog, il nous suffit d'utiliser la fonction :
La valeur de retour est importante pour savoir si l'utilisateur a sélectionné un nom de fichier ou pas.

### Récupération du nom de fichier

Encore une fois, nous allons utiliser les propriétés du contrôle GtkDialog. Si la valeur de retour de gtk_dialog_run est GTK_RESPONSE_OK, alors un nom de fichier a été sélectionné, et on peut donc récupérer sa valeur avec la fonction suivante :
Le paramètre filesel doit être utilisé avec la fonction de conversion GTK_FILE_SELECTION. Attention, la valeur de retour n'est pas modifiable.
Pour toutes les autres valeurs de retour de la fonction gtk_dialog_run, cette fonction renverra le chemin complet du répertoire affiché au moment où l'utilisateur a annulé.

### Initialisation du nom de fichier

Un nom de fichier peut être donné à la boîte de dialogue avant son affichage. Cela se fait avec la fonction :

## Programme exemple

Nous allons créer une fenêtre avec un bouton nous permettant d'ouvrir une GtkFileSelection. Une fois le fichier sélectionné, nous affichons son chemin dans un label de la fenêtre.
Voici le fichier gtk048.pas :
Voila ce que donne l'exécution du programme gtk048 :
La fenêtre principale s'affiche et on clique sur le bouton « Ouvrir », voilà la fenêtre de dialogue qui s'ouvre :
# Programmation GTK2 en Pascal/GtkContainer

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie

## Présentation

Le contrôle GtkContainer est un contrôle de base qui va nous permettre d'insérer un ou plusieurs contrôle dans un autre contrôle.
En effet si l'on veut insérer du texte dans une fenêtre, il va bien falloir insérer le GtkLabel quelque part. C'est là que l'on s'aperçoit que le contrôle GtkWindow dérive du contrôle GtkContainer et que l'on va pouvoir insérer le texte dans la fenêtre.

### Hiérarchie

* Hiérarchie
* GObject
* └─GtkObject
* └─GtkWidget
* └─GtkContainer

## Utilisation de base

Le contrôle GtkContainer n'est pas utilisé en tant que tel mais plutôt au travers d'autres contrôles qui en dérivent. Par exemple, les GtkHBox, GtkVBox, GtkWindow, etc.

### Ajout et suppression d'éléments

La fonction pour ajouter un élément à un GtkContainer est très souvent utilisée mais elle est aussi très simple d'utilisation :
Le paramètre container est le contrôle parent dans lequel on veut insérer le contrôle enfant qui vient en deuxième paramètre. Le premier paramètre demande un contrôle du type GtkContainer, il est très probable que le contrôle parent ne soit pas de ce type là, mais d'une classe fille. Il faudra donc utiliser la fonction GTK_CONTAINER.
Pour la suppression c'est aussi simple, il faut utiliser la fonction :
Attention, avec cette fonction le contrôle widget va être détruit.

### Espacement

Avec le contrôle GtkContainer, il existe la possibilité de laisser un espace minimum entre le bord du contrôle parent et le bord du contrôle enfant. Cela est rendu possible grâce à cette fonction :
Le paramètre border_width correspond à l'espacement minimum.
Et pour connaître la valeur de cet espacement, il y a la fonction :
* Conteneurs :
* GtkContainer ~
* GtkBox ~
* GtkBin —
* GtkHBox ~
* GtkVBox ~
* GtkTable ~
* GtkNotebook
# Programmation GTK2 en Pascal/GtkDrawingArea

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie

## Présentation

Le contrôle GtkDrawingArea est un contrôle basique qui n'a pas d'aspect par défaut et dont l'affichage est complètement géré par nos soins. Il permet donc d'afficher des images, des formes, et / ou du texte.

### Hiérarchie

* Hiérarchie
* GObject
* └─GtkObject
* └─GtkWidget
* └─GtkDrawingArea

## Utilisation de base
### Création

La création est très simple :

### Modification de la taille de la zone de dessin

Une fonction permet de choisir ou de modifier la taille de la zone de dessin :

### Utilisation des signaux

Le signal realize est émis lors du premier affichage de la GtkDrawingArea.
Le signal expose_event est émis lorsque celle-ci à besoin d'un rafraichissement (lorsque la fenêtre devient cachée par une autre, puis revient au premier plan par exemple).
Il faut connecter ces deux signaux à des fonctions qui vont réaliser le dessin. Plusieurs méthodes sont possibles : soit on dessine systématiquement et à ce moment on peut se permettre de ne connecter que expose_event, soit on dessine dans une image (pixmap) à l'appel du signal realize puis lors de l'appel expose_event on ne redessine que l'image mémorisée.

### Le dessin

Il va être réalisé avec des fonctions du Gdk, Gimp Drawing Kit, les outils de dessin de Gimp. Cf le chapitre Dessiner avec le Gdk.

## Programme exemple

On va dessiner dans une zone de dessin une ligne, puis un rectangle, une moitié de ballon de rugby et enfin un quadrilatère, tout cela en noir sur fond blanc.
Voilà le fichier gtk019.pas :
Voilà ce que donne l'exécution du programme gtk019 :
* Visuels :
* GtkLabel ~
* GtkImage ~
* GtkStatusBar ~
* GtkProgressBar ~
* GtkDrawingArea
# Mathc initiation/Fichiers h : c34da

Sommaire
Calcul de int(f(x)) en fonction des bornes ax et bx avec nx itérations . C'est la deuxième partie du calcul. :
| Simple intégrale | Double intégrale |
| /* ---------------------------------- */ double simpson( double (*P_f)(double x), double ax, double bx, int nx ) { int i = 0; double m = 0.; double M = 0.; for(i = 0; i <= nx; i++) { if(i ==0 || i== nx){m = 1.;} else if(fmod(i,2) == 0 ){m = 2.;} else {m = 4.;} M += m * (*P_f) (ax+i*(bx-a)/nx); } return( ((bx-ax)*M) / (3*nx) ); } /* ---------------------------------- */ | /* ---------------------------------- */ double simpson_dydx( double (*P_f)(double x, double y), double (*P_ay)(double x), double (*P_by)(double x), int ny, double ax, double bx, int nx ) { int i = 0; double m = 0.; double M = 0.; for(i = 0; i <= nx; i++) { if(i ==0 || i== nx){m = 1.;} else if(fmod(i,2) == 0) {m = 2.;} else {m = 4.;} M += m * int_dy( (*P_f), (*P_ay),(*P_by),ny, (ax + i*(bx-ax)/nx)); } return( ((bx -ax)*M) / (3*nx) ); } /* ---------------------------------- */ |
Comparons les deux fonctions.
Dans les deux premières colonnes, il y a la fonction de référence pour calculer une intégrale simple par la méthode de Simpson. Dans les deuxièmes colonnes il y a deux fonctions pour calculer l'intégrale double. L'intégrale double est calculé par la fonction simpson_dydx; qui appelle la fonction int_dy;
int_dy; Cette fonction applique la méthode de Simpson pour la variable y.
simpson_dydx; Cette fonction applique la méthode de Simpson pour la variable x.
En comparant ces deux fonctions à la fonction de référence, on voit immédiatement l'analogie qu'il existe entre ces fonctions.
Calcul de int(f(y)) en fonction des bornes ay(x) et by(x) avec ny itérations :
| Simple intégrale | Double intégrale |
| /* ---------------------------------- */ double simpson( double (*P_f)(double x), double ay, double by, int ny ) { int i = 0; double m = 0.; double M = 0.; for(i = 0; i <= ny; i++) { if(i ==0 || i== ny){m = 1.;} else if(fmod(i,2) == 0 ){m = 2.;} else {m = 4.;} M += m * (*P_f) (ay + i*(by -ay)/ny); } return( ((by -ay)*M) / (3*ny) ); } /* ---------------------------------- */ | /* ---------------------------------- */ double int_dy( double (*P_f)(double x, double y), double (*P_ay)(double x), double (*P_by)(double x), int ny, double x ) { int i = 0; double m = 0.; double M = 0.; for(i = 0; i <= ny; i++) { if(i ==0 || i== ny){m = 1.;} else if(fmod(i,2) == 0) {m = 2.;} else {m = 4.;} M += m * (*P_f)( x, ((*P_ay)(x)) + i*(((*P_by)(x)) -((*P_ay)(x)))/ny); } return( ((((*P_by)(x)) -((*P_ay)(x)))*M) / (3*ny) ); } /* ---------------------------------- */ |
# Mathc initiation/Fichiers h : c32bd

Sommaire

## Dessiner les points d'intersection entre la tangente et les axes x et y

En mathématiques, une représentation paramétrique ou paramétrage d’un ensemble est sa description comme ensemble image d’une fonction d’une ou plusieurs variables appelées alors paramètres. Pour un ensemble de points du plan ou d’un espace de plus grande dimension muni d’un repère, l’expression des différentes composantes se décompose en contraintes sur le paramétrage appelées équations paramétriques. wikipedia
Copier la bibliothèque dans votre répertoire de travail :
* x_hfile.h ............ Déclaration des fichiers h
* x_def.h .............. Déclaration des utilitaires
* x_strct.h ............ Déclaration des structures pour la variable t
* x_strcg.h ........... Déclaration des structures pour gnuplot
* kgt_c.h .............. Dessiner la tangente
Les fonctions et leurs dérivés pour les différents exemples :
* f.h
Dessiner les points d'intersection entre la tangente et les axes x et y :
* c00a.c
* c00b.c
* c00c.c
* c00d.c
* c00e.c
# Mathc initiation/Fichiers h : c34

Sommaire

## Intégrale double

En analyse numérique, la méthode de Simpson, du nom de Thomas Simpson, est une technique de calcul numérique d'une intégrale. ... ... Khanacademy : double integral
Copier la bibliothèque dans votre répertoire de travail :
* x_hfile.h ............ Déclaration des fichiers h
* x_def.h .............. Déclaration des utilitaires
* x_dydx.h ............ Les intégrales de la forme dydx
* x_dxdy.h ............ Les intégrales de la forme dxdy
Les fonctions f
* f.h
Quelques exemples d'applications :
* c00a.c .. f(x,y) =x**2+y**2+1 .. ay(x) =0 ........... by(x) =2-2*x
* c00b.c .. f(x,y) =1 ................... ay(x) =2-(x/2) ... by(x) =8-(x**2/2)
* c00c.c .. f(x,y) =x**3+4*y ....... ax(y) =y/2 ......... bx(y) =sqrt(y)
* c00d.c .. f(x,y) =sqrt(9-y**2) ... ax(y) =0 ........... by(y) =sqrt(9-y**2)
Vérifier le résultat avec Octave :
* c00e.c .. f(x,y) =sin(cos(x*y)) ... ax(y) =0 ........... bx(y) =.5
Regardons la fonction qui effectue le travail :
* Étudions la fonction simpson_dydx;
# Mathc initiation/Fichiers h : c33

Sommaire

## Intégrale double II (trapèzes)

En analyse numérique, la méthode des trapèzes est une méthode pour le calcul numérique d'une intégrale. wikipedia
Copier la bibliothèque dans votre répertoire de travail :
* x_hfile.h ............ Déclaration des fichiers h
* x_def.h .............. Déclaration des utilitaires
* x_dydx.h ............ Les intégrales de la forme dydx
* x_dxdy.h ............ Les intégrales de la forme dxdy
Les fonctions f
* f.h
Quelques exemples d'applications :
* c00a.c .. f(x,y) =x**2+y**2+1 .. ay(x) =0 ........... by(x) =2-2*x
* c00b.c .. f(x,y) =1 ................... ay(x) =2-(x/2) ... by(x) =8-(x**2/2)
* c00c.c .. f(x,y) =x**3+4*y ....... ax(y) =y/2 ......... bx(y) =sqrt(y)
* c00d.c .. f(x,y) =sqrt(9-y**2) ... ax(y) =0 ........... bx(y) =sqrt(9-y**2)
# Mathc initiation/Fichiers h : c32da

Sommaire
Calcul de int(f(x)) en fonction des bornes ax et bx avec nx itérations . C'est la deuxième partie du calcul. :
| Simple intégrale | Double intégrale |
| /* ---------------------------------- */ double simpson( double (*P_f)(double x), double ax, double bx, int nx ) { int i = 0; double m = 0.; double M = 0.; for(i = 0; i <= nx; i++) { if(i ==0 || i== nx){m = 1.;} else if(fmod(i,2) == 0 ){m = 2.;} else {m = 4.;} M += m * (*P_f)(ax+i*(bx-ax)/nx); } return( ((bx-ax)*M) / (3*nx) ); } /* ---------------------------------- */ | /* ---------------------------------- */ double simpson_dydx( double (*P_f)(double x, double y), double ay, double by, int ny, double ax, double bx, int nx ) { int i = 0; double m = 0.; double M = 0.; for(i = 0; i <= nx; i++) { if(i ==0 || i== nx){m = 1.;} else if(fmod(i,2) == 0 ){m = 2.;} else {m = 4.;} M += m * int_dy((*P_f), ay,by,ny, (ax + i*(bx-ax)/nx)); } return( ((bx -ax)*M) / (3*nx) ); } /* ---------------------------------- */ |
Comparons les deux fonctions.
Dans les deux premières colonnes, il y a la fonction de référence pour calculer une intégrale simple par la méthode de Simpson. Dans les deuxièmes colonnes il y a deux fonctions pour calculer l'intégrale double. L'intégrale double est calculé par la fonction simpson_dydx; qui appelle la fonction int_dy;
int_dy; Cette fonction applique la méthode de Simpson pour la variable y.
simpson_dydx; Cette fonction applique la méthode de Simpson pour la variable x.
En comparant ces deux fonctions à la fonction de référence, on voit immédiatement l'analogie qu'il existe entre ces fonctions.
Calcul de int(f(y)) en fonction des bornes ay et by avec ny itérations :
| Simple intégrale | Double intégrale |
| /* ---------------------------------- */ double simpson( double (*P_f)(double x), double ay, double by, int ny ) { int i = 0; double m = 0.; double M = 0.; for(i = 0; i <= ny; i++) { if(i ==0 || i== ny){m = 1.;} else if(fmod(i,2) == 0 ){m = 2.;} else {m = 4.;} M += m * (*P_f)(ay+i*(by-ay)/n); } return( ((by-ay)*M) / (3*ny) ); } /* ---------------------------------- */ | /* ---------------------------------- */ double int_dy( double (*P_f)(double x, double y), double ay, double by, int ny, double x ) { int i = 0; double m = 0.; double M = 0.; for(i = 0; i <= ny; i++) { if(i ==0 || i== ny){m = 1.;} else if(fmod(i,2) == 0 ){m = 2.;} else {m = 4.;} M += m * (*P_f)(x, ay + i*(by-ay)/ny); } return( ((by -ay)*M) / (3*ny) ); } /* ---------------------------------- */ |
# Programmation/Programmation concurrente

* Historique
* Abstraction

## Concepts de base

* Commentaires
* Instructions
* Variables
* Types
* Expressions
* Comparaisons
* Instructions de contrôle
* Entrées-sorties

## Concepts spécifiques

* Manipulation de chaînes
* Procédures et fonctions
* Gestion de mémoire
* Gestion des exceptions
* Paradigmes de programmation
* Programmation séquentielle
* Programmation concurrente
* Programmation impérative
* Programmation orientée objet
* Programmation générique
* Programmation orientée aspect
* Programmation fonctionnelle
* Programmation logique
* Programmation par contrat

## Logiciels

* Eclipse
* NetBeans
* PhpStorm
* PyCharm
* SciTE
* Visual Studio Code

## Annexes

* Structure et style
* Règles de programmation
* Langages
* Historique
* Abstraction

## Concepts de base

* Commentaires
* Instructions
* Variables
* Types
* Expressions
* Comparaisons
* Instructions de contrôle
* Entrées-sorties

## Concepts spécifiques

* Manipulation de chaînes
* Procédures et fonctions
* Gestion de mémoire
* Gestion des exceptions
* Paradigmes de programmation
* Programmation séquentielle
* Programmation concurrente
* Programmation impérative
* Programmation orientée objet
* Programmation générique
* Programmation orientée aspect
* Programmation fonctionnelle
* Programmation logique
* Programmation par contrat

## Logiciels

* Eclipse
* NetBeans
* PhpStorm
* PyCharm
* SciTE
* Visual Studio Code

## Annexes

* Structure et style
* Règles de programmation
* Langages
[ Modifier le sommaire ]
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)
Tous les systèmes d'exploitation actuels sont multi-tâches : Ils permettent l'exécution "en parallèle" de plusieurs applications : lancer un traitement de texte tout en écoutant sa musique préférée.
Au sein de la même application (ou programme), plusieurs tâches peuvent également s'effectuer "en parallèle" :
* Dans un traitement de texte, une tâche récupère ce que l'utilisateur tape tout en vérifiant l'orthographe de ce qui a été tapé précédemment,
* Le logiciel d'écoute de musique a une tâche de lecture du fichier pour le jouer, une autre pour afficher le temps écoulé, ...

## "En parallèle"

En fait, les tâches ne sont pas exécutées en parallèle, à moins que la machine possède plusieurs processeurs. Le système d'exploitation accorde à chaque tâche lancée un peu de temps de processeur pour s'exécuter. Une fois ce temps écoulé, il donne du temps à une autre tâche, etc. La durée et l'attribution du temps dépend du système d'exploitation et de la priorité attribuée à chaque tâche (priorité pouvant évoluer dans le temps). Si le système dispose de plusieurs processeurs, ceux-ci travaillent en parallèle pour exécuter plus d'une tâche à la fois.
Exemple de tâches :
Et un exemple d'ordre d'exécution :
# Programmation/Make

En programmation, make est, entre autres, un outil pour compiler de grandes applications. C'est un moteur de production principalement pour travailler dans un langage compilé sous environnement Unix.

## Installation
### Linux

make est fourni par défaut sur Ubuntu. Sinon :

### Windows

Dans Powershell en admin :
Ensuite cela fonctionne à peu près comme sur Linux, nonobstant la nécessité de préfixer certaines commandes par "start ".

## Utilisation

En langage C, l'utilisation basique est :
cela remplace :
Son principal avantage et ce pourquoi il fut imaginé est de simplifier grandement le travail du programmeur. Lorsque l'on compile un programme utilisant de nombreuses bibliothèques comme pour l'utilisation d'interfaces graphiques par exemple :
On aura besoin de directives indiquant que l'on compilera avec cette longue ligne de bibliothèques, ces directives sont enregistrés dans un fichier texte toujours nommé Makefile.
La commande make et fichier ASCII Makefile (M majuscule) vont toujours de pair. Makefile se trouvant dans le répertoire ou l'on exécute make.

## Exemple de Makefile

Un Makefile commun est :
En exécutant make en ligne de commande dans le répertoire où se trouve le Makefile nous avons :

## Variables

Il est possible de définir des variables dans un makefile. Ces variables sont très souvent utilisées pour définir le compilateur utilisé, les options de compilation, les chemins vers les bibliothèques, et autres variables spécifiques à l'environnement de l'utilisateur. Par exemple, on utilisera :
Il existe aussi des variables magiques comme :
    $@ : le nom de la cible courante.
    $< : le fichier source de la dépendance
Le précédent Makefile se simplifie en :

## .PHONY

Il existe une cible réservée nommée .PHONY qui force les dépendances à se reconstruire.

## Voir aussi

* Programmation C
* Programmation C++
* Man make
* Manuel de l'outil GNU make
# Programmation/Paradigmes de programmation

* Historique
* Abstraction

## Concepts de base

* Commentaires
* Instructions
* Variables
* Types
* Expressions
* Comparaisons
* Instructions de contrôle
* Entrées-sorties

## Concepts spécifiques

* Manipulation de chaînes
* Procédures et fonctions
* Gestion de mémoire
* Gestion des exceptions
* Paradigmes de programmation
* Programmation séquentielle
* Programmation concurrente
* Programmation impérative
* Programmation orientée objet
* Programmation générique
* Programmation orientée aspect
* Programmation fonctionnelle
* Programmation logique
* Programmation par contrat

## Logiciels

* Eclipse
* NetBeans
* PhpStorm
* PyCharm
* SciTE
* Visual Studio Code

## Annexes

* Structure et style
* Règles de programmation
* Langages
* Historique
* Abstraction

## Concepts de base

* Commentaires
* Instructions
* Variables
* Types
* Expressions
* Comparaisons
* Instructions de contrôle
* Entrées-sorties

## Concepts spécifiques

* Manipulation de chaînes
* Procédures et fonctions
* Gestion de mémoire
* Gestion des exceptions
* Paradigmes de programmation
* Programmation séquentielle
* Programmation concurrente
* Programmation impérative
* Programmation orientée objet
* Programmation générique
* Programmation orientée aspect
* Programmation fonctionnelle
* Programmation logique
* Programmation par contrat

## Logiciels

* Eclipse
* NetBeans
* PhpStorm
* PyCharm
* SciTE
* Visual Studio Code

## Annexes

* Structure et style
* Règles de programmation
* Langages
[ Modifier le sommaire ]
Il existe différentes classes de langage qui fonctionnent à partir de concepts et de schémas de pensées différents. Ainsi, le langage C est assez éloigné du langage Lisp qui lui-même ne partage guère les structures de base du langage SmallTalk.
On parle de paradigme pour désigner un ensemble de concept particulier.
Les langages de programmation impératifs représentent le premier paradigme de programmation utilisé : ce sont les langages qui héritent de l'Algol, dont le C est le meilleur représentant.
Bien qu'inventé en même temps, le paradigme orienté objet a connu le succès avec le C++ et, au début du XXIème siècle grâce aux langages Java et C#.
Les autres paradigmes, comme par exemple la programmation fonctionnelle, sont moins utilisés. Ils comprennent le LISP, le Scheme et le Prolog. Le logo est également un langage respectant le paradigme fonctionnel.
Certains langages sont multi-paradigmes, ainsi le Python offre les trois paradigmes présentés dans cette introduction.
# Pathologie/Pathologie générale/Notions de base/Méthodes d'étude
## Instruments

* Macrocopie
** Table de macroscopie
** Table de dissection
** Table d'autopsie
** Atlas macroscopique
** Collections macroscopiques
* Microscopie
** Microscope optique
** Photomicroscope
** Lame numérique
** Atlas microscopique
** Collection microscopique
# Pathologie/Pathologie générale/Notions de base/Normal et normalité

Normal et normalité
Le normal en médecine s'oppose au malade, étudié par la pathologie et défini par l'adjectif pathologique. Il a été étudié par le médecin philosophe Georges Canghillem dans son ouvrage "Le Normal et le pathologique" (1943).
Chez François Broussais (1772-1838), « Il y a identité du normal et du pathologique, aux variations quantitatives près ».
L'anormalité d'une réalité peut être définie comme un écart à une norme définie au préalable. En pathologie morphologique, il est défini une norme morphologique par la cytologie et l'histologie.
Une anomalie