www.jammni.de

1 2

Gepostet:
17.11.2008 09:30

~.~ verwirrt ~.~

was du gemacht hast hab ich ja gesehn ;) aber mich verwundert es wenn ich auf eine liste eine funktion anwende, verändern sich ja die listen elemente, wieso füg ich vorne dann elemente an. meiner logik zu folge würde ich wenn ich auf diese liste eine funktion anwende automatisch das neu hinzugefügte glied mit verändern.
oder: wie unterscheidet haskell zwischen der liste und den elementen die ich als zähler nutzen will.

ich stelle mir das gerade so vor
map (1+) [1,2,3] ++[n]
map [1+] [1,2,3] und neues element rein [2,3,4, n] folgen würde ja
-> map [1+] [2,3,4, (n)] ++ [n]
-> map [1+] [2,3,4, (n+1), (n)] ++ [n]
____________

vielleicht wäre auch ein komplexeres Bsp angebracht, wo sehe das etwas gemacht wird und wie der zähler zählt. wo ich dann nach 5mal das ergebnis raus werfe.

Zum Seitenanfang

Siracusa

Gepostet:
19.11.2008 23:41

Tut mir Leid, mir ist irgendwie nicht ganz klar, wo dein Problem liegt. Welcher Parameter als Liste oder Zähler dient, bestimmt nicht Haskell, sondern du als Programmierer. Du muß nur dafür sorgen, daß beim rekursiven Aufruf einer Funktion der Zählerwert entsprechend geändert bzw. erhöht wird. Wie du dann deinen Zähler in die Liste (oder welche Daten auch immer) einbindest, bleibt auch völlig dir überlassen.

Zum Seitenanfang

lordofblh

Gepostet:
21.11.2008 15:55

Hab 2neue Problem und das alte:
1. was genau versteht man unter List Comprehension
2. was ist die "Signatur einer Funktion"

3.
erkläre mir zähler nocheinmal wenn du den folgenen text nicht verstehst. >>Ich hoffe du verstehst zumindest das ich ein zähler problem habe<<

"hmm...

also ich habe eine liste [k]. mit der will ich n-mal etwas machen.
ich hab deine erklärung so verstanden: das ich das n meiner liste [k] hinzufüge und dann n -1 rechne und die funktion noch einmal aufrufe.
wenn n = 0 ist beendet er die aufrufe.
jetzt hab ich doch der liste [k] ein element hinzugefügt (das n) oder nicht?

mich wundert es, das wenn ich nun mein n der liste [k] hinzufüge nicht eine neue liste bekomm nenn ich sie [g] da [k] /= [g].
____________dann folgt folgenes__>

ich hab eine anfangsliste [k] auf alle elemente in dieser liste rechne ich +1,
jetzt fügt mein zähler genau dieser liste ein neues element zu und ruft sich selbst auf.
jetzt müsste er doch wieder alle elemente in der liste (+1) rechnen? ... ?

also auch dem neu hinzugefügten element. ABER DAS NEUE ELEMENT IST DOCH DAS WAS MEIN ZÄHLER HINZUGEFÜGT HATTE?!? anders gesagt das zähler element will ich doch gar nicht verändern durch (+1)
wie weiß haskell das die ersten X-elemente listen elemente sind und die letzten N-elemente von einem zähler stammen?"

Zum Seitenanfang

Siracusa

Gepostet:
21.11.2008 21:10

1.) siehe hier -> http://en.wikipedia.org/wiki/List_comprehension

2.) Die Signatur ist der Typ der Funktion, den man zusätzlich zu einer Funktionsdefinition angeben kann:
func :: Int -> Int -> Int -- Signatur
func x y = x*x + y*y -- Definition

3.) Mir scheint, du hältst Zähler für irgendein merkwürdiges Haskell-Konstrukt. Es handelt sich aber nur um einen gewöhnlichen Parameter einer Funktion, der z.B. den Typ Int haben kann. Da du in Haskell keine globalen Variablen anlegen kannst, muß du dir irgendeine Methode überlegen, wie du einer Funktion klarmachst, daß sie nur eine bestimmte Anzahl Mal aufgerufen werden soll. Das kann man eben mit einem zusätzlichen Funktionsparameter und einem rekursiven Aufruf der Funktion machen. Bei jeder Rekursion wird der Zähler eins runtergezählt und wenn er 0 ist, dann ruft die Funktion sich nicht mehr selbst auf.

> ich hab eine anfangsliste [k] auf alle elemente in dieser liste rechne ich +1,
> jetzt fügt mein zähler genau dieser liste ein neues element zu und ruft sich selbst auf.
> jetzt müsste er doch wieder alle elemente in der liste (+1) rechnen? ... ?

Ja, wenn du deine Funktion so gestaltet hast, daß sie das macht, dann macht sie das auch. Wenn du willst, daß sie was anderes macht, dann mußt du sie natürlich entsprechend umdefinieren. Sei f mal die rekursive Funktion:
f n liste = (f (n-1) (map (+1) liste)) ++ [n]
Hier mapst du erst über deine Liste, dann rufst du rekursiv auf und fügst danach n an.

f n liste = (map (+1) (f (n-1) liste)) ++ [n]
Hier rufst du erst rekursiv auf, mapst dann und fügst dann n an.

f n liste = map (+1) ((f (n-1) liste) ++ [n])
Hier rufst du rekursiv auf, fügst dann n an und mapst zum Schluß über alles.

> wie weiß haskell das die ersten X-elemente listen elemente sind und die letzten N-elemente
> von einem zähler stammen?

Das weiß Haskell gar nicht. Wenn du Zählerwerte einer Liste hinzufügst, dann entsteht eine neue Liste, die genau wie jede andere Liste behandelt wird. Haskell kann nicht unterscheiden, ob die neuen Werte von einem Zähler oder einer anderen Berechnung kommen. Wenn du eine Funktion brauchst, die die Elemente einer Liste und alle Zählerwerte unterschiedlich behandeln soll, dann solltest du der Funktion vielleicht zwei Listen übergeben, statt nur einer, und dann beide Listen unterschiedlich bearbeiten.

Auch wenn du letztens nach einen komplexeren Beispiel gefragt hast, versuche ich es jetzt nochmal mit einem ganz einfachen, einer Funktion die n Mal die Zahl 1 als Liste zurückgibt:

func :: Int -> [Int]
func 0 = []
func n = 1 : func (n-1)

Der Zählerwert fließt hier also gar nicht in die Ergebnisliste ein.

Viele Grüße,

Siracusa

Zum Seitenanfang

lordofblh

Gepostet:
21.11.2008 21:46

1.)
ahh so ^.^
also nochmal, ob ichs jetzt halbwegs gerafft habe.
wenn ich eine funktion hoch zählen will brauch ich z. bsp eine leere liste in die ich ++[n] hinzufüge und pro aktion runter zähle bis n == 0

wenn ich also eine funktion habe die einfach x ausgibt und das n-mal, dann kan ich das nicht so realisieren
gibxmalaus :: Int -> Int

sondern muss ihm zusätzlich ein parameter geben der zählt
gibxmalaus :: Int -> n -> Int
gibxmalaus x n = x gibxmalaus (n-1) ++[n]

arg... okay das bsp ist sehr schwammig, weiß nicht an welche stelle n == 0 gehört, für den abbruch.

2.)
ich hab folgnde signatur: listfunk :: [Int -> Int] -> Int -> [Int]
wenn ich k funktionen hab die ich auf ein x anwenden will
wie schreibe ich ihm das

2,5)
weiß nicht wieso ich jetzt erst drauf komme gibt es ein leicht verständliches jedoch umfangreiches tutorial?

3.) ein DANKE für die gedult mit mir :)

Zum Seitenanfang

Siracusa

Gepostet:
21.11.2008 23:41

1.) Also den Zähler brauchst du, die Liste und das ++[n] nur dann, wenn dein Ergbnistyp irgendwie eine Liste beinhaltet und du an das Ende dieser Liste eine Zahl (den aktuellen Zählerwert) anhängen willst. ++ verbindet zwei Listen, und [n] konstruiert aus dem Wert n eine Liste, die nur das Element n hat.

> gibxmalaus :: Int -> n -> Int
> gibxmalaus x n = x gibxmalaus (n-1) ++[n]

Also die Signatur ist falsch. Ein n in der Signatur ist ein polymorpher Typ, da sollte aber ein Int hin. Da du hier nirgends eine Liste verwendest, muß auch das ++[n] hinten weg. Die Frage ist jetzt, was die Funktion genau machen soll. Zahlen ausgeben kannst du nur unter Verwendung von I/O-Aktionen. Mal angenommen die Funktion soll die Zahl x n Mal addieren, dann sähe das so aus:

gibxmalaus :: Int -> Int -> Int
gibxmalaus x 0 = 0
gibxmalaus x n = x + gibxmalaus x (n-1)

2.) Z.B. so (ungetestet):

listfunk :: [Int -> Int] -> Int -> [Int]
listfunk [] x = []
listfunk (f : fs) x = f x : listfunk fs x

2,5.) Da sieht es leider recht mau aus, vor allem bei deutschen Tutorials. Bei englischsprachigen lohnt sich ein Blick in die "Gentle Introduction to Haskell 98" und sehr empfehlenswert auch das Buch "Programming in Haskell" von Graham Hutton.

3.) Bitteschön. :-)

Zum Seitenanfang

lordofblh

Gepostet:
23.11.2008 14:59

1.)

applyAll [] x = x
applyAll (f: fs) x = f (applyAll fs (x))

ich finde keine signatur, wie sähe die hier aus?. zuerst geb ich ihm ja eine liste und ein parameter, danach eine liste und eine funktion.

2.)
ich möchte das er mir zum Bsp. folgenes liefert.
(((f1 x) f2) f3) = ergebnis
(((x-3)*4)+10) = 6
in meiner funktion gibt er mir nur die 6 aus also das ergebnis, er soll aber auch noch zeigen was er macht und das ergibnis ausgeben.

3.) erste die frage dann mein problem mit der frage.
Vervollständigen Sie dann die folgende, noch unvollständige Datendefinition so, dass die sich ergebende, durch deriving abgeleitete Ordnung für aus Angaben zu Tag, Monat und Jahr zusammengesetzte Datum-Objekte der korrekten Ordnung entspricht.
data Datum = Datum ... ... ...
deriving (Eq, Ord, Show, Read)
type Tag = Int
type Jahr = Int

problem: ich seh das man einen eigenen "datum" mithilfe von "data" erstellt.
was macht deriving genau wieso steht da das ich etwas vergleichen kann, sowie auslesen und zeign?

+ vervollständigt müsste es so aus sehn?

data Datum = Tag| Monat| Jahr
   deriving (Eq, Ord, Show, Read)    
type Tag = Int 
type Jahr = Int 
data Monat = Januar | Februar | Maerz | April | Mai | Juni | Juli |
             August | September | Oktober | November | Dezember

4.)
ich hab eine unendliche reihe
in part sum wollte ich: "1 geteilt durch n" und davon die summe:
1.. n .. unendlich -> n= 4 -> 1/4+1/3+1/2+1/1 = 2,083333
nun wollte ich eine funktion auf alle n anwenden, mit hilfe von der funktion induction:


partsum :: (Int -> Int) -> Int -> Float
partsum f n = induction 1(\ x ->(1 `div`(f n))) n


induction :: (Num a, Ord a) => b -> (a -> b -> b) -> a -> b
induction base comb n
 | n == 0 = base
 | n > 0  = comb n (induction base comb (n-1))

da induction von n runter zählt bis zur basis die ich hier mit 1 wählte.

ich weiß nicht wo hier jetzt der fehler liegt

Zum Seitenanfang

Siracusa

Gepostet:
23.11.2008 22:59

1.) Tipp: Mit Hugs oder dem GHCi kannst du dir mit :type applyAll im Interpreter den Typ der Funktion automatisch berechnen lassen.

2.) Wenn du mit "zeigen" meinst, daß er die genauen Berechnungschritte ausgibt, dann dürfte das recht kompliziert umzusetzen sein. Du bräuchtest nämlich eine Funktion, die dir für eine beliebige andere Funktion auf der Konsole ausgibt, was sie grad gerechnet hat. Und das ist extrem kompliziert bis unmöglich. Du könntest die Ausgabe einschränken auf wenige vordefinierte Funktionen und dir einen eigenen Datentyp anlegen, von dem jeder Konstruktor einer Rechenoperation entspricht. Dann dürfte deine Funktion aber nur noch mit diesem Typ rechnen, könnte also keine beliebigen Funktionen mehr auswerten.

3.) Die Datumsangabe stimmt noch nicht. Das würde jetzt heißen, daß ein Datum entweder aus einem Tag, einem Monat oder einem Jahr besteht. Du brauchst eigentlich nur in deiner Vorgabe die ... Pünktchen durch die drei Typen ersetzen.
Das deriving gibt an, daß für den Datentyp Datum die Instanzen für die angegebenen Klassen automatisch abgeleitet werden sollen. Das heißt der Compiler "berechnet" dir automatisch die Funktion == für den Typ Datum. Das gleiche gilt für das Ordnen von Daten, das Ausgeben und das Einlesen.

4.) induction erwartet als zweiten Parameter eine zweistellige Funktion (a -> b -> b), du übergibst mit (\ x ->(1 `div`(f n))) aber nur eine einstellige Funktion.

Viele Grüße,

Siracusa

Zum Seitenanfang

lordofblh

Gepostet:
23.11.2008 23:24

1-4 -hat sich erledigt.

5.)Definiere .... als Instanz von Eq durch Definition der Methode (==) ...

was ist unter "instanz" zu verstehen?

Zum Seitenanfang

Siracusa

Gepostet:
26.11.2008 11:30

zu 5.) siehe hier: http://www.informatik.uni-bonn.de/~ralf/teaching/Hskurs_4.html#SEC32

Zum Seitenanfang

vorherige Seite

1 2

Haskell-Forum