www.jammni.de

import ResolutionBasics

-----------------------
-- Aufgabe 2
-----------------------

-- 2a)

data MobilE = KugeL | StaB MobilE MobilE

-- aequivalent testet, ob zwei MobilEs gleich sind, wobei die Drehbarkeit
-- berücksichtigt wird.

aequivalent :: MobilE -> MobilE -> Bool
aequivalent KugeL KugeL           = True
aequivalent (StaB a b) (StaB c d) =    ((aequivalent a c) && (aequivalent b d))
                                    || ((aequivalent a d) && (aequivalent b c))
aequivalent _ _                   = False


-- 2b)
data Mobile = Kugel Float | Stab Mobile Mobile

-- laenge ermittelt die Länge des obersten Stabes eines Mobiles und gibt als Tupel
-- die Längen links und rechts von der Aufhängung aus.
-- Die Funtkion länge bestimmt dabei die Gesamtlänge des Stabes, die dann über die 
-- Massen entsprechend ins Verhältnis gesetzt werden.
-- Die Massen werden rekursiv durch die Funktion masse ermittelt.
-- Die Gesamtlänge des obersten Stabes besteht aus der Länge des rechten Teils des
-- linken Mobiles und der Länge des linken Teils des rechten Mobiles. Diese werden
-- durch wegR bzw. wegL bestimmt.

laenge :: Mobile -> (Float, Float)
laenge (Kugel m) = (0,0)
laenge (Stab l r) =  (länge * masseR / masseG, länge * masseL / masseG)
  where länge, masseR, masseL, masseG :: Float
        masseR = masse r
        masseL = masse l
        masseG = masseR +  masseL
        
        länge  = (wegR l) + (wegL r)
        
        wegR, wegL :: Mobile -> Float 
        wegR (Kugel a)  = 0.5
        wegR (Stab a b) = (snd (laenge (Stab a b))) + (wegR b)
        wegL (Kugel a)  = 0.5
        wegL (Stab a b) = (fst (laenge (Stab a b))) + (wegL a)        

masse :: Mobile -> Float
masse (Kugel m)  = m
masse (Stab l r) = (masse l) + (masse r)
        
-- 2c)
-- laenge2 funktioniert nahezu analog zu 2b). Nur wird hier die freie Drehbarkeit
-- vorausgesetzt. Daher werden hier sowohl beim linken als auch beim rechten Mobile
-- mit wegM der maximale Weg ermittelt und nicht nur der linke bzw. rechte.

laenge2 :: Mobile -> (Float, Float)
laenge2 (Kugel m) = (0,0)
laenge2 (Stab l r) =  (länge * masseR / masseG, länge * masseL / masseG)
  where 
        länge, masseR, masseL, masseG :: Float
        masseR = masse r
        masseL = masse l
        masseG = masseR +  masseL
        
        länge  = (wegM l) + (wegM r)
        
        wegM :: Mobile -> Float   
        wegM (Kugel a)  = 0.5
        wegM (Stab a b) = max (fst (laenge2 (Stab a b)) + wegM a) 
                              (snd (laenge2 (Stab a b)) + wegM b)