matlisp-users — General discussion list.

Re: [Matlisp-users] No Invert Functions?

[Raymond T. <to...@rt...>]

>>>>> "Nicolas" == Nicolas Neuss <Nic...@iw...> writes:

    Nicolas> Joseph Dale <jd...@uc...> writes:
    >> Hi,
    >> 
    >> I've just installed matlisp from the latest CVS at sourceforge. From 
    >> looking at the online help and reading some of the source, it looks to 
    >> me like none of the wrappers around matrix inversion functions (for 
    >> example, DGETRI and ZGETRI in LAPACK) have been implemented. Is there 
    >> any particular reason for this omission, or is it just lack of time? Or 
    >> am I totally missing something?
    >> 
    >> If there are no technical barriers to implementing these functions, and 
    >> no one else is already working on it, I'd be happy to have a go at it. 
    >> Let me know.
    >> 
    >> Thanks,
    >> 
    >> Joe

    Nicolas> A related thing: I have recently implemented wrappers for
    Nicolas> dgetrs/zgetrs.  Are the maintainers interested in that change?  It
    Nicolas> involves changes in getrf.lisp, lapack.lisp, packages.lisp and
    Nicolas> system.dcl, as well as a new file getrs.lisp.  If yes, in which form
    Nicolas> do you want the contribution?

A unified diff would be just fine.  If not, just send the wrappers and
I can figure out how to change the rest.

You can send the stuff to this list, if you like.

Ray

Re: [Matlisp-users] No Invert Functions?

[Raymond T. <to...@rt...>]

>>>>> "Joseph" == Joseph Dale <jd...@uc...> writes:

    Joseph> Hi,

    Joseph> I've just installed matlisp from the latest CVS at sourceforge. From
    Joseph> looking at the online help and reading some of the source, it looks to
    Joseph> me like none of the wrappers around matrix inversion functions (for
    Joseph> example, DGETRI and ZGETRI in LAPACK) have been implemented. Is there
    Joseph> any particular reason for this omission, or is it just lack of time? 
    Joseph> Or am I totally missing something?

Either a lack of time or no one had a need for it.

    Joseph> If there are no technical barriers to implementing these functions,
    Joseph> and no one else is already working on it, I'd be happy to have a go at
    Joseph> it. Let me know.

Just send a patch to the list here and it will get incorporated.  If
you could provide a simple test case for it, that would be great too!

Ray

Re: [Matlisp-users] matlisp/debian/cmucl-problem

[Raymond T. <to...@rt...>]

>>>>> "Pontus" == Pontus Svenson <pon...@fo...> writes:

    Pontus> I have a problem compiling matlisp for cmucl on a machine running
    Pontus> Debian. I can't

    Pontus> get any functions in matlisp to work, even though I can define matrices, ie:

    Pontus> **************************************************************
    Pontus> * (setf a [1 2])
    Pontus> Warning:  Declaring A special.
    Pontus>  #<MATLISP:REAL-MATRIX  1 x 2

    Pontus>     1.0000      2.0000     >
    Pontus> * (m+ a a)
    Pontus>  Warning: This function is undefined:

    Pontus>   M+
    Pontus>  Error in KERNEL:%COERCE-TO-FUNCTION:  the function M+ is undefined.

What package are you in?  Do you do a (in-package :matlisp-user) or
(use-package :matlisp) as suggested by the start up message?

Ray

Re: [Matlisp-users] No Invert Functions?

[Nicolas N. <Nic...@iw...>]

I forgot:

cvs diff lapack.lisp
Index: lapack.lisp
===================================================================
RCS file: /cvsroot/matlisp/matlisp/src/lapack.lisp,v
retrieving revision 1.6
diff -r1.6 lapack.lisp
68,69c68,69
< "DGESV" "DGEEV" "DGETRF" "DGESVD"
< "ZGESV" "ZGEEV" "ZGETRF" "ZGESVD" ))
---
> "DGESV" "DGEEV" "DGETRF" "DGETRS" "DGESVD"
> "ZGESV" "ZGEEV" "ZGETRF" "ZGETRS" "ZGESVD" ))
321a322,386
> (def-fortran-routine dgetrs :void
> "
>    -- LAPACK routine (version 3.0) --
>       Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
>       Courant Institute, Argonne National Lab, and Rice University
>       March 31, 1993
> 
>    Purpose
>    =======
> 
>    DGETRS solves a system of linear equations
>       A * X = B  or  A' * X = B
>    with a general N-by-N matrix A using the LU factorization computed
>    by DGETRF.
> 
>    Arguments
>    =========
> 
>    TRANS   (input) CHARACTER*1
>            Specifies the form of the system of equations:
>            = 'N':  A * X = B  (No transpose)
>            = 'T':  A'* X = B  (Transpose)
>            = 'C':  A'* X = B  (Conjugate transpose = Transpose)
> 
>    N       (input) INTEGER
>            The order of the matrix A.  N >= 0.
> 
>    NRHS    (input) INTEGER
>            The number of right hand sides, i.e., the number of columns
>            of the matrix B.  NRHS >= 0.
> 
>    A       (input) DOUBLE PRECISION array, dimension (LDA,N)
>            The factors L and U from the factorization A = P*L*U
>            as computed by DGETRF.
> 
>    LDA     (input) INTEGER
>            The leading dimension of the array A.  LDA >= max(1,N).
> 
>    IPIV    (input) INTEGER array, dimension (N)
>            The pivot indices from DGETRF; for 1<=i<=N, row i of the
>            matrix was interchanged with row IPIV(i).
> 
>    B       (input/output) DOUBLE PRECISION array, dimension (LDB,NRHS)
>            On entry, the right hand side matrix B.
>            On exit, the solution matrix X.
> 
>    LDB     (input) INTEGER
>            The leading dimension of the array B.  LDB >= max(1,N).
> 
>    INFO    (output) INTEGER
>            = 0:  successful exit
>            < 0:  if INFO = -i, the i-th argument had an illegal value
> 
> "
>   (trans :string :input)
>   (n :integer :input)
>   (nhrs :integer :input)
>   (a (* :double-float) :input)
>   (lda :integer :input)
>   (ipiv (* :integer) :input)
>   (b (* :double-float) :input-output)
>   (ldb :integer :input)
>   (info :integer :output)
> )
> 
694a760,823
>   (info :integer :output)
> )
> 
> (def-fortran-routine zgetrs :void
> "
>    -- LAPACK routine (version 3.0) --
>       Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
>       Courant Institute, Argonne National Lab, and Rice University
>       September 30, 1994
>  
>    Purpose
>    =======
>  
>    ZGETRS solves a system of linear equations
>       A * X = B,  A**T * X = B,  or  A**H * X = B
>    with a general N-by-N matrix A using the LU factorization computed
>    by ZGETRF.
>  
>    Arguments
>    =========
>  
>    TRANS   (input) CHARACTER*1
>            Specifies the form of the system of equations:
>            = 'N':  A * X = B     (No transpose)
>            = 'T':  A**T * X = B  (Transpose)
>            = 'C':  A**H * X = B  (Conjugate transpose)
>  
>    N       (input) INTEGER
>            The order of the matrix A.  N >= 0.
>  
>    NRHS    (input) INTEGER
>            The number of right hand sides, i.e., the number of columns
>            of the matrix B.  NRHS >= 0.
>  
>    A       (input) COMPLEX*16 array, dimension (LDA,N)
>            The factors L and U from the factorization A = P*L*U
>            as computed by ZGETRF.
>  
>    LDA     (input) INTEGER
>            The leading dimension of the array A.  LDA >= max(1,N).
>  
>    IPIV    (input) INTEGER array, dimension (N)
>            The pivot indices from ZGETRF; for 1<=i<=N, row i of the
>            matrix was interchanged with row IPIV(i).
>  
>    B       (input/output) COMPLEX*16 array, dimension (LDB,NRHS)
>            On entry, the right hand side matrix B.
>            On exit, the solution matrix X.
>  
>    LDB     (input) INTEGER
>            The leading dimension of the array B.  LDB >= max(1,N).
>  
>    INFO    (output) INTEGER
>            = 0:  successful exit
>            < 0:  if INFO = -i, the i-th argument had an illegal value
> "
>   (trans :string :input)
>   (n :integer :input)
>   (nhrs :integer :input)
>   (a (* :complex-double-float) :input)
>   (lda :integer :input)
>   (ipiv (* :integer) :input)
>   (ldb :integer :input)
>   (b (* :complex-double-float) :input-output)

Re: [Matlisp-users] No Invert Functions?

[Nicolas N. <Nic...@iw...>]

Nicolas Neuss <Nic...@iw...> writes:

> The problem with using only GESV and M/ is that it computes an LU
> decomposition (which is the major O(N^3) part of the work).

This is written badly.  The problem is that this decomposition cannot
be used again without GETRS.

>  To use it again (e.g. in a time-stepping scheme) you need GETRS.
> 
> Nicolas.

Re: [Matlisp-users] No Invert Functions?

[Michael A. K. <ma...@ll...>]

> The problem with using only GESV and M/ is that it computes an LU
> decomposition (which is the major O(N^3) part of the work).  To use it
> again (e.g. in a time-stepping scheme) you need GETRS.
> 
Nicolas,

1.  I have no argument with this...I do have argument with implying that
    MATLISP does _not_ now use LU decomposition to compute inverses.

mike

Re: [Matlisp-users] No Invert Functions?

[Nicolas N. <Nic...@iw...>]

"Michael A. Koerber" <ma...@ll...> writes:

> Nicolas,
> 
> 1.  (M/ A) eventually calls (GESV A I), where I is the identity
>     matrix, which intern calls the FORTRAN ?GESV which performs the LU
>     decomposition on the system of equations [A I] to form the inverse
>     of A.
> 
> 2.  Your statement concerning inverses is correct...and it is correctly 
>     implimented in MATLISP.
> 
> > The point is that computing the inverse is often not recommended
> > because of numerical stability.  Usually one uses the LU decomposition
> > directly which is done by the getrf/getrs-pair.  Of course, if you
> > only need to apply the inverse once you could be satisfied with m/.
> > 


The problem with using only GESV and M/ is that it computes an LU
decomposition (which is the major O(N^3) part of the work).  To use it
again (e.g. in a time-stepping scheme) you need GETRS.

Nicolas.

Re: [Matlisp-users] No Invert Functions?

[Michael A. K. <ma...@ll...>]

Nicolas,

1.  (M/ A) eventually calls (GESV A I), where I is the identity
    matrix, which intern calls the FORTRAN ?GESV which performs the LU
    decomposition on the system of equations [A I] to form the inverse
    of A.

2.  Your statement concerning inverses is correct...and it is correctly 
    implimented in MATLISP.

> The point is that computing the inverse is often not recommended
> because of numerical stability.  Usually one uses the LU decomposition
> directly which is done by the getrf/getrs-pair.  Of course, if you
> only need to apply the inverse once you could be satisfied with m/.
> 


mike
**************************************************
Dr Michael A. Koerber    	Micro$oft Free Zone
MIT/Lincoln Laboratory	 	

Re: [Matlisp-users] No Invert Functions?

[Nicolas N. <Nic...@iw...>]

Tunc Simsek <si...@ee...> writes:

> Hello; I can put the getrs stuff in the repository for you.
> It looks like you've got the code in the Matlisp style
> already so it should be straightforward.  I will need to know
> which functions are exported.  These functions should have
> doc strings.
> 
> I looked up getrs and it seems that it does basically m/ 
> but more explicitly.  That is, it keeps the residuals of the
> LU factorization.  Is there more to it?
> 
> Best, Tunc

The point is that computing the inverse is often not recommended
because of numerical stability.  Usually one uses the LU decomposition
directly which is done by the getrf/getrs-pair.  Of course, if you
only need to apply the inverse once you could be satisfied with m/.

Nicolas.


>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Here are the patches (I used "cvs diff", is there a better way with
"cvs rdiff"?).  (I didn't change getrf! in contrast to what I said before.)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

~/CL-HOME/matlisp$ cvs diff system.dcl
Index: system.dcl
===================================================================
RCS file: /cvsroot/matlisp/matlisp/system.dcl,v
retrieving revision 1.19
diff -r1.19 system.dcl
183c183,184
< 		     "getrf"))
---
> 		     "getrf"
> 		     "getrs"))



~/CL-HOME/matlisp$ cvs diff packages.lisp
Index: packages.lisp
===================================================================
RCS file: /cvsroot/matlisp/matlisp/packages.lisp,v
retrieving revision 1.14
diff -r1.14 packages.lisp
118,119c118,119
<    "DGESV" "DGEEV" "DGETRF" "DGESVD"
<    "ZGESV" "ZGEEV" "ZGETRF" "ZGESVD" 
---
>    "DGESV" "DGEEV" "DGETRF" "DGETRS" "DGESVD"
>    "ZGESV" "ZGEEV" "ZGETRF" "ZGETRS" "ZGESVD" 
218a219,220
>      "GETRS!"
>      "GETRS"


And finally src/getrs.lisp:

;;; -*- Mode: lisp; Syntax: ansi-common-lisp; Package: :matlisp; Base: 10 -*-
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Copyright (c) 2000 The Regents of the University of California.
;;; All rights reserved. 
;;; 
;;; Permission is hereby granted, without written agreement and without
;;; license or royalty fees, to use, copy, modify, and distribute this
;;; software and its documentation for any purpose, provided that the
;;; above copyright notice and the following two paragraphs appear in all
;;; copies of this software.
;;; 
;;; IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
;;; FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
;;; ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
;;; THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
;;; SUCH DAMAGE.
;;;
;;; THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
;;; INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
;;; MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
;;; PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
;;; CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
;;; ENHANCEMENTS, OR MODIFICATIONS.
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Written by Nicolas Neuss (analogous to gesv.lisp by R. Toy)
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; $Id:$
;;;
;;; $Log:$
;;; o Initial revision.
;;;
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(in-package "MATLISP")

#+nil (use-package "BLAS")
#+nil (use-package "LAPACK")
#+nil (use-package "FORTRAN-FFI-ACCESSORS")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Generic function definitions
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defgeneric getrs! (a ipiv b &key trans)
  (:documentation
   "
  Syntax
  ======
  (GETRS! a ipiv b [:trans :N])

  Purpose
  =======
  Solves a system of linear equations
      A * X = B  or  A' * X = B
  with a general N-by-N matrix A using the LU factorization computed
  by GETRF.  A and IPIV are the results from GETRF, TRANS specifies
  the form of the system of equations: 
           = 'N':  A * X = B  (No transpose)
           = 'T':  A'* X = B  (Transpose)
           = 'C':  A'* X = B  (Conjugate transpose)

  Return Values
  =============
  [1] The NxM matrix X. (overwriting B)
  [4] INFO = T: successful
             i:  U(i,i) is exactly zero.  The LU factorization
                 used in the computation has been completed, 
                 but the factor U is exactly singular.
                 Solution could not be computed.
"))

(defgeneric getrs (a ipiv b &key trans)
  (:documentation
 "
  Sytnax
  ======
  (GETRS a ipiv b [:trans :N])

  Purpose
  =======
  Same as GETRS! except that B is not overwritten.
"))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Method definitions
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defmethod getrs! :before ((a standard-matrix) ipiv (b standard-matrix) &key trans)
  (declare (ignore trans))
  (let ((n-a (nrows a))
	(m-a (ncols a))
	(n-b (nrows b)))
    (if (not (= n-a m-a n-b))
	(error "Dimensions of A,B given to GETRS! do not match"))
    ;;(check-type ipiv (simple-array (unsigned-byte 32) (*)))
    (if (< (length ipiv) n-a)
	(error "The argument IPIV given to GETRS! must have dimension >= N,
where NxN is the dimension of the argument A given to GETRS!"))))

(defmethod getrs! ((a real-matrix) ipiv (b real-matrix) &key trans)
  (let* ((n (nrows a))
	 (m (ncols b)))

    (declare (type fixnum n m)
	     (type (simple-array (unsigned-byte 32) (*)) ipiv))

    (multiple-value-bind (x info)
	(dgetrs (case trans
		  (:C "C")
		  (:T "T")
		  (t "N"))
		n
		m
		(store a)
		n
		ipiv
		(store b)
		n
		0)
	
	(values 
	 (make-instance 'real-matrix :nrows n :ncols m :store x)
	 (if (zerop info)
	     t
	   info)))))

(defmethod getrs! ((a complex-matrix) ipiv (b complex-matrix) &key trans)

  (let* ((n (nrows a))
	 (m (ncols b)))

    (declare (type fixnum n m)
	     (type (simple-array (unsigned-byte 32) (*)) ipiv))

    (multiple-value-bind (x info)
	(zgetrs (case trans
		  (:C "C")
		  (:T "T")
		  (t "N"))
		n
		m
		(store a)
		n
		ipiv
		(store b)
		n
		0)
	
	(values 
	 (make-instance 'complex-matrix :nrows n :ncols m :store x) 
	 (if (zerop info)
	     t
	   info)))))

(defmethod getrs! ((a standard-matrix) ipiv (b standard-matrix) &key trans)
  (let ((a (typecase a
	     (real-matrix (copy! a (make-complex-matrix-dim (nrows a) (ncols a))))
	     (complex-matrix a)
	     (t (error "argument A given to GETRS! is not a REAL-MATRIX or COMPLEX-MATRIX"))))
	(b (typecase b
	     (real-matrix (copy! b (make-complex-matrix-dim (nrows b) (ncols b))))
	     (complex-matrix b)
	     (t (error "argument B given to GETRS! is not a REAL-MATRIX or COMPLEX-MATRIX")))))
    (getrs! a ipiv b :trans trans)))

(defmethod getrs :before ((a standard-matrix) ipiv (b standard-matrix) &key trans)
  (declare (ignore trans))
  (if (not (= (nrows a) (ncols a) (nrows b) (length ipiv)))
      (error "dimensions of A,B,ipiv given to GETRS do not match")))

(defmethod getrs ((a real-matrix) ipiv (b real-matrix) &key trans)
  (getrs! a ipiv (copy b) :trans trans))

(defmethod getrs ((a complex-matrix) ipiv (b complex-matrix) &key trans)
  (getrs! a ipiv (copy b) :trans trans))

(defmethod getrs ((a standard-matrix) ipiv (b standard-matrix) &key trans)
  (let ((a (typecase a
	     (real-matrix (copy! a (make-complex-matrix-dim (nrows a) (ncols a))))
	     (complex-matrix (copy a))
	     (t (error "argument A given to GETRS is not a REAL-MATRIX or COMPLEX-MATRIX"))))
	(b (typecase b
	     (real-matrix (copy! b (make-complex-matrix-dim (nrows b) (ncols b))))
	     (complex-matrix (copy b))
	     (t (error "argument B given to GETRS is not a REAL-MATRIX or COMPLEX-MATRIX")))))
    (getrs! a ipiv b :trans trans)))

Re: [Matlisp-users] No Invert Functions?

[Joseph D. <jd...@uc...>]

Michael A. Koerber wrote:
>>I've just installed matlisp from the latest CVS at sourceforge. From 
>>looking at the online help and reading some of the source, it looks to 
>>me like none of the wrappers around matrix inversion functions (for 
>>example, DGETRI and ZGETRI in LAPACK) have been implemented. Is there 
>>any particular reason for this omission, or is it just lack of time? Or 
>>am I totally missing something?
> 
> 
> Joe,
> 
>   I don't see such a wrapper either.  However, matrix inversion is
> currently performed with ZGESV by calling the MATLISP function M/ with
> a single argument.  So if you just need the inverse of A use (M/ A).
> Of course, if its ?GETRI specifically, a wrapper will be needed.
> 

Thanks Michael and Tunc,

M/ should be sufficient for me. However, there appears to be a bug/typo 
in the documentation:


* (help m/)

In package MATLISP, the function M/
===================================

   Syntax
   ======
   (M/ a [b])

   Purpose
   =======

   Equivalent to inv(A) * B, but far more efficient and accurate.
   If A is not given, the inverse of B is returned.

   A is an NxN square matrix and B is NxM.

   B may be a scalar in which case M/ is equivalent to M./

   See M/!, M./, M./!, GESV


It seems that the line "If A is not given, the inverse of B is 
returned." should read "If B is not given, the inverse of A is returned."


Joe

Re: [Matlisp-users] No Invert Functions?

[Michael A. K. <ma...@ll...>]

> A related thing: I have recently implemented wrappers for
> dgetrs/zgetrs.  Are the maintainers interested in that change?  It
> involves changes in getrf.lisp, lapack.lisp, packages.lisp and
> system.dcl, as well as a new file getrs.lisp.  If yes, in which form
> do you want the contribution?

I'm just a user, however, I'd be interested in having this as part
of the MATLISP core.

mike
**************************************************
Dr Michael A. Koerber    	Micro$oft Free Zone
MIT/Lincoln Laboratory	 	

Re: [Matlisp-users] No Invert Functions?

[Michael A. K. <ma...@ll...>]

> I've just installed matlisp from the latest CVS at sourceforge. From 
> looking at the online help and reading some of the source, it looks to 
> me like none of the wrappers around matrix inversion functions (for 
> example, DGETRI and ZGETRI in LAPACK) have been implemented. Is there 
> any particular reason for this omission, or is it just lack of time? Or 
> am I totally missing something?

Joe,

  I don't see such a wrapper either.  However, matrix inversion is
currently performed with ZGESV by calling the MATLISP function M/ with
a single argument.  So if you just need the inverse of A use (M/ A).
Of course, if its ?GETRI specifically, a wrapper will be needed.


mike
**************************************************
Dr Michael A. Koerber    	Micro$oft Free Zone
MIT/Lincoln Laboratory	 	

Re: [Matlisp-users] No Invert Functions?

[Nicolas N. <Nic...@iw...>]

Joseph Dale <jd...@uc...> writes:

> Hi,
> 
> I've just installed matlisp from the latest CVS at sourceforge. From 
> looking at the online help and reading some of the source, it looks to 
> me like none of the wrappers around matrix inversion functions (for 
> example, DGETRI and ZGETRI in LAPACK) have been implemented. Is there 
> any particular reason for this omission, or is it just lack of time? Or 
> am I totally missing something?
> 
> If there are no technical barriers to implementing these functions, and 
> no one else is already working on it, I'd be happy to have a go at it. 
> Let me know.
> 
> Thanks,
> 
> Joe

A related thing: I have recently implemented wrappers for
dgetrs/zgetrs.  Are the maintainers interested in that change?  It
involves changes in getrf.lisp, lapack.lisp, packages.lisp and
system.dcl, as well as a new file getrs.lisp.  If yes, in which form
do you want the contribution?


Nicolas.

[Matlisp-users] No Invert Functions?

[Joseph D. <jd...@uc...>]

Hi,

I've just installed matlisp from the latest CVS at sourceforge. From 
looking at the online help and reading some of the source, it looks to 
me like none of the wrappers around matrix inversion functions (for 
example, DGETRI and ZGETRI in LAPACK) have been implemented. Is there 
any particular reason for this omission, or is it just lack of time? Or 
am I totally missing something?

If there are no technical barriers to implementing these functions, and 
no one else is already working on it, I'd be happy to have a go at it. 
Let me know.

Thanks,

Joe

[Matlisp-users] matlisp/debian/cmucl-problem

[Pontus S. <pon...@fo...>]

I have a problem compiling matlisp for cmucl on a machine running 
Debian. I can't
get any functions in matlisp to work, even though I can define matrices, ie:

**************************************************************
* (setf a [1 2])
Warning:  Declaring A special.
 
#<MATLISP:REAL-MATRIX  1 x 2
    1.0000      2.0000     >
* (m+ a a)
 
Warning: This function is undefined:
  M+
 
Error in KERNEL:%COERCE-TO-FUNCTION:  the function M+ is undefined.
 
Restarts:
  0: [ABORT] Return to Top-Level.
 
Debug  (type H for help)
 
(KERNEL:%COERCE-TO-FUNCTION M+)
Source:
; File: target:code/fdefinition.lisp
 
; File has been modified since compilation:
;   target:code/fdefinition.lisp
; Using form offset instead of character position.
(ERROR 'UNDEFINED-FUNCTION :NAME NAME)
0]

**************************************************************

This seems to be very similar to a problem discussed here before, where 
the solution
was to manually edit the f77-mangling.lisp file. The same solution 
doesn't work
in my case, however -- doing so and make'ing gives me this error:


**************************************************************

;; Loading #p"/home/ponsve/linux_matlisp/config.lisp".
 
File: /home/ponsve/linux_matlisp/src/f77-mangling.lisp
 
In: DEFUN MAKE-FORTRAN-NAME
  (IF +F77-UNDERSCORE+ "" "")
==>
  ""
Note: Deleting unreachable code.
 
  (IF +F77-LOWER-CASE+ (STRING-DOWNCASE NAME) NAME)
==>
  NAME
Note: Deleting unreachable code.
 
 
Compilation unit finished.
  2 notes
 
 
 
Error in function COMMON-LISP::FOREIGN-SYMBOL-ADDRESS-AUX:
   Unknown foreign symbol: "daxpy"
 
Restarts:
  0: [CONTINUE] Return NIL from load of 
"/home/ponsve/linux_matlisp/bin/blas.x86f".
  1:            Return NIL from load of "start.lisp".
  2: [ABORT   ] Skip remaining initializations.
 
Debug  (type H for help)
 
(COMMON-LISP::FOREIGN-SYMBOL-ADDRESS-AUX "daxpy")
Source:
; File: target:code/x86-vm.lisp
 
; File has been modified since compilation:
;   target:code/x86-vm.lisp
; Using form offset instead of character position.
(ERROR "Unknown foreign symbol: ~S" NAME)
0]


**************************************************************

I'm using the CVS-version of matlisp and gcc-3.0.

What I do is:

beo201 17:41:34 ~/linux_matlisp/>export 
LDFLAGS=-L/usr/lib/gcc-lib/i386-linux/3.0.4
beo201 17:41:41 ~/linux_matlisp/>export CC=/usr/bin/gcc-3.0
beo201 17:41:41 ~/linux_matlisp/>export F77=/usr/bin/g77-3.0
beo201 17:41:42 ~/linux_matlisp/>./configure --with-lisp=cmucl 
--with-lisp-exec=lisp --prefix=`pwd`
checking build system type... i686-pc-linux-gnu
checking host system type... i686-pc-linux-gnu
checking target system type... i686-pc-linux-gnu
checking for ranlib... ranlib
checking for gcc... /usr/bin/gcc-3.0
checking for C compiler default output... a.out
checking whether the C compiler works... yes
checking whether we are cross compiling... no
checking for executable suffix...
checking for object suffix... o
checking whether we are using the GNU C compiler... yes
checking whether /usr/bin/gcc-3.0 accepts -g... yes
checking whether /usr/bin/gcc-3.0 and cc understand -c and -o 
together... yes
checking whether we are using the GNU Fortran 77 compiler... yes
checking whether /usr/bin/g77-3.0 accepts -g... yes
checking whether /usr/bin/g77-3.0 understand -c and -o together... yes
checking whether we are using the GNU Fortran 77 compiler... (cached) yes
checking whether /usr/bin/g77-3.0 accepts -g... (cached) yes
checking how to get verbose linking output from /usr/bin/g77-3.0... -v
checking for Fortran 77 libraries...  
-L/usr/lib/gcc-lib/i386-linux/3.0.4 
-L/usr/lib/gcc-lib/i386-linux/3.0.4/../../.. -lg2c -lm
checking for Fortran 77 name-mangling scheme... lower case, underscore, 
extra underscore
configure: creating ./config.status
config.status: creating matlisp.mk
config.status: creating lib/lazy-loader.lisp
config.status: creating src/f77-mangling.lisp


**************************************************************

Trying to make with the standard f77-mangling.lisp gives this output:

**************************************************************

beo201 18:03:09 ~/linux_matlisp/>make
make -f matlisp.mk
make[1]: Entering directory `/home/ponsve/linux_matlisp'
               
                [removed output of compilation and linking -- no error 
messages here]

lisp -noinit -eval '(progn (load "start.lisp"))'
; Loading #p"/home/ponsve/linux_matlisp/start.lisp".
Converted SETLOGICALROOT.
Converted GETLOGICALROOT.
Converted DEFLOGICALPATH.
;; Loading #p"/home/ponsve/linux_matlisp/system.dcl".
;; Loading #p"/home/ponsve/linux_matlisp/config.lisp".

File: /home/ponsve/linux_matlisp/src/f77-mangling.lisp

In: DEFUN MAKE-FORTRAN-NAME
  (IF +F77-UNDERSCORE+ "_" "")
==>
  ""
Note: Deleting unreachable code.

  (IF +F77-LOWER-CASE+ (STRING-DOWNCASE NAME) NAME)
==>
  NAME
Note: Deleting unreachable code.


Compilation unit finished.
  2 notes


File: /home/ponsve/linux_matlisp/src/matrix.lisp

In: DEFMETHOD FILL-MATRIX (COMPLEX-MATRIX NUMBER)
  (COPY! FILL MATRIX)
Warning: Undefined function: COPY!


In: DEFMETHOD FILL-MATRIX (REAL-MATRIX REAL)
  (COPY! FILL MATRIX)
Warning: Undefined function: COPY!


Warning: This function is undefined:
  COPY!


Compilation unit finished.
  3 warnings


File: /home/ponsve/linux_matlisp/src/ref.lisp

In: DEFUN GET-REAL-MATRIX-SLICE-1D
  (MAKE-INSTANCE 'REAL-MATRIX :NROWS (IF (> N 1) K 1) :NCOLS ...)
--> FUNCALL C::%FUNCALL IF
==>
  (KERNEL:%COERCE-TO-FUNCTION FUNCTION)
Note: Unable to optimize because:
      Might be a symbol, so must call FDEFINITION at runtime.

  (FLOOR VAL)
--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Forced to do full call.
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES - 
- FLOAT
==>
  (KERNEL:%DOUBLE-FLOAT C::N)
Note: Forced to do full call.
      Unable to do inline float coercion (cost 5) because:
      The first argument is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float coercion (cost 6) because:
      The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 1-
==>
  (- C::TRU 1)
Note: Forced to do GENERIC-- (cost 10).
      Unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      etc.

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Doing float to pointer coercion (cost 13).


In: DEFUN GET-REAL-MATRIX-SLICE-1D-SEQ
  (LENGTH IDX)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR VECTOR CONS NULL), not a (SIMPLE-ARRAY 
* (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR VECTOR CONS NULL), not a VECTOR.

  (MAKE-INSTANCE 'REAL-MATRIX :NROWS (IF (> N 1) K 1) :NCOLS ...)
--> FUNCALL C::%FUNCALL IF
==>
  (KERNEL:%COERCE-TO-FUNCTION FUNCTION)
Note: Unable to optimize because:
      Might be a symbol, so must call FDEFINITION at runtime.


In: DEFUN %MATRIX-EVERY
  (FORTRAN-MATRIX-INDEXING I J N)
--> BLOCK +
==>
  (* COL NROWS)
Note: Unable to recode as shift and add due to type uncertainty:
      The result is a (MOD 288230374541099011), not a (UNSIGNED-BYTE 32).

  (FUNCALL FN IDX)
--> C::%FUNCALL IF
==>
  (KERNEL:%COERCE-TO-FUNCTION FUNCTION)
Note: Unable to optimize because:
      Might be a symbol, so must call FDEFINITION at runtime.

  (FORTRAN-MATRIX-INDEXING I J N)
--> BLOCK +
==>
  (* COL NROWS)
Note: Forced to do GENERIC-* (cost 30).
      Unable to do inline fixnum arithmetic (cost 4) because:
      The result is a (MOD 288230374541099011), not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The result is a (MOD 288230374541099011), not a (SIGNED-BYTE 32).
      etc.

--> BLOCK
==>
  (+ ROW (* COL NROWS))
Note: Forced to do GENERIC-+ (cost 10).
      Unable to do inline fixnum arithmetic (cost 2) because:
      The second argument is a (MOD 288230374541099011), not a FIXNUM.
      Unable to do inline (signed-byte 32) arithmetic (cost 5) because:
      The second argument is a (MOD 288230374541099011), not a 
(SIGNED-BYTE 32).
      etc.

  (FLOOR VAL)
--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Forced to do full call.
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES - 
- FLOAT
==>
  (KERNEL:%DOUBLE-FLOAT C::N)
Note: Forced to do full call.
      Unable to do inline float coercion (cost 5) because:
      The first argument is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float coercion (cost 6) because:
      The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 1-
==>
  (- C::TRU 1)
Note: Forced to do GENERIC-- (cost 10).
      Unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      etc.

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Doing float to pointer coercion (cost 13).


In: DEFUN SET-REAL-MATRIX-SLICE-1D
  (FLOOR VAL)
--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Forced to do full call.
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES - 
- FLOAT
==>
  (KERNEL:%DOUBLE-FLOAT C::N)
Note: Forced to do full call.
      Unable to do inline float coercion (cost 5) because:
      The first argument is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float coercion (cost 6) because:
      The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 1-
==>
  (- C::TRU 1)
Note: Forced to do GENERIC-- (cost 10).
      Unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      etc.

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Doing float to pointer coercion (cost 13).


In: DEFUN SET-REAL-FROM-SCALAR-MATRIX-SLICE-1D
  (FLOOR VAL)
--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Forced to do full call.
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES - 
- FLOAT
==>
  (KERNEL:%DOUBLE-FLOAT C::N)
Note: Forced to do full call.
      Unable to do inline float coercion (cost 5) because:
      The first argument is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float coercion (cost 6) because:
      The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 1-
==>
  (- C::TRU 1)
Note: Forced to do GENERIC-- (cost 10).
      Unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      etc.

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Doing float to pointer coercion (cost 13).


In: DEFUN GET-COMPLEX-MATRIX-SLICE-1D
  (MAKE-INSTANCE 'COMPLEX-MATRIX :NROWS (IF (> N 1) K 1) :NCOLS ...)
--> FUNCALL C::%FUNCALL IF
==>
  (KERNEL:%COERCE-TO-FUNCTION FUNCTION)
Note: Unable to optimize because:
      Might be a symbol, so must call FDEFINITION at runtime.

  (FLOOR VAL)
--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Forced to do full call.
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES - 
- FLOAT
==>
  (KERNEL:%DOUBLE-FLOAT C::N)
Note: Forced to do full call.
      Unable to do inline float coercion (cost 5) because:
      The first argument is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float coercion (cost 6) because:
      The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 1-
==>
  (- C::TRU 1)
Note: Forced to do GENERIC-- (cost 10).
      Unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      etc.

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Doing float to pointer coercion (cost 13).


In: DEFUN GET-COMPLEX-MATRIX-SLICE-1D-SEQ
  (LENGTH IDX)
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR VECTOR CONS NULL), not a (SIMPLE-ARRAY 
* (*)).
Note: Unable to optimize due to type uncertainty:
      The first argument is a (OR VECTOR CONS NULL), not a VECTOR.

  (MAKE-INSTANCE 'COMPLEX-MATRIX :NROWS (IF (> N 1) K 1) :NCOLS ...)
--> FUNCALL C::%FUNCALL IF
==>
  (KERNEL:%COERCE-TO-FUNCTION FUNCTION)
Note: Unable to optimize because:
      Might be a symbol, so must call FDEFINITION at runtime.


In: DEFUN SET-COMPLEX-FROM-COMPLEX-MATRIX-SLICE-1D
  (FLOOR VAL)
--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Forced to do full call.
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES - 
- FLOAT
==>
  (KERNEL:%DOUBLE-FLOAT C::N)
Note: Forced to do full call.
      Unable to do inline float coercion (cost 5) because:
      The first argument is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float coercion (cost 6) because:
      The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 1-
==>
  (- C::TRU 1)
Note: Forced to do GENERIC-- (cost 10).
      Unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      etc.

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Doing float to pointer coercion (cost 13).


In: DEFUN SET-COMPLEX-FROM-REAL-MATRIX-SLICE-1D
  (FLOOR VAL)
--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Forced to do full call.
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES - 
- FLOAT
==>
  (KERNEL:%DOUBLE-FLOAT C::N)
Note: Forced to do full call.
      Unable to do inline float coercion (cost 5) because:
      The first argument is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float coercion (cost 6) because:
      The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 1-
==>
  (- C::TRU 1)
Note: Forced to do GENERIC-- (cost 10).
      Unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      etc.

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Doing float to pointer coercion (cost 13).


In: DEFUN SET-COMPLEX-FROM-SCALAR-MATRIX-SLICE-1D
  (REALPART NEW)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX RATIONAL).

  (IMAGPART NEW)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX RATIONAL).

  (FLOOR VAL)
--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Forced to do full call.
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float truncate (cost 5) because:
      The result is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES - 
- FLOAT
==>
  (KERNEL:%DOUBLE-FLOAT C::N)
Note: Forced to do full call.
      Unable to do inline float coercion (cost 5) because:
      The first argument is a INTEGER, not a (SIGNED-BYTE 32).
      Unable to do inline float coercion (cost 6) because:
      The first argument is a INTEGER, not a (UNSIGNED-BYTE 32).

--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 1-
==>
  (- C::TRU 1)
Note: Forced to do GENERIC-- (cost 10).
      Unable to do inline fixnum arithmetic (cost 1) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      Unable to do inline fixnum arithmetic (cost 2) because:
      The first argument is a INTEGER, not a FIXNUM.
      The result is a INTEGER, not a FIXNUM.
      etc.

  (REALPART NEW)
Note: Forced to do full call.
      Unable to do complex float realpart (cost 3) because:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

  (IMAGPART NEW)
Note: Forced to do full call.
      Unable to do complex float imagpart (cost 3) because:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

  (FLOOR VAL)
--> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET
==>
  (KERNEL:%UNARY-TRUNCATE (/ C::X C::Y))
Note: Doing float to pointer coercion (cost 13).


In: DEFUN SET-COMPLEX-FROM-SCALAR-MATRIX-SLICE-1D-SEQ
  (REALPART NEW)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX RATIONAL).

  (IMAGPART NEW)
Note: Unable to optimize due to type uncertainty:
      The first argument is a NUMBER, not a (COMPLEX RATIONAL).

  (REALPART NEW)
Note: Forced to do full call.
      Unable to do complex float realpart (cost 3) because:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

  (IMAGPART NEW)
Note: Forced to do full call.
      Unable to do complex float imagpart (cost 3) because:
      The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).


Compilation unit finished.
  52 notes


File: /home/ponsve/linux_matlisp/src/geev.lisp

In: DEFMETHOD GEEV (COMPLEX-MATRIX)
  (DIAG W)
Warning: Undefined function: DIAG


Warning: This function is undefined:
  DIAG


Compilation unit finished.
  2 warnings


File: /home/ponsve/linux_matlisp/src/compat.lisp

In: DEFUN JOIN-MATRIX
  #'JOIN
Warning: Undefined function: JOIN


Warning: This function is undefined:
  JOIN


Compilation unit finished.
  2 warnings


File: /home/ponsve/linux_matlisp/lib-src/macros.l

In: DEFUN DSIN
  (SIN X)
Note: Unable to avoid inline argument range check
because the argument range (DOUBLE-FLOAT) was not within 2^64


In: DEFUN DCOS
  (COS X)
Note: Unable to avoid inline argument range check
because the argument range (DOUBLE-FLOAT) was not within 2^64


In: DEFUN DTAN
  (TAN X)
Note: Unable to avoid inline argument range check
because the argument range (DOUBLE-FLOAT) was not within 2^64


In: DEFUN PROCESS-IMPLIED-DO
  (POSITION '= IMPLIED-DO)
--> DO BLOCK LET TAGBODY RETURN-FROM
==>
  (PROGN NIL)
Warning: This is not a (VALUES &OPTIONAL NUMBER &REST T):
  NIL
[Last message occurs 2 times]


Compilation unit finished.
  2 warnings
  3 notes


File: /home/ponsve/linux_matlisp/src/quadpack.lisp

In: DEFUN INTEGRATE-QAG
  (DQAG F (FLOAT A 1.0d0) (FLOAT B 1.0d0) (FLOAT EPSABS 1.0d0) ...)
Warning: Undefined function: DQAG


In: DEFUN INTEGRATE-QAGI
  (DQAGI F (FLOAT BOUND 1.0d0) INF (FLOAT EPSABS 1.0d0) ...)
Warning: Undefined function: DQAGI


In: DEFUN INTEGRATE-QAGS
  (DQAGS F (FLOAT A 1.0d0) (FLOAT B 1.0d0) (FLOAT EPSABS 1.0d0) ...)
Warning: Undefined function: DQAGS


In: DEFUN INTEGRATE-QAWC
  (DQAWC F (FLOAT A 1.0d0) (FLOAT B 1.0d0) (FLOAT C 1.0d0) ...)
Warning: Undefined function: DQAWC


In: DEFUN INTEGRATE-QAWS
  (DQAWS F (FLOAT A 1.0d0) (FLOAT B 1.0d0) (FLOAT ALFA 1.0d0) ...)
Warning: Undefined function: DQAWS


In: DEFUN INTEGRATE-QNG
  (DQNG F (FLOAT A 1.0d0) (FLOAT B 1.0d0) (FLOAT EPSABS 1.0d0) ...)
Warning: Undefined function: DQNG


Warning: These functions are undefined:
  DQAG DQAGI DQAGS DQAWC DQAWS DQNG


Compilation unit finished.
  7 warnings


File: /home/ponsve/linux_matlisp/lib-src/quadpack/dqwgtf.lisp

In: DEFUN DQWGTF
  (DCOS OMX)
--> BLOCK
==>
  (COS FORTRAN-TO-LISP::X)
Note: Unable to avoid inline argument range check
because the argument range (DOUBLE-FLOAT) was not within 2^64

  (DSIN OMX)
--> BLOCK
==>
  (SIN FORTRAN-TO-LISP::X)
Note: Unable to avoid inline argument range check
because the argument range (DOUBLE-FLOAT) was not within 2^64


Compilation unit finished.
  2 notes


File: /home/ponsve/linux_matlisp/lib-src/quadpack/dqc25f.lisp

In: DEFUN DQC25F
  (DSIN PARINT)
--> BLOCK
==>
  (SIN FORTRAN-TO-LISP::X)
Note: Unable to avoid inline argument range check
because the argument range (DOUBLE-FLOAT) was not within 2^64

  (DCOS PARINT)
--> BLOCK
==>
  (COS FORTRAN-TO-LISP::X)
Note: Unable to avoid inline argument range check
because the argument range (DOUBLE-FLOAT) was not within 2^64

  (DCOS (* CENTR OMEGA))
--> BLOCK
==>
  (COS FORTRAN-TO-LISP::X)
Note: Unable to avoid inline argument range check
because the argument range (DOUBLE-FLOAT) was not within 2^64

  (DSIN (* CENTR OMEGA))
--> BLOCK
==>
  (SIN FORTRAN-TO-LISP::X)
Note: Unable to avoid inline argument range check
because the argument range (DOUBLE-FLOAT) was not within 2^64


Compilation unit finished.
  4 notes


File: /home/ponsve/linux_matlisp/lib-src/minpack/dpmpar.lisp

In: DEFUN DPMPAR
  '""
Note: Deleting unreachable code.

  (PROG ((MAXMAG #) (MINMAG #) (MCHEPS #) (DPMPAR 0.0d0) (EQUIVALENCE 0.0))
    (DECLARE (TYPE SINGLE-FLOAT EQUIVALENCE)
             (TYPE DOUBLE-FLOAT DPMPAR)
             (TYPE # MCHEPS MINMAG MAXMAG))
    '"     **********" ..)
--> BLOCK
==>
  (LET ((MAXMAG #) (MINMAG #) (MCHEPS #) (DPMPAR 0.0d0) (EQUIVALENCE 0.0))
    (DECLARE (TYPE SINGLE-FLOAT EQUIVALENCE)
             (TYPE DOUBLE-FLOAT DPMPAR)
             (TYPE # MCHEPS MINMAG MAXMAG))
    (TAGBODY '"     **********" '"" '"     function dpmpar" '"" ...))
Note: Variable MAXMAG defined but never used.
Note: Variable MINMAG defined but never used.
Note: Variable MCHEPS defined but never used.
Note: Variable EQUIVALENCE defined but never used.


Compilation unit finished.
  5 notes


File: /home/ponsve/linux_matlisp/lib-src/minpack/enorm.lisp

In: DEFUN ENORM
  '""
Note: Deleting unreachable code.


Compilation unit finished.
  1 note


File: /home/ponsve/linux_matlisp/lib-src/minpack/fdjac2.lisp

In: DEFUN FDJAC2
  '""
Note: Deleting unreachable code.


Compilation unit finished.
  1 note


File: /home/ponsve/linux_matlisp/lib-src/minpack/qrsolv.lisp

In: DEFUN QRSOLV
  '""
Note: Deleting unreachable code.


Compilation unit finished.
  1 note


File: /home/ponsve/linux_matlisp/lib-src/minpack/lmpar.lisp

In: DEFUN LMPAR
  '""
Note: Deleting unreachable code.


Compilation unit finished.
  1 note


File: /home/ponsve/linux_matlisp/lib-src/minpack/qrfac.lisp

In: DEFUN QRFAC
  '""
Note: Deleting unreachable code.

  (PROG ((AJNORM 0.0d0) (EPSMCH 0.0d0) (SUM 0.0d0) (TEMP 0.0d0) (I 0) ...)
    (DECLARE (TYPE SINGLE-FLOAT ARRAY-SLICE DOUBLE-FLOAT)
             (TYPE INTEGER4 MINMN KMAX K ...)
             (TYPE DOUBLE-FLOAT TEMP SUM EPSMCH ...))
    (DECLARE (FTYPE # DPMPAR)) ..)
--> BLOCK
==>
  (LET ((AJNORM 0.0d0) (EPSMCH 0.0d0) (SUM 0.0d0) (TEMP 0.0d0) (I 0) ...)
    (DECLARE (TYPE SINGLE-FLOAT ARRAY-SLICE DOUBLE-FLOAT)
             (TYPE INTEGER4 MINMN KMAX K ...)
             (TYPE DOUBLE-FLOAT TEMP SUM EPSMCH ...))
    (DECLARE (FTYPE # DPMPAR)) ..)
Note: Variable DOUBLE-FLOAT defined but never used.
Note: Variable ARRAY-SLICE defined but never used.


Compilation unit finished.
  3 notes


File: /home/ponsve/linux_matlisp/lib-src/minpack/lmdif.lisp

In: DEFUN LMDIF
  '""
Note: Deleting unreachable code.


Compilation unit finished.
  1 note


File: /home/ponsve/linux_matlisp/lib-src/minpack/lmdif1.lisp

In: DEFUN LMDIF1
  '""
Note: Deleting unreachable code.


Compilation unit finished.
  1 note


File: /home/ponsve/linux_matlisp/lib-src/minpack/lmder.lisp

In: DEFUN LMDER
  '""
Note: Deleting unreachable code.


Compilation unit finished.
  1 note


File: /home/ponsve/linux_matlisp/lib-src/minpack/lmder1.lisp

In: DEFUN LMDER1
  '""
Note: Deleting unreachable code.


Compilation unit finished.
  1 note


File: /home/ponsve/linux_matlisp/lib-src/minpack/dogleg.lisp

In: DEFUN DOGLEG
  '""
Note: Deleting unreachable code.


Compilation unit finished.
  1 note


File: /home/ponsve/linux_matlisp/lib-src/minpack/qform.lisp

In: DEFUN QFORM
  '""
Note: Deleting unreachable code.


Compilation unit finished.
  1 note


File: /home/ponsve/linux_matlisp/lib-src/minpack/r1mpyq.lisp

In: DEFUN R1MPYQ
  '""
Note: Deleting unreachable code.


Compilation unit finished.
  1 note


File: /home/ponsve/linux_matlisp/lib-src/minpack/r1updt.lisp

In: DEFUN R1UPDT
  '""
Note: Deleting unreachable code.


Compilation unit finished.
  1 note


File: /home/ponsve/linux_matlisp/lib-src/minpack/hybrj.lisp

In: DEFUN HYBRJ
  '""
Note: Deleting unreachable code.


Compilation unit finished.
  1 note


File: /home/ponsve/linux_matlisp/lib-src/minpack/hybrj1.lisp

In: DEFUN HYBRJ1
  '""
Note: Deleting unreachable code.
 
 
Compilation unit finished.
  1 note
 
;; Loading #p"/home/ponsve/linux_matlisp/save.lisp".
 
 
 ** MATLISP is loaded.  Type (HELP MATLISP)
    to see a list of available symbols.
    To use matlisp:
 
          (use-package "MATLISP")
 
    or
 
          (in-package "MATLISP-USER")
 
 ** The logical pathname matlisp has been
    set to:
 
          /home/ponsve/linux_matlisp/
 
CMU Common Lisp release x86-linux 3.0.12 18d+ 23 May 2002 build 3350, 
running on beo201.foi.se
For support see http://www.cons.org/cmucl/support.html Send bug reports 
to the debian BTS.
or to pva...@de...
type (help) for help, (quit) to exit, and (demo) to see the demos
 
Loaded subsystems:
    Python 1.0, target Intel x86
    CLOS based on PCL version:  September 16 92 PCL (f)
    MATLISP/Pre 2.0
* (setf a [1 2])
Warning:  Declaring A special.
 
#<MATLISP:REAL-MATRIX  1 x 2
    1.0000      2.0000     >
* (m+ a a)
 
Warning: This function is undefined:
  M+
 
Error in KERNEL:%COERCE-TO-FUNCTION:  the function M+ is undefined.
 
Restarts:
  0: [ABORT] Return to Top-Level.
 
Debug  (type H for help)
 
(KERNEL:%COERCE-TO-FUNCTION M+)
Source:
; File: target:code/fdefinition.lisp
 
; File has been modified since compilation:
;   target:code/fdefinition.lisp
; Using form offset instead of character position.
(ERROR 'UNDEFINED-FUNCTION :NAME NAME)
0]


**************************************************************

Does anybody have any idea what I might be doing wrong?

Thanks,
Pontus

Re: [Matlisp-users] Still can't get Matlisp working

[Raymond T. <to...@rt...>]

>>>>> "rif" == rif  <ri...@MI...> writes:

    rif> In my CMUCL, it seems that at least (quit) (I don't know if there's
    rif> anything else) is part of the common-lisp-user package --- if I
    rif> (in-package :matlisp) I can't (quit) without changing back.  This was
    rif> what made me not want to do it, although it's not a big deal (of
    rif> course, uninterning the CMUCL help is not a big deal either).

That's because quit is actually in the ext package so if you're in the
matlisp-user package you need to type (ext:quit).  Use (describe
'quit) to find out where the symbol really lives.

Matlisp should probably import the ext package, or at least ext:quit.

Ray

Re: [Matlisp-users] Still can't get Matlisp working

[rif <ri...@MI...>]

In my CMUCL, it seems that at least (quit) (I don't know if there's
anything else) is part of the common-lisp-user package --- if I
(in-package :matlisp) I can't (quit) without changing back.  This was
what made me not want to do it, although it's not a big deal (of
course, uninterning the CMUCL help is not a big deal either).

rif

Re: [Matlisp-users] Still can't get Matlisp working

[Raymond T. <to...@rt...>]

>>>>> "rif" == rif  <ri...@MI...> writes:

    rif> I'm uninterning the symbol manually because I do it in my init file
    rif> noninteractively.

    rif> (in-package :matlisp) does "just work", but that means I lose all the
    rif> functions in the common-lisp-user package, yes?

Yes.  But unless you define functions there yourself, there aren't any
functions there anyway.  (They're all imported from other packages.)

Ray

Re: [Matlisp-users] Still can't get Matlisp working

[rif <ri...@MI...>]

I'm uninterning the symbol manually because I do it in my init file
noninteractively.

(in-package :matlisp) does "just work", but that means I lose all the
functions in the common-lisp-user package, yes?

rif

Re: [Matlisp-users] Still can't get Matlisp working

[Raymond T. <to...@rt...>]

>>>>> "rif" == rif  <ri...@MI...> writes:

    rif> What am I missing?  When I start lisp up, it certainly seems like

[snip]

    rif> rif@oscar:~$ lisp -init /dev/null
    rif> ; Loading #p"/dev/null".
    rif> CMU Common Lisp release x86-linux 3.0.8 18c+ 31 December 2001 build 3030, running on oscar
    rif> For support see http://www.cons.org/cmucl/support.html Send bug reports to the debian BTS.
    rif> or to pva...@de...
    rif> type (help) for help, (quit) to exit, and (demo) to see the demos

You're not missing anything.  I'm the one that's missing something!

I now see you're using the Debian version of cmucl.  I don't use that.

    rif> * (use-package :matlisp)


    rif> Error in function USE-PACKAGE:
    rif>    Use'ing package MATLISP results in name conflicts for these symbols:
    rif> (HELP)

    rif> Restarts:
    rif>   0: [CONTINUE] Unintern the conflicting symbols in the COMMON-LISP-USER package.
    rif>   1: [ABORT   ] Return to Top-Level.

    rif> 0] 1

You can answer 0 here and unintern the conflicting symbols instead of
doing it manually.

I think matlisp can try to do something more intelligent here.  I'll
have to think about it.

However, I also tend to use (in-package :matlisp-user) instead of
use-package.  Can you try that instead?

Ray

Re: [Matlisp-users] Still can't get Matlisp working

[rif <ri...@MI...>]

What am I missing?  When I start lisp up, it certainly seems like
there's a help function --- the message says type (help) for help.
This (help) function does not seem to be an artifact, since it does
seem to provide help on using CMUCL.  And I'm getting a symbol
conflict with matlisp.  If my uninterning choice is bad, what's a
better approach?

rif


rif@oscar:~$ lisp -init /dev/null
; Loading #p"/dev/null".
CMU Common Lisp release x86-linux 3.0.8 18c+ 31 December 2001 build 3030, running on oscar
For support see http://www.cons.org/cmucl/support.html Send bug reports to the debian BTS.
or to pva...@de...
type (help) for help, (quit) to exit, and (demo) to see the demos

Loaded subsystems:
    Python 1.0, target Intel x86
    CLOS based on PCL version:  September 16 92 PCL (f)
* (help) 
Welcome to CMUCL for Linux.

If you aren't running this with ilisp in emacs,
or aren't intending to use hemlock then you
deserve to lose. :-)

Read the documentation in /usr/share/doc/cmucl.

Create your own personal image with
/usr/sbin/cmuclconfig

(quit) is to quit.
(ed) starts hemlock (if installed)
(demo) shows a list of demos
(describe 'progn) gives information about progn for 
 example.
(inspect '*a*) interactively inspects *a* for example.
NIL
* (load "Software/matlisp/start.lisp")

; Loading #p"/home/rif/Software/matlisp/start.lisp".
Converted SETLOGICALROOT.
Converted GETLOGICALROOT.
Converted DEFLOGICALPATH.
;; Loading #p"/home/rif/Software/matlisp/system.dcl".
;; Loading #p"/home/rif/Software/matlisp/config.lisp".
;; Loading #p"/home/rif/Software/matlisp/save.lisp".


 ** MATLISP is loaded.  Type (HELP MATLISP)
    to see a list of available symbols.
    To use matlisp:

          (use-package "MATLISP")

    or

          (in-package "MATLISP-USER")

 ** The logical pathname matlisp has been
    set to:

          /home/rif/Software/matlisp/

T
* (use-package :matlisp)


Error in function USE-PACKAGE:
   Use'ing package MATLISP results in name conflicts for these symbols:
(HELP)

Restarts:
  0: [CONTINUE] Unintern the conflicting symbols in the COMMON-LISP-USER package.
  1: [ABORT   ] Return to Top-Level.

Debug  (type H for help)

(USE-PACKAGE :MATLISP
             #<The COMMON-LISP-USER package, 47/95 internal, 0/9 external>)
Source: Error finding source: 
Error in function DEBUG::GET-FILE-TOP-LEVEL-FORM:  Source file no longer exists:  target:code/package.lisp.
0] 1

* (unintern 'help)

T
* (use-package :matlisp)

T

Re: [Matlisp-users] Still can't get Matlisp working

[Raymond T. <to...@rt...>]

>>>>> "rif" == rif  <ri...@MI...> writes:

    rif> Ok, I have it pretty much working now.  I have to (unintern 'help)
    rif> (the standard CMUCL help function) before I can (use-package
    rif> :matlisp), but I guess that's not a problem.  

There is no standard CMUCL help function.  This is probably an
artifact of the experiments you did to get it working.  If you start
matlisp from scratch, you shouldn't have to unintern help.  And if
help were a standard CMUCL function, it would probably not be a good
idea to unintern it. :-)

    rif> Thanks for all the help!

Glad it's working for you now!

Ray

Re: [Matlisp-users] Still can't get Matlisp working

[rif <ri...@MI...>]

Ok, I have it pretty much working now.  I have to (unintern 'help)
(the standard CMUCL help function) before I can (use-package
:matlisp), but I guess that's not a problem.  Thanks for all the help!

Cheers,

rif

Re: [Matlisp-users] Still can't get Matlisp working

[Raymond T. <to...@rt...>]

>>>>> "rif" == rif  <ri...@MI...> writes:

    rif> If I try to (use-package "matlisp"), it says it's not a package.  I
    rif> can choose 0 in the debugger to "Make this package", but still no
    rif> help:

    rif> * (use-package "matlisp")

It's case sensitive.  Try (use-package "MATLISP") or (in-package
"MATLISP-USER") as the message says. (Or (use-package :matlisp) or
(in-package :matlisp-user)).  Should probably change the message to
use the keywords instead of strings.

Ray

Re: [Matlisp-users] Still can't get Matlisp working

[rif <ri...@MI...>]

If I try to (use-package "matlisp"), it says it's not a package.  I
can choose 0 in the debugger to "Make this package", but still no
help:

* (use-package "matlisp")

Type-error in COMMON-LISP::PACKAGE-OR-LOSE:  "matlisp" is not of type PACKAGE

Restarts:
  0: [CONTINUE] Make this package.
  1: [ABORT   ] Return to Top-Level.

Debug  (type H for help)

(COMMON-LISP::PACKAGE-OR-LOSE "matlisp")
Source: Error finding source: 
Error in function DEBUG::GET-FILE-TOP-LEVEL-FORM:  Source file no longer exists:  target:code/package.lisp.
0] 0  

T
* (help matlisp)


Error in KERNEL::UNBOUND-SYMBOL-ERROR-HANDLER:  the variable MATLISP is unbound


(in-package "matlisp-user") gives similar, but not identical behavior:

 (in-package "matlisp-user")

The package named "matlisp-user" doesn't exist.

Restarts:
  0: [CONTINUE] Make this package.
  1: [ABORT   ] Return to Top-Level.

Debug  (type H for help)

(KERNEL:%IN-PACKAGE "matlisp-user")
Source: Error finding source: 
Error in function DEBUG::GET-FILE-TOP-LEVEL-FORM:  Source file no longer exists:  target:code/package.lisp.
0] 0

#<The matlisp-user package, 0/9 internal, 0/9 external>
* (help matlisp)

Warning: This variable is undefined:
  MATLISP


Warning: This function is undefined:
  HELP


Error in KERNEL:%COERCE-TO-FUNCTION:  the function HELP is undefined.

Restarts:
  0: [ABORT] Return to Top-Level.

Debug  (type H for help)

(KERNEL:%COERCE-TO-FUNCTION HELP)
Source: Error finding source: 
Error in function DEBUG::GET-FILE-TOP-LEVEL-FORM:  Source file no longer exists:  target:code/fdefinition.lisp.
0] 


I'm still lost.

rif





> >>>>> "Ryan" == Ryan M Rifkin <ri...@MI...> writes:
> 
>     Ryan> ---------------
>     Ryan>  ** MATLISP is loaded.  Type (HELP MATLISP)
>     Ryan>     to see a list of available symbols.
>     Ryan>     To use matlisp:
> 
>     Ryan>           (use-package "MATLISP")
> 
>     Ryan>     or
> 
>     Ryan>           (in-package "MATLISP-USER")
> 
>     Ryan>  ** The logical pathname matlisp has been
>     Ryan>     set to:
> 
>     Ryan>           /home/rif/Software/matlisp/
> 
>     Ryan> CMU Common Lisp release x86-linux 3.0.8 18c+ 31 December 2001 build 3030, running on oscar
>     Ryan> For support see http://www.cons.org/cmucl/support.html Send bug reports to the debian BTS.
>     Ryan> or to pva...@de...
>     Ryan> type (help) for help, (quit) to exit, and (demo) to see the demos
> 
>     Ryan> Loaded subsystems:
>     Ryan>     Python 1.0, target Intel x86
>     Ryan>     CLOS based on PCL version:  September 16 92 PCL (f)
>     Ryan>     MATLISP/Pre 2.0
> 
> The fact that you get this far tells me that it very likey worked.
> 
>     Ryan> * (help matlisp)
> 
>     Ryan> Error in KERNEL::UNBOUND-SYMBOL-ERROR-HANDLER:  the variable MATLISP is unbound.
> 
> Did you do (use-package "MATLISP") or (in-package "MATLISP-USER") as
> suggested by the banner?  If not, try that and then try the help
> command again.
> 
> Ray