[Maxima] How to decide what to kill / packages
Yasuaki Honda
yhonda@mac.com
Wed, 30 Apr 2003 00:37:16 +0900
--Apple-Mail-5-308992739
Content-Transfer-Encoding: 7bit
Content-Type: text/plain;
charset=US-ASCII;
format=flowed
Dear all,
About a year ago, I have proposed the similar idea of introducing
maxima user package for solving different issue of strange behavior
for uppercase/lowercase symbols related to bug ID 530030 in the
database.
Recently I re-started playing with Maxima and found that this was
not solved since then. Then I have started some hack for introducing
maxima-user package.
Here I attach two files, maxima-user-package.lisp and symbol.lisp
which I created a year ago and updated recently.
Some coincidence is that my hack does NOT pass the regression test
rtest13s.mac in tests directory. That is because I still cannot figure
out
how rule names introduced by tellsimp, infix, prefix, postfix and so on
are interned, and killed. Some hacks made it work for rtest13.mac,
though
I am not satisfied with my hack.
I think it will take some more time for me to complete even 1) below.
Yasuaki Honda
Independent developer
Chiba, Japan
--Apple-Mail-5-308992739
Content-Disposition: attachment;
filename=maxima-user-package.lisp
Content-Transfer-Encoding: 7bit
Content-Type: application/octet-stream;
x-unix-mode=0755;
name="maxima-user-package.lisp"
;;; Written by Yasuaki Honda
;;; yhonda@mac.com
;;; Independent Software Developer
;;; Chiba, Japan
;;; Copyright 2002 Yasuaki Honda
;;;
;;; You are granted to use, copy, modify, or distribute this software without
;;; any form of an explicit permission from the author.
;;; This file implements what is described in the NewPackageProposal.rtf
;;; Usage:
;;; Invoke maxima.
;;; :lisp (load "maxima-user-package.lisp") to load this file.
;;; symbol.lisp will be loaded as well.
;;;
;;; Regression test is performed on maxima 5.9.0 on clisp 2.30 on cygwin.
;;; April 25th, 2003
;;;
;;; Regression test resuts:
;;; rtest1, rtest1a, and rtest2 are OK.
;;; rtest3 does not pass (probably due to totally unrelated issue.)
;;; rtest4 to rtest13 are OK.
;;; rtest13s does not pass due to some issues related to tellsimp and kill.
(in-package :maxima)
(load "symbol.lisp")
;;; create a maxima-user package.
(defpackage :maxima-user
;; First of all, import all the lisp system symbols.
;; Immediately some of them will be shadowed.
;; Then :maxima package symbols will be imported.
(:use :lisp))
;;; The function implode1 is taken from file commac.lisp.
;;; This function interns the symbol.
;;; Last line of the function is changed so that it interns
;;; symbol into "MAXIMA-USER" package instead of "MAXIMA" package.
(defun implode1 (lis upcase &aux (ar *string-for-implode*) (leng 0))
(declare (type string ar) (fixnum leng))
(or (> (array-total-size ar) (setq leng (length lis)))
(adjust-array ar (+ leng 20)))
(setf (fill-pointer ar) leng)
(sloop for v in lis
for i below leng
do
(cond ((typep v 'character))
((symbolp v) (setq v (aref (symbol-name v) 0)))
((numberp v) (setq v (code-char v))))
(setf (aref ar i) (if upcase (char-upcase v) v)))
(intern ar :maxima-user))
;;;
;;; Original bothcase-implode requires that upcase symbol
;;; needs to be there and actually used (i.e., function
;;; is defined or property list is defined on the symbol)
;;; for the symbol being converted to the upcase symbol.
;;; This is too strong a requirement for symbols such as
;;; $U, $V, $W, $X, $Y, $Z for Poisson series special
;;; functions.
;;; This version does not require such strong condition.
;;; Just upcase symbol needs to be there.
;;;
(defun bothcase-implode (lis &aux tem )
(cond ((not (eql (car lis) #\$))
(return-from bothcase-implode (implode1 lis nil))))
(multiple-value-bind
(sym there)
(implode1 lis nil)
(cond (there (if (setq tem (get sym 'upcase)) tem sym))
(t
;; if all upper case lets not bother interning...
(sloop for v in lis with haslower
when (not (eql (char-upcase v) v))
do (setq haslower t) (loop-finish)
finally (or haslower (return-from bothcase-implode sym)))
(multiple-value-bind
(symup there)
(implode1 lis t)
(cond (there
(setf (get sym 'upcase) symup)
symup)
(t (or there (unintern symup))
sym)))))))
(DEFMFUN GETOPR (X)
(if (symbolp x)
(let (tmp)
(setq tmp (intern (symbol-name X) :maxima))
(or (get tmp 'opr) x))
x))
;;;
;;; When REMOVERULE is called, RULE is bound to a symbol
;;; representing a name of a rule, in maxima package.
;;; Since the rule name symbol is effectively defined
;;; in maxima-user package, it needs to be converted first.
;;;
(DEFUN REMOVERULE (OP RULE)
(SETQ RULE (FIND-SYMBOL (SYMBOL-NAME RULE) :maxima-user))
(PROG (OLDRULES OLD OTHRULENAME OTHRULE)
(SETQ OLDRULES (MGET OP 'OLDRULES))
(COND ((OR (NULL RULE) (NULL (SETQ OLDRULES (zl-MEMBER RULE OLDRULES))))
(MERROR "~:M - no such rule." RULE))
((NULL (CAR (SETQ OLDRULES (CDR OLDRULES))))
(SETQ OLDRULES (CDR OLDRULES))
(SETQ OTHRULENAME 'SIMPARGS1)
(SETQ OTHRULE #'(LAMBDA (A B C) (SIMPARGS A C))))
(T (SETQ OTHRULENAME (CAR OLDRULES))
(SETQ OTHRULE (CADR (GETL (CAR OLDRULES) '(EXPR SUBR))))))
(PUTPROP RULE OTHRULE 'EXPR)
(SETQ OLD (CDR (zl-MEMBER RULE (REVERSE (MGET OP 'OLDRULES)))))
(IF OLD (PUTPROP (CAR OLD)
(SUBST OTHRULENAME RULE (GET (CAR OLD) 'EXPR))
'EXPR))
(IF (BOUNDP RULE) (MAKUNBOUND RULE))
(MREMPROP RULE '$RULE)
(MREMPROP RULE '$RULETYPE)
(MREMPROP RULE 'RULEOF)
(REMPROP RULE 'EXPR)
(DELQ RULE $RULES 1)
(PUTPROP RULE OTHRULENAME 'EXPR)
(IF (EQ (GET OP 'OPERATORS) RULE)
(PUTPROP OP OTHRULENAME 'OPERATORS))
(RETURN (MPUTPROP OP (DELQ RULE (MGET OP 'OLDRULES)) 'OLDRULES))))
;;; Below is copy from maxima-package.lisp. Some modifications were made
;;; so that symbols defined in common lisp are available in maxima-user
;;; as well.
(shadow '(complement continue tan sinh cosh tanh #+ti file-position ) 'maxima-user)
;;defined in polyrz
(shadow '(signum ) 'maxima-user)
;;lmsup
#+lispm
(shadow '(namestring) 'maxima-user)
;;in transs
#+lispm
(import '(global::array-leader
si::arglist
global::gc-on
global::gc-off
global::user-id
global::ERROR-RESTART-LOOP
global::condition-case
global::compile-flavor-methods
global::default-cons-area
global::errset
global::make-condition
si::signal-condition
si::set-in-instance
si::record-source-file-name
#+ti tv::define-user-option-alist
#+ti tv::font-char-height ;for plot win
#+ti tv::font-char-width ;for plot win
#-ti global::define-user-option-alist
#-symbolics global::defflavor
#-symbolics global::defmethod
#-symbolics global::defun-method
global::self
global::send
global::print-herald
global::without-interrupts
global::current-process
global::working-storage-area
) 'maxima-user)
(shadow '(copy xor putprop) 'maxima-user)
(shadow '(
ARRAY ;;"CL-MAXIMA-SOURCE: MAXIMA; COMMAC" ;not a function in common lisp but symbol in the package
EXP ;;various files declare this special which is bad since it is in LISP package.
LET ;;"CL-MAXIMA-SOURCE: MAXIMA; LET" ;;like let*
LET* ;;"CL-MAXIMA-SOURCE: MAXIMA; LET" ;;maxima:let* does destructuring.
LISTEN ;;"CL-MAXIMA-SOURCE: MAXIMA; SUPRV" ;;has trivial definition in suprv (listen any) ==> 0
SIGNUM ;;"CL-MAXIMA-SOURCE: MAXIMA; COMMAC" ;same except (cl:signum 1.3)==1.0 not 1 but I think this is ok for macsyma
ATAN ;; (zl:atan y x) == (cl:atan y x) + 2 pi if latter is negative
ASIN ;; different for complex numbers
ACOS
ASINH
ACOSH
ATANH
TANH ;;"CL-MAXIMA-SOURCE: MAXIMA; TRIGI" ;same could remove from trigi
COSH ;;"CL-MAXIMA-SOURCE: MAXIMA; TRIGI" ;same ditto
SINH ;;"CL-MAXIMA-SOURCE: MAXIMA; TRIGI" ;same ditto
TAN ;;"CL-MAXIMA-SOURCE: MAXIMA; TRIGI" ;;same ditto
) 'maxima-user)
;;new definitions in commac to handle narg compat.
(shadow '(arg listify setarg) 'maxima-user)
;;MANY instances are (if a b &rest c). I changed a bunch but there were
;;many more
(shadow 'lisp::IF 'maxima-user)
#+kcl
(import '(si::modulus si::cmod si::ctimes si::cdifference si::cplus)
'maxima-user)
#+(or clisp gcl)
(import '(system::getenv) (find-package "MAXIMA"))
#+gcl
(import '(si::getpid) (find-package "MAXIMA"))
;;get
#+gcl
(import '( si::cleanup si::*info-paths*
si::get-instream si::short-name si::cleanup
si::instream-stream-name si::instream-line si::instream-name
si::instream-stream
si::stream-name si::complete-prop
si::*stream-alist*
si::break-call
) "MAXIMA")
#+gcl
(setf (symbol-function 'maxima::newline) (symbol-function 'si::newline))
;; *info-paths* from cl-info.lisp
#+(or clisp cmu)
(import '( si::*info-paths* ) "MAXIMA" )
;; detect which version of clisp REGEXP we have
#+clisp
(if (find-package "REGEXP")
(push (cond ((apply (intern "REGEXP-EXEC" "REGEXP")
(list (apply (intern "REGEXP-COMPILE" "REGEXP")
'("AAA" t))
"aaa"))
':case-fold-search )
(t ':case-fold-search-not ))
*features* ))
;;redefined in commac lucid 2.1 does (functionp 'jiljay)-->t
(if (lisp::functionp 'dotimes) (push :shadow-functionp *features*))
(unless (lisp::functionp 'lisp::functionp)
(pushnew :shadow-functionp *features*))
#+shadow-functionp
(shadow 'lisp::functionp 'maxima-user)
;;;REMOVE The following two forms when the kcl reader can read
;;;the most-negative-double-float again.
#+kcl ;bug fix for float not readable:
(progn
(shadow '( most-positive-single-float most-negative-double-float) 'maxima-user))
#+kcl
(progn ;bug fix for float not readable:
(defvar maxima::most-positive-single-float
(* .1 lisp::most-positive-single-float))
(defvar maxima::most-negative-double-float
(* .1 lisp::most-negative-double-float)))
#+(or gcl kcl)
(in-package "SERROR" :use '( "LISP" "SLOOP"))
(shadow 'lisp::float 'maxima-user)
#+lispm
(shadow 'lisp::loop 'maxima-user)
;;
(use-package :maxima :maxima-user)
(in-package :maxima-user)
--Apple-Mail-5-308992739
Content-Disposition: attachment
Content-Type: multipart/appledouble;
boundary=Apple-Mail-6-308992742
--Apple-Mail-6-308992742
Content-Disposition: attachment;
filename=symbol.lisp
Content-Transfer-Encoding: base64
Content-Type: application/applefile;
name="symbol.lisp"
AAUWBwACAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAJAAAAMgAAAAoAAAADAAAAPAAAAAsAAAAAAAAA
AAEAc3ltYm9sLmxpc3A=
--Apple-Mail-6-308992742
Content-Disposition: attachment;
filename=symbol.lisp
Content-Transfer-Encoding: 7bit
Content-Type: application/octet-stream;
x-mac-creator=0;
x-unix-mode=0755;
x-mac-type=0;
name="symbol.lisp"
;;; package: maxima
(in-package :maxima)
(export '(
$%
$%%
$%EDISPFLAG
$%RNUM_LIST
$%TH
%LAPLACE
$?ROUND
$?TRUNCATE
$ABS
$ABSBOXCHAR
$ACOS
$ACOSH
$ACOT
$ACOTH
$ACSC
$ACSCH
$ACTIVATE
$ACTIVECONTEXTS
$ADDCOL
$ADDITIVE
$ADDROW
$ADJOINT
$AIRY
$ALARMCLOCK
$ALGEBRAIC
$ALGEPSILON
$ALGEXACT
$ALGSYS
$ALIAS
$ALIASES
$ALL
$ALL_DOTSIMP_DENOMS
$ALLBUT
$ALLOC
$ALLROOTS
$ALLSYM
$ALPHABETIC
$AND
$ANTID
$ANTIDIFF
$ANTISYMMETRIC
$APPEND
$APPENDFILE
$APPLY
$APPLY1
$APPLY2
$APPLY_NOUNS
$APPLYB1
$APROPOS
$ARGS
$ARRAY
$ARRAYAPPLY
$ARRAYINFO
$ARRAYMAKE
$ARRAYS
$ASEC
$ASECH
$ASIN
$ASINH
$ASKEXP
$ASKINTEGER
$ASKSIGN
$ASSOC_LEGENDRE_P
$ASSOC_LEGENDRE_Q
$ASSUME
$ASSUME_POS
$ASSUME_POS_PRED
$ASSUMESCALAR
$ASYMP
$ASYMPA
$AT
$ATAN
$ATAN2
$ATANH
$ATOM
$ATOMGRAD
$ATRIG1
$ATVALUE
$AUGCOEFMATRIX
$BACKSUBST
$BACKTRACE
$BACKUP
$BASHINDICES
$BATCH
$BATCHKILL
$BATCHLOAD
$BATCON
$BATCOUNT
$BC2
$BERLEFACT
$BERN
$BERNPOLY
$BESSEL
$BESSEL_I
$BESSEL_J
$BESSEL_K
$BESSEL_Y
$BESSELEXPAND
$BETA
$BEZOUT
$BFFAC
$BFLOAT
$BFLOATP
$BFPSI
$BFTORAT
$BFTRUNC
$BFZETA
$BGZETA
$BHZETA
$BINDTEST
$BINOMIAL
$BLOCK
$BOTHCASES
$BOTHCOEF
$BOX
$BOXCHAR
$BREAK
$BREAKUP
$BUG
$BUILDQ
$BURN
$BZETA
$CABS
$CANFORM
$CANTEN
$CARG
$CARTAN
$CATCH
$CAUCHYSUM
$CBFAC
$CF
$CFDISREP
$CFEXPAND
$CFLENGTH
$CGAMMA
$CGAMMA2
$CHANGE_FILEDEFAULTS
$CHANGEVAR
$CHARPOLY
$CHEBYSHEV_T
$CHEBYSHEV_U
$CHECK_OVERLAPS
$CHR1
$CHR2
$CHRISTOF
$CLEARSCREEN
$CLOSEFILE
$CLOSEPS
$COEFF
$COEFMATRIX
$COL
$COLLAPSE
$COLUMNVECTOR
$COMBINE
$COMMUTATIVE
$COMP2PUI
$COMPFILE
$COMPGRIND
$COMPILE
$COMPILE_FILE
$COMPILE_LISP_FILE
$CONCAT
$CONJUGATE
$CONS
$CONSTANT
$CONSTANTP
$CONT2PART
$CONTENT
$CONTEXT
$CONTEXTS
$CONTINUE
$CONTRACT
$COPYLIST
$COPYMATRIX
$COS
$COSH
$COT
$COTH
$COUNTER
$COVDIFF
$CREATE_LIST
$CSC
$CSCH
$CURRENT_LET_RULE_PACKAGE
$CURSORDISP
$CURVATURE
$DBLINT
$DDT
$DEACTIVATE
$DEBUG
$DEBUGMODE
$DEBUGPRINTMODE
$DECLARE
$DECLARE_TRANSLATED
$DECLARE_WEIGHT
$DEFAULT_LET_RULE_PACKAGE
$DEFCON
$DEFINE
$DEFINE_VARIABLE
$DEFINT
$DEFMATCH
$DEFRULE
$DEFTAYLOR
$DEL
$DELETE
$DELFILE
$DELTA
$DEMO
$DEMOIVRE
$DENOM
$DEPENDENCIES
$DEPENDS
$DERIVABBREV
$DERIVDEGREE
$DERIVLIST
$DERIVSUBST
$DESCRIBE
$DESOLVE
$DETERMINANT
$DETOUT
$DIAGMATRIX
$DIAGMETRIC
$DIFF
$DIM
$DIMENSION
$DIREC
$DIRECT
$DISKFREE
$DISOLATE
$DISP
$DISPCON
$DISPFLAG
$DISPFORM
$DISPFUN
$DISPLAY
$DISPLAY2D
$DISPLAY_FORMAT_INTERNAL
$DISPRULE
$DISPTERMS
$DISTRIB
$DIVIDE
$DIVSUM
$DO
$DOALLMXOPS
$DOMAIN
$DOMXEXPT
$DOMXMXOPS
$DOMXNCTIMES
$DONE
$DONTFACTOR
$DOSCMXOPS
$DOSCMXPLUS
$DOT0NSCSIMP
$DOT0SIMP
$DOT1SIMP
$DOTASSOC
$DOTCONSTRULES
$DOTDISTRIB
$DOTEXPTSIMP
$DOTIDENT
$DOTSCRULES
$DOTSIMP
$DPART
$DSCALAR
$DSKALL
$DUMMY
$%E
$ECHELON
$EIGENVALUES
$EIGENVECTORS
$EINSTEIN
$ELE2COMP
$ELE2POLYNOME
$ELE2PUI
$ELEM
$ELSE
$ELIMINATE
$ELLIPTIC_E
$ELLIPTIC_EC
$ELLIPTIC_EU
$ELLIPTIC_F
$ELLIPTIC_KC
$ELLIPTIC_PI
$EMATRIX
$ENDCONS
$ENTERMATRIX
$ENTIER
$EQUAL
$ERF
$ERFFLAG
$ERRCATCH
$ERREXP
$ERRINTSCE
$ERROR
$ERROR_SIZE
$ERROR_SYMS
$ERRORFUN
$ERRORMSG
$EULER
$EV
$EVAL
$EVEN
$EVENFUN
$EVENP
$EVFLAG
$EVFUN
$EXAMPLE
$EXP
$EXPAND
$EXPANDWRT
$EXPANDWRT_DENOM
$EXPANDWRT_FACTORED
$EXPLOSE
$EXPON
$EXPONENTIALIZE
$EXPOP
$EXPRESS
$EXPT
$EXPTDISPFLAG
$EXPTISOLATE
$EXPTSUBST
$EXTRACT_LINEAR_EQUATIONS
$EZGCD
$FACEXPAND
$FACTCOMB
$FACTLIM
$FACTOR
$FACTORFLAG
$FACTORIAL
$FACTOROUT
$FACTORSUM
$FACTS
$FALSE
$FASSAVE
$FAST_CENTRAL_ELEMENTS
$FAST_LINSOLVE
$FASTTIMES
$FEATURE
$FEATUREP
$FEATURES
$FFT
$FIB
$FIBTOPHI
$FILE_SEARCH
$FILE_STRING_PRINT
$FILE_TYPE
$FILEDEFAULTS
$FILENAME
$FILENAME_MERGE
$FILENUM
$FILLARRAY
$FIRST
$FIX
$FLOAT
$FLOAT2BF
$FLOATDEFUNK
$FLOATNUMP
$FLUSH
$FLUSHD
$FLUSHND
$FOR
$FORGET
$FORTINDENT
$FORTMX
$FORTRAN
$FORTSPACES
$FPPREC
$FPPRINTPREC
$FREEOF
$FULLMAP
$FULLMAPL
$FULLRATSIMP
$FULLRATSUBST
$FUNCSOLVE
$FUNCTIONS
$FUNDEF
$FUNMAKE
$GAMMA
$GAMMALIM
$GAUSS
$GCD
$GCDEX
$GCFACTOR
$GEN_LAGUERRE
$GENDIFF
$GENFACT
$GENINDEX
$GENMATRIX
$GENSUMNUM
$GET
$GETCHAR
$GFACTOR
$GFACTORSUM
$GLOBALSOLVE
$GO
$GRADEF
$GRADEFS
$GRAMSCHMIDT
$GRIND
$GROBNER_BASIS
$HACH
$HALFANGLES
$HERMITE
$HIPOW
$HORNER
$%I
$IBASE
$IC1
$IC2
$IDENT
$IEQN
$IEQNPRINT
$IF
$IFT
$ILT
$IMAGPART
$IN_NETMATH
$INCHAR
$INDICES
$INF
$INFEVAL
$INFINITY
$INFIX
$INFLAG
$INFOLISTS
$INNERPRODUCT
$INPART
$INRT
$INTEGER
$INTEGERP
$INTEGRATE
$INTEGRATE_USE_ROOTSOF
$INTEGRATION_CONSTANT_COUNTER
$INTERPOLATE
$INTFACLIM
$INTOPOIS
$INTOSUM
$INTPOLABS
$INTPOLERROR
$INTPOLREL
$INTSCE
$INVERSE_JACOBI_CD
$INVERSE_JACOBI_CN
$INVERSE_JACOBI_CS
$INVERSE_JACOBI_DC
$INVERSE_JACOBI_DN
$INVERSE_JACOBI_DS
$INVERSE_JACOBI_NC
$INVERSE_JACOBI_ND
$INVERSE_JACOBI_NS
$INVERSE_JACOBI_SC
$INVERSE_JACOBI_SD
$INVERSE_JACOBI_SN
$INVERT
$IS
$ISOLATE
$ISOLATE_WRT_TIMES
$ISQRT
$JACOBI
$JACOBI_CD
$JACOBI_CN
$JACOBI_CS
$JACOBI_DC
$JACOBI_DN
$JACOBI_DS
$JACOBI_NC
$JACOBI_ND
$JACOBI_NS
$JACOBI_P
$JACOBI_SC
$JACOBI_SD
$JACOBI_SN
$KDELTA
$KEEPFLOAT
$KILL
$KILLCONTEXT
$KOSTKA
$LABELS
$LAGUERRE
$LAMBDA
$LAPLACE
$LASSOCIATIVE
$LAST
$LASTTIME
$LC
$LCM
$LDEFINT
$LDISP
$LDISPLAY
$LEGENDRE_P
$LEGENDRE_Q
$LENGTH
$LET
$LET_RULE_PACKAGES
$LETRAT
$LETRULES
$LETSIMP
$LFREEOF
$LGTREILLIS
$LHOSPITALLIM
$LHS
$LIMIT
$LINEAR
$LINECHAR
$LINEDISP
$LINEL
$LINENUM
$LINSOLVE
$LINSOLVE_PARAMS
$LINSOLVEWARN
$LISPDEBUGMODE
$LIST_NC_MONOMIALS
$LISTARITH
$LISTARRAY
$LISTCONSTVARS
$LISTDUMMYVARS
$LISTOFVARS
$LISTP
$LMXCHAR
$LOAD
$LOADFILE
$LOADPRINT
$LOCAL
$LOG
$LOGABS
$LOGARC
$LOGCONCOEFFP
$LOGCONTRACT
$LOGEXPAND
$LOGNEGINT
$LOGNUMER
$LOGSIMP
$LOPOW
$LORENTZ
$LPART
$LRATSUBST
$LRICCICOM
$LSUM
$LTREILLIS
$M1PBRANCH
$MACROEXPANSION
$MAINVAR
$MAKE_ARRAY
$MAKEBOX
$MAKEFACT
$MAKEGAMMA
$MAKELIST
$MAP
$MAPATOM
$MAPERROR
$MAPLIST
$MATCHDECLARE
$MATCHFIX
$MATRIX
$MATRIX_ELEMENT_ADD
$MATRIX_ELEMENT_MULT
$MATRIX_ELEMENT_TRANSPOSE
$MATRIXMAP
$MATRIXP
$MATTRACE
$MAX
$MAXAPPLYDEPTH
$MAXAPPLYHEIGHT
$MAXNEGEX
$MAXPOSEX
$MAXPRIME
$MAXTAYORDER
$MEMBER
$METRIC
$MIN
$MINF
$MINFACTORIAL
$MINOR
$MINUS
$MOD
$MODE_CHECK_ERRORP
$MODE_CHECK_WARNP
$MODE_CHECKP
$MODE_DECLARE
$MODE_IDENTITY
$MODULUS
$MON2SCHUR
$MONO
$MONOMIAL_DIMENSIONS
$MOTION
$MULTI_ELEM
$MULTI_ORBIT
$MULTI_PUI
$MULTINOMIAL
$MULTIPLICATIVE
$MULTIPLICITIES
$MULTSYM
$MULTTHRU
MUNBOUND
$MYOPTIONS
$NARY
$NC_DEGREE
$NCEXPT
$NCHARPOLY
$NEGDISTRIB
$NEGSUMDISPFLAG
$NEW-DISREP
$NEWCONTEXT
$NEWDET
$NEWFAC
$NEWTON
$NICEINDICES
$NICEINDICESPREF
$NOEVAL
$NOLABELS
$NON
SCALAR
$NONSCALAR
$NONSCALARP
$NOSTRING
$NOT
$NOUN
$NOUNDISP
$NOUNIFY
$NOUNS
$NROOTS
$NTERMS
$NTERMSG
$NTERMSRCI
$NTHROOT
$NUM
$NUMBERP
$NUMER
$NUMERVAL
$NUMFACTOR
$NUSUM
$NZETA
$OBASE
$ODD
$ODDFUN
$ODDP
$ODE
$ODE2
$OMEGA
$OP
$OPERATORP
$OPENPLOT_CURVES
$OPPROPERTIES
$OPSUBST
$OPTIMIZE
$OPTIMPREFIX
$OPTIONSET
$OR
$ORBIT
$ORDERGREAT
$ORDERGREATP
$ORDERLESS
$ORDERLESSP
$OUTATIVE
$OUTCHAR
$OUTOFPOIS
$PACKAGEFILE
$PADE
$PARSEWINDOW
$PART
$PART2CONT
$PARTFRAC
$PARTITION
$PARTPOL
$PARTSWITCH
$PCOEFF
$PERMANENT
$PERMUT
$PFEFORMAT
$%PI
$PICKAPART
$PIECE
$PLAYBACK
$PLOG
$PLOT2D
$PLOT2D_PS
$PLOT3D
$PLOT_OPTIONS
$PLUS
$POISDIFF
$POISEXPT
$POISINT
$POISLIM
$POISMAP
$POISPLUS
$POISSIMP
$POISSON
$POISSUBST
$POISTIMES
$POISTRIM
$POLARFORM
$POLARTORECT
$POLY_DISCRIMINANT
$POLYNOME2ELE
$POSFUN
$POTENTIAL
$POWERDISP
$POWERS
$POWERSERIES
$PRED
$PREDERROR
$PRIME
$PRIMEP
$PRINT
$PRINTPOIS
$PRINTPROPS
$PRODHACK
$PRODRAC
$PRODUCT
$PROGRAMMODE
$PROMPT
$PROPERTIES
$PROPS
$PROPVARS
$PSCOM
$PSDRAW_CURVE
$PSEXPAND
$PSI
$PUI
$PUI2COMP
$PUI2ELE
$PUI2POLYNOME
$PUI_DIRECT
$PUIREDUC
$PUT
$QPUT
$QQ
$QUANC8
$QUIT
$QUNIT
$QUOTIENT
$RADCAN
$RADEXPAND
$RADPRODEXPAND
$RADSUBSTFLAG
$RAISERIEMANN
$RANDOM
$RANK
$RASSOCIATIVE
$RAT
$RATALGDENOM
$RATCOEF
$RATDENOM
$RATDENOMDIVIDE
$RATDIFF
$RATDISREP
$RATEINSTEIN
$RATEPSILON
$RATEXPAND
$RATFAC
$RATMX
$RATNUMER
$RATNUMP
$RATP
$RATPRINT
$RATRIEMAN
$RATRIEMANN
$RATSIMP
$RATSIMPEXPONS
$RATSUBST
$RATVARS
$RATWEIGHT
$RATWEIGHTS
$RATWEYL
$RATWTLVL
$READ
$READONLY
$REALONLY
$REALPART
$REALROOTS
$REARRAY
$RECTFORM
$RECTTOPOLAR
$REFCHECK
$REM
$REMAINDER
$REMARRAY
$REMBOX
$REMCON
$REMFUNCTION
$REMLET
$REMOVE
$REMRULE
$REMTRACE
$REMVALUE
$RENAME
$RESET
$RESIDUE
$RESOLVANTE
$RESOLVANTE_ALTERNEE1
$RESOLVANTE_BIPARTITE
$RESOLVANTE_DIEDRALE
$RESOLVANTE_KLEIN
$RESOLVANTE_KLEIN3
$RESOLVANTE_PRODUIT_SYM
$RESOLVANTE_UNITAIRE
$RESOLVANTE_VIERER
$REST
$RESTORE
$RESULTANT
$RETURN
$REVEAL
$REVERSE
$REVERT
$RHS
$RICCICOM
$RIEMANN
$RINVARIANT
$RISCH
$RMXCHAR
$RNCOMBINE
$ROMBERG
$ROMBERGABS
$ROMBERGIT
$ROMBERGMIN
$ROMBERGTOL
$ROOM
$ROOTSCONMODE
$ROOTSCONTRACT
$ROOTSEPSILON
$ROW
$SAVE
$SAVEDEF
$SAVEFACTORS
$SCALAR
$SCALARMATRIXP
$SCALARP
$SCALEFACTORS
$SCANMAP
$SCHUR2COMP
$SCONCAT
$SCSIMP
$SCURVATURE
$SEC
$SECH
$SET_PLOT_OPTION
$SET_UP_DOT_SIMPLIFICATIONS
$SETCHECK
$SETCHECKBREAK
$SETELMX
$SETUP
$SETUP_AUTOLOAD
$SETVAL
$SHOW
$SHOWRATVARS
$SHOWTIME
$SIGN
$SIGNUM
$SIMILARITYTRANSFORM
$SIMP
$SIMPSUM
$SIN
$SINH
$SOLN2
$SOLVE
$SOLVE_INCONSISTENT_ERROR
$SOLVEDECOMPOSES
$SOLVEEXPLICIT
$SOLVEFACTORS
$SOLVENULLWARN
$SOLVERADCAN
$SOLVETRIGWARN
$SOMRAC
$SORT
$SPARSE
$SPHERICAL_BESSEL_J
$SPHERICAL_BESSEL_Y
$SPHERICAL_HANKEL1
$SPHERICAL_HANKEL2
$SPHERICAL_HARMONIC
$SPLICE
$SPRINT
$SQFR
$SQRT
$SQRTDISPFLAG
$SRRAT
$SSTATUS
$STARDISP
$STATUS
$STRING
$STRINGOUT
$SUBLIS
$SUBLIS_APPLY_LAMBDA
$SUBLIST
$SUBMATRIX
$SUBST
$SUBSTINPART
$SUBSTPART
$SUBVARP
$SUM
$SUMCONTRACT
$SUMEXPAND
$SUMHACK
$SUMSPLITFACT
$SUPCONTEXT
$SYMBOLP
$SYMMETRIC
$SYSTEM
$TAN
$TANH
$TAYLOR
$TAYLOR_LOGEXPAND
$TAYLOR_ORDER_COEFFICIENTS
$TAYLOR_SIMPLIFIER
$TAYLOR_TRUNCATE_POLYNOMIALS
$TAYLORDEPTH
$TAYLORINFO
$TAYLORP
$TAYTORAT
$TCL_OUTPUT
$TCONTRACT
$TELLRAT
$TELLSIMP
$TELLSIMPAFTER
$TEX
$THEN
$THROW
$TIME
$TIMER
$TIMER_DEVALUE
$TIMER_INFO
$TLDEFINT
$TLIMIT
$TLIMSWITCH
$TO_LISP
$TOBREAK
$TODD_COXETER
$TOPLEVEL
$TOTALDISREP
$TOTIENT
$TPARTPOL
$TR_ARRAY_AS_REF
$TR_BOUND_FUNCTION_APPLYP
$TR_FILE_TTY_MESSAGESP
$TR_FLOAT_CAN_BRANCH_COMPLEX
$TR_FUNCTION_CALL_DEFAULT
$TR_GEN_TAGS
$TR_NUMER
$TR_OPTIMIZE_MAX_LOOP
$TR_OUTPUT_FILE_DEFAULT
$TR_PREDICATE_BRAIN_DAMAGE
$TR_SEMICOMPILE
$TR_STATE_VARS
$TR_TRUE_NAME_OF_FILE_BEING_TRANSLATED
$TR_VERSION
$TR_WARN_BAD_FUNCTION_CALLS
$TR_WARN_FEXPR
$TR_WARN_MEVAL
$TR_WARN_MODE
$TR_WARN_UNDECLARED
$TR_WARN_UNDEFINED_VARIABLE
$TR_WARNINGS_GET
$TR_WINDY
$TRACE
$TRACE_OPTIONS
$TRANSBIND
$TRANSCOMPILE
$TRANSFORM
$TRANSLATE
$TRANSLATE_FILE
$TRANSPOSE
$TRANSRUN
$TREILLIS
$TREINAT
$TRIANGULARIZE
$TRIGEXPAND
$TRIGEXPANDPLUS
$TRIGEXPANDTIMES
$TRIGINVERSES
$TRIGRAT
$TRIGREDUCE
$TRIGSIGN
$TRIGSIMP
$TRUE
$TRUNC
$TSETUP
$TTRANSFORM
$TTYINTFUN
$TTYINTNUM
$TTYOFF
$ULTRASPHERICAL
$UNDECLAREDWARN
$UNDIFF
$UNITEIGENVECTORS
$UNITVECTOR
$UNKNOWN
$UNORDER
$UNSUM
$UNTELLRAT
$UNTRACE
$USE_FAST_ARRAYS
$VALUES
$VECT_CROSS
$VECTORPOTENTIAL
$VECTORSIMP
$VERB
$VERBIFY
$VERBOSE
$WEYL
$WITH_STDOUT
$WRITEFILE
$xgraph_curves
$XTHRU
$ZEROBERN
$ZEROEQUIV
$ZEROMATRIX
$ZETA
$ZETA%PI
$ZRPOLY
$ZSOLVE
$ZUNDERFLOW
;;; Control Flow keywords
$FOR
$STEP
$THRU
$DO
$WHILE
$UNLESS
$NEXT
$FROM
$IN
;; Poisson Series
$U $V $W $X $Y $Z
;; Actually internal, but necessary for rtest6a.mac, problem 36.
MBOX
) :maxima)
;;; TEST
;;; 1. for a in [1,2,3] do print(a);
;;; 2. [y0,y1,y2,y3,y4,y5,y6];
;;; 3. %;
;;; 4. SIN(%PI);
;;; 5. LOG(%E);
--Apple-Mail-6-308992742--
--Apple-Mail-5-308992739
Content-Transfer-Encoding: 7bit
Content-Type: text/plain;
charset=US-ASCII;
format=flowed
> 1). First step is to introduce MAXIMA and MAXIMA-USER
> packages. This is relatively easy to do but immediately
> makes Maxima significantly more robust and resolves
> kill problem.
>
> 2). Later MAXIMA package must be split on smaller
> packages to make Maxima core clean and modular.
> Ceratanly this is very serious and complicated undertaking
> which requires deep understanding of Maxima core and
> we are not ready to do this now. But in my opinion
> eventually we have do such Maxima core modularization.
>
> 3). Maxima desperately needs user-level package system.
> In particular each package in SHARE must form separate
> user package with clean interface. Internally Maxima
> user-level packages may be implemented with the help
> of CL packages. Certainly, this is also not highest
> priority task.
>
> Finally some other but somewhat related to the
> "kill problem" issue. Right now all packages
> in SHARE remains uncompiled and get installed as
> source code. This seems to be unnatural to me.
> AFAIK all share packages in commercial Macsyma are
> compiled (at least this is true for quite old
> Windows 3.1 Macsyma which I have).
> As far as I remember Richard mentioned that
> not all packages in share could be successfully compiled.
> But this is probably rather exception than general
> rule. This may also depend on the background lisp.
> Eventually I'd like to see all share package in
> compiled form on all lisp platforms but for the
> time being one can modify Maxima make/install
> machinery to compile share packages at least
> selectively. Any opinions?
>
> Best wishes,
>
> Vadim
>
>
> --
> Vadim V. Zhytnikov
>
> <vvzhy@mail.ru>
> <vvzhy@netorn.ru>
>
>
>
>
> _______________________________________________
> Maxima mailing list
> Maxima@www.math.utexas.edu
> http://www.math.utexas.edu/mailman/listinfo/maxima
>
--Apple-Mail-5-308992739--