Prev: Algebra Rizing
Next: GNU Emacs and Xemacs Schism
From: Nicolas Neuss on 1 Jul 2010 04:11
Marc Mientki <mientki(a)nonet.com> writes:

> And how about this version?
>
> (defun transpose-m (matrix)
> (apply 'mapcar 'list matrix))

This is my favorite, too. Unfortunately, it is not useable given only
ANSI CL (see CALL-ARGUMENTS-LIMIT).

Nicolas
From: w_a_x_man on 3 Jul 2010 12:23
On Jun 29, 7:23 am, pero <perogarridogo...(a)yahoo.es> wrote:
> Hello, recently I saw this code on the maxima list for computing the
> transpose of a matrix,
> can you do it better (less computing time)?  How this speed compares
> to C?
>
>  B. Willis version:
>
> (defun transpose-wb (ll)
>   (let ((acc nil))
>     (loop while (car ll) do
>       (push (mapcar #'car ll) acc)
>       (setq ll (mapcar #'cdr ll)))
>     (nreverse acc)))
>
> ---------------------------------------------------
>
> My version. This version is destructive and avoid consing.
>
> (defvar l1 nil)
> (defvar l2 nil)
>
> (defun transpose-pg(m)
>   (let (m1)
>     (setq m1 (loop for x on (car m) collect x))
>     (transposeaux m)
>     m1))
>
> (defun transposeaux(ll)
>   (let (next)
>     (loop for l1 in ll
>        for l2 in (cdr ll) do
>            (loop for ai = l1 then next
>               for bi on l2 do
>                 (setf next (cdr ai))
>                 (rplacd ai bi))
>          finally
>            (loop for bi = l2 then next
>                 while (cdr bi) do
>                 (setf next (cdr bi)
>                       (cdr bi) nil)))
>     ll))
>
> (defun a-matrix(i j)
>   "construct a rectangular matrix"
>   (loop repeat i collect
>        (loop repeat j collect (random 20))))
>
> (defun transpose-wb (ll)
>   (let ((acc nil))
>     (loop while (car ll) do
>       (push (mapcar #'car ll) acc)
>       (setq ll (mapcar #'cdr ll)))
>     (nreverse acc)))
>
> Now a benchmark:
>
> CL-USER> (progn (setq l2 (copy-tree (setq l1 (a-matrix 1000 1000))))
> nil)
> NIL
> CL-USER> (time (progn (transpose-wb l1) 'done))
> Evaluation took:
>   0.184 seconds of real time
>   0.190000 seconds of total run time (0.130000 user, 0.060000 system)
>   [ Run times consist of 0.140 seconds GC time, and 0.050 seconds non-
> GC time. ]
>   103.26% CPU
>   431,324,341 processor cycles
>   32,046,400 bytes consed
>
> DONE
> CL-USER> (time (progn (transpose-pg l2) 'done))
> Evaluation took:
>   0.028 seconds of real time
>   0.030000 seconds of total run time (0.020000 user, 0.010000 system)
>   107.14% CPU
>   67,007,521 processor cycles
>   16,384 bytes consed
>
> --------------------------

Array.new(1000){[0]*1000}.transpose
From: Raffael Cavallaro on 3 Jul 2010 13:30
On 2010-07-03 09:23:30 -0700, w_a_x_man said:

> Array.new(1000){[0]*1000}.transpose

Troll.sameOld(waxMan).goAway


--
Raffael Cavallaro

First  |  Prev  | 
Pages: 1 2 3 4
Prev: Algebra Rizing
Next: GNU Emacs and Xemacs Schism