Matroids Matheplanet Forum Index
Moderiert von matph
Informatik » Programmieren » Einige Fragen zu Übungen mit Haskell
Thema eröffnet 2021-11-02 21:42 von carlox
Seite 2   [1 2]   2 Seiten
Autor
Universität/Hochschule Einige Fragen zu Übungen mit Haskell
tactac
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 15.10.2014
Mitteilungen: 2626
  Beitrag No.40, eingetragen 2021-11-07

Wenn der Typ des Arguments an print Instanz von Show ist, gibt es die Fehlermeldung nicht. Für Funktionstypen werden keine solchen Instanzen vordefiniert. Das müsstest du selbst tun. Es kann aber auch sein, dass du gar keine Funktion an print übergeben willst, worauf die Fehlermeldung auch hinweist.


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.41, vom Themenstarter, eingetragen 2021-11-08

\quoteon(2021-11-07 14:16 - tactac in Beitrag No. 40) Wenn der Typ des Arguments an print Instanz von Show ist, gibt es die Fehlermeldung nicht. Für Funktionstypen werden keine solchen Instanzen vordefiniert. \quoteoff In meinem Beitrag 15 habe ich jede Menge Funktionen als Argument von print aufgerufen, ohne dass es Fehlermeldungen gibt. \quoteon Das müsstest du selbst tun. \quoteoff Wie macht man das konkret für mein Beispiel? \quoteon Es kann aber auch sein, dass du gar keine Funktion an print übergeben willst, worauf die Fehlermeldung auch hinweist. \quoteoff Doch. Ich will wie in meinen anderen Beiträgen (bzw. Programmen) das Ergebnis meiner Funktionen auf dem Bildschirm ausgeben. mfg cx


   Profil
tactac
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 15.10.2014
Mitteilungen: 2626
  Beitrag No.42, eingetragen 2021-11-08

Eine Funktion ist nicht dasselbe wie der Funktionswert an einer Stelle. So kann man zwar sin 42 einfach an print übergeben, sin aber nicht.


   Profil
tactac
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 15.10.2014
Mitteilungen: 2626
  Beitrag No.43, eingetragen 2021-11-08

\quoteon(2021-11-08 09:25 - carlox in Beitrag No. 41) \quoteon Das müsstest du selbst tun. \quoteoff Wie macht man das konkret für mein Beispiel? \quoteoff Wenn du wirklich eine Show-Instanz für Funktionstypen deklarieren willst, ginge das etwa per \sourceon Haskell instance Show (a -> b) where show _ = "SOME FUNCTION" \sourceoff Sehr nützlich ist das aber nicht. Und ich wiederhole nochmal: Wahrscheinlich willst du gar keine Funktion ausgeben. Dies ist oft der Fall, und darum befindet sich in der Fehlermeldung auch die Klammerbemerkung "(maybe you haven't applied a function to enough arguments?)".


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.44, vom Themenstarter, eingetragen 2021-11-08

\quoteon Sehr nützlich ist das aber nicht. Und ich wiederhole nochmal: Wahrscheinlich willst du gar keine Funktion ausgeben. Dies ist oft der Fall, und darum befindet sich in der Fehlermeldung auch die Klammerbemerkung "(maybe you haven't applied a function to enough arguments?)". \quoteoff Aaaah.... Asche auf mein Haupt. Du hast Recht: Ich hatte aus Versehen ein Komma gemacht nach test 'x' !!! print (test 'x', [("ab","cd","ef"),("gh","ij","kl")]) Entschuldigung! mfg cx


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.45, vom Themenstarter, eingetragen 2021-11-08

\quoteon(2021-11-07 12:09 - tactac in Beitrag No. 38) \quoteon(2021-11-07 09:16 - carlox in Beitrag No. 37) Danke für den Tipp. Leider vertshe ich nicht, was da gemacht wird. Hast du dazu Quellen? \quoteoff Die Syntax kann man jedenfalls hier nachlesen: https://www.haskell.org/onlinereport/haskell2010/haskellch10.html#x17-18000010.5 \quoteon Habe den Quellcode von dir eingegeben. Dann kommt die Fehlermeldung: \sourceon main_101.hs:25:16: error: Not in scope: type constructor or class `Location' | 25 | loc :: Location | ^^^^^^^^ Failed, no modules loaded. \sourceoff Was muss ich machen, damit es klappt? \quoteoff Der Typ „Location“ muss verfügbar sein. \quoteoff \quoteoff Bei mir ist das leider nicht der Fall. Was muss ich machen, damit er (Location) verfügbar wird ? mfg cx


   Profil
tactac
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 15.10.2014
Mitteilungen: 2626
  Beitrag No.46, eingetragen 2021-11-08

\quoteon(2021-11-08 10:36 - carlox in Beitrag No. 45) Bei mir ist das leider nicht der Fall. Was muss ich machen, damit er (Location) verfügbar wird ? \quoteoff Task1 ist ja anscheinend verfügbar. Mache mit Location dasselbe (etwa: in die export-Liste des Moduls eintragen, in dem es definiert ist.)


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.47, vom Themenstarter, eingetragen 2021-11-08

\quoteon(2021-11-08 11:22 - tactac in Beitrag No. 46) \quoteon(2021-11-08 10:36 - carlox in Beitrag No. 45) Bei mir ist das leider nicht der Fall. Was muss ich machen, damit er (Location) verfügbar wird ? \quoteoff Task1 ist ja anscheinend verfügbar. Mache mit Location dasselbe (etwa: in die export-Liste des Moduls eintragen, in dem es definiert ist.) \quoteoff Habe es nochmals probiert. Es kommt noch eine weitere Fehlermeldung. Ich benutze hir nur eine Datei. Deswegen gibt es auch keine export-Liste. \sourceon ghci> :load main_16.hs [1 of 1] Compiling Main ( main_16.hs, interpreted ) main_16.hs:3:24: error: Not in scope: type constructor or class `Task1' | 3 | let complexTask :: Task1 | ^^^^^ main_16.hs:4:16: error: Not in scope: type constructor or class `Location' | 4 | loc :: Location | ^^^^^^^^ Failed, no modules loaded. \sourceoff \sourceon main = do print "Start" let complexTask :: Task1 loc :: Location complexTask = ComplexTask1 "Write Memo" 30 loc loc = Office print complexTask \sourceoff mfg cx


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.48, vom Themenstarter, eingetragen 2021-11-09

Hallo allerseits, 1) habe jetzt endlich - Dank eurer Unterstützung und Hilfe - eine Funktion geschrieben, die von einem String bestimmt, ob er ein mathematischer Term ist oder nicht (siehe unten). Alles funktioniert soweit, aber: Frage: Geht das auch einfacher mit rekursiven Datentypen? Das vermute ich zumindest. Vielleicht gibt es gerade auch deswegen solche rekursiven Datentypen? Wenn ja, will ich das probieren (erst mal ohne Hilfestellung). 2) Ich habe mal gelesen, dass Hasekell auf dem Lambda-Kalkül basiert. Ich habe bis jetzt noch kein einziges Mal diesen Lambda-Operator benutzt. Wo wird dieser benötigt? (Ich will damit etwas üben). mfg cx \sourceon {- P R O G R A M M B E S C H R E I B U N G Def: Ein mathematischer Term besteht hier nur aus dem Rechenzeichen '+' und den Primtermen (Grundzeichen) 'a', ..., 'z', '0', ..., '9' und den Klammern '(' und ')' Beispiele: 1 d (3+a) ((4+5)+(a+b)) Dies wird durch die Funktion istTerm präzisiert. -} import Myfunc_200 main = do {- /*****************************************************************************/ /** **/ /** Hier wird getestet, welche Strings mathematische terme sind **/ /** und welche nicht **/ /** **/ /*****************************************************************************/ -} print("===========") print (istTerm "?") -- Kein Term print (istTerm "a+") -- Kein Term print (istTerm "a+b") -- Kein Term print (istTerm "(a+b") -- Kein Term print (istTerm "3+5)") -- Kein Term print (istTerm "2") -- ein Term print (istTerm "(a+b)") -- ein Term print (istTerm "((a+b)+(c+d))") -- ein Term print (istTerm "((a+b)+(c+d))") -- ein Term print (istTerm "((a+b)+c)") -- ein Term print (istTerm "(((a+b)+c)+4)") -- ein Term \sourceoff \sourceon {- P R O G R A M M B E S C H R E I B U N G Dieses Modul berechnet, ob ein String, d.h. [Char] ein mathematischer Term ist. Def: Ein mathematischer Term besteht hier nur aus dem Rechenzeichen '+' und den Primtermen (Grundzeichen) 'a', ..., 'z', '0', ..., '9' und den Klammern '(' und ')' Besipiele: 1 d (3+a) ((4+5)+(a+b)) Dies wird durch die Funktion istTerm präzisiert. Bemerkungen: 1) !!!!! ACHTUNG Syntax: !!!! anfuegen_3(z (tail liste)) ist syntaktisch falsch geschrieben: RICHTIG ist: anfuegen_3 z (tail liste) Im Gegensatz zur Notation in der (Schul-) Mathematik werden in Haskell Funktionenmit Außenklammernnotiert Man schreibt (f 4)oder (g 4 5)anstelle von f(4)oder g(4,5 -} module Myfunc_200 ( istPrimterm, index_3, anfuegen_3, erzeugeTeillisten, existiertTerm, istTerm, istTupelTerm, ) where {- /*****************************************************************************/ /** **/ /** Bool istPrimterm (Char z) **/ /** **/ /*****************************************************************************/ /* Parameter: (i) Char z : ein Zeichen Return: (o) True: Zeichen ist Kleinbuchstabe False: sonst Beschreibung: Berechnet, ob ein Zeichen ein Primterm, d.h. nicht aus anderen Termen zusammengesetzt ist. */ -} istPrimterm :: Char -> Bool istPrimterm z | (elem z (['a'..'z'] ++ ['0','1' .. '9'])) = True | otherwise = False {- /*****************************************************************************/ /** **/ /** [Char] index_3 (Int index, ([Char], [Char], [Char]) tupel3) **/ /** **/ /*****************************************************************************/ /* Parameter: (i) Int index : der Index (0...2) im 3er-Tupel tupel (i) ([Char], [Char], [Char]) tupel3: der 3er-Tupel Return: (o) True: das durch den Index bestimmte Element des 3er-Tupels Beschreibung: Berechnet das Element mit Datentyp [Char] des durch den index bestimmten Elemetns */ -} index_3 :: Int -> ([Char], [Char], [Char]) -> [Char] index_3 i (a,b,c) | i==0 = a | i==1 = b | i==2 = c {- /*****************************************************************************/ /** **/ /** [Char] anfuegen_3 (Char z, [([Char], [Char], [Char])] liste) **/ /** **/ /*****************************************************************************/ /* Parameter: (i) Char z : das anzufügende Zeichen (i) [([Char], [Char], [Char])] liste : Liste von 3er-Tupeln Return: (o) [([Char], [Char], [Char])]: Liste von 3er-Tupeln Beschreibung: An eine Liste von 3-er Tupeln (jedes Element ist ein String) wird jeweils an das 1. Element eines Tupels ein Zeichen vorne angefügt. Beispiel: [ ("wer", "ist", "otto"), ("man", "hat", "Zeit"), ("für", "alle")] Das zeichen 'x' wird an jeden Tupel an das jeweils 1. Element vorne angefügt: [ ("xwer", "ist", "otto"), ("xman", "hat", "Zeit"), ("xfür", "alle")] */ -} anfuegen_3 :: Char -> [([Char], [Char], [Char])] -> [([Char], [Char], [Char])] anfuegen_3 z liste | length liste == 0 = [] | otherwise = [( [z]++(index_3 0 (liste !! 0)), index_3 1 (liste !! 0), index_3 2 (liste !! 0) )] ++ anfuegen_3 z (tail liste) {- /*****************************************************************************/ /** **/ /** [([Char], [Char], [Char])] erzeugeTeillisten [Char] liste **/ /** **/ /*****************************************************************************/ /* Parameter: (i) [Char] liste : String, d.h. [Char] Return: (o) [([Char], [Char], [Char])]: Liste von 3er-Tupeln Beschreibung: Ein String wird an allen möglichen Stellen in 3 Teilstrings (3er-Tupel) zerlegt. Alle diese 3er-Tupels werden zu einer Liste zusammengefasst. Beispiel: Aus dem String [abcde] wird folgende Liste gebastelt: [([], [a], [bcde]), ([a, [b], [cde]), ([ab], [c], [de]), ([abc], [d, [e]), ([abcd], [e], [])] -} erzeugeTeillisten :: [Char] -> [([Char], [Char], [Char])] erzeugeTeillisten liste | length liste == 0 = [] | length liste == 1 = [([], [liste !! 0], [])] | otherwise = [([],[head liste], tail liste)] ++ anfuegen_3 (liste!!0) (erzeugeTeillisten (tail liste)) {- /*****************************************************************************/ /** **/ /** Bool existiertTerm [[([Char], [Char], [Char])]] liste **/ /** **/ /*****************************************************************************/ /* Parameter: (i) [[([Char], [Char], [Char])]] liste Return: (o) Bool : True, wenn in der Liste ein 3er-Tupel Beschreibung: Wenn sich in der Liste der 3er-Tupel ein 3er-Tupel befindet, in dem das 1. und 3. Element ein mathematischer Term ist und das 2. Element das Pluszeichen '+' ist, dann wird True zurückgeliefert, sonst False. Beispiel: Aus dem String [abcde] wird folgende Liste gebastelt: [([hallo], [welt], [planet]), ([a, [b], [cde]), ([((a+b)], [+], [(c+d))]) liefert: True -} existiertTerm :: [([Char], [Char], [Char])] -> Bool existiertTerm liste | (length liste) == 0 = False | (istTupelTerm (liste !! 0))== True = True | otherwise = (existiertTerm (tail liste)) {- /*****************************************************************************/ /** **/ /** Bool istTerm [Char] liste **/ /** **/ /*****************************************************************************/ /* Parameter: (i) [Char] liste Return: (o) Bool : True, wenn der String ein mathematischer Term ist, sonst False Beschreibung: True, wenn in dem 3er-Tupel das linke und rechte Element ein Term ist und das mittlere Element das Pluszeichen '+' ist. Beispiel: [halloweltplanet] : False [((a+b)+(c+d))] : True [(3+5)] : True -} istTerm :: [Char] -> Bool istTerm liste | (length liste) == 0 = False | (length liste) == 1 && istPrimterm (liste !! 0) = True | (length liste) == 2 = False | (length liste) == 3 = False | (length liste) == 4 = False | (length liste) == 5 && (liste!!0)=='(' && istPrimterm (liste!!1) && (liste!!2)=='+' && istPrimterm (liste!!3) && (liste!!4)==')' = True | otherwise = (existiertTerm (erzeugeTeillisten liste)) {- /*****************************************************************************/ /** **/ /** Bool istTupelTerm [[([Char], [Char], [Char])]] liste **/ /** **/ /*****************************************************************************/ /* Parameter: (i) [[([Char], [Char], [Char])]] liste Return: (o) Bool : True, wenn in der Liste ein 3er-Tupel Beschreibung: Wenn sich in der Liste der 3er-Tupel ein 3er-Tupel befindet, in dem das 1. und 3. Element ein mathematischer Term ist und das 2. Element das Pluszeichen '+' ist, dann wird True zurückgeliefert, sonst False. Beispiel: ([hallo], [welt], [planet]) : False ([((a+b)], [+], [(c+d))]) : True ([(3], [+], [5)]) : True -} istTupelTerm :: ([Char], [Char], [Char]) -> Bool istTupelTerm tupel | (index_3 0 tupel)==[] || (index_3 1 tupel)==[] || (index_3 2 tupel)==[] = False | (istTerm (tail (index_3 0 tupel))) && (index_3 1 tupel)==['+'] && (istTerm (init (index_3 2 tupel))) = True | otherwise = False \sourceoff mfg cx


   Profil
DerEinfaeltige
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 11.02.2015
Mitteilungen: 3211
  Beitrag No.49, eingetragen 2021-11-09

"a+b" sollte doch sicherlich wahr ergeben, nicht falsch. Daneben würde ich mal testen, ob bei "((a+b))" das Gewünschte (mutmaßlich kein Term?!?) ausgegeben wird. Zu Haskell kann ich nichts sagen. Lambda-Funktionen sind normalerweise einfach anonyme Funktionen, die den Namespace schonen und den Code schönen.


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.50, vom Themenstarter, eingetragen 2021-11-09

\quoteon(2021-11-09 13:31 - DerEinfaeltige in Beitrag No. 49) "a+b" sollte doch sicherlich wahr ergeben, nicht falsch. Daneben würde ich mal testen, ob bei "((a+b))" das Gewünschte (mutmaßlich kein Term?!?) ausgegeben wird. \quoteoff Laut den implementierten Regeln sind "a+b" und "((a+b))" keine mathematischen Terme. Das ist - zugegebenmassen - nicht gerade intuitiv, naja eher kontraintuitiv ... Wollte man dies ändern, müsste ich die Regeln abändern, d.h. die dahinterstehende induktive Definition für mathematische Terme abändern. mfg cx


   Profil
tactac
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 15.10.2014
Mitteilungen: 2626
  Beitrag No.51, eingetragen 2021-11-09

@#47 Du hast doch mal https://mmhaskell.com/liftoff/data-types verlinkt. Da wurden Task1 und Location definiert.


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.52, vom Themenstarter, eingetragen 2021-11-09

\quoteon(2021-11-09 15:22 - tactac in Beitrag No. 51) @#47 Du hast doch mal https://mmhaskell.com/liftoff/data-types verlinkt. Da wurden Task1 und Location definiert. \quoteoff Genau, das war der Punkt meiner Verwirrung. Vielen Dank mfg cx


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.53, vom Themenstarter, eingetragen 2021-11-09

\quoteon(2021-11-09 13:31 - DerEinfaeltige in Beitrag No. 49) "a+b" sollte doch sicherlich wahr ergeben, nicht falsch. Daneben würde ich mal testen, ob bei "((a+b))" das Gewünschte (mutmaßlich kein Term?!?) ausgegeben wird. \quoteoff Du hast Recht. Ich korrigiere mich: // main_201.hs \sourceon {- /*****************************************************************************/ /** **/ /** Hier wird getestet, welche Strings mathematische Terme sind **/ /** und welche nicht **/ /** **/ /*****************************************************************************/ -} print("===========") print (istTerm "?") -- Kein Term print (istTerm "a+") -- Kein Term print (istTerm "(a+b") -- Kein Term print (istTerm "3+5)") -- Kein Term print (istTerm "!+?)") -- Kein Term print (istTerm "(((((a+b)+c)+4))))") -- Kein Term rechenzeitintensiv!! print (istTerm "2") -- ein Term print (istTerm "a+b") -- ein Term print (istTerm "(a+b)") -- ein Term print (istTerm "((a+b))") -- ein Term print (istTerm "((a+b)+(c+d))") -- ein Term print (istTerm "((a+b)+(c+d))") -- ein Term print (istTerm "((a+b)+c)") -- ein Term print (istTerm "(((a+b)+c)+4)") -- ein Term print (istTerm "((((((a+b)+c)+4))))") -- ein Term \sourceoff // myfunc_201.hs \sourceon {- P R O G R A M M B E S C H R E I B U N G Achtung: Im Gegensatz zur letzen Version sollen Strings der folgenden Form auch mathematischeTerme sein: a+b ((a+b)) Regeln für die mathematischen Terme: ------- t Element aus {a, ... ,z, 0, ..., 9} t t, s -------- (t+s) t, s ------- t Element aus {a, ... ,z, 0, ..., 9} t+s t ------- t Term (t) =========================================================== Dieses Modul berechnet, ob ein String, d.h. [Char] ein mathematischer Term ist. Def: Ein mathematischer Term besteht hier nur aus dem Rechenzeichen '+' und den Primtermen (Grundzeichen) 'a', ..., 'z', '0', ..., '9' und den Klammern '(' und ')' Besipiele: 1 d (3+a) ((4+5)+(a+b)) Dies wird durch die Funktion istTerm präzisiert. Bemerkungen: 1) !!!!! ACHTUNG Syntax: !!!! anfuegen_3(z (tail liste)) ist syntaktisch falsch geschrieben: RICHTIG ist: anfuegen_3 z (tail liste) Im Gegensatz zur Notation in der (Schul-) Mathematik werden in Haskell Funktionenmit Außenklammernnotiert Man schreibt (f 4)oder (g 4 5)anstelle von f(4)oder g(4,5 -} module Myfunc_201 ( istPrimterm, index_3, anfuegen_3, erzeugeTeillisten, existiertTerm, istTerm, istTupelTerm, ) where {- /*****************************************************************************/ /** **/ /** Bool istPrimterm (Char z) **/ /** **/ /*****************************************************************************/ /* Parameter: (i) Char z : ein Zeichen Return: (o) True: Zeichen ist Kleinbuchstabe False: sonst Beschreibung: Berechnet, ob ein Zeichen ein Primterm, d.h. nicht aus anderen Termen zusammengesetzt ist. */ -} istPrimterm :: Char -> Bool istPrimterm z | (elem z (['a'..'z'] ++ ['0','1' .. '9'])) = True | otherwise = False {- /*****************************************************************************/ /** **/ /** [Char] index_3 (Int index, ([Char], [Char], [Char]) tupel3) **/ /** **/ /*****************************************************************************/ /* Parameter: (i) Int index : der Index (0...2) im 3er-Tupel tupel (i) ([Char], [Char], [Char]) tupel3: der 3er-Tupel Return: (o) True: das durch den Index bestimmte Element des 3er-Tupels Beschreibung: Berechnet das Element mit Datentyp [Char] des durch den index bestimmten Elemetns */ -} index_3 :: Int -> ([Char], [Char], [Char]) -> [Char] index_3 i (a,b,c) | i==0 = a | i==1 = b | i==2 = c {- /*****************************************************************************/ /** **/ /** [Char] anfuegen_3 (Char z, [([Char], [Char], [Char])] liste) **/ /** **/ /*****************************************************************************/ /* Parameter: (i) Char z : das anzufügende Zeichen (i) [([Char], [Char], [Char])] liste : Liste von 3er-Tupeln Return: (o) [([Char], [Char], [Char])]: Liste von 3er-Tupeln Beschreibung: An eine Liste von 3-er Tupeln (jedes Element ist ein String) wird jeweils an das 1. Element eines Tupels ein Zeichen vorne angefügt. Beispiel: [ ("wer", "ist", "otto"), ("man", "hat", "Zeit"), ("für", "alle")] Das zeichen 'x' wird an jeden Tupel an das jeweils 1. Element vorne angefügt: [ ("xwer", "ist", "otto"), ("xman", "hat", "Zeit"), ("xfür", "alle")] */ -} anfuegen_3 :: Char -> [([Char], [Char], [Char])] -> [([Char], [Char], [Char])] anfuegen_3 z liste | length liste == 0 = [] | otherwise = [( [z]++(index_3 0 (liste !! 0)), index_3 1 (liste !! 0), index_3 2 (liste !! 0) )] ++ anfuegen_3 z (tail liste) {- /*****************************************************************************/ /** **/ /** [([Char], [Char], [Char])] erzeugeTeillisten [Char] liste **/ /** **/ /*****************************************************************************/ /* Parameter: (i) [Char] liste : String, d.h. [Char] Return: (o) [([Char], [Char], [Char])]: Liste von 3er-Tupeln Beschreibung: Ein String wird an allen möglichen Stellen in 3 Teilstrings (3er-Tupel) zerlegt. Alle diese 3er-Tupels werden zu einer Liste zusammengefasst. Beispiel: Aus dem String [abcde] wird folgende Liste gebastelt: [([], [a], [bcde]), ([a, [b], [cde]), ([ab], [c], [de]), ([abc], [d, [e]), ([abcd], [e], [])] -} erzeugeTeillisten :: [Char] -> [([Char], [Char], [Char])] erzeugeTeillisten liste | length liste == 0 = [] | length liste == 1 = [([], [liste !! 0], [])] | otherwise = [([],[head liste], tail liste)] ++ anfuegen_3 (liste!!0) (erzeugeTeillisten (tail liste)) {- /*****************************************************************************/ /** **/ /** Bool existiertTerm [[([Char], [Char], [Char])]] liste **/ /** **/ /*****************************************************************************/ /* Parameter: (i) [[([Char], [Char], [Char])]] liste Return: (o) Bool : True, wenn in der Liste ein 3er-Tupel Beschreibung: Wenn sich in der Liste der 3er-Tupel ein 3er-Tupel befindet, in dem das 1. und 3. Element ein mathematischer Term ist und das 2. Element das Pluszeichen '+' ist, dann wird True zurückgeliefert, sonst False. Beispiel: Aus dem String [abcde] wird folgende Liste gebastelt: [([hallo], [welt], [planet]), ([a, [b], [cde]), ([((a+b)], [+], [(c+d))]) liefert: True -} existiertTerm :: [([Char], [Char], [Char])] -> Bool existiertTerm liste | (length liste) == 0 = False | (istTupelTerm (liste !! 0))== True = True | otherwise = (existiertTerm (tail liste)) {- /*****************************************************************************/ /** **/ /** Bool istTerm [Char] liste **/ /** **/ /*****************************************************************************/ /* Parameter: (i) [Char] liste Return: (o) Bool : True, wenn der String ein mathematischer Term ist, sonst False Beschreibung: True, wenn in dem 3er-Tupel das linke und rechte Element ein Term ist und das mittlere Element das Pluszeichen '+' ist. Beispiel: [halloweltplanet] : False [((a+b)+(c+d))] : True [(3+5)] : True -} istTerm :: [Char] -> Bool istTerm liste | (length liste) == 0 = False | (length liste) == 1 && istPrimterm (liste !! 0) = True | (length liste) == 2 = False | (length liste) == 3 && istPrimterm (liste!!0) && (liste!!1)=='+' && istPrimterm (liste!!1) = True | (length liste) == 3 && not (istPrimterm (liste!!0) && (liste!!1)=='+' && istPrimterm (liste!!1)) = True | (length liste) == 4 = False | (length liste) == 5 && (liste!!0)=='(' && istPrimterm (liste!!1) && (liste!!2)=='+' && istPrimterm (liste!!3) && (liste!!4)==')' = True | otherwise = (existiertTerm (erzeugeTeillisten liste)) {- /*****************************************************************************/ /** **/ /** Bool istTupelTerm [[([Char], [Char], [Char])]] liste **/ /** **/ /*****************************************************************************/ /* Parameter: (i) [[([Char], [Char], [Char])]] liste Return: (o) Bool : True, wenn in der Liste ein 3er-Tupel Beschreibung: Wenn sich in der Liste der 3er-Tupel ein 3er-Tupel befindet, in dem das 1. und 3. Element ein mathematischer Term ist und das 2. Element das Pluszeichen '+' ist, dann wird True zurückgeliefert, sonst False. Beispiel: ([hallo], [welt], [planet]) : False ([((a+b)], [+], [(c+d))]) : True ([(3], [+], [5)]) : True -} istTupelTerm :: ([Char], [Char], [Char]) -> Bool istTupelTerm tupel | (index_3 0 tupel)==[] || (index_3 1 tupel)==[] || (index_3 2 tupel)==[] = False | (length (index_3 0 tupel))==1 && (index_3 1 tupel)==['+'] && (length (index_3 2 tupel))==1 = True -- a+b | (istTerm (tail (index_3 0 tupel))) && (index_3 1 tupel)==['+'] && (istTerm (init (index_3 2 tupel))) = True -- (a+b) | istTerm ( (tail (index_3 0 tupel)) ++ (index_3 1 tupel) ++ (init (index_3 2 tupel)) ) = True -- (t) | otherwise = False \sourceoff mfg cx


   Profil
tactac
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 15.10.2014
Mitteilungen: 2626
  Beitrag No.54, eingetragen 2021-11-10

Eigentlich willst du ja wahrscheinlich nicht nur einen Booleschen Wert haben, sondern vielleicht auch den Term als aufbereitete Datenstruktur (statt Zeichenkette), mit der man dann schön weiterarbeiten kann. Zumindest dafür bietet sich ein rekursiver Datentyp an: \sourceon Haskell data Term = Int Int | Var Char | Add Term Term deriving (Eq, Ord, Show) \sourceoff und am Ende willst du eine Funktion mit dem Typ String -> Maybe Term haben. Einen Wert vom Typ Term könnte man mit einer Funktion vom Typ (Char -> Int) -> Term -> Int beispielsweise auswerten. Zum Parsen eines Terms bietet sich ein Typ wie \sourceon Haskell type Parser a = String -> Maybe (a, String) \sourceoff an sowie viele kleine solche (oder recht ähnliche) Parser und Kombinatoren für solche Parser. Falls dich das interessiert, google mal nach Parser-Kombinatoren.


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.55, vom Themenstarter, eingetragen 2021-11-10

\quoteon und am Ende willst du eine Funktion mit dem Typ String -> Maybe Term haben. Einen Wert vom Typ Term könnte man mit einer Funktion vom Typ (Char -> Int) -> Term -> Int beispielsweise auswerten. Zum Parsen eines Terms bietet sich ein Typ wie \sourceon Haskell type Parser a = String -> Maybe (a, String) \sourceoff an sowie viele kleine solche (oder recht ähnliche) Parser und Kombinatoren für solche Parser. Falls dich das interessiert, google mal nach Parser-Kombinatoren. \quoteoff Danke für die Tipps. 1) Ich will zunächst einen eigenen Datentyp für die Primterme: 'a','b', ..., 'z','0',...,'9' definieren. Leider funktioniert Folgendes nicht: type Primterm = ['a' .. 'z'] ++ ['0' .. '9'] oder auch: data Primterm = a | b | c .. Wie kann man das in Hasekell realisieren? 2) Gibt es den eingebauten Datentyp String in Hasekell? Habe ihn dort nicht entedeckt: https://www.tutorialspoint.com/haskell/haskell_types_and_type_class.htm 3) So was habe ich noch nie gesehen: type Parser a = String -> Maybe (a, String) Ich kenn nur so was wie: type MyType1 = Int oder type MyType2 = (Int,Int) Gibt es dazu Quellen bzw. was bedeutet das ? mfg cx


   Profil
tactac
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 15.10.2014
Mitteilungen: 2626
  Beitrag No.56, eingetragen 2021-11-10

1) Es geht \sourceon Haskell data PrimTerm = A | B | C | D -- ... \sourceoff Wertkonstruktoren müssen mit einem Großbuchstaben beginnen, oder, als infix-Operator, mit :. 2) Ja. https://www.haskell.org/definition/haskell2010.pdf Abschnitt 6.1.2 3) https://www.haskell.org/definition/haskell2010.pdf 10.5 hat eine Grammatik. Es bedeutet, dass etwas vom Typ Parser a eine Funktion ist, die etwas vom Typ String nimmt und etwas vom Typ Maybe (a, String) zurückgibt. Maybe ist übrigens auch im Haskell-Report definiert. (Bemerkung am Rande dazu: die neueste standardisierte Haskell-Version ist m.W.n. immer noch Haskell 2010; (nicht nur) die Standardbibliothek, die mit GHC kommt, definiert aber inzwischen einige Dinge anders, besonders um die Typklasse Monad herum.)


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.57, vom Themenstarter, eingetragen 2021-11-11

\quoteon Wertkonstruktoren müssen mit einem Großbuchstaben beginnen, oder, als infix-Operator, mit :. \quoteoff Mein Ziel ist Folgendes: Da ich keinen selbstgebastelten Datentyp der Form: data Primterm = ['a','b', ..., 'z','0',...,'9'] bauen kann, bastle ich aus Verzweiflung eine abgespeckte Version: (siehe unten im Code-Teil) data Primterm = A | B | C deriving (Show) -- und baue noch andere, syntaktisch korrekte Datentypen: -- L bzw. R stehen für die runden Klammern ( und ) data Klammer = L | R deriving (Show) -- P steht für das Rechenzeichen + data Rechenzeichen = P deriving (Show) -- Dann wird die Vereinigungsmenge aus diesen Datentypen gebaut: data Zeichen = Primterm | Klammer | Rechenzeichen deriving (Show) Bei mir müssen Terme (in the first run) erstmal die folgenden Formen haben: Primterme wie a,b,c, ... oder (t), wobei t wieder ein Term ist oder (t1+t2) wobei t1 und t2 Terme sind. Dazu baue ich den folgenden Datentyp: data Term = Blatt Primterm | Zweig Klammer Term Rechenzeichen Term Klammer | Pseudozweig Klammer Term Klammer Das ist syntaktisch alles noch korrekt. Aber bei der Definition von termliste und bei let z1 :: Zeichen (Deswegen habe ich let z1 :: Zeichen gleich auskommentiert) gibt es viele Fehlermeldungen beim Kompilieren. Selbst wenn ich den Quellcode abändere, wird alles ein Riesenmurks. Irgendwo habe ich da eine falsche Denke und bin auf dem Holzweg. Wer kann mir weiterhelfen ? mfg cx \sourceon ghci> :load main_2.hs [1 of 1] Compiling Main ( main_2.hs, interpreted ) main_2.hs:30:25: error: Variable not in scope: b | 30 | | term == (Primterm b) = [b] | ^ main_2.hs:30:31: error: Variable not in scope: b :: Zeichen | 30 | | term == (Primterm b) = [b] | ^ main_2.hs:31:22: error: Variable not in scope: k1 :: Klammer | 31 | | term == (Zweig k1 t1 r t2 k2) = (termliste t1) ++ (termliste t2) | ^^ main_2.hs:31:25: error: Variable not in scope: t1 :: Term | 31 | | term == (Zweig k1 t1 r t2 k2) = (termliste t1) ++ (termliste t2) | ^^ main_2.hs:31:28: error: Variable not in scope: r :: Rechenzeichen | 31 | | term == (Zweig k1 t1 r t2 k2) = (termliste t1) ++ (termliste t2) | ^ main_2.hs:31:30: error: Variable not in scope: t2 :: Term | 31 | | term == (Zweig k1 t1 r t2 k2) = (termliste t1) ++ (termliste t2) | ^^ main_2.hs:31:33: error: Variable not in scope: k2 :: Klammer | 31 | | term == (Zweig k1 t1 r t2 k2) = (termliste t1) ++ (termliste t2) | ^^ main_2.hs:31:50: error: Variable not in scope: t1 :: Term | 31 | | term == (Zweig k1 t1 r t2 k2) = (termliste t1) ++ (termliste t2) | ^^ main_2.hs:31:68: error: Variable not in scope: t2 :: Term | 31 | | term == (Zweig k1 t1 r t2 k2) = (termliste t1) ++ (termliste t2) | ^^ main_2.hs:32:28: error: Variable not in scope: k1 :: Klammer | 32 | | term == (Pseudozweig k1 t k2) = termliste t | ^^ main_2.hs:32:31: error: Variable not in scope: t :: Term | 32 | | term == (Pseudozweig k1 t k2) = termliste t | ^ main_2.hs:32:33: error: Variable not in scope: k2 :: Klammer | 32 | | term == (Pseudozweig k1 t k2) = termliste t | ^^ main_2.hs:32:49: error: Variable not in scope: t :: Term | 32 | | term == (Pseudozweig k1 t k2) = termliste t | ^ Failed, no modules loaded. \sourceoff \sourceon main = do let p1 :: Primterm p1 = A print p1 -- let z1 :: Zeichen {- ************************************************************* ** BEGINN DER DEFINITIONEN DER FUNKTIONEN UND DATENTYPEN ** ************************************************************* -} data Primterm = A | B | C deriving (Show) data Klammer = L | R deriving (Show) -- Klammern ( und ) data Rechenzeichen = P deriving (Show) -- Rechenzeichen + data Zeichen = Primterm | Klammer | Rechenzeichen deriving (Show) data Term = Blatt Primterm | Zweig Klammer Term Rechenzeichen Term Klammer | Pseudozweig Klammer Term Klammer termliste :: Term -> [Zeichen] termliste term | term == (Primterm b) = [b] | term == (Zweig k1 t1 r t2 k2) = (termliste t1) ++ (termliste t2) | term == (Pseudozweig k1 t k2) = termliste t \sourceoff


   Profil
tactac
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 15.10.2014
Mitteilungen: 2626
  Beitrag No.58, eingetragen 2021-11-11

\sourceon Haskell data Primterm = A | B | C deriving (Show) data Klammer = L | R deriving (Show) -- Klammern ( und ) data Rechenzeichen = P deriving (Show) -- Rechenzeichen + data Zeichen = Primterm | Klammer | Rechenzeichen deriving (Show) \sourceoff Du definierst hier zwei Dinge namens Primterm, die nichts miteinander zu tun haben. Sie sind derartig unverwandt, dass sie von vorn herein in verschiedenen Namensräumen "leben" und deshalb denselben Namen haben können. 1) Einen algebraischen Datentyp mit den (argumentlosen) Wertkonstruktoren A,B und C 2) Einen der (argumentlosen) Wertkonstruktoren von Zeichen. Es kommt etwas heraus, was du wohl eher haben willst, wenn Zeichen so definiert wird: \sourceon Haskell data Zeichen = Primterm Primterm | Klammer Klammer | Rechenzeichen Rechenzeichen deriving (Show) \sourceoff Damit wird u.a. Rechenzeichen zu einem Wertkonstruktor für Zeichen, der nicht argumentlos ist, sondern ein Argument vom Typ Rechenzeichen entgegennimmt.


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.59, vom Themenstarter, eingetragen 2021-11-12

\quoteon Eigentlich willst du ja wahrscheinlich nicht nur einen Booleschen Wert haben, sondern vielleicht auch den Term als aufbereitete Datenstruktur (statt Zeichenkette), mit der man dann schön weiterarbeiten kann. Zumindest dafür bietet sich ein rekursiver Datentyp an: \quoteoff Kannst du mir Beispiele nennen, zu was man dann diese aufbereitete Datenstruktur weiterverarbeiten kann ? Mir fällt nur das ein: Was außer dem Boolschen Wert noch interessant ist, ist Folgendes: Wenn der String kein Term ist (also False zurückgegegeben wird), soll der Teilstring angegeben werden (z.B. durch Index von Anfang und Ende des Teilstrings), der kein Term ist. mfg cx


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.60, vom Themenstarter, eingetragen 2021-11-12

\quoteon(2021-11-10 00:12 - tactac in Beitrag No. 54) Eigentlich willst du ja wahrscheinlich nicht nur einen Booleschen Wert haben, sondern vielleicht auch den Term als aufbereitete Datenstruktur (statt Zeichenkette), mit der man dann schön weiterarbeiten kann. Zumindest dafür bietet sich ein rekursiver Datentyp an: \sourceon Haskell data Term = Int Int | Var Char | Add Term Term deriving (Eq, Ord, Show) \sourceoff \quoteoff Habe den Vorschlag von dir umgesetzt. So weit klappt es auch. Aber: Da ich gerne mit "Wächtern" arbeite, habe ich versucht die Funktion termliste in die Funktion termliste1 mit Wächtern umzuschreiben. Dabei gibt es jede Menge Fehlermeldungen. Was mache ich da falsch ? mfg cx // main_6.hs \sourceon ghci> :load main_6.hs [1 of 1] Compiling Main ( main_6.hs, interpreted ) main_6.hs:30:20: error: Variable not in scope: z :: Int | 30 | | term == (Int z) = (show z) | ^ main_6.hs:30:31: error: Variable not in scope: z | 30 | | term == (Int z) = (show z) | ^ main_6.hs:31:20: error: Variable not in scope: v :: Char | 31 | | term == (Var v) = [v] | ^ main_6.hs:31:26: error: Variable not in scope: v :: Char | 31 | | term == (Var v) = [v] | ^ main_6.hs:32:20: error: Variable not in scope: t1 :: Term | 32 | | term == (Add t1 t2) = ['{'] ++ (termliste t1) ++ ['+'] ++ (termliste t2) ++ ['}'] | ^^ main_6.hs:32:23: error: Variable not in scope: t2 :: Term | 32 | | term == (Add t1 t2) = ['{'] ++ (termliste t1) ++ ['+'] ++ (termliste t2) ++ ['}'] | ^^ main_6.hs:32:50: error: Variable not in scope: t1 :: Term | 32 | | term == (Add t1 t2) = ['{'] ++ (termliste t1) ++ ['+'] ++ (termliste t2) ++ ['}'] | ^^ main_6.hs:32:77: error: Variable not in scope: t2 :: Term | 32 | | term == (Add t1 t2) = ['{'] ++ (termliste t1) ++ ['+'] ++ (termliste t2) ++ ['}'] | ^^ Failed, no modules loaded. \sourceoff \sourceon main = do let str1 :: String str1 = termliste (Add (Int 5) (Int 8) ) print str1 print (termliste (Int 5)) print (termliste (Add (Int 5) (Int 8))) print ( termliste (Add (Add (Int 5) (Int 8)) (Add (Int 5) (Int 8)) ) ) {- ************************************************************* ** BEGINN DER DEFINITIONEN DER FUNKTIONEN UND DATENTYPEN ** ************************************************************* -} data Term = Int Int | Var Char | Add Term Term deriving (Eq, Ord, Show) termliste :: Term -> String termliste (Int z) = (show z) termliste (Var v) = [v] termliste (Add t1 t2) = ['{'] ++ (termliste t1) ++ ['+'] ++ (termliste t2) ++ ['}'] termliste1 :: Term -> String termliste1 term | term == (Int z) = (show z) | term == (Var v) = [v] | term == (Add t1 t2) = ['{'] ++ (termliste t1) ++ ['+'] ++ (termliste t2) ++ ['}'] \sourceoff


   Profil
tactac
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 15.10.2014
Mitteilungen: 2626
  Beitrag No.61, eingetragen 2021-11-12

\quoteon(2021-11-12 14:08 - carlox in Beitrag No. 59) \quoteon Kannst du mir Beispiele nennen, zu was man dann diese aufbereitete Datenstruktur weiterverarbeiten kann ? \quoteoff Wie gesagt, ist eine Möglichkeit, ein Element des Term-Typs unter einer bestimmten Variablenbelegung auszuwerten. Eine weitere ist, diverse "Programmtransformationen" wie etwa Optimierungen vorzunehmen.


   Profil
tactac
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 15.10.2014
Mitteilungen: 2626
  Beitrag No.62, eingetragen 2021-11-12

\quoteon(2021-11-12 16:22 - carlox in Beitrag No. 60) [...] Was mache ich da falsch ? // main_6.hs \sourceon Haskell \numberson main = do let str1 :: String str1 = termliste (Add (Int 5) (Int 8) ) print str1 print (termliste (Int 5)) print (termliste (Add (Int 5) (Int 8))) print ( termliste (Add (Add (Int 5) (Int 8)) (Add (Int 5) (Int 8)) ) ) {- ************************************************************* ** BEGINN DER DEFINITIONEN DER FUNKTIONEN UND DATENTYPEN ** ************************************************************* -} data Term = Int Int | Var Char | Add Term Term deriving (Eq, Ord, Show) termliste :: Term -> String termliste (Int z) = (show z) termliste (Var v) = [v] termliste (Add t1 t2) = ['{'] ++ (termliste t1) ++ ['+'] ++ (termliste t2) ++ ['}'] termliste1 :: Term -> String termliste1 term | term == (Int z) = (show z) | term == (Var v) = [v] | term == (Add t1 t2) = ['{'] ++ (termliste t1) ++ ['+'] ++ (termliste t2) ++ ['}'] \sourceoff \quoteoff Wenn du einen "Wächter" hast, der ein logischer Ausdruck ist, werden durch den keine neuen Variablen gebunden. Verwende Pattern-Matching. Das ist eigentlich genau für den Zweck da, den du da anscheinend umzusetzen versuchst. \sourceon (Haskell) termliste1 :: Term -> String termliste1 (Int z) = show z termliste1 (Var v) = [v] termliste1 (Add t1 t2) = ['{'] ++ termliste t1 ++ ['+'] ++ termliste t2 ++ ['}'] \sourceoff


   Profil
tactac
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 15.10.2014
Mitteilungen: 2626
  Beitrag No.63, eingetragen 2021-11-13

Ergänzung: "Pattern Guards" gingen natürlich auch: \sourceon Haskell termliste1 :: Term -> String termliste1 term | Int z <- term = show z | Var v <- term = [v] | Add t1 t2 <- term = ['{'] ++ termliste t1 ++ ['+'] ++ termliste t2 ++ ['}'] \sourceoff


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.64, vom Themenstarter, eingetragen 2021-11-14

Hallo allerseits, Mein Programm funktioniert jetzt eingermaßen. (Ich werde es später vorstellen). Da Haskell massiv mit Rekursion arbeitet, will ich kurz auf Folgendes eingehen: Prof. Kindler schreibt auf S. 68 von: https://drive.google.com/file/d/1yYguG1p9WMB9OYkj8kkV6GC2hs7DimgU/view "Ein weiterer Grund ist, ein Bewußtsein dafur zu schaffen, daß in der Informatik fast uberall nur mit Wasser gekocht wird, wobei das Wasser die Konzepte des induktiven Definierens und Beweisens sind." Deswegen habe ich früher mal für eine einfache, abgespeckte imperative Sprache (ich glaube in C) einen Parser programmiert, der die Syntax testet. Das hat geklappt - und das nur mit induktiven Definitionen (für Terme, Formeln, Schleifen, usw.), also ohne Grammatiken u.ä. Frage: Könnte man also theoretisch den ganzen "Kram" (Grammatiken, usw.) weglassen, um die Syntax einer Sprache zu beschreiben und auf Korrektheit zu prüfen und nur das Prinzip der "induktiv definierten Mengen" (siehe Skript oben von Prof. Kindler) verwenden. Allerdings ohne das Laufzeitverhalten zu berücksichtigen! Denn die ist verheerend schlecht (mein o.g. Parser "schläft" für etwas "größere" Programme ein und ist praktisch nicht verwendbar). mfg cx


   Profil
tactac
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 15.10.2014
Mitteilungen: 2626
  Beitrag No.65, eingetragen 2021-11-14

Eine kontextfreie Grammatik ist doch einfach eine induktive Definition eines Tupels von Sprachen.


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.66, vom Themenstarter, eingetragen 2021-11-15

\quoteon(2021-11-14 21:57 - tactac in Beitrag No. 65) Eine kontextfreie Grammatik ist doch einfach eine induktive Definition eines Tupels von Sprachen. \quoteoff Nein, zumindest wenn man die Begrifflichkeiten (ab S.48) im Skript von Prof. Kindler zugrunde legt. Man kann aber jede kontextfrei Sprache durch eine induktiv definierte Menge beschreiben. Vermutung1: Man kann jede Sprache (vom Typ 0,1,2,3) durch eine induktiv definierte Menge beschreiben. Ist das korrekt? Vermutung2: Man kann jede entscheidbare Sprache durch eine induktiv definierte Menge beschreiben. Ist das korrekt? mfg cx


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.67, vom Themenstarter, eingetragen 2021-11-16

\quoteon(2021-11-15 10:49 - carlox in Beitrag No. 66) \quoteon(2021-11-14 21:57 - tactac in Beitrag No. 65) Eine kontextfreie Grammatik ist doch einfach eine induktive Definition eines Tupels von Sprachen. \quoteoff Nein, zumindest wenn man die Begrifflichkeiten (ab S.48) im Skript von Prof. Kindler zugrunde legt. Man kann aber jede kontextfrei Sprache durch eine induktiv definierte Menge beschreiben. Vermutung1: Man kann jede Sprache (vom Typ 0,1,2,3) durch eine induktiv definierte Menge beschreiben. Ist das korrekt? Vermutung2: Man kann jede entscheidbare Sprache durch eine induktiv definierte Menge beschreiben. Ist das korrekt? mfg cx \quoteoff Ich stelle diese Frage in das Forum: "Theoretische Informatik" des Matheplaneten. Da gehört es eher hin. mfg cx


   Profil
carlox
Aktiv Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2007
Mitteilungen: 1427
  Beitrag No.68, vom Themenstarter, eingetragen 2021-11-16

Hallo allerseits, mit eurer Hilfe habe ich jetzt einigen lauffähigen Quellcode erzeugt: Einfache Konstrukte, Funktionen, usw. Um auch etwas zurückzugeben: Besteht Interesse, dass ich diesen Quellcode hier poste? mfg cx


   Profil
carlox hat die Antworten auf ihre/seine Frage gesehen.
carlox wird per Mail über neue Antworten informiert.
Seite 2Gehe zur Seite: 1 | 2  

Wechsel in ein anderes Forum:
 Suchen    
 
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters, all the rest © 2001-2022 by Matroids Matheplanet
This web site was originally made with PHP-Nuke, a former web portal system written in PHP that seems no longer to be maintained nor supported. PHP-Nuke is Free Software released under the GNU/GPL license.
Ich distanziere mich von rechtswidrigen oder anstößigen Inhalten, die sich trotz aufmerksamer Prüfung hinter hier verwendeten Links verbergen mögen.
Lesen Sie die Nutzungsbedingungen, die Distanzierung, die Datenschutzerklärung und das Impressum.
[Seitenanfang]