Ist Haskell für produktiven Einsatz geeignet oder eher nur eine Herausforderung für den Programmierer?

nachtfeuer

Zeus schrieb:

nachtfeuer schrieb:

KVLKNL

Ist das eine Abkürzung, die man kennen muss?

nein nein, keine Bange, ist ein Eigenentwurf
(das letzte L meint Lesen...)

Dravere

nachtfeuer schrieb:

Zeus schrieb:

nachtfeuer schrieb:

KVLKNL

Ist das eine Abkürzung, die man kennen muss?

nein nein, keine Bange, ist ein Eigenentwurf
(das letzte L meint Lesen...)

Sag mir als nächstes nur noch, dass das "KniViL Kann Nicht Lesen" heisst? Dann müsste ich nämlich nach deinen Altern zurückfragen. Wobei schon diese Abkürzung, welche wie bei kleinen Kinder als Schutz dient, damit nur der Verfasser weiss, was damit gemeint ist und er sich dadurch ins Fäustchen lachen kann, einem leichte Zweifel aufkommen lässt. Was soll der Unsinn?

Grüssli

nachtfeuer

Dravere schrieb:

Sag mir als nächstes nur noch, dass das "KniViL Kann Nicht Lesen" heisst?

Grüssli

nein nein, kein Bange, das erste K steht für Kann...

(das nächste mal schreibe ich wohl besser KBLKNVLLKNL)

werauchimmer.... schrieb:

Oder wenns um Threads geht, wie würde man sowas in Haskell programmieren?
http://doc.qt.nokia.com/4.6/threads-mandelbrot.html
Kann jemand die RenderThread::run-Methode in Haskellcode schreiben und erklären, wie sie dann einfach parallelisiert werden kann?

Kann das keiner?

Michael E.

nachtfeuer schrieb:

nein nein, kein Bange, das erste K steht für Kann...

(das nächste mal schreibe ich wohl besser KBLKNVLLKNL)

KVLKNL: kann vor Lachen kaum noch lesen.

DHDAFG. HHDNK. (=> Das hast du aber fein gemacht. Hier hast du nen Keks.)

audacia

nix? schrieb:

werauchimmer.... schrieb:

Oder wenns um Threads geht, wie würde man sowas in Haskell programmieren?
http://doc.qt.nokia.com/4.6/threads-mandelbrot.html
Kann jemand die RenderThread::run-Methode in Haskellcode schreiben und erklären, wie sie dann einfach parallelisiert werden kann?

Kann das keiner?

Die Frage ist eher: hat irgendjemand die Bemüßigung, extra für dich seitenlangen Quelltext zum Spaß nach Haskell zu übersetzen, anstatt seinem Tagwerk nachzugehen?

knivil

werauchimmer.... schrieb:

Oder wenns um Threads geht, wie würde man sowas in Haskell programmieren?
http://doc.qt.nokia.com/4.6/threads-mandelbrot.html
Kann jemand die RenderThread::run-Methode in Haskellcode schreiben und erklären, wie sie dann einfach parallelisiert werden kann?

Ich muss sagen, schoen eingefaerbt und multi-threaded: http://hackage.haskell.org/package/hfractal
Andere Links zum Thema: http://gregheartsfield.com/fractal-hs/ oder http://web.cecs.pdx.edu/~mpj/pubs/composing-fractals.html

hmm - ich sehe beim Mandelbrotviewing jetzt aber nicht sofort den spezifischen Vorteil der Verwendung von Fun.Prog. - ?

meine mandelbrot-viewer in C/C++ ohne/mit X11 Ausgabe sind nicht so viel länger evtl sogar kürzer (228 Zeilen für 2D-Ausschnitte der 4D-Mandelbrotmenge (Quaternionen) mit Fileausgabe ohne X11), wahlweise parallelisiert mittels

#pragma omp parallel for schedule ... // openMP

ich seh' gerade, mein C/C++ Programm ist großzügig kommentiert

ohne Kommentare sind's nur 151 Zeilen, eine Funktion für die Berechnung von ganzen Bilderserien (Variation der quaternionischen j-Koordinate) schon mitgezählt.

Mr. N schrieb:

Es hat in Haskell viele Abstraktionen, die in C++ undenkbar wären. Ich versuche ja auch in C++ möglichst abstrakt zu programmieren, aber Haskell bietet da nochmal deutlich mächtigere Tools.

Es ist wahrscheinlich schwer, dafuer Beispiele anzugeben, aber faellt dir gerade was ein? Rein aus Neugier, nicht weil ich dagegen argumentieren wollen wuerde.

knivil

zum Beispiel schrieb:

ohne Kommentare sind's nur 151 Zeilen, eine Funktion für die Berechnung von ganzen Bilderserien (Variation der quaternionischen j-Koordinate) schon mitgezählt.

Dann messe dich mit http://www.bestinclass.dk/index.php/2009/10/brians-functional-brain/ oder http://blog.willdonnelly.net/2009/10/14/brians-purely-functional-brain/ .

asddd schrieb:

Es ist wahrscheinlich schwer, dafuer Beispiele anzugeben, aber faellt dir gerade was ein? Rein aus Neugier, nicht weil ich dagegen argumentieren wollen wuerde.

Z.B. Der ganze parallele Kram in Haskell.

knivil schrieb:

Dann messe dich mit http://www.bestinclass.dk/index.php/2009/10/brians-functional-brain/ oder http://blog.willdonnelly.net/2009/10/14/brians-purely-functional-brain/ .

kein problem - meine C/C++ Version ist 45 Zeilen lang, inklusive X11 Ausgabe im Fenster und Parallelisierung.

g++ foo.c -o foo -O3 -fopenmp -lX11 -lm

Starte ich meinen 45-Zeiler, kann ich im gnome-system-monitor schön sehen, wie die Lastkurven für alle 4 CPU cores auf 100% gehen, während die Zellularen Muster herumschwirren ...

hier das Wesentliche:

int main(int argc, char* argv[]){
  d = XOpenDisplay(NULL);
  if(d == NULL) return(1);
  s = DefaultScreen(d);
  bp = BlackPixel(d, s);
  wp = WhitePixel(d, s);
  r = RootWindow(d, s);
  w = XCreateSimpleWindow(d, r, 0, 0, W, H, 1, bp, wp);

[...]

  while(1){
  #pragma omp parallel for schedule(dynamic, 1) private(r)
  for(y = 0; y < H; y++){
    for(x = 0; x < W; x++){
      n = ison(O[((y+1)*W+x) % (W*H)]) + ison(O[((y-1)*W+x) % (W*H)]) \
        + ison(O[((y)*W+x-1) % (W*H)]) + ison(O[((y)*W+x+1) % (W*H)]) \
        + ison(O[((y+1)*W+x-1) % (W*H)]) + ison(O[((y-1)*W+x-1) % (W*H)]) \
        + ison(O[((y+1)*W+x+1) % (W*H)]) + ison(O[((y-1)*W+x+1) % (W*H)]);
      i = y*W+x;
      switch(O[i]){
      case 1: N[i] = -1;
      case -1: N[i] = 0;
      case 0: N[i] = n == 2? 1:0; }}}

[...]  

  for(y = 0; y < H; y++){
    for(x = 0; x < W; x++){
      if(N[y*W+x]) XSetForeground(d, gc, wp);
      else XSetForeground(d, gc, bp);
      XDrawPoint(d, w, gc, x, y); }}
    XFlush (d); }
  XCloseDisplay(d); }

... die restlichen 17 Zeilen sind hauptsächlich Variablendeklarationen und Erzeugung eines zufälligen Musters als Anfangszustand.

und da die 4 Zeilen

n = ison(O[...]) + ison(...) + ...

eigentlich eine 3-mal fortgesetzte zeile darstellen, komme ich genau genommen auf 42 Zeilen

knivil

In der Clojure- bzw. Haskell-Variante sind "includes" und Leerzeilen mitgezaehlt worden. Dabei war die Zeilenlaenge auf 80 Zeichen begrenzt. Es wurde eine uebliche (uebersichtliche) Formatierung eingehalten. Dort ist auch ein SDL-Eventloop enthalten, der auf SDL-Quit reagiert. Es werden Rechtecke gezeichnet und nicht nur Pixel. Auch koenntest du deine Version zum Download anbieten ...

no tricks - ich zähle alles mit! - auch #includes, und die längste Zeile ist 75 Z. lang, im Durchschnitt 30 Zeichen/Zeile

... die 28 wesentlichen zeilen stehen ja schon da, und viel mehr ist nicht dran außer paar Deklarationen und einer for-Schleife für einen zufälligen Anfangszustand ...

#include <stdlib.h>
#include <X11/Xlib.h>
#define w 256
#define h 256
#define isOn(c) (c == 1? 1:0)
Display* D;
Window W;
GC gc;
int s, bp, wp, i, n, 
[...]

knivil

Ich wuerde es gern ausprobieren ..

ich bin jetzt durch ein paar umstellungen bei 37 Zeilen C/C++ angelangt (34 zeilen, wenn man die verlängerte Zeile als einzelne zählt) - nach wie vor gilt: nur 1 Anweisung pro Zeile, und alles ist mitgezählt.

ich würde das 37 Zeilen-Programm ja posten, habe aber im Augenblick leider nicht die Zeit, mich detailliert in die diesbezügliche rechtliche Lage einzuarbeiten (copyright, Haftungsfragen, Lizenz usw.)

ich würde das 37 Zeilen-Programm ja posten, habe aber im Augenblick leider nicht die Zeit, mich detailliert in die diesbezügliche rechtliche Lage einzuarbeiten (copyright, Haftungsfragen, Lizenz usw.)

Was für Probleme sollte es denn da geben? Oder ist das nur ein billiger Vorwand?

ich bin jetzt durch ein paar umstellungen bei 37 Zeilen C/C++ angelangt

Wenn du so weiter machst, hast du bald einen Einzeiler...

ich meine disclaimer usw. - ist mir jetzt zu viel Aufwand für 37 Zeilen, das wasserdicht abzuklopfen. Vllt wäre der Disclaimer dann 10 x länger als das Programm

Ich habe fast alle zeilen schon gepostet, das bisschen was fehlt, sind ein paar augenfällige Variablendeklarationen

int O[W*H], N[W*H];

und eine Schleife, die das Array O (=old) mit einem Zufallsmuster als Anfangszustand

float rnd = (double)rand() / (double)RAND_MAX;
    O[i] = rnd < 0.2? 0:1;

vorbelegt.

Sonst noch was, was gut mit Funk.Prog geht ?