bendudson / array-operations Goto Github PK

This is my output from a fresh install of quicklisp when I try to quickload :array-operations as of today.

• (ql:quickload :array-operations)
  To load "array-operations":
  Load 1 ASDF system:
  asdf
  Install 4 Quicklisp releases:
  alexandria anaphora array-operations let-plus
  ; Fetching #<URL "http://beta.quicklisp.org/archive/anaphora/2018-02-28/anaphora-20180228-git.tgz">
  ; 6.01KB
  ==================================================
  6,151 bytes in 0.00 seconds (0.00KB/sec)
  ; Fetching #<URL "http://beta.quicklisp.org/archive/alexandria/2018-12-10/alexandria-20181210-git.tgz">
  ; 50.00KB
  ==================================================
  51,197 bytes in 0.00 seconds (49997.07KB/sec)
  ; Fetching #<URL "http://beta.quicklisp.org/archive/let-plus/2017-11-30/let-plus-20171130-git.tgz">
  ; 10.87KB
  ==================================================
  11,126 bytes in 0.00 seconds (0.00KB/sec)
  ; Fetching #<URL "http://beta.quicklisp.org/archive/array-operations/2019-05-21/array-operations-20190521-git.tgz">
  ; 25.65KB
  ==================================================
  26,268 bytes in 0.00 seconds (0.00KB/sec)
  ; Loading "array-operations"

debugger invoked on a QUICKLISP-CLIENT:SYSTEM-NOT-FOUND in thread
#<THREAD "main thread" RUNNING {100399C633}>:
System "array-operations/all" not found

I'm making a lot of use of array-operations, and polished the documentation a bit. If this is useful, I can submit a pull request whenever I improve it.

There's a note in all.lisp:

;; Note: array-operations/utilities not exported for external use.

Is there any kind of operator that I can use to destructively/nondestructively "rotate" a 2D array by 90/180/270 degrees? If not, would it be permissible to add one?

Example behavior that I am thinking of:

;; 90 degrees
#2A((1 0 0)    #2A((3 2 1)
    (2 0 0)  →     (0 0 0)
    (3 0 0))       (0 0 0))

;; 180 degrees
#2A((1 0 0)    #2A((0 0 3)
    (2 0 0)  →     (0 0 2)
    (3 0 0))       (0 0 1))

;; 270 degrees
#2A((1 0 0)    #2A((0 0 0)
    (2 0 0)  →     (0 0 0)
    (3 0 0))       (1 2 3))