HA4 7

[ChRiZz88]

nee wieso sollte er...

ich kann doch genauso gut rekursiv die liste durchgehen, mehr macht map auch nicht

"Rekursiv durch die Liste" dauert aber länger, glaubs einfach Und zwar viel länger...

[Skylo]

nee in der ausführung war es genauso lang beim Sierpinski !

Meine Funktion war total easy geschriebe und draw-lsystem is ja auch nichts was irgendwie viel Code braucht

Aber ich hab gemerkt bei einer rekursionstiefe von 15 und einer Levy Kurve is ein unterschied von 7 zu 5 sekunden mit map!

[Skylo]

übrigens probiert mal diese hier aus ....

Code: Alles auswählen

(define axiom-kochflocke '(F - - F - - F))
(define rules-kochflocke '( ( F ( F + F - - F + F ))))

(define axiom-hilbert '(X))
(define rules-hilbert '( (X (- Y F + X F X + F Y -))
                         (Y (+ X F - Y F Y - F X +))))

(define axiom-levy '( F))
(define rules-levy '( (F (+ F - - F +))))

Müsst dafür natürlich auch noch - implementieren ... aber das kriegt wohl jeder hin

[base_FFM]

Probier mal erstens eine korrekte Liste mit den G, F, +, - zu erzeugen. Dann kannste diese Liste mit map durcharbeiten und dabei jeden Befehl durch einen turtle Befehl ersetzen bzw. da ersetzen ja gleich ausführen bedeutet, ausführen lassen.

so inetwa ? :

Code: Alles auswählen

(turtles)
(define lst' ((F) (G)  (+)  (-) ))

(define (sre lst)
  (cond
    ((eq? 'F (car lst)) (draw 10))     
    ((eq? 'G (car lst)) (move 10))
    ((eq? '+ (car lst)) (turn 90))     
    ((eq? '- (car lst)) (turn -90))
    (else     "none")))

(map sre lst)

das ist doch quasi die 7.3 also drawmässig....

aber, über welche listen soll ich mein sre (sukzesive regelbasierte Ersetzungen)
rennen lassen ???

in welcher beziehungen stehen die regeln zu den basisaxiomen ?
ich werd aus der einleitung nicht schlau !

[Lindenmayer-System:] Basisaxiom: F
Regeln: F := F G + F -
[Iterative Expansion:] Iteration 0: F
Iteration 1: F G + F -
Iteration 2: F G + F - G + F G + F - -

hmmm....

p.s ich hoff das is nich der falsche thread, weils hier schon um den speedvergleich von map zu rek ging....

[Osterlaus]

übrigens probiert mal diese hier aus ....

Code: Alles auswählen

(define axiom-kochflocke '(F - - F - - F))
(define rules-kochflocke '( ( F ( F + F - - F + F ))))

(define axiom-hilbert '(X))
(define rules-hilbert '( (X (- Y F + X F X + F Y -))
                         (Y (+ X F - Y F Y - F X +))))

(define axiom-levy '( F))
(define rules-levy '( (F (+ F - - F +))))

Müsst dafür natürlich auch noch - implementieren ... aber das kriegt wohl jeder hin

Der Hilbert schlägt bei mir fehl, weil keine Rules für F vorhanden sind - kannst du da mal helfen?

[ChRiZz88]

wie kann man den überprüfen ob es sich um eine liste handelt oder nicht?
"list?" gibts ja wohl nicht :-/

list? gibts schon, allerdings erst auf nem höheren Sprachlevel...

[arit]

(draw-lsystem (expand-ntimes 5 axiom-sierpinski rules-sierpinski) 10 60)

Dauert zwar 37 sec. auf einem 1,86 GHz PentiumM, aber das Dreieck erscheint. Wobei meine expand-ntimes prozedur mit 34sec der Übeltäter zu sein scheint.

Der Hauptteil besteht aus

Code: Alles auswählen

(expand-ntimes (sub1 num)(expand-once lst loR)

Aber mir fällt nichts zum optimieren ein :/

_________________
Guilty Gear, ST ftw!

[ChRiZz88]

Ich schätze, dass expand-once der Übeltäter ist, der wird bei expand-ntimes schließlich rekursiv aufgerufen...
Versuch die expand-once mal mit map zu machen...

[base_FFM]

übrigens probiert mal diese hier aus ....

Code: Alles auswählen

(define axiom-kochflocke '(F - - F - - F))
(define rules-kochflocke '( ( F ( F + F - - F + F ))))

(define axiom-hilbert '(X))
(define rules-hilbert '( (X (- Y F + X F X + F Y -))
                         (Y (+ X F - Y F Y - F X +))))

(define axiom-levy '( F))
(define rules-levy '( (F (+ F - - F +))))

Müsst dafür natürlich auch noch - implementieren ... aber das kriegt wohl jeder hin

cool

! levy macht richtig spass ! aber da stösst mein rechner bzw SCHEME (!) schan langsam an grenzen. bei ner iterationstiefe von 15 kann das schon n paar sec dauern exklusive der void ausgabe natürlich, die kann mann ja stoppen.

das wär ma n benchmark mit ner anderen sprache wert.... ich würd fast schon wetten, das es in .net schneller is...