# Gap-Kommandos

gap  # ruft gap auf

quit; # beendet Sitzung; Kommandos werden mit ";" abgeschlossen
   
      # Kommentare beginnen mit einem "#"

############ Standardkommandos ###################



### Zuweisungen ######

a:=2; b:=3; c:=a+b;

lis:=[1, 17, 1, 0, 2];  # geordnete Liste

lis[2];   # zweites Element

lis[3];   # drittes Element 

set:= Set( lis ); # macht aus der Liste eine Menge, keine "doppelten" Elemente


#### Schleifen #########

# gewoenliche Schleife: Aufsummieren der Zahlen 1-100

su:=0;

for i in [1..100] do

  su:=su+i;

od;

#### Dasselbe als bedingte Schleife

su:=0;

i:=1;

while i<=100 do

  su:=su+i;  i:=i+1;

od;


## Abfragen, bedingte Anweisungen ###

x:=1; y:=2000; z:=1;

x=y;    # "x=y" ? Antw: "false"

x=z;    # "x=z" ? Antw: "true"

hu:=[1..100];

x in hu; 
y in hu;  # "x" ist in "hu", "y" ist nicht in "hu"


x:=Random([ 1..10000] ); # x wird zufaellig aus 1-10000 gewaehlt

######## "Falls" Anweisung

if x > 5000 then 

  x:= x - 1000; 

fi;

###### "Entweder-Oder" Anweisung  #######

if x > 5000 then 

  x:= x - 1000; 

else 

  x:= x + 1000;

fi;


############ Ausgaben #################
   
su; # < v >; gibt den Wert von < v > auf den Bildschirm
    # < v >;;  ";;" unterdrueckt das Echo
 
## weitere Ausgaben ###

## Am Bildschirm ####

Print( su );
Print(" su= ", su,"\n"); # schreibt "su= 5050" und macht Zeilenvorschub

## in  Datei  ####

PrintTo("data"," su= ", su,"\n"); # schreibt "su= 5050" in "data"

AppendTo("data"," k:= ", su,"; \n"); # schreibt nun "k:= 5050;" in "data"
                                     # PrintTo("data",..); 
                                     # wuerde "su= 5050" loeschen

   
###### Gruppen ###########

g1:=SymmetricGroup(3); # vordefinierte Permutationsgruppe

g2:=GL(2,2);           # vordefinierte Matrixgruppe

# dieselben Gruppen selbst mittels Erzeuger herstellen

h1:=Group( (1,2),(1,2,3) );

m1:= [ [ 0*Z(2) , Z(2) ],
       [  Z(2) , 0*Z(2) ] ];

m2:= [ [ 0*Z(2) , Z(2) ],
       [  Z(2) ,  Z(2) ] ];

h2:=Group( m1, m2 );

# GF(q) hat als Erzeuger der multiplikativen Gruppe "Z(q)" und
# besteht daher aus den Elementen "0*Z(q)" Null, "Z(q)^i", i beliebig aus Z,
# wobei "Z(q)^0" Eins ist

g1=h1; # "true", da beide Gruppen gleich

g1=h2; # "false", da beide Gruppen nicht gleich 

hom:=IsomorphismGroups( g1, h2); # stellt falls moeglich einen Isomorphismus her
                                 # man erhaelt "fail" falls kein Iso existiert

Order(g1); Size(g1);  # Ordnung von g1, "Size" funktioniert 
                      # fuer beliebige Listen

Elem1:=Elements( g1 ); # nummeriert die Elemente von g1 
                       # auf die man nun zugreifen kann

Elem1[1];              # "()" ist die Identitaet in einer Permutationsgruppe
Elem1[6];


Elem1[2]*Elem1[3];    # Produkt


Elem1[2]^-1;          # Invertieren

u1:=Group( Elem1[2] ); u2:=Group( Elem1[4] );

IsSubgroup( g1, u1);   # "true" , da u1 <= g1

IsNormal( g1, u1);     # "false" , da u1 kein NT von g1

IsNormal( g1, u2);    

IsAbelian( g1);      # g1 nicht abelsch

IsAbelian( u1);      # u1  abelsch


########## Fehlermeldung ###########

su:=0;

for i in [1..Size( A )] do

  su:=su+A[i];

od;

#  es erscheint eine Fehlermeldung, die mit "brk>" abgeschlossen wird
#  man befindet sich auf dem Fehlerlevel "brk>", den man mit "quit;"
#  verlaesst

A:=[1..100];  su:=0;

for i in [1..Size( A )] do

  su:=su+A[i];

od;  # keine Fehlermeldung


############# Hilfe ################

?< x > # fragt ob es eine Hilfe zum Begriff "x" gibt

?group # man erhaelt 44 Kommentare; man ruft zB. den 4-ten mit "?4" auf