www.jammni.de

Logo - Kleiner Drache
Login
Username:

Passwort:

Daten merken
Auto-Login
Registrieren
 
Online
niemand
 
Forumsuche
Suche nach:

Logo - DracheHaskell-Forum

  1 2 nächste Seite

HaskellToigerl

Gepostet:
14.08.2011 13:07

Ausgabe von Variablen - Faltung  
Sehr geehrte Foren - Mitglieder!
Habe mich bei Haskell \"verirrt\" und wollte an sich \"nur\" eine vorhandene Funktion kennenlernen und für Kontrollzwecke nutzen!
Doch leider ist die Sache doch sehr viel anspruchsvoller als zunächst angenommen. Ersuche um Hilfe. Für folgende Funktionen sollten die \"Variablen\" x,n und Zwischenergebnisse ausgegeben werden (in ein File geschrieben oder am Bildschirm angezeigt)
Dient zur Kontrolle erzeugter gleichverteilter Psedozufallszahlen.

Der Code:

inhomoSum :: RealFloat a => [a] -> a
inhomoSum xs
= sum [ ((s1 n)**2 + (s2 n)**2) / n**2
| i <- [1..huge], n <- [fromIntegral i] ]
where
s1 n = sum [ cos (2 * pi * n * x) | x <- xs ]
s2 n = sum [ sin (2 * pi * n * x) | x <- xs ]


huge = 1000


inhomoSignificance :: RealFloat a => [a] -> a
inhomoSignificance xs
| xs == [] = error \"inhomoSignificance undefined for empty list\"
| otherwise = prob (inhomoSum xs / count)
where
count = fromIntegral (length xs)

prob x = limit (
sum [ (if i < huge then 2 else 1) *
(-1)**(n-1) * exp (-n**2 * x)
| i <- [1..huge], n <- [fromIntegral i] ]
)

limit = (min 1 . max 0)

huge = 1000



inhomogeneity :: RealFloat a => [a] -> a
inhomogeneity xs
| xs == [] = error \"inhomogenity undefined for empty list\"
| length xs == 1 = error \"inhomogenity undefined for single value\"
| otherwise = sqrt ( limit (
(inhomoSum xs * 6 / pi**2 - 1) /
(count**2 - 1)
) )
where
count = fromIntegral (length xs)
limit = max 0

Hoffe auf Ihre Unterstützung
Zum Seitenanfang Homepage      
 
Landei

Gepostet:
14.08.2011 17:06

   
Das gestaltet sich in Haskell schwierig. Vielleicht finden sich hier ein paar Anregungen: http://www.haskell.org/haskellwiki/Debugging

Dann gäbe es noch unsafePerformIO, mit der man eine Konsolenausgabe o.ä. von der IO-Monade \"befreien\" kann, siehe http://hackage.haskell.org/packages/archive/base/latest/doc/html/System-IO-Unsafe.html#v:unsafePerformIO

Will man die Werte an einer einzigen Stelle wissen, kann man einfach einen error werfen.

Alle anderen Methoden, die ich kenne, verhunzen mehr oder weniger die komplette Programmstruktur: http://www.jammni.de/php/forum.php?foid=1&forum=6&PHPSESSID=0df5142b1b9b892eadf4a60e4b61018d&forum=6&posting=3083
Zum Seitenanfang    
 
HaskellToigerl

Gepostet:
15.08.2011 13:59

Danke für die Hinweise  
.. leider fehlt es an Basiswissen, damit ich die selbst gestellten Anforderungen erfüllen kann
Die Auswertung (schrittweise) von inhomoSum bzw. inhomoSignificance, inhomogeineity der sin und cos Therme wäre interessant, um ein imperatives Programm zu kontrollieren ...

Vielleicht hat ein kundiger eine ferige Lösung parat - wäre mir sehr damit geholfen

mit trace schaffe ich nur die Ausgabe von xs bzw. n nicht so interessant, da bekannt ..

mit observe stoße ih auf meine Grenzen

mfg HT
Zum Seitenanfang Homepage      
 
Landei

Gepostet:
15.08.2011 14:47

   
Ganz ehrlich: Das Programm benutzt kaum Haskell-spezifische Konstrukte außer den (hier einfachen) List-Comprehensions. Vielleicht ist die beste Strategie, einfach alles nach Java oder so zu übersetzten, bevor man sich wuschig macht. Wäre das eine Alternative?
Zum Seitenanfang    
 
HaskellToigerl

Gepostet:
15.08.2011 16:12

Ja das wäre sicher eine sinnvolle Alternative  
... allerding hat mich Haskell \"gepackt\" und ein falscher Ehrgeiz hat sich breitgemacht ...

was mich ärgert, dass Haskell keine \"einfache\" Form liefert Kontrollausgaben vorzunehmen .. der Code wäre ja nicht all zu lang -:(


Zum Seitenanfang Homepage      
 
Landei

Gepostet:
15.08.2011 21:20

   
Ich habe gerade die Idee mit unsafePerformIO probiert, und es klappt einwandfrei:


import System.IO.Unsafe

output :: Show b => a -> b -> a
output a text = unsafePerformIO $ print text >> return a

-- original
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

-- mit Ausgabe
fib 0 = 0
fib 1 = 1
fib n = let result = fib (n-1) + fib (n-2)
in output result (\"fib \" ++ show n ++ \" = \" ++ show result)

{-Ausgabe bei Aufruf:
\"fib 2 = 1\"
\"fib 3 = 2\"
\"fib 2 = 1\"
\"fib 2 = 1\"
\"fib 3 = 2\"
\"fib 4 = 3\"
\"fib 5 = 5\"
-}


Dabei hat output zwei Argumente. Das erste wird unverändert als Ergebnis geliefert. Das zweite muss zur Typklasse Show gehören und wird ausgegeben. Das kannst du sicher an deine Bedürfnisse anpassen.
Zum Seitenanfang    
 
HaskellToigerl

Gepostet:
17.08.2011 16:11

Danke ... werde es versuchen  
Danke für den Hinweis .. ich hoffe, dass ich das so adaptieren kann, dass ich die Ausgaben geschrieben bekomme. Nach dem Hinweis, dass das kein \"klassischer\" Haskell-Ansatz ist
habe ich mich mit dem Code auseinandergesetzt .. ja für limit habe ich noch keine Erklärung gefunden und auch sonst muss ich erst genau verstehen was das Programm tut .. bis zu einer
gewissen Stelle (inhomoSum) geht es komform mit einem VBA Programm dann allerdings bekomme ich \"gewaltig\" andere Ergebnisse...

Danke vorerst ... mfg HT
Zum Seitenanfang Homepage      
 
HaskellToigerl

Gepostet:
17.08.2011 19:04

.. WinHugs vs. WinGHCi  
.. das von mir präsentierte Programm läuft unter WinGHCi aber nicht unter WinHugs ...

.. beim Test mit deinem Fallbeispiel st es gerade verkehrt rum .. sind hier lib. zu installieren?

mfg HT
Zum Seitenanfang Homepage      
 
Landei

Gepostet:
18.08.2011 08:37

   
Schon möglich. Hugs gilt als veraltet, auch wenn es viele Unis noch einsetzen. WinGHCi habe ich nicht ausprobiert. Ich habe bei mir die Haskell-Platform (und damit GHC) installiert, und dann die IDE Leksah, die ganz ordentlich arbeitet. Hin und wieder habe ich dort unbekannte Packages eintragen müssen, aber in diesem Fall nicht, es hat sofort funktioniert.

Was limit angeht: Das ist sogenannter punktfreier (\"pointfree\", böse Zungen sagen auch \"pointless\") Stil. Nicht wundern, die \"Punkte\" sind dabei nicht die \".\", sondern Variablen. Eine freie Übersetzung wäre also \"variablenloser Stil\". Zur \"Übersetzung\" gibt es eine Daumenregel, die meistens funktioniert: Auf der linken und rechten Seite am Ende eine Variable anfügen und jeden \".\" durch ein \"$\" ersetzen.


limit x = min 1 $ max 0 x

--oder

limit x = min 1 (max 0 x)


Wie du siehst wird x hier auf den Bereich von 0 bis eins beschränkt (von der 3D-Grafik kenne ich diese Funktion als \"clamp\")

Zum Seitenanfang    
 
HaskellToigerl

Gepostet:
18.08.2011 15:09

min 1 . max 0  
prob x = limit (
sum [ (if i < huge then 2 else 1) *
(-1)**(n-1) * exp (-n**2 * x)
| i <- [1..huge], n <- [fromIntegral i] ]
)

limit = (min 1 . max 0)

Habe mich der Funktionskomposition beschäftigt - theoretisch konnte ich nachvollziehen, was dieses \"Konstrukt\" tut -
aber was genau die oben eingefügten Programmzeilen machen ...??




Zum Seitenanfang Homepage      
 

  1 2 nächste Seite