310 lines
8.2 KiB
Ada
Executable file
310 lines
8.2 KiB
Ada
Executable file
with Ada.Text_IO; use Ada.Text_IO;
|
|
with Vecteurs_Creux; use Vecteurs_Creux;
|
|
|
|
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
|
|
with Ada.Float_Text_IO; use Ada.Float_Text_IO;
|
|
|
|
procedure Test_Vecteurs_Creux is
|
|
|
|
|
|
procedure Initialiser (VC0, VC1, VC2 : out T_Vecteur_Creux) is
|
|
begin
|
|
-- VC0 est un vecteur nul
|
|
Initialiser (VC0);
|
|
|
|
-- VC1 est un vecteur à deux composante
|
|
Initialiser (VC1);
|
|
Modifier (VC1, 10, 4.0);
|
|
Modifier (VC1, 3, -3.0);
|
|
|
|
Initialiser (VC2);
|
|
Modifier (VC2, 100, 2.0);
|
|
Modifier (VC2, 3, 3.0);
|
|
Modifier (VC2, 1, 2.0);
|
|
|
|
-- Afficher les vecteurs
|
|
-- Put ("VC0 = "); Afficher (VC0); New_Line;
|
|
-- Put ("VC1 = "); Afficher (VC1); New_Line;
|
|
-- Put ("VC2 = "); Afficher (VC2); New_Line;
|
|
end;
|
|
|
|
|
|
procedure Detruire (VC0, VC1, VC2 : in out T_Vecteur_Creux) is
|
|
begin
|
|
Detruire (VC0);
|
|
Detruire (VC1);
|
|
Detruire (VC2);
|
|
end;
|
|
|
|
|
|
procedure Tester_Nul is
|
|
VC0, VC1, VC2: T_Vecteur_Creux;
|
|
begin
|
|
Initialiser (VC0, VC1, VC2);
|
|
|
|
pragma Assert (Est_Nul (VC0));
|
|
pragma Assert (not Est_Nul (VC1));
|
|
pragma Assert (not Est_Nul (VC2));
|
|
|
|
Detruire (VC0, VC1, VC2);
|
|
end Tester_Nul;
|
|
|
|
|
|
procedure Tester_Norme2 is
|
|
VC0, VC1, VC2: T_Vecteur_Creux;
|
|
begin
|
|
Initialiser (VC0, VC1, VC2);
|
|
|
|
pragma Assert (0.0 = Norme2 (VC0));
|
|
pragma Assert (25.0 = Norme2 (VC1));
|
|
|
|
Detruire (VC0, VC1, VC2);
|
|
end Tester_Norme2;
|
|
|
|
|
|
type T_Fonction_Composante is
|
|
access Function (VC : in T_Vecteur_Creux ; Indice : in Integer) return Float;
|
|
--! Un pointeur sur un sous-programme permet de manipuler un
|
|
--! sous-programme comme une donnée.
|
|
|
|
Composante : constant T_Fonction_Composante := Composante_Recursif'Access;
|
|
--! Composante est donc une constante qui pointe sur le sous-programme
|
|
--! Composante_Recursif.
|
|
|
|
|
|
procedure Tester_Composante(La_Composante : T_Fonction_Composante) is
|
|
--! Remarque : On aurait pu arriver au même résultat en définissant un
|
|
--! sous-programme générique.
|
|
--! Voir Tester_Sont_Egaux pour une version générique.
|
|
|
|
VC0, VC1, VC2: T_Vecteur_Creux;
|
|
begin
|
|
Initialiser (VC0, VC1, VC2);
|
|
|
|
pragma Assert ( 0.0 = La_Composante (VC0, 1));
|
|
|
|
pragma Assert ( 0.0 = La_Composante (VC1, 1));
|
|
pragma Assert (-3.0 = La_Composante (VC1, 3));
|
|
pragma Assert ( 0.0 = La_Composante (VC1, 4));
|
|
pragma Assert ( 0.0 = La_Composante (VC1, 9));
|
|
pragma Assert ( 4.0 = La_Composante (VC1, 10));
|
|
pragma Assert ( 0.0 = La_Composante (VC1, 11));
|
|
|
|
Detruire (VC0, VC1, VC2);
|
|
end Tester_Composante;
|
|
|
|
|
|
procedure Tester_Modifier is
|
|
VC0, VC1, VC2: T_Vecteur_Creux;
|
|
begin
|
|
Initialiser (VC0, VC1, VC2);
|
|
pragma Assert (2 = Nombre_Composantes_Non_Nulles (VC1));
|
|
|
|
-- Changer des composantes non nulles
|
|
-- * en première position
|
|
Modifier (VC1, 3, 3.0);
|
|
pragma Assert (3.0 = Composante (VC1, 3));
|
|
pragma Assert (2 = Nombre_Composantes_Non_Nulles (VC1));
|
|
|
|
-- * après la première
|
|
Modifier (VC1, 10, 15.0);
|
|
pragma Assert (15.0 = Composante (VC1, 10));
|
|
pragma Assert (2 = Nombre_Composantes_Non_Nulles (VC1));
|
|
|
|
-- Ajouter au début
|
|
Modifier (VC1, 1, 1.5);
|
|
pragma Assert (1.5 = Composante (VC1, 1));
|
|
pragma Assert (3 = Nombre_Composantes_Non_Nulles (VC1));
|
|
|
|
-- Ajouter au milieu
|
|
Modifier (VC1, 7, 7.5);
|
|
pragma Assert (7.5 = Composante (VC1, 7));
|
|
pragma Assert (4 = Nombre_Composantes_Non_Nulles (VC1));
|
|
|
|
-- Ajouter à la fin.
|
|
Modifier (VC1, 111, 0.5);
|
|
pragma Assert (0.5 = Composante (VC1, 111));
|
|
pragma Assert (5 = Nombre_Composantes_Non_Nulles (VC1));
|
|
|
|
-- Mettre à 0.0 une composante existante
|
|
-- * Au milieu
|
|
Modifier (VC1, 10, 0.0);
|
|
pragma Assert (0.0 = composante (VC1, 10));
|
|
pragma Assert (4 = Nombre_Composantes_Non_Nulles (VC1));
|
|
|
|
-- * À la fin
|
|
Modifier (VC1, 111, 0.0);
|
|
pragma Assert (0.0 = composante (VC1, 111));
|
|
pragma Assert (3 = Nombre_Composantes_Non_Nulles (VC1));
|
|
|
|
|
|
-- * Au début
|
|
Modifier (VC1, 1, 0.0);
|
|
pragma Assert (0.0 = composante (VC1, 1));
|
|
pragma Assert (2 = Nombre_Composantes_Non_Nulles (VC1));
|
|
|
|
-- Mettre à 0.0 une composante déjà nulle
|
|
Modifier (VC1, 6, 0.0);
|
|
pragma Assert (2 = Nombre_Composantes_Non_Nulles (VC1));
|
|
Modifier (VC1, 2, 0.0);
|
|
pragma Assert (2 = Nombre_Composantes_Non_Nulles (VC1));
|
|
Modifier (VC1, 56, 0.0);
|
|
pragma Assert (2 = Nombre_Composantes_Non_Nulles (VC1));
|
|
|
|
-- Supprimer toutes les composantes
|
|
Modifier (VC1, 7, 0.0);
|
|
pragma Assert (1 = Nombre_Composantes_Non_Nulles (VC1));
|
|
Modifier (VC1, 3, 0.0);
|
|
pragma Assert (0 = Nombre_Composantes_Non_Nulles (VC1));
|
|
pragma Assert (Est_Nul (VC1));
|
|
|
|
Detruire (VC0, VC1, VC2);
|
|
end Tester_Modifier;
|
|
|
|
|
|
generic
|
|
with function Egaux (Vecteur1, Vecteur2 : in T_Vecteur_Creux) return Boolean;
|
|
procedure Tester_Sont_Egaux;
|
|
|
|
|
|
procedure Tester_Sont_Egaux is
|
|
VC0, VC1, VC2, VC3: T_Vecteur_Creux;
|
|
begin
|
|
Initialiser (VC0, VC1, VC2);
|
|
|
|
pragma Assert (Egaux (VC0, VC0));
|
|
pragma Assert (Egaux (VC1, VC1));
|
|
pragma Assert (Egaux (VC2, VC2));
|
|
|
|
pragma Assert (not Egaux (VC0, VC1));
|
|
pragma Assert (not Egaux (VC0, VC2));
|
|
pragma Assert (not Egaux (VC1, VC2));
|
|
|
|
pragma Assert (not Egaux (VC1, VC0));
|
|
pragma Assert (not Egaux (VC2, VC0));
|
|
pragma Assert (not Egaux (VC2, VC1));
|
|
|
|
-- VC3 avec les mêmes composantes que VC1
|
|
Initialiser (VC3);
|
|
Modifier (VC3, 10, 4.0);
|
|
Modifier (VC3, 3, -3.0);
|
|
|
|
pragma Assert (Egaux (VC1, VC3));
|
|
pragma Assert (Egaux (VC3, VC1));
|
|
|
|
Detruire (VC0, VC1, VC2);
|
|
Detruire (VC3);
|
|
end Tester_Sont_Egaux;
|
|
|
|
|
|
--! Remarque : si on instancie les deux sous-programmes suivant juste
|
|
--! avant l'implantation de Tester_Sont_Egaux ci-dessus, on n'a pas
|
|
--! d'erreur de compilation mais une erreur à l'exécution.
|
|
procedure Tester_Sont_Egaux_Iteratif is
|
|
new Tester_Sont_Egaux (Sont_Egaux_Iteratif);
|
|
|
|
|
|
procedure Tester_Sont_Egaux_Recursif is
|
|
new Tester_Sont_Egaux (Sont_Egaux_Recursif);
|
|
|
|
|
|
procedure Tester_Produit_Scalaire is
|
|
VC0, VC1, VC2, VC3: T_Vecteur_Creux;
|
|
begin
|
|
Initialiser (VC0, VC1, VC2);
|
|
|
|
pragma Assert (0.0 = Produit_Scalaire (VC0, VC1));
|
|
pragma Assert (0.0 = Produit_Scalaire (VC0, VC2));
|
|
pragma Assert (0.0 = Produit_Scalaire (VC1, VC0));
|
|
|
|
pragma Assert (-9.0 = Produit_Scalaire (VC1, VC2));
|
|
|
|
pragma Assert (25.0 = Produit_Scalaire (VC1, VC1));
|
|
|
|
Initialiser (VC3);
|
|
Modifier (VC3, 150, 5.0);
|
|
Modifier (VC3, 10, 4.0);
|
|
Modifier (VC3, 3, 3.0);
|
|
Modifier (VC3, 2, 2.0);
|
|
Modifier (VC3, 1, 1.0);
|
|
|
|
pragma Assert (11.0 = Produit_Scalaire (VC2, VC3));
|
|
pragma Assert (11.0 = Produit_Scalaire (VC3, VC2));
|
|
|
|
pragma Assert (7.0 = Produit_Scalaire (VC1, VC3));
|
|
pragma Assert (7.0 = Produit_Scalaire (VC3, VC1));
|
|
|
|
Detruire (VC0, VC1, VC2);
|
|
Detruire (VC3);
|
|
end Tester_Produit_Scalaire;
|
|
|
|
|
|
procedure Tester_Additionner_Partage is
|
|
VC0, VC1: T_Vecteur_Creux;
|
|
begin
|
|
-- Construire VC0
|
|
Initialiser (VC0);
|
|
for I in 1..5 loop
|
|
Modifier (VC0, I, Float(I));
|
|
end loop;
|
|
|
|
-- Construire VC1
|
|
Initialiser (VC1);
|
|
for I in 4..15 loop
|
|
Modifier (VC1, I, Float(I));
|
|
end loop;
|
|
|
|
-- Additionner
|
|
Additionner (VC0, VC1);
|
|
|
|
Afficher(VC1); New_Line;
|
|
-- Vérifier qu'il n'y a pas de partage entre cellules de VC0 et VC1
|
|
Modifier (VC1, 10, 111.0);
|
|
pragma Assert (111.0 = Composante (VC1, 10));
|
|
put(Composante (VC0, 10)); New_Line;
|
|
pragma Assert (10.0 = Composante (VC0, 10));
|
|
|
|
Detruire (VC0);
|
|
Detruire (VC1);
|
|
end Tester_Additionner_Partage;
|
|
|
|
|
|
procedure Tester_Additionner is
|
|
VC0, VC1, VC2: T_Vecteur_Creux;
|
|
begin
|
|
Initialiser (VC0, VC1, VC2);
|
|
|
|
Additionner (VC0, VC1);
|
|
pragma Assert (Sont_Egaux_Recursif (VC0, VC1));
|
|
pragma Assert (2 = Nombre_Composantes_Non_Nulles (VC0));
|
|
pragma Assert (-3.0 = Composante (VC0, 3));
|
|
pragma Assert ( 4.0 = Composante (VC0, 10));
|
|
|
|
Additionner (VC0, VC2);
|
|
pragma Assert (3 = Nombre_Composantes_Non_Nulles (VC0));
|
|
pragma Assert (2.0 = Composante (VC0, 1));
|
|
pragma Assert (0.0 = Composante (VC0, 3));
|
|
pragma Assert (4.0 = Composante (VC0, 10));
|
|
pragma Assert (2.0 = Composante (VC0, 100));
|
|
|
|
Additionner (VC2, VC1);
|
|
|
|
pragma Assert (Sont_Egaux_Recursif (VC0, VC2));
|
|
|
|
Detruire (VC0, VC1, VC2);
|
|
end Tester_Additionner;
|
|
|
|
|
|
begin
|
|
Tester_Nul;
|
|
Tester_Norme2;
|
|
Tester_Composante (Composante_Recursif'Access);
|
|
Tester_Composante (Composante_Iteratif'Access);
|
|
Tester_Modifier;
|
|
Tester_Sont_Egaux_Recursif;
|
|
Tester_Sont_Egaux_Iteratif;
|
|
Tester_Produit_Scalaire;
|
|
Tester_Additionner_Partage;
|
|
Tester_Additionner;
|
|
end Test_Vecteurs_Creux;
|