---------------
#  Aufgabe 1  #
---------------

# 1b)

x = seq(from=0,to=10,by=0.1)
y1 = -x/2+3
y2 = -2*x+6
y3 = -x/3 +1


plot(x,y1,type="l")
lines(x,y2)                # fuegt Punkte zu einem schon bestehenden Plot hinzu, 
lines(x,y3)                # im Prinzip dasselbe wie plot(...,type="l"), nur
                           # ohne neues plot-Fenster
# auch moeglich:
plot(x,y1,type="l")        # also nochmal neu..
points(x,y2,type="l")                
points(x,y3,type="l")


# wir koennten noch die y-Achse einzeichnen, die 
# Begrenzung von x>=0:
# da die Steigung unendlich ist, gibt es einen extra Befehl:
abline(v=0)    # v fuer vertikale Linie und 0 ist der 
               # Schnittpunkt mit der x-Achse

# und jetzt noch die x-Achse als Begrenzung von y>=0:
abline(h=0)    # h fuer horizontale Linie und 0 ist der 
               # Schnittpunkt mit der y-Achse


# Hoehenlinien: x+y=c <=> y = -x+c,
# c vielleicht von 0 bis 10:

c = 0:10
for(cc in c)
{
  y = -x+cc
  lines(x,y,col="red")
}

# man sieht: Minimum bei (x,y)=(0,1) mit Wert 1, 
# Maximum bei (x,y)=(2,2) mit Wert 4.
# Versuchen wir das jetzt mit dem linprog-package zu machen:


# 1c)

# das linprog-Paket ist bereits installiert, wir muessen 
# es nur noch laden, etwa mit dem require()-Befehl:

require(linprog)

# wir muessen das LOP auf Standardform Ax<=b bringen:
# 1 x + 2 y <= 6        ist ok so
# 2 x +   y <= 6        ist ok so
#   x + 3 y >= 3        formen wir um zu
# - x - 3 y <= -3
#
# Damit:

c = c(1,1)            # da F(x,y) = 1*x+1*y -> max/min
b = c(6,6,-3)
v1 = c(1,2)
v2 = c(2,1)
v3 = c(-1,-3)
A = rbind(v1,v2,v3)
A

# zur besseren Uebersicht schreiben wir das Resultat der
# solveLP()-Funktion in eine Variable resmax fuer das 
# Maximum und resmin fuer das Minimum:

resmax = solveLP(c,b,A,maximum=TRUE)
names(resmax)
resmax$opt         # das ist das Maximum = 4, ist ok
resmax$solution    # das sind die x,y, also = (2,2), ist ok

resmin = solveLP(c,b,A,maximum=FALSE)
names(resmin)
resmin$opt         # das ist das Minimum = 1, ist ok
resmin$solution    # das sind die x,y, also = (0,1), ist ok






---------------
#  Aufgabe 2  #
---------------

??rank                # das englische Wort fuer "Rang"

# -> in dem Matrix-package gibt es einen rankMatrix Befehl, 
# wir installieren und laden das Matrix package:
# installieren ueber Menue-Tab Packages->InstallPackage(s), 
# dann einen Server-Ort, etwa Germany(Muenster) auswaehlen, 
# dann erscheint eine Liste mit Paketen, aus der man dann 
# das gewuenschte Paket auswaehlen kann. 

# Installieren muss man nur einmal, wenn man ein Paket aber in 
# einer R-Session benutzen moechte, muss man es bei jeder neuen 
# Session neu laden; laden geht etwa mit dem require()-Befehl:
 
require(Matrix)

# Bitte beachten Sie: In der R-Version 3.4.0 (oder hoeher) ist das 
# Matrix package aufgrund seiner Wichtigkeit automatisch vor-
# installiert, man kann direkt require(Matrix) eingeben und dann 
# das package benutzen. In aelteren R-Versionen muss das package 
# erst installiert werden wie oben beschrieben. Wenn man nicht 
# weiss, ob ein package schon installiert ist oder nicht, kann man 
# einfach require(packagename) eingeben und erhaelt dann gegebenen-
# falls eine Fehler- oder Warning-message "there is no package 
# called 'packagename'".


n = 50
m = 500

a = runif(n*m,min=1,max=2)
A = matrix(a,ncol=n,nrow=m)
head(A)     # die ersten 6 Zeilen
tail(A)     # die letzten 6 Zeilen

rankMatrix(A)         # etwas mehr als nur einfach eine Zahl
res = rankMatrix(A)
names(res)            # ok..
mode(res)             # some info
str(res)              # further info
res[1]                # also nehmen wir das..


# 1000 Realisierungen:

M = 1000

# wir schreiben den Rang(A) jeder Realisierung A in einen 
# Vektor rangA der Laenge 1000:

rangA = rep(0,M)      # initialisieren mit 1000 Nullen
for(i in 1:M)
{
  a = runif(n*m,min=1,max=2)
  A = matrix(a,ncol=n,nrow=m)
  res = rankMatrix(A)
  rangA[i] = res[1]
} # dauert ein paar Sekunden..

plot(rangA)           # alles 50

# numerical check:
test = ifelse(rangA==50,1,0)          # testet Element-weise
sum(test)             # 1000 mal true