# Dies ist ein kleines MPD-Beispielprogramm. (bzw. eine Zeile Kommentar)

/* 
  /* (dies ist ein mehrzeiliger Kommentar 
      auch geschachtelte Kommentare sind erlaubt) 
  */

a) Falls zwei Argumente übergeben werden,
   berechnet es (sehr ungeschickt!) 
   Binomialkoeffizienten mit Hilfe einer Prozedur, 
   welche die Fakultät einer Zahl berechnet.  

b) Falls nur ein Argument übergeben wird, inkrementieren
   zwei konkurrierende Threads einen globalen Zähler von
   Null bis zum gegebenen Wert hoch, aber ohne Synchronisation.

********************************************************/


global counter
    int value
    op inc() # eigene inc-Methode, synchronisiert?

body counter
   value = 0
   proc inc() {
     value = value + 1
     write("Value: ",value)
   }

# bei Termination ausgeführt:
  final {
      write("Global Counter: ", value);
  }

end counter

resource countingRes(int ID, int upTo)
  import counter # Counter importieren... beim ersten Import instanziert
  
  procedure countThread() {
    int i
    for[i=1 to upTo] {
#       call inc()
        int myVal
        myVal = value + 1
        write(ID,": writing Value :",myVal);
        nap(int(random()))
        value = myVal;
        nap(int(random()*10))
    }
  }

  fork countThread()

end countingRes

# dies ist die Hauptressource, wird beim Start automatisch instanziert:
resource binomi()
import countingRes

op fak_ret(int n) returns int # Deklaration der Fakultät mit Rückgabe
op fak(ref int n) # Fakultät mit call by reference (default wäre "val")


if (numargs() == 0 ) { # prüfe Zahl der Parameter
  write("Fehler: keine Parameter"); stop(1)
}


# Zähler-Modus: Counter-Resource zweimal instanzieren
if (numargs() == 1 ) { # prüfe Zahl der Parameter
  write("Zähler-Modus") 
  
  int i, max;
  getarg(1,max);
  
  for[i=1 to 2] {
    create countingRes(i,max)
  }
} else {

# ab hier: mindestens zwei Parameter
write("Binomi-Modus")

int n,k,nk
getarg(1,n); getarg(2,k) # Parameter lesen

if (n>0) {
     nk = n-k
     co   # nebenläufige bzw. parallele Ausführung von n!, k! und (n-k)!, 
       n = fak_ret(n) // fak(k) // fak(nk)
     oc  # an dieser Stelle wird automatisch synchronisiert
     write("  n! = ",n,"\n  k! = ",k,"\n(n-k)! = ",nk);
}
write("n über k = ", n/(k*nk));


}


proc fak(n) { # "ref": call by reference, Parameter liefert Ergebnis
   int i

   if (n<=0) {n=1}
   i=n-1; while (i > 0) {n = n * i;i--}
}

proc fak_ret(n) returns akk { # Definition der Fakultät mit Rückgabe
   int i
   akk=1 # akk ist durch "returns akk" bereits deklariert, Typ aus op-Deklaration.

   for[i=1 to n] { akk = akk * i }
  /* hier würde man ein "return akk" erwarten, 
     was aber am Ende der Prozedur nicht nötig ist */
}

end binomi