Return to drivers_for_symmetry_group_io.adb CVS log

Up to [local] / OpenXM_contrib / PHC / Ada / Root_Counts / Symmetry

Annotation of OpenXM_contrib/PHC/Ada/Root_Counts/Symmetry/drivers_for_symmetry_group_io.adb, Revision 1.1.1.1

1.1       maekawa     1: with text_io,integer_io;                 use text_io,integer_io;
                      2: with Communications_with_User;           use Communications_with_User;
                      3: with Numbers_io;                         use Numbers_io;
                      4: with Symbol_Table,Symbol_Table_io;       use Symbol_Table;
                      5: with Symbolic_Symmetry_Group_io;
                      6:
                      7: package body Drivers_for_Symmetry_Group_io is
                      8:
                      9:   procedure Read_Permutation_Group
                     10:                ( n : in natural; g,v : in out List_of_Permutations;
                     11:                  allperms : out boolean ) is
                     12:
                     13:     ans : character;
                     14:     nb : natural;
                     15:
                     16:   begin
                     17:     new_line;
                     18:     put("Is the group the full permutation group ? (y/n) ");
                     19:     Ask_Yes_or_No(ans);  allperms := (ans = 'y');
                     20:     if ans = 'y'
                     21:      then
                     22:        g := SymGrp(n);
                     23:      else
                     24:        put("The neutral element of the group is represented as ");
                     25:        for i in 1..n loop
                     26:          declare
                     27:            sb : Symbol;
                     28:          begin
                     29:            sb := (sb'range => ' ');
                     30:            sb := Symbol_Table.Get(i);
                     31:            Symbol_Table_io.put(sb);
                     32:            put(" ");
                     33:          end;
                     34:        end loop;
                     35:        new_line;
                     36:        put("Give the number of generating elements in the group : ");
                     37:        Read_Natural(nb);
                     38:        put("Give "); put(nb,1);
                     39:        put_line(" vector representations of the generating elements :");
                     40:        Symbolic_Symmetry_Group_io.Get(g,n,nb);
                     41:     end if;
                     42:     put("Do you want the generation of the group ? (y/n) ");
                     43:     Ask_Yes_or_No(ans);
                     44:     if ans = 'y'
                     45:      then v := Generate(g);
                     46:      else v := g;
                     47:     end if;  -- v = either full group or group supplied by user
                     48:   end Read_Permutation_Group;
                     49:
                     50:   procedure Read_Symmetry_Group
                     51:                ( n : in natural; g,v : in out List_of_Permutations;
                     52:                  allperms,signsym,allsigns : out boolean ) is
                     53:
                     54:     ans : character;
                     55:     nb : natural;
                     56:     pv,fv,fg : List_of_Permutations;
                     57:
                     58:   begin
                     59:     Read_Permutation_Group(n,pv,fv,allperms);
                     60:     put("Is there any sign symmetry to take into account ? (y/n) ");
                     61:     Ask_Yes_or_No(ans);
                     62:     signsym := (ans = 'y');
                     63:     if ans = 'y'
                     64:      then
                     65:        put("Contains the group all sign permutations ? (y/n) ");
                     66:        Ask_Yes_or_No(ans);
                     67:        if ans = 'y'
                     68:         then
                     69:           allsigns := true;
                     70:         else
                     71:           allsigns := false;
                     72:           signsym := false;  -- fv will contain these permutations
                     73:           allperms := false; -- fv will be used for the generating solutions
                     74:           put("The sign inversion of all elements is represented as ");
                     75:           for i in 1..n loop
                     76:             put('-');
                     77:             declare
                     78:               sb : Symbol;
                     79:             begin
                     80:               sb := (sb'range => ' ');
                     81:               sb := Symbol_Table.get(i);
                     82:               Symbol_Table_io.put(sb); put(" ");
                     83:             end;
                     84:           end loop;
                     85:           new_line;
                     86:           put("Give the number of generating elements in the group : ");
                     87:           Read_Natural(nb);
                     88:           put("Give "); put(nb,1);
                     89:           put_line(" vector representations of the generating elements :");
                     90:           Symbolic_Symmetry_Group_io.Get(fg,n,nb);
                     91:        end if;
                     92:        put("Do you want the generation of the group ? (y/n) ");
                     93:        Ask_Yes_or_No(ans);
                     94:        if ans = 'y'
                     95:         then fv := Generate(Union(fg,pv));
                     96:         else fv := Union(fg,pv);
                     97:        end if;
                     98:      else
                     99:        allsigns := false;
                    100:     end if;
                    101:     g := Union(fg,pv); v := fv;
                    102:   end Read_Symmetry_Group;
                    103:
                    104: end Drivers_for_Symmetry_Group_io;