---

also ich bin jetzt mit meinem latein ziemlich am ende und fuer jeden einwurf dankbar:
ausgangssituation: - laengeschnitt zeichnen mit mehrerern linien
koordinatenliste mit einer x und mehreren y koordinaten (bei mir 13!)
wurde eingelesen und bearbeitet und in gkoord als liste gespeichert
z.b.
(0 10 20 30 40)
(1 11 21 31 41)
(2 12 22 32 42)

nun sollten soviele lsiten entstehen wie y koordinaten (im bsp 4) die x bleibt immer gleich sodass zum beispiel entsteht
liste data1
(0 10)
(1 11)
(2 12)

liste data2
(0 20)
(1 21)
(2 22)

mein code dazu ... der fast funkt: ;-)

Code:

---

;;; Gelaende und WSP zeichnen
  (setq i 0
j 1
pre "data"
  )
  ; variablenliste fuer die daten initialisieren
  (while (<= j l)
    (setq vname (strcat pre (itoa j)))
    (set (read vname) nil)
    (setq j (1+ j))
  ); end while
  ; Variablenlisten fuellen
  (while (setq p (nth i gkoord))
(setq x (car p)
      j 1
)
        (while (<= j l)
  (setq temp (list x (nth j p)))
  (set (read (strcat pre (itoa j))) (cons temp (read (strcat pre (itoa j))))
  (setq j (1+ j))
)
        (setq i (1+ i))
  ); end while
  (princ data1)

---

danke im vorraus mfg chris
p.s. i'm a funky newbie writing in this forum

[Diese Nachricht wurde von wasserbauer am 26. Jul. 2006 editiert.]

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

versuchs mal damit:

Code:

---

(defun C:TEST ( / i pre temp )
  (setq gkoord
(list
  '(0 10 20 30 40)
  '(1 11 21 31 41)
  '(2 12 22 32 42)
)
        i 1 pre "data"
  )
  (repeat (1- (length (car gkoord)))
    (setq temp ())
    (foreach n gkoord
        (setq temp (append temp (list (list (car n)(nth i n))) ))
    )
    (set (read (strcat pre (itoa i))) temp)
    (setq i (1+ i))
  )

  (setq i 1)
  (textscr)
  (repeat (1- (length (car gkoord)))
    (terpri)
    (prompt (strcat pre (itoa i) " = "))
    (princ (eval (read (strcat pre (itoa i)))))
    (setq i (1+ i))
  )
  (princ)
)

---

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

dankeschoen, das wars was ich brauchte, den kick auf den richtigen weg
funktioniert gut

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Mahlzeit zusammen,

da ich dieses Thema sehr interessant finde, klinke ich mich mal ein    .

Sobald eine größere Liste zum Einsatz kommt, sollte man sich überlegen, ob man hierbei nicht besser auf append und nth verzichten soll (siehe hier *klick*

Wenn ich es richtig verstanden habe, könnte diese Liste doch auch so aussehen...

Code:

---

((0 10 20 30 40 ... n)
(1 11 21 31 41 ... n)
(2 12 22 32 42 ... n)
...
)

---

Ich möchte gerne meine Idee mittels mapcar vorschlagen. Herausgekommen sind zwei Funkionen..

Code:

---

;;; Funktion teilt eine Liste mit Listen
;;; in Spalten auf
;;; Voraussetzung: Liste mit gleichlangen Listeinträgen
(defun columnlist (#lst / rl)
  (while (car #lst)
    (setq rl   (cons (mapcar 'car #lst) rl)
  #lst (mapcar 'cdr #lst)
    )
  )
  (reverse rl)
)

;;; Funktion benutzt den car-Eintrag der Liste
;;; um diese Werte als Zähler zu setzen
;;; Voraussetzung: Liste mit gleichlangen Listeinträgen
(defun split (#lst / cl)
  (setq cl (car #lst))
  (mapcar '(lambda (l) (mapcar 'list cl l))
  (cdr #lst)
  )
)

---

Beispiel:

Code:

---

(setq
  gkoord
   (list
     '(0 10 20 30 40)
     '(1 11 21 31 41)
     '(2 12 22 32 42)
   )
)

---

Aufruf sieht dann so aus...

(split(columnlist gkoord))

=> (((0 10) (1 11) (2 12)) ((0 20) (1 21) (2 22)) ((0 30) (1 31) (2 32)) ((0 40) (1 41) (2 42)))

... in Anregung auf noch was effizienteres      

Greets Rolf

------------------
CADmaro.de

[Diese Nachricht wurde von benwisch am 27. Jul. 2006 editiert.]

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Tag zusammen.

Zitat:

---

da ich dieses Thema sehr interessant finde, klinke ich mich mal ein    .

---

Da sind wir schon 2 ..

Ich nehme mal deine Annahmen auf, dass wir es mit einer Liste von Listen gleicher Länge zu tun haben, wobei die Länge der Unterlisten beliebig sein darf. Wie deine Implementierung von columnlist sehr schön zeigt, ist's mit der Verwendung von mapcar etwas kompliziert, weil die Funktion ja eigentlich die einzelnen Unterlisten abarbeitet. Viel schöner wäre es, wenn wir gleich die auf die Spalten losgehen könnten. Das funktioniert im Prinzip ja auch, wenn wir einen auf die Anzahl der Unterlisten abgestimmten Lambda-Ausdruck verwenden:

Code:

---

(mapcar'cons
  '(1 2 3)
  '(10 20 30)
)

-> ((1 . 10) (2 . 20) (3 . 30))

(mapcar'list
  '(0 10 20 30 40)
  '(1 11 21 31 41)
  '(2 12 22 32 42)
)

-> ((0 1 2) (10 11 12) (20 21 22) (30 31 32) (40 41 42))

---

Damit steht aber schon fast eine effizienter und elegantere Implemntierung für columnlist. Ich nenne die Funktion mal :transpose, weil so ein Spiegeln an der Diagonalen bei Matrizen als Transponieren bezeichnet wird:

Code:

---

(defun :transpose (list-of-lists)
  (if list-of-lists
    (apply'mapcar
      (cons'list list-of-lists)
    )
  )
)

---

Oder etwas allgemeiner, wobei hier bei der Anwendung schon darauf zu achten ist, dass Anzahl der Listen zum Lambda-Ausdruck passen:

Code:

---

(defun :apply-transpose (lambda-expression list-of-lists)
  (if list-of-lists
    (apply'mapcar
      (cons lambda-expression list-of-lists)
    )
  )
)

---

Schöne Beispiele sind neben dem oben schon benutzen

Code:

---

(:apply-transpose'list'((0 10 20 30 40)(1 11 21 31 41)(2 12 22 32 42)))

---

auch die hier:

Code:

---

(:apply-transpose'max'((0 10 20 30 40)(1 11 21 31 41)(2 12 22 32 42)))
(:apply-transpose'min'((0 10 20 30 40)(1 11 21 31 41)(2 12 22 32 42)))
(:apply-transpose'+  '((0 10 20 30 40)(1 11 21 31 41)(2 12 22 32 42)))

---

Zitat:

---

... in Anregung auf noch was effizienteres   

---

Na, ich bin mir nicht sicher, aber der Idee mit dem (split(:apply-transpose .. halte ich das hier entgegen:

Code:

---

(defun :apply-map (lambda-expression-with-2-args assoc-list)
  (setq lambda-expression-with-2-args  (eval lambda-expression-with-2-args ));** einmal EVAL reicht
  (mapcar
  '(lambda(pair)
      (lambda-expression-with-2-args  (car pair)(cdr pair))
    )
    assoc-list
  )
)

---

Wie die Bezeichung des 2. Funktions-Argument schon verrät, benutze ich sowas primär bei der Verarbeitung von Assoziationslisten. Hierbei dient :apply-map dazu, den Assoziations-Schlüssel (car) mit dem Assoziations-Wert (cdr) zu verheiraten und deshalb braucht der Lambda-Ausdruck 2 Argumente. Ein paar Beispiele:

Code:

---

(:apply-map
'(lambda(bezeichnung wert)
    (strcat bezeichnung": "wert)
  )
'(("Name" . "Müller")("Vorname" . "Knuth"))
)

-> ("Name: Müller" "Vorname: Knuth")

(:apply-map
'(lambda(bezeichnung wert)
    (mapcar
    '(lambda(x)(strcat bezeichnung": "x))
      wert
    ) 
  )
'(("Name" "Müller" "Meier" "Schulze")
  ("Vorname" "Knuth" "Elke" "Zermelo")
  )
)

-> (("Name: Müller" "Name: Meier" "Name: Schulze")
    ("Vorname: Knuth" "Vorname: Elke" "Vorname: Zermelo"))

---

und beides zusammen:

Code:

---

(:apply-transpose'strcat
  (:apply-map
  '(lambda(bezeichnung wert)
      (mapcar
      '(lambda(x)(strcat bezeichnung": "x","))
        wert
      ) 
    )
  '(("Name" "Müller" "Meier" "Schulze")
    ("Vorname" "Knuth" "Elke" "Zermelo")
    )
  )
) 

-> ("Name: Müller,Vorname: Knuth,"
    "Name: Meier,Vorname: Elke,"
    "Name: Schulze,Vorname: Zermelo,")

---

Für unser Beispiel hier mit den Koordinatenlisten braucht es meiner Meinung nach nur :apply-map:

Code:

---

(:apply-map
'(lambda(bezeichnung wert)
    (mapcar
    '(lambda(x)(list bezeichnung x))
      wert
    ) 
  )
'((0 10 20 30 40)(1 11 21 31 41)(2 12 22 32 42))
)

-> (((0 10) (0 20) (0 30) (0 40))
    ((1 11) (1 21) (1 31) (1 41))
    ((2 12) (2 22) (2 32) (2 42)))

---

.. aber das geht bestimmt noch besser ..

Achim Dabrunz

------------------

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Na super, Achim.
Hatte gerade meinen Beitrag fertig und dann kommst du.
Jetzt muss ich erst mal sehen, wie ich meinen Unterkiefer wieder von der Tischplatte in die ursprüngliche Lage bringe. 

@benwisch
Alter Listen-Lispler. 
Dachte mir schon, dass da was von dir kommt. 

Zitat:

---

Original erstellt von benwisch:

... in Anregung auf noch was effizienteres        

---

Effizienter und am Ende auch noch kürzer als dein Code wird wohl kaum machbar sein. (Achims Code muss ich jetzt erst noch verkraften) und angesichts Achims Zeilen habe ich mich fast nicht getraut, auch zu posten.
Aber ich hätte noch was rekursives im Angebot und das ist doch auch was:

Code:

---

(defun x-zu-y (#l)
  (mapcar
    '(lambda (#arg1 #arg2)
      (mapcar
        '(lambda (#rest)
            (list #arg1 #rest)
          )
        #arg2
      )
    )
    (mapcar 'car #l)
    (mapcar 'cdr #l)
  )
)

(defun sammeln (#l)
  (repeat (length (car #l))
    (cons (mapcar 'car #l)
          (sammeln (mapcar 'cdr #l))
    )
  )
)

---

-> (sammeln (x-zu-y gkoord))

@Wasserbauer
Genau wie bei benwisch und Achim werden hier keine Variablennamen erzeugt, die Rückgabe ist eine einzige Liste. Reicht doch auch. Ist doch viel einfacher zu handeln als ein Wust von Variablen. 

Gruß
CADchup

------------------
CADmaro.de

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo,
na, den ganzen Beiträgen ist wohl kaum noch was hinzuzufügen (bei den meisten verstehe ich sowieso kaum die Hälfte). Ich habe nochmal eine mapcar-Variante, ob Sie wirklich effizient ist, das weiß ich auch nicht so genau.

Code:

---

(setq gkoord (list
                '(0 10 20 30 40)
'(1 11 21 31 41)
'(2 12 22 32 42)))
  (defun test (gkoord / )
        (mapcar '(lambda(A)
            (mapcar '(lambda(B)
      (list(car A) B))(cdr A)))
                  gkoord))

---

[edit]
Ich sehe gerade, da kommt nur Blödsinn raus, das müßte dann noch transponiert werden, aber da oben sind ja genug sinnvolle Beiträge.
[/edit]

------------------
viele Grüße

Jörn

[Diese Nachricht wurde von joern bosse am 28. Jul. 2006 editiert.]

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

danke leute,

das hilft alles schon mal weiter ... werde dann mal die original anwendung dann mal hier posten wenn sie nicht mer so beta ist wie jetzt ... muss mal erst durch die codeverkuerzungsphase durch.

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

@Achim,

Ich hoffte natürlich, daß du antwortest und freue mich, daß du die Zeit und Lust dazu gefunden hast.

Zitat:

---

Damit steht aber schon fast eine effizienter und elegantere Implemntierung für columnlist.

---

Fast?? Das tut weh... => (apply 'mapcar (cons 'list gkoord))
auf diesen Einzeiler bin ich nicht gekommen, obwohl ich eigentlich deine apply-transpose Funktion kenne. Naja, zeigt mir, daß ich hier noch tiefer eintauchen sollte!

Zitat:

---

Ich nenne die Funktion mal :transpose, weil so ein Spiegeln an der Diagonalen bei Matrizen als Transponieren bezeichnet wird:

---

Ja klar   , ich wollt's ja nur nicht so kompliziert machen und habe mich deswegen zurückgehalten. Nee ernsthaft, wieder was dazu gelernt!!

Deine :apply-m* Funktionen sind, mal locker ausgedrückt, "sexy coded" und flexibler einzusetzen.

Nun, ich bin natürlich neugierig und habe deshalb eine Liste mit 1000 Unterlisten erstellt. Die Unterlisten selbst bestehen aus 300 +1 (Bezeichner als durchlaufende Nummer) Atomen. Jetzt habe ich deine :apply-transpose, meine transpose  und die X-zu-Y Funktion von CADchup durch deinen Profiler laufen lassen mit jeweils 50 Durchläufen. Das Ergebnis ist niederschmetternd

Ergebnis:
transpose  -> ~ 9.62501 Sek.
X-ZU-Y -> 14.25 Sek.
:apply-transpose -> 2.79701 Sek.   <- Waffenschein wird beantragt!

Hast du eigentlich die Zeit gefunden, dir das Buch "Fermats letzter Satz" durchzulesen? 2004 CAD.PRO Messe, wir sprachen kurz darüber als du mir die Endrekursion erklärtest.

@CADchup

Zitat:

---

Alter Listen-Lispler.  
Dachte mir schon, dass da was von dir kommt.

---

Du weißt doch, wer daran die Schuld trägt 

Zitat:

---

Effizienter und am Ende auch noch kürzer als dein Code wird wohl kaum machbar sein.

---

Doch  wie zu lesen ist.
Warum einfach -> (apply 'mapcar (cons 'list gkoord))...
wenn's doch auch kompliziert geht ->
  (while (car #lst)
    (setq rl   (cons (mapcar 'car #lst) rl)
  #lst (mapcar 'cdr #lst)
    )
  )
  (reverse rl)
  

Greets Rolf

------------------
CADmaro.de

[Diese Nachricht wurde von benwisch am 29. Jul. 2006 editiert.]

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP