Schwerpunktkurs mathematisches Modellieren

Seit dem Schuljahr 2001/2002 gibt es am Hohenstaufen-Gymansium im Rahmen des mathematisch-naturwissenschaftlichen Schwerpunktes eine Oberstufen-Arbeitsgruppe, die Anwendungsprobleme mit Hilfe von Mathematik löst.

Das WM-Simulations-Programm wurde im Auftrag der Firma Höhn-Communication-Partners geschrieben und kam bei der WM-Auslosungsparty auf dem Stiftsplatz zum Einsatz.

Dr. Loch, Schott-AG, führte in der AG einen Workshop zum Thema Evolution technischer Prozesse durch.

Simulation eines Preisausschreibens der Privatbrauerei Bischoff.

zur Fortbildung 'Modellieren' (9.2. - 11.2.2011)

MaMaEuSch - WiMS

Zum Standortproblem

Aufgabenstellung

standort.pdf

Materialien der Gruppe

3_Dualer_Ansatz.ggb, 4_Dualer_Ansatz_Mannheim.ggb, 5_Verbotenes_Gebiet.ggb, 5_Verbotenes_Gebiet_Projektion.ggb, 8_Steiner_120.ggb, 8_Steiner_Punkt.ggb, 9_Mannheim_Metrik.ggb, 10_Euklid_Metrik.ggb Doku_final.ppt

Versuche zu einer Computerlösung

minimaler Maximalabstand

# Punkte
P = [(0,4),(7.02,4.78),(7,-3),(1,1)]

import math

# Metriken
def d1(p1,p2):
    """
    euklidisch
    """
    return math.sqrt((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2)

def d2(p1,p2):
    """
    'Mannheim-Metrik'
    """
    return abs(p1[0]-p2[0]) + abs(p1[1]-p2[1])
    
# Bewertungsfunktion
def wert(punkt,P,m):
    """
    gibt das Maximum der 'Abstaende' des Punktes punkt zu den Punkten aus P
    zurueck, dabei wird die Metrik m benutzt
    """
    maxi = 0
    for p in P:
        dist = m(p,punkt)
        if dist > maxi:
            maxi = dist
    return maxi 

def schwerpunkt(P):
    sx = 0
    sy = 0
    for p in P:
        sx = sx + p[0]
        sy = sy + p[1]
    n = len(P)
    xs = sx/n
    ys = sy/n
    return (xs,ys)

import random

diff = 0.01
(x,y) = schwerpunkt(P)
w = wert((x,y),P,d1)

for i in range(20000):
    dx = 2*diff*random.random()-diff
    dy = 2*diff*random.random()-diff
    xneu = x + dx
    yneu = y + dy
    wneu = wert((xneu,yneu),P,d1)
    if wneu < w:
        (x,y) = (xneu,yneu)
        w = wneu
        # print((x,y),w)

print((x,y),w)

standort0.py

ohne 'See', minimaler Gesamtabstand

# Punkte
P = [(2,3),(7,1),(5,8)]

import math

# Bewertungsfunktion
def wert(punkt,P):
    x = punkt[0]
    y = punkt[1]
    s = 0
    for p in P:
        s = s + math.sqrt((x-p[0])**2+(y-p[1])**2)
    return s

def schwerpunkt(P):
    sx = 0
    sy = 0
    for p in P:
        sx = sx + p[0]
        sy = sy + p[1]
    n = len(P)
    xs = sx/n
    ys = sy/n
    return (xs,ys)

import random

d = 0.01
(x,y) = schwerpunkt(P)
w = wert((x,y),P)

for i in range(10000):
    dx = 2*d*random.random()-d
    dy = 2*d*random.random()-d
    xneu = x + dx
    yneu = y + dy
    wneu = wert((xneu,yneu),P)
    if wneu < w:
        (x,y) = (xneu,yneu)
        w = wneu
        # print((x,y),w)

print((x,y),w)

standort1.py

mit 'See'

# Punkte
P = [(2,3),(7,1),(5,8)]
# 'See'
S = [(4,3),(5,3),(5,4),(4,4)]

import math

# Bewertungsfunktion
def wert(punkt,P):
    """
    wert gibt die Summe der Entfernungen der Punkte aus P (Liste von 2-Tupeln
    von floats) zu dem Punkt punkt (2-Tupel von float) zurueck
    """
    x = punkt[0]
    y = punkt[1]
    s = 0
    for p in P:
        s = s + math.sqrt((x-p[0])**2+(y-p[1])**2)
    return s

def schwerpunkt(P):
    """
    gibt den Schwerpunkt (2-Tupel von floats) der Punkte aus P
    (Liste von 2-Tupeln von floats) zurueck
    """
    sx = 0
    sy = 0
    for p in P:
        sx = sx + p[0]
        sy = sy + p[1]
    n = len(P)
    xs = sx/n
    ys = sy/n
    return (xs,ys)

def ccw(p0,p1,p2):
    """
    Die Funktion ccw (counterclockwise) gibt für drei Punkte P0, P1 und P2 an,
    ob sie in dieser Reihenfolge im Gegenuhrzeigersinn (linksherum, ccw = +1)
    oder im Uhrzeigersinn (rechtsherum, ccw= - 1)durchlaufen werden.
    ccw = 0 bedeutet, dass P2 auf der Strecke [P0,P2] (einschließlich P0,P1)
    liegt.
    Der Algorithmus ist aus Robert Sedgewick, Algorithmen, Kapitel 24 entnommen.
    """
    dx1 = p1[0] - p0[0]
    dy1 = p1[1] - p0[1]
    dx2 = p2[0] - p0[0]
    dy2 = p2[1] - p0[1]
    if dx1*dy2 > dy1*dx2:
        return +1
    elif dx1*dy2 < dy1*dx2:
        return -1
    else:
        if (dx1*dx2 < 0) or (dy1*dy2 < 0):
            return -1
        else:
            if (dx1*dx1 + dy1*dy1) >= (dx2*dx2 + dy2*dy2):
                return 0
            else:
                return +1

def inside(punkt,P):
    """
    gibt genau dann True zurueck, wenn der Punkt punkt in dem
    durch P beschriebenenen konvexen Polygon liegt.
    """
    n = len(P)
    innen = True
    i = 0
    while (i < n-1) and innen:
        innen = (ccw(P[i],P[i+1],punkt) == +1)
        i = i + 1
    if innen:
        innen = (ccw(P[n-1],P[0],punkt) == +1)
    return innen

import random

d = 0.01
(x,y) = (0,0)
w = wert((x,y),P)

for i in range(10000):
    dx = 2*d*random.random()-d
    dy = 2*d*random.random()-d
    xneu = x + dx
    yneu = y + dy
    
    while inside((xneu,yneu),S):
        dx = 2*d*random.random()-d
        dy = 2*d*random.random()-d
        xneu = x + dx
        yneu = y + dy
        
    wneu = wert((xneu,yneu),P)
    if wneu < w:
        (x,y) = (xneu,yneu)
        w = wneu
        print((x,y),w)

print((x,y),w)

standort2.py, standort1.ggb