projet-programmation-imperative/src/pagerank.adb

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
with Ada.Command_Line; use Ada.Command_Line;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

with Vector;
with Google_Naive;
with Google_Creux;

procedure pageRank is
    
    ERROR_args: Exception;

    -- définition du type T_Double
    Type T_Double is digits 11;
    -- on utilise le module générique Float_IO pour pouvoir afficher T_Double directement
    package Text_T_Double is
        new Ada.Text_IO.Float_IO(Num => T_Double);
    use Text_T_Double;




    -- proédure pour récupérer les arguments de la ligne de commande
    procedure get_args(filename: in out Unbounded_String;
                       ite_max: in out Natural;
                       alpha: in out T_Double;
                       naif: in out Boolean) is
        i: Natural := 1;
    begin
    
        -- on affiche tous les arguments
        put("Argument_Count = "); put(Argument_Count, 1); new_line;
        for i in 1..Argument_Count loop
            Put("Argument(");
            Put(i, 0);
            Put(") = ");
            Put_line(Argument(i));
        end loop;
        
        new_line;

        -- on vérifie d'abord que le nombre d'arguments est cohérent
        if not(0 < Argument_Count and Argument_Count <= 6) then
            raise ERROR_args;
        else -- sinon on parse les arguments
            loop
                if Argument(i) = "-P" then
                    naif := True;
                    i := i + 1;
                    put_line("parsed naif");

                elsif Argument(i) = "-A" then
                    alpha := T_Double'Value(Argument(i+1));
                    i := i + 2;
                    put_line("parsed alpha");

                elsif Argument(i) = "-I" then
                    ite_max := Natural'Value(Argument(i+1));
                    i := i + 2;
                    put_line("parsed ite_max");

                elsif Argument(i)(Argument(i)'Last-3 .. Argument(i)'Last) = ".net" then
                    filename := To_Unbounded_String(Argument(i)(Argument(i)'First .. Argument(i)'Last-4));
                    i := i + 1;
                    put_line("parsed filename");

                else
                    put_line("unexpected passing case");
                    raise ERROR_args;

                end if;
                exit when i > Argument_Count;
            end loop;
        end if;
        
        new_line;
        put("alpha = "); put(alpha, 1); new_line;
        put("naif = "); put(Boolean'Pos(naif), 1); new_line;
        put("ite_max = "); put(ite_max, 1); new_line;
        put("filename = "); put_line(To_String(filename));
        new_line;
        
    exception
        when others => raise ERROR_args; 
    end get_args;




    -- procédure pour choisir le type d'algo, une fois N et les arguments récupérés
    procedure type_algo(N: Natural;
                        filename: in Unbounded_String;
                        file: in out Ada.Text_IO.File_Type;
                        alpha: T_Double;
                        ite_max: Natural;
                        naif: Boolean) is
        
        -- on instancie le module générique Vecteur
        package Vector_T_Double is
            new Vector(T_Element => T_Double,
                       N => N);
        use Vector_T_Double;

        -- procédure qui effectue l'algorithme du pageRank avec Google_Naive
        procedure algorithm_naif(file: in out Ada.Text_IO.File_Type;
                                 alpha: in T_Double;
                                 ite_max: in Natural;
                                 pi: out T_Vecteur) is

            -- on instancie le module générique Naif de Google
            package Google is
                new Google_Naive(T_Element => T_Double,
                                 N => N,
                                 Vector_T_Element => Vector_T_Double);
            use Google;

            -- définition de la matrice Google
            G: T_Google;

        begin

            initialize(pi);
            put_line("initialized pi");
            --put(pi); new_line;

            initialize(G);
            put_line("initialized G");
            --put(G); new_line;
            
            create_H(G, file);
            put_line("created H");
            close(file);
            --put(G); new_line;
            
            create_S(G);
            put_line("created S");
            --put(G); new_line;

            create_G(G, alpha);
            put_line("created G");
            --put(G); new_line;

            -- on applique l'algorithme itératif
            put("ite: ");
            for i in 1..ite_max loop
                pi := pi * G;
                put(i, 1); put(" ");
            end loop; new_line;

            --new_line;
            --put_line("final pi:");
            --put(pi);
    
        end algorithm_naif;

        -- procédure qui effectue l'algorithme du pageRank avec Google_Creux
        procedure algorithm_creux(file: in out Ada.Text_IO.File_Type;
                                 alpha: in T_Double;
                                 ite_max: in Natural;
                                 pi: out T_Vecteur) is
            
            -- on instancie le module générique Creux de Google
            package Google is
                new Google_Creux(T_Element => T_Double,
                                 N => N,
                                 Vector_T_Element => Vector_T_Double);
            use Google;
            
            -- définition de la matrice Google
            G: T_Google;
        
        begin

            put("TODO");

        end algorithm_creux;





        -- procédure pour écrire les résultats dans les fichiers
        procedure write_to_files(filename: in Unbounded_String;
                                 pi_sorted: in T_Vecteur;
                                 pi_index: in T_Vecteur_Index) is

            file: Ada.Text_IO.File_Type;

        begin
            create(file, Out_File, To_String(filename & ".p"));
            put(file, N, 1);
            put(file, alpha, 2);
            put(file, ite_max, 2);
            new_line(file);
            put(file, pi_sorted);
            close(file);

            create(file, Out_File, To_String(filename & ".ord"));
            put(file, pi_index);
            close(file);
        end write_to_files;





        -- définition des vecteurs
        pi: T_Vecteur;
        pi_index: T_Vecteur_Index;

    begin

        if naif then
            algorithm_naif(file, alpha, ite_max, pi);
        else
            algorithm_creux(file, alpha, ite_max, pi);
        end if;

        -- on trie les poids par ordre décroissant, on tri en même temps les indices des pages
        initialize(pi_index);
        sort_with_index_desc(pi, pi_index);

        new_line;
        put_line("sorted pi:");
        put(pi); new_line;

        -- on écrit les resultats dans des fichiers
        write_to_files(filename, pi, pi_index);

    end type_algo;





    -- définition des arguments
    filename: Unbounded_String;
    ite_max: Natural := 150;
    naif: Boolean := False;
    alpha: T_Double := 0.85;

    -- définition des variables pour créer les matices/vecteurs
    N: Positive;
    file: Ada.Text_IO.File_Type;

begin

    -- on récupère les arguments de la ligne de commande
    get_args(filename, ite_max, alpha, naif);
    put_line("args OK");

    -- on ouvre le fichier .net
    open(file, In_File, To_String(filename & ".net"));
    put_line("file OK");

    -- on récupère le nombre de pages
    get(file, N);
    put("N = "); put(N, 1); new_line;
    
    -- on peut maintenant choisir le type de matrice que l'on souhaite
    type_algo(N, filename, file, alpha, ite_max, naif);

exception

    -- si il y a une erreur lors du parsing des arguments, on rappelle l'usage.
    when ERROR_args =>
        put_line("Erreur lors de la saisi de la commande");
        put_line("Usage: pagerank [-I max_iterations] [-A alpha] [-P] fichier_reseau.net");

end pageRank;