Print Page - nxn matrices

Title: nxn matrices - challenge
Post by: ribarm on November 11, 2013, 01:30:14 PM

I never had some math books ab matrices, so my research is totally unknown...

With this my examples, I realized that I can't get correct m/m if determinant is 0.0... Beside that, maybe I am wrong and maybe there is more elegant and efficient way to accomplish this task and what is more important my version isn't correct... It may give correct result in random cases but with this case I am pretty stuck... If I multiply 2 matrices and get their product, when I try to divide product with one of these 2 matrix I get wrong or error result (divide by zero)... Can someone reply with right direction?

Code - Auto/Visual Lisp: [Select]

;;;***********************************************************************************;;;
;;; (detm m) function calculates determinant of square martix                         ;;;
;;; Marko Ribar, d.i.a.                                                               ;;;
;;; Args: m - nxn matrix                                                              ;;;
;;; (detm '((0 1) (1 0)))                                                             ;;;
;;; (detm '((1.4 2.1 5.4 6.5) (4.1 9.3 4.5 8.5) (1.2 4.1 6.2 7.5) (4.7 8.5 9.3 0.1))) ;;;
;;;***********************************************************************************;;;
(defun detm ( m / d i j r )
 
  (defun d ( k n / z )
    (setq k (cdr k))
    (setq k (apply 'mapcar (cons 'list k)))
    (setq z -1)
    (while (<= (setq z (1+ z)) (length k))
      (if (eq z n)
        (setq k (cdr k))
        (setq k (reverse (cons (car k) (reverse (cdr k)))))
      )
    )
    (setq k (apply 'mapcar (cons 'list k)))
    (if (= (length k) 1) (caar k) k)
  )
 
  (if (not (eq (length m) 1))
    (progn
      (setq i -1)
      (setq j -1)
      (setq r 0)
      (foreach e (car m)
        (setq i (1+ i))
        (setq j (* j (- 1)))
        (setq r (+ r (* j e (if (listp (d m i)) (detm (d m i)) (d m i)))))
      )
      r
    )
    (caar m)
  )
)
 
;; TRP
;; Transposes a matrix -Doug Wilson-
;;
;; Argument : a matrix
 
(defun trp (m) (apply 'mapcar (cons 'list m)))
 
;; MXV
;; Applies a transformation matrix to a vector -Vladimir Nesterovsky-
;;
;; Arguments : a matrix and a vector
 
(defun mxv (m v)
  (mapcar (function (lambda (r) (apply '+ (mapcar '* r v))))
          m
  )
)
 
;; MXM
;; Multiplies (combinates) two matrices -Vladimir Nesterovsky-
;;
;; Arguments : two matrices
 
(defun mxm (m q)
  (mapcar (function (lambda (r) (mxv (trp q) r))) m)
)
 
;; M/V
;; Applies a transformation matrix to a vector -Marko Ribar-
;;
;; Arguments : a matrix and a vector
 
(defun m/v (m v)
  (mapcar
    (function
      (lambda (r)
        (apply '+
               (mapcar '/ r (mapcar (function (lambda (r) (* -1 r))) v))
        )
      )
    )
    m
  )
)
 
;; M/M
;; Divides two matrices -Marko Ribar-
;;
;; Arguments : two matrices
 
(defun m/m (m q / Dq k j D mj mk)
  (setq Dq (detm (trp q)))
  (setq k -1)
  (repeat (length m)
    (setq k (1+ k))
    (setq j -1)
    (repeat (length (car (trp q)))
      (setq j (1+ j))
      (setq D
             (detm
               (mapcar
                 (function
                   (lambda (x y)
                     (subst x (nth j y) y)
                   )
                 )
                 (nth k m)
                 (trp q)
               )
             )
      )
      (setq mj (cons (/ D Dq) mj))
    )
    (setq mj (reverse mj))
    (setq mk (cons mj mk))
    (setq mj nil)
  )
  (reverse mk)
)
 
(defun c:m1xm2 ()
  (setq mat1 '(
               (10. 20. 30.)
               (40. 50. 60.)
               (70. 80. 90.)
              )
  )
  (setq mat2 '(
               (90. 80. 70.)
               (60. 50. 40.)
               (30. 20. 10.)
              )
  )
  (princ (setq mm (mxm mat1 mat2)))
  (prin1)
)
 
(defun c:mm/m2 ()
  (princ (m/m mm mat2))
  (prin1)
)
 
(defun c:mm/m1 ()
  (princ (m/m mm mat1))
  (prin1)
)
 

M.R.

Title: Re: nxn matrices - challenge
Post by: ribarm on November 11, 2013, 06:34:55 PM

I figured that only with normal multiplications and divisions of matrices, results can be correct in both directions (m/m-n mm mat1) = mat2 and (m/m-n mm mat2) = mat1... With (transposed additional multiplication and division) direction is single : (mxm mat1 mat2) = mm; (m/m mm mat2) = mat1, but (m/m mm mat1) /= mat2...

Beside this with normal multiplication and division of matrices there can't be error (determinant isn't used in calculations, so no divide by zero error)

Code - Auto/Visual Lisp: [Select]

;;;***********************************************************************************;;;
;;; (detm m) function calculates determinant of square martix                         ;;;
;;; Marko Ribar, d.i.a.                                                               ;;;
;;; Args: m - nxn matrix                                                              ;;;
;;; (detm '((0 1) (1 0)))                                                             ;;;
;;; (detm '((1.4 2.1 5.4 6.5) (4.1 9.3 4.5 8.5) (1.2 4.1 6.2 7.5) (4.7 8.5 9.3 0.1))) ;;;
;;;***********************************************************************************;;;
(defun detm ( m / d i j r )
 
  (defun d ( k n / z )
    (setq k (cdr k))
    (setq k (apply 'mapcar (cons 'list k)))
    (setq z -1)
    (while (<= (setq z (1+ z)) (length k))
      (if (eq z n)
        (setq k (cdr k))
        (setq k (reverse (cons (car k) (reverse (cdr k)))))
      )
    )
    (setq k (apply 'mapcar (cons 'list k)))
    (if (= (length k) 1) (caar k) k)
  )
 
  (if (not (eq (length m) 1))
    (progn
      (setq i -1)
      (setq j -1)
      (setq r 0)
      (foreach e (car m)
        (setq i (1+ i))
        (setq j (* j (- 1)))
        (setq r (+ r (* j e (if (listp (d m i)) (detm (d m i)) (d m i)))))
      )
      r
    )
    (caar m)
  )
)
 
;; TRP
;; Transposes a matrix -Doug Wilson-
;;
;; Argument : a matrix
 
(defun trp (m) (apply 'mapcar (cons 'list m)))
 
;; MXV
;; Applies a transformation matrix to a vector -Vladimir Nesterovsky-
;;
;; Arguments : a matrix and a vector
 
(defun mxv (m v)
 (mapcar (function (lambda (r) (apply '+ (mapcar '* r v))))
         m
 )
)
 
;; MXM
;; Multiplies (combinates) two matrices -Vladimir Nesterovsky-
;;
;; Arguments : two matrices
 
(defun mxm (m q)
 (mapcar (function (lambda (r) (mxv (trp q) r))) m)
)
 
;; MXM-N
;; Multiplies two matrices (normal) -Marko Ribar-
;;
;; Arguments : two matrices
 
(defun mxm-n (m q)
 (mapcar (function (lambda (r j) (mapcar (function (lambda (a b) (* a b))) r j))) m q)
)
 
;; M/V
;; Applies a transformation matrix to a vector (inverse signs multiplication) -Marko Ribar-
;;
;; Arguments : a matrix and a vector
 
(defun m/v (m v)
 (mapcar
   (function
     (lambda (r)
       (apply '+
              (mapcar '/ r (mapcar (function (lambda (r) (* -1 r))) v))
       )
     )
   )
   m
 )
)
 
;; V/M
;; Calculates vector of division of vector and matrix -Marko Ribar-
;; (v/m (mxv mat v) mat) = v
;; Arguments : a vector and a matrix
 
(defun v/m (v m / Dm k D mk)
 (setq Dm (detm m))
 (setq k -1)
 (repeat (length v)
   (setq k (1+ k))
   (setq D
          (detm
            (mapcar
              (function
                (lambda (x y)
                  (subst x (nth k y) y)
                )
              )
              v
              m
            )
          )
   )
   (setq mk (cons (/ D Dm) mk))
 )
 (reverse mk)
)
 
;; M/M
;; Divides two matrices -Marko Ribar-
;;
;; Arguments : two matrices
 
(defun m/m (m q / Dq k j D mj mk)
 (setq Dq (detm (trp q)))
 (setq k -1)
 (repeat (length m)
   (setq k (1+ k))
   (setq j -1)
   (repeat (length (car (trp q)))
     (setq j (1+ j))
     (setq D
            (detm
              (mapcar
                (function
                  (lambda (x y)
                    (subst x (nth j y) y)
                  )
                )
                (nth k m)
                (trp q)
              )
            )
     )
     (setq mj (cons (/ D Dq) mj))
   )
   (setq mj (reverse mj))
   (setq mk (cons mj mk))
   (setq mj nil)
 )
 (reverse mk)
)
 
;; M/M-N
;; Divides two matrices (normal) -Marko Ribar-
;;
;; Arguments : two matrices
 
(defun m/m-n (m q)
 (mapcar (function (lambda (r j) (mapcar (function (lambda (a b) (/ a b))) r j))) m q)
)
 
(defun c:m1xm2 ()
 (setq mat1 '(
              (1. 4. 7.)
              (3. 6. 5.)
              (2. 9. 8.)
             )
 )
 (setq mat2 '(
              (1. 5. 6.)
              (3. 2. 8.)
              (9. 7. 4.)
             )
 )
 (princ (setq mm (mxm mat1 mat2)))
 (prin1)
)
 
(defun c:mm/m2 ()
 (princ (m/m mm mat2))
 (prin1)
)
 
(defun c:m1xm2-n ()
 (setq mat1 '(
              (1. 4. 7.)
              (3. 6. 5.)
              (2. 9. 8.)
             )
 )
 (setq mat2 '(
              (1. 5. 6.)
              (3. 2. 8.)
              (9. 7. 4.)
             )
 )
 (princ (setq mm (mxm-n mat1 mat2)))
 (prin1)
)
 
(defun c:mm/m2-n ()
 (princ (m/m-n mm mat2))
 (prin1)
)
 
(defun c:mm/m1-n ()
 (princ (m/m-n mm mat1))
 (prin1)
)
 

M.R.

Title: Re: nxn matrices - challenge
Post by: ribarm on November 12, 2013, 09:07:41 AM

I've added function :

Code - Auto/Visual Lisp: [Select]

;; V/M
;; Calculates vector of division of vector and matrix -Marko Ribar-
;; (v/m (mxv mat v) mat) = v
;; Arguments : a vector and a matrix
 

M.R.

Title: Re: nxn matrices - challenge
Post by: Stefan on November 12, 2013, 11:24:09 AM

Hi Marko

Just a remark: (detm '((0 1) (1 0))) = 0 but it should be -1.

Try one of this http://www.theswamp.org/index.php?topic=30944.0 (http://www.theswamp.org/index.php?topic=30944.0)

Title: Re: nxn matrices - challenge
Post by: Lee Mac on November 12, 2013, 11:53:28 AM

Here is an updated version of my code in that thread:

Code - Auto/Visual Lisp: [Select]

;; Matrix Determinant  -  Lee Mac
;; Args: m - nxn matrix
 
(defun detm ( m / i j )
    (setq i -1 j 0)
    (cond
        (   (null (cdr  m)) (caar m))
        (   (null (cddr m)) (- (* (caar m) (cadadr m)) (* (cadar m) (caadr m))))
        (   (apply '+
                (mapcar
                   '(lambda ( c ) (setq j (1+ j))
                        (* c (setq i (- i))
                            (detm
                                (mapcar
                                   '(lambda ( x / k )
                                        (setq k 0)
                                        (vl-remove-if '(lambda ( y ) (= j (setq k (1+ k)))) x)
                                    )
                                    (cdr m)
                                )
                            )
                        )
                    )
                    (car m)
                )
            )
        )
    )
)

Code - Auto/Visual Lisp: [Select]

_$ (detm '((0 1) (1 0)))
-1
_$ (detm '((1.4 2.1 5.4 6.5) (4.1 9.3 4.5 8.5) (1.2 4.1 6.2 7.5) (4.7 8.5 9.3 0.1)))
-577.975

( Verification of last example ) (http://www.wolframalpha.com/input/?i=det+{{1.4%2C2.1%2C5.4%2C6.5}%2C{4.1%2C9.3%2C4.5%2C8.5}%2C{1.2%2C4.1%2C6.2%2C7.5}%2C{4.7%2C8.5%2C9.3%2C0.1}})

Title: Re: nxn matrices - challenge
Post by: ElpanovEvgeniy on November 13, 2013, 02:26:24 AM

my new version

Code - Auto/Visual Lisp: [Select]

(defun detm (m / d)
  ;; Matrix Determinant  -  ElpanovEvgeniy
  ;; Last edit 2013.11.13
  ;; Args: m - nxn matrix
  ;; (detm '((0 1) (1 0)))
  ;; (detm '((1.4 2.1 5.4 6.5) (4.1 9.3 4.5 8.5) (1.2 4.1 6.2 7.5) (4.7 8.5 9.3 0.1)))
  (cond ((null m) 1)
        ((and (zerop (caar m))
              (setq d (car (vl-member-if-not (function (lambda (a) (zerop (car a)))) (cdr m))))
         )
         (detm (cons (mapcar (function +) (car m) d) (cdr m)))
        )
        ((zerop (caar m)) 0)
        ((* (caar m)
            (detm (mapcar (function (lambda (a / d)
                                      (setq d (/ (car a) (float (caar m))))
                                      (mapcar (function (lambda (b c) (- b (* c d)))) (cdr a) (cdar m))
                                    )
                          )
                          (cdr m)
                  )
            )
         )
        )
  )
)

Title: Re: nxn matrices - challenge
Post by: Lee Mac on November 13, 2013, 04:57:29 PM

Bravo Evgeniy :kewl:

Your code using LU decomposition is far more efficient than my implementation of Laplace's formula :-)

Title: Re: nxn matrices - challenge
Post by: ymg on November 14, 2013, 01:32:01 AM

Great!

When you got a need for speed you can always rely on Evgeniy

ymg

Title: Re: nxn matrices - challenge
Post by: ElpanovEvgeniy on November 14, 2013, 02:46:40 AM

Quote from: Lee Mac on November 13, 2013, 04:57:29 PM

Bravo Evgeniy :kewl:

Your code using LU decomposition is far more efficient than my implementation of Laplace's formula :-)

Quote from: ymg on November 14, 2013, 01:32:01 AM

Great!

When you got a need for speed you can always rely on Evgeniy

ymg

Yes, I'm doing upper triangular matrix and multiplies the diagonal.

Thanks! :-)

Title: Re: nxn matrices - challenge
Post by: ribarm on May 25, 2014, 05:03:18 AM

Here is my version, also uses Laplace's method... Don't know if it's usable, but it works... Efficiency was not my issue for this one...

Code - Auto/Visual Lisp: [Select]

;;;***********************************************************************************;;;
;;; (detm m) function calculates determinant of square martix                         ;;;
;;; Marko Ribar, d.i.a.                                                               ;;;
;;; Args: m - nxn matrix                                                              ;;;
;;; (detm '((0 1) (1 0)))                                                             ;;;
;;; (detm '((1.4 2.1 5.4 6.5) (4.1 9.3 4.5 8.5) (1.2 4.1 6.2 7.5) (4.7 8.5 9.3 0.1))) ;;;
;;;***********************************************************************************;;;
(defun detm ( m / d i j r )
 
  (defun d ( k n / z )
    (setq k (cdr k))
    (setq k (apply 'mapcar (cons 'list k)))
    (setq z -1)
    (while (<= (setq z (1+ z)) (length k))
      (if (eq z n)
        (setq k (cdr k))
        (setq k (reverse (cons (car k) (reverse (cdr k)))))
      )
    )
    (setq k (apply 'mapcar (cons 'list k)))
    (if (= (length k) 1) (caar k) k)
  )
 
  (if (not (eq (length m) 1))
    (progn
      (setq i -1)
      (setq j -1)
      (setq r 0)
      (foreach e (car m)
        (setq i (1+ i))
        (setq j (* j (- 1)))
        (setq r (+ r (* j e (if (listp (d m i)) (detm (d m i)) (d m i)))))
      )
      r
    )
    (caar m)
  )
)
 

Title: Re: nxn matrices - challenge
Post by: chlh_jd on May 25, 2014, 07:09:06 AM

Quote from: ymg on November 14, 2013, 01:32:01 AM

Great!

When you got a need for speed you can always rely on Evgeniy

ymg

1+

Hi, Ribarm, why don't you use this method to do "m/m" ----> A / B = A* [inverse B] ,
if the Det of Matrix B is zero , it has no inverse matrix , but has a generalized inverse matrix or Moore-Penrose inverse matrix .

Title: Re: nxn matrices - challenge
Post by: ribarm on June 13, 2015, 12:14:09 PM

Quote from: chlh_jd on May 25, 2014, 07:09:06 AM

Hi, Ribarm, why don't you use this method to do "m/m" ----> A / B = A* [inverse B] ,
if the Det of Matrix B is zero , it has no inverse matrix , but has a generalized inverse matrix or Moore-Penrose inverse matrix .

Code - Auto/Visual Lisp: [Select]

;;;***********************************************************************************;;;
;;; (detm m) function calculates determinant of square martix                         ;;;
;;; Marko Ribar, d.i.a.                                                               ;;;
;;; Args: m - nxn matrix                                                              ;;;
;;; (detm '((0 1) (1 0)))                                                             ;;;
;;; (detm '((1.4 2.1 5.4 6.5) (4.1 9.3 4.5 8.5) (1.2 4.1 6.2 7.5) (4.7 8.5 9.3 0.1))) ;;;
;;;***********************************************************************************;;;
(defun detm ( m / d i j r )
 
  (defun d ( k n / z )
    (setq k (cdr k))
    (setq k (apply 'mapcar (cons 'list k)))
    (setq z -1)
    (while (<= (setq z (1+ z)) (length k))
      (if (eq z n)
        (setq k (cdr k))
        (setq k (reverse (cons (car k) (reverse (cdr k)))))
      )
    )
    (setq k (apply 'mapcar (cons 'list k)))
    (if (= (length k) 1) (caar k) k)
  )
 
  (if (not (eq (length m) 1))
    (progn
      (setq i -1)
      (setq j -1)
      (setq r 0)
      (foreach e (car m)
        (setq i (1+ i))
        (setq j (* j (- 1)))
        (setq r (+ r (* j e (if (listp (d m i)) (detm (d m i)) (d m i)))))
      )
      r
    )
    (caar m)
  )
)
 
;;;***********************************************************************************;;;
;;; (mmin m) function calculates matrix of minors of square martix                    ;;;
;;; Marko Ribar, d.i.a.                                                               ;;;
;;; Args: m - nxn matrix                                                              ;;;
;;; (mmin '((0 1) (1 0)))                                                             ;;;
;;; (mmin '((1.4 2.1 5.4 6.5) (4.1 9.3 4.5 8.5) (1.2 4.1 6.2 7.5) (4.7 8.5 9.3 0.1))) ;;;
;;;***********************************************************************************;;;
(defun mmin ( m / i j r rr )
 
  (defun dd ( r c m )
    (setq m (vl-remove (nth r m) m))
    (setq m (apply 'mapcar (cons 'list m)))
    (setq m (vl-remove (nth c m) m))
    (setq m (apply 'mapcar (cons 'list m)))
    (detm m)
  )
 
  (setq i -1)
  (mapcar '(lambda ( x ) 
    (setq j -1)
    (mapcar '(lambda ( y )
      (setq r (cons (dd (1+ i) (setq j (1+ j)) m) r))) x
    )
    (setq i (1+ i))
    (setq r (reverse r))
    (setq rr (cons r rr))
    (setq r nil)
    ) m
  )
  (reverse rr)
)
 
;;;***********************************************************************************;;;
;;; (cofm m) function calculates cofactor matrix of square martix                     ;;;
;;; Marko Ribar, d.i.a.                                                               ;;;
;;; Args: m - nxn matrix                                                              ;;;
;;; (cofm '((0 1) (1 0)))                                                             ;;;
;;; (cofm '((1.4 2.1 5.4 6.5) (4.1 9.3 4.5 8.5) (1.2 4.1 6.2 7.5) (4.7 8.5 9.3 0.1))) ;;;
;;;***********************************************************************************;;;
(defun cofm ( m / i j r rr )
 
  (setq i -1)
  (mapcar '(lambda ( x )
    (setq j -1)
    (mapcar '(lambda ( y )
      (setq r (cons (if (equal (rem (float (+ (1+ i) (setq j (1+ j)))) 2.0) 1.0) (- y) y) r))) x
    )
    (setq i (1+ i))
    (setq r (reverse r))
    (setq rr (cons r rr))
    (setq r nil)
    ) m
  )
  (reverse rr)
)
 
;;;***********************************************************************************;;;
;;; (adjm m) function calculates adjugate matrix of square martix                     ;;;
;;; Marko Ribar, d.i.a.                                                               ;;;
;;; Args: m - nxn matrix                                                              ;;;
;;; (adjm '((0 1) (1 0)))                                                             ;;;
;;; (adjm '((1.4 2.1 5.4 6.5) (4.1 9.3 4.5 8.5) (1.2 4.1 6.2 7.5) (4.7 8.5 9.3 0.1))) ;;;
;;;***********************************************************************************;;;
(defun adjm ( m )
  (apply 'mapcar (cons 'list m))
)
 
;;;***********************************************************************************;;;
;;; (invm m) function calculates inverse matrix of square martix                      ;;;
;;; or returns nil if matrix is singular                                              ;;;
;;; Marko Ribar, d.i.a.                                                               ;;;
;;; Args: m - nxn matrix                                                              ;;;
;;; (invm '((0 1) (1 0)))                                                             ;;;
;;; (invm '((1.4 2.1 5.4 6.5) (4.1 9.3 4.5 8.5) (1.2 4.1 6.2 7.5) (4.7 8.5 9.3 0.1))) ;;;
;;;***********************************************************************************;;;
(defun invm ( m / k i j r rr )
 
  (if (and (listp m) (vl-every '(lambda ( x ) (eq (length x) (length m))) m) (/= (detm m) 0.0))
    (progn
      (setq k (/ 1.0 (detm m)))
      (setq i -1)
      (mapcar '(lambda ( x )
        (setq j -1)
        (mapcar '(lambda ( y )
          (setq r (cons (* k y) r))) x
        )
        (setq i (1+ i))
        (setq r (reverse r))
        (setq rr (cons r rr))
        (setq r nil)
        ) (adjm (cofm (mmin m)))
      )
      (reverse rr)
    )
    (if (not (listp m))
      (prompt "\nSupplied argument isn't matrix list")
      (if (not (vl-every '(lambda ( x ) (eq (length x) (length m))) m))
        (prompt "\nSupplied argument list isn't square matrix")
        nil
      )
    )
  )
)
 

What should I do?

Title: Re: nxn matrices - challenge
Post by: ribarm on December 18, 2019, 06:28:30 PM

I've just updated my version to be applicable and for complex numbers...

Code - Auto/Visual Lisp: [Select]

;;;***********************************************************************************;;;
;;; (detm m) function calculates determinant of square martix                         ;;;
;;; this version includes complex numbers                                             ;;;
;;; Marko Ribar, d.i.a.                                                               ;;;
;;; Args: m - nxn matrix of complex numbers                                           ;;;
;;; (detm '(((0 0) (1 0)) ((1 0) (0 0))))                                             ;;;
;;; (detm '(((1.4 0) (2.1 0) (5.4 0) (6.5 0)) ((4.1 0) (9.3 0) (4.5 0) (8.5 0)) ((1.2 0) (4.1 0) (6.2 0) (7.5 0)) ((4.7 0) (8.5 0) (9.3 0) (0.1 0))))                                                                                 ;;;
;;;***********************************************************************************;;;
 
;;; Command: (detm '(((1.2 1.0) (2.4 1.3) (0.5 0.6)) ((1.3 1.25) (1.5 2.0) (0.8 -1.4)) ((-2.3 -1.4) (0.6 -0.6) (-0.3 -0.3))))
;;; (-15.3785 7.4325)
 
;;; det = (1.2 + 1.0i)(1.5 + 2.0i)(-0.3 - 0.3i)+(2.4 + 1.3i)(0.8 - 1.4i)(-2.3 - 1.4i)+(0.5 + 0.6i)(1.3 + 1.25i)(0.6 - 0.6i)-(-2.3 - 1.4i)(1.5 + 2.0i)(0.5 + 0.6i)-(0.6 - 0.6i)(0.8 - 1.4i)(1.2 + 1.0i)-(-0.3 - 0.3i)(1.3 + 1.25i)(2.4 + 1.3i)
;;; det = (1.8 + 2.4i + 1.5i - 2)(-0.3 - 0.3i)+(1.92 - 3.36i + 1.04i + 1.82)(-2.3 - 1.4i)+(0.65 + 0.625i + 0.78i - 0.75)(0.6 - 0.6i)-(-3.45 - 4.6i - 2.1i + 2.8)(0.5 + 0.6i)-(0.48 - 0.84i - 0.48i - 0.84)(1.2 + 1.0i)-(-0.39 - 0.375i - 0.39i + 0.375)(2.4 + 1.3i)
;;; det = (-0.2 + 3.9i)(-0.3 - 0.3i)+(3.74 - 2.32i)(-2.3 - 1.4i)+(-0.1 + 1.405i)(0.6 - 0.6i)-(-0.65 - 6.7i)(0.5 + 0.6i)-(-0.36 - 1.32i)(1.2 + 1.0i)-(-0.015 - 0.765i)(2.4 + 1.3i)
;;; det = 0.06 + 0.06i - 1.17i + 1.17 - 8.602 - 5.236i + 5.336i - 3.248 - 0.06 + 0.06i + 0.843i + 0.843 + 0.325 + 0.39i + 3.35i - 4.02 + 0.432 + 0.36i + 1.584i - 1.32 + 0.036 + 0.0195i + 1.836i - 0.9945
;;; det = -15.3785 + 7.4325i
 
(defun detm ( m / d cxc det )
 
  (defun d ( k n / z )
    (setq k (cdr k))
    (setq k (apply 'mapcar (cons 'list k)))
    (setq z -1)
    (while (<= (setq z (1+ z)) (length k))
      (if (= z n)
        (setq k (cdr k))
        (setq k (reverse (cons (car k) (reverse (cdr k)))))
      )
    )
    (setq k (apply 'mapcar (cons 'list k)))
    (if (= (length k) 1) (caar k) k)
  )
 
  (defun cxc ( c1 c2 / a1 a2 b1 b2 r i )
    (setq a1 (car c1) b1 (cadr c1))
    (setq a2 (car c2) b2 (cadr c2))
    (setq r (- (* a1 a2) (* b1 b2)))
    (setq i (+ (* a1 b2) (* a2 b1)))
    (list r i)
  )
 
  (defun det ( q / i j r )
    (if (not (vl-every 'numberp q))
      (progn
        (setq i -1)
        (setq j -1)
        (setq r (list 0 0))
        (foreach e (car q)
          (setq i (1+ i))
          (setq j (* j (- 1)))
          (setq r (mapcar '+ r (cxc (mapcar '* (list j j) e) (det (d q i)))))
        )
        r
      )
      q
    )
  )
 
  (det m)
)
 

Maybe now there will be more deeper attempt to final solution of eigenvalues and eigenvectors problem, as eigenvalues can be also real and also complex numbers...

Title: Re: nxn matrices - challenge
Post by: dgpuertas on December 23, 2019, 07:43:40 AM

Following the reasoning of ribarm, and with this post of Matlab I have managed to reverse a matrix of complex numbers
I hope it is useful
https://es.mathworks.com/matlabcentral/fileexchange/49373-complex-matrix-inversion-by-real-matrix-inversion (https://es.mathworks.com/matlabcentral/fileexchange/49373-complex-matrix-inversion-by-real-matrix-inversion)

Code: [Select]

(defun invmcomplex (mat / a b r i)
  (setq a (mapcar (function (lambda (v) (mapcar (function car) v))) mat)
	b (mapcar (function (lambda (v) (mapcar (function cadr) v))) mat)
	r (invm (m+m a (mxm (mxm b (invm a)) b)))
	i (invm (m+m b (mxm (mxm a (invm b)) a)))
	)
  
  (mapcar (function (lambda (a b) (mapcar (function (lambda (c d) (list c (- d)))) a b))) r i)
)

With

Code: [Select]

;; Matrix Inverse  -  gile & Lee Mac
;; Uses Gauss-Jordan Elimination to return the inverse of a non-singular nxn matrix.
;; Args: m - nxn matrix

(defun invm ( m / c f p r)
    
    (defun f ( p m )
        (mapcar (function (lambda ( x ) (mapcar (function (lambda ( a b ) (- a (* (car x) b)))) (cdr x) p))) m)
    )
    (setq  m (mapcar (function append) m (imat (length m))))
    (while m
        (setq c (mapcar (function (lambda (x) (abs (car x)))) m))
        (repeat (vl-position (apply (function max) c) c)
            (setq m (append (cdr m) (list (car m))))
        )
        (if (equal 0.0 (caar m) 1e-14)
            (setq m nil
                  r nil
            )
            (setq p (mapcar (function (lambda (x) (/ (float x) (caar m)))) (cdar m))
                  m (f p (cdr m))
                  r (cons p (f p r))
            )
        )
    )
    (reverse r)
)



 (defun mxm ( m n )
    ((lambda ( a ) (mapcar '(lambda ( r ) (mxv a r)) m)) (transpose n))
)


;; Matrix + Matrix - Lee Mac
;; Args: m,n - nxn matrices

(defun m+m (m n)
  (mapcar (function (lambda ( r s ) (mapcar (function +) r s))) m n)
)

Title: Re: nxn matrices - challenge
Post by: mailmaverick on February 19, 2020, 11:59:33 PM

Another easy way is to open a new excel workbook through AutoLISP, write your matrix in Excel, Use Inbuilt Matrix functions of Excel, get the result, Close the Excel workbook and switch back to your LISP with the result in your hand.
Note : Excel matrix functions would be much faster for big matrices.

TheSwamp

Code Red => AutoLISP (Vanilla / Visual) => Topic started by: ribarm on November 11, 2013, 01:30:14 PM