Une procédure ou une fonction est une sous-routine, en général appelée plusieurs fois. Ceci permet de regrouper un code utilisé plusieurs fois, de diviser le programme en sous-programmes.
Différences procédure/fonction.
Procédures et fonctions acceptent des paramètres, seule une fonction retourne une valeur. La procédure n'en retourne pas.
Déclaration d'une procédure.
La déclaration d'une procédure se fait avec le mot clé codice_1 suivi du nom de la procédure, et de la liste des paramètres entre parenthèses. Cette liste de paramètres est déclarée avec la même syntaxe que les variables.
Ensuite, les variables locales sont déclarées, puis les instructions sont comprises dans un bloc codice_2 ... codice_3
Par exemple :
 procedure NumeroFoisDix( numero : integer ) ;
 var j : integer;
 begin
 j := numero * 10 ;
 writeln('j = ', j) ;
 end ;
Déclaration d'une fonction.
La syntaxe est similaire à celle d'une procédure, excepté que le mot clé utilisé est codice_4 et que le type de retour doit être déclaré.
Par exemple :
 function NumeroPlusCinq( numero : integer ) : integer ;
 var j : integer ;
 begin
 j := numero + 5 ;
 NumeroPlusCinq := j ;
 end ;
Retourner une valeur se fait en affectant celle-ci au nom de la fonction.
Interface et implémentation dans un module.
Dans un module, la partie codice_5 contient le code des sous-routines en utilisant la syntaxe des paragraphes précédant.
La partie codice_6 ne reprend que la première ligne.
Par exemple :
unit MonModule;
interface
procedure NumeroFoisDix( numero : integer ) ;
function NumeroPlusCinq( numero : integer ) : integer ;
implementation
procedure NumeroFoisDix( numero : integer ) ;
var j : integer ;
begin
 j := numero * 10 ;
 writeln("j = ", j) ;
end ;
function NumeroPlusCinq( numero : integer ) : integer ;
var j : integer ;
begin
 j := numero + 5 ;
 NumeroPlusCinq := j ;
end ;
end.
Ordre de déclaration.
La compilation en une passe implique que chaque fonction ou procédure appelée doit être définie avant. L'ordre des sous-routines est donc important.
L'exemple suivant produit une erreur de compilation :
 procedure FaireFaire;
 begin
 writeln('Procédure qui sous-traite l"action');
 Faire;
 end;
 procedure Faire;
 begin
 writeln('Procédure qui fait l"action');
 end;
L'ordre correct est le suivant :
 procedure Faire;
 begin
 writeln('Procédure qui fait l"action');
 end;
 procedure FaireFaire;
 begin
 writeln('Procédure qui sous-traite l"action');
 Faire;
 end;
Cette restriction ne s'applique pas aux sous-routines publiques d'un même module, car elles sont pré-déclarées dans la partie interface.
Il existe des cas où deux procédures s'appellent mutuellement. Aucune ne peut être située avant/après l'autre. Dans ce cas, il faut en prédéclarer une avec le mot clé codice_7.
Par exemple :
 procedure GrandCalcul(n:integer); forward;
 procedure PetitCalcul(n:integer);
 begin
 if n>100 then GrandCalcul(n);
 else begin
 endif;
 end;
 procedure GrandCalcul(n:integer);
 begin
 if n<=100 then PetitCalcul(n);
 else begin
 endif;
 end;

Programmation Pascal/Variables
Une variable sert à stocker une donnée. Elle a un nom, et un type (entier, chaîne de caractères, tableaux d'entiers, ...).
Déclaration des variables.
Les variables peuvent être déclarées en début de programme ou de module. Dans ce cas, elles sont globales, car accessibles à toutes les procédures et fonctions qui suivent.
Les variables peuvent également être déclarées en début de procédure ou de fonction, où elles seront locales à celle-ci.
Les déclarations de variables commencent par le mot clé codice_1, puis chaque variable est déclarée selon la syntaxe suivante :
 nom_variable : type_de_variable ;
Il est également possible de regrouper les variables ayant le même type :
 nom_variable1 , nom_variable2 : type_de_variable ;
Par exemple :
 var
 i,j : integer;
 s : String;
Affectation.
Pour affecter une valeur constante ou le résultat d'une expression à une variable, il faut utiliser l'opérateur codice_2 (caractère deux-points suivi du caractère égal).
Par exemple :
 i:=5;
 j:=i+10;
Affectation à la déclaration.
Il est possible d'affecter une valeur à la déclaration d'une variable, en utilisant l'opérateur égal ( codice_3 ), le caractère deux-points étant déjà utilisé pour déclarer le type :
 var i:integer=5;

Programmation Pascal/Créer de nouveaux types

Déclaration des types.
Les déclarations de types commencent par le mot clé codice_1, puis chaque nouveau type est déclaré selon la syntaxe suivante :
 "nom_type" = "type" ;
Par exemple :
 type
 entier = integer;
 vraifaux = boolean;
Ensuite, les variables peuvent utiliser ces types :
 var i:entier;
 b:vraifaux;
Structure.
Une structure est appelée "record" (enregistrement) en Pascal. Ce type regroupe plusieurs données, chacune portant un nom. Elle ne nécessite pas d'allocation de mémoire particulière, au contraire des objets (type codice_2).
Exemple.
 type
 point = record
 x , y : integer ;
 end record;
Une variable de ce type :
 var point_depart : point;
possède deux membres accessibles par l'opérateur point ( codice_3 ) :
 point_depart.x := 10;
 point_depart.y := 15;

Recueil d'exercices de mécanique élémentaire

Même si on est débutant, il vaut mieux apprendre à classer et noter ses exercices dans un recueil.
En voici un. Il a été prévu pour interroger à l'examen (cf. Mécanique, enseignée via l'Histoire des Sciences, remarques-en-vrac).

Photographie/Fabricants/Schneider-Kreuznach

Historique de l'entreprise.
Le groupe Schneider a été fondé en 1913 à Bad Kreuznach, en Allemagne. Il est l'un des principaux fabricants mondiaux dans le domaine des objectifs de haute qualité et des systèmes opto-mécaniques pour les applications industrielles, la vision artificielle, la photographie et la projection cinématographique. Plus de 15 000 000 d'objectifs ont été fabriqués au fil des années et le groupe emploie actuellement 600 personnes de par le monde.

Programmation C sharp/Bibliographie et liens

Programmation C sharp/Un premier programme