You can subscribe to this list here.
2001 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}
(20) 
_{Dec}
(17) 

2002 
_{Jan}
(39) 
_{Feb}
(21) 
_{Mar}
(33) 
_{Apr}
(135) 
_{May}
(53) 
_{Jun}
(88) 
_{Jul}
(47) 
_{Aug}
(59) 
_{Sep}
(207) 
_{Oct}
(40) 
_{Nov}
(7) 
_{Dec}
(26) 
2003 
_{Jan}
(49) 
_{Feb}
(39) 
_{Mar}
(117) 
_{Apr}
(50) 
_{May}
(62) 
_{Jun}
(6) 
_{Jul}
(19) 
_{Aug}
(24) 
_{Sep}
(11) 
_{Oct}
(11) 
_{Nov}
(49) 
_{Dec}
(9) 
2004 
_{Jan}
(29) 
_{Feb}
(123) 
_{Mar}
(32) 
_{Apr}
(53) 
_{May}
(52) 
_{Jun}
(19) 
_{Jul}
(33) 
_{Aug}
(10) 
_{Sep}
(76) 
_{Oct}
(86) 
_{Nov}
(171) 
_{Dec}
(163) 
2005 
_{Jan}
(147) 
_{Feb}
(121) 
_{Mar}
(120) 
_{Apr}
(126) 
_{May}
(120) 
_{Jun}
(213) 
_{Jul}
(76) 
_{Aug}
(79) 
_{Sep}
(140) 
_{Oct}
(83) 
_{Nov}
(156) 
_{Dec}
(202) 
2006 
_{Jan}
(181) 
_{Feb}
(171) 
_{Mar}
(157) 
_{Apr}
(98) 
_{May}
(96) 
_{Jun}
(97) 
_{Jul}
(193) 
_{Aug}
(76) 
_{Sep}
(130) 
_{Oct}
(63) 
_{Nov}
(196) 
_{Dec}
(253) 
2007 
_{Jan}
(256) 
_{Feb}
(293) 
_{Mar}
(276) 
_{Apr}
(258) 
_{May}
(181) 
_{Jun}
(91) 
_{Jul}
(108) 
_{Aug}
(69) 
_{Sep}
(107) 
_{Oct}
(179) 
_{Nov}
(137) 
_{Dec}
(121) 
2008 
_{Jan}
(124) 
_{Feb}
(129) 
_{Mar}
(192) 
_{Apr}
(201) 
_{May}
(90) 
_{Jun}
(86) 
_{Jul}
(115) 
_{Aug}
(142) 
_{Sep}
(49) 
_{Oct}
(91) 
_{Nov}
(95) 
_{Dec}
(218) 
2009 
_{Jan}
(230) 
_{Feb}
(149) 
_{Mar}
(118) 
_{Apr}
(72) 
_{May}
(77) 
_{Jun}
(68) 
_{Jul}
(102) 
_{Aug}
(72) 
_{Sep}
(89) 
_{Oct}
(76) 
_{Nov}
(125) 
_{Dec}
(86) 
2010 
_{Jan}
(75) 
_{Feb}
(90) 
_{Mar}
(89) 
_{Apr}
(121) 
_{May}
(111) 
_{Jun}
(66) 
_{Jul}
(75) 
_{Aug}
(66) 
_{Sep}
(66) 
_{Oct}
(166) 
_{Nov}
(121) 
_{Dec}
(73) 
2011 
_{Jan}
(74) 
_{Feb}

_{Mar}

_{Apr}
(14) 
_{May}
(22) 
_{Jun}
(31) 
_{Jul}
(53) 
_{Aug}
(37) 
_{Sep}
(23) 
_{Oct}
(25) 
_{Nov}
(31) 
_{Dec}
(28) 
2012 
_{Jan}
(18) 
_{Feb}
(11) 
_{Mar}
(32) 
_{Apr}
(17) 
_{May}
(48) 
_{Jun}
(37) 
_{Jul}
(23) 
_{Aug}
(54) 
_{Sep}
(15) 
_{Oct}
(11) 
_{Nov}
(19) 
_{Dec}
(22) 
2013 
_{Jan}
(11) 
_{Feb}
(32) 
_{Mar}
(24) 
_{Apr}
(37) 
_{May}
(31) 
_{Jun}
(14) 
_{Jul}
(26) 
_{Aug}
(33) 
_{Sep}
(40) 
_{Oct}
(21) 
_{Nov}
(36) 
_{Dec}
(84) 
2014 
_{Jan}
(23) 
_{Feb}
(20) 
_{Mar}
(27) 
_{Apr}
(24) 
_{May}
(31) 
_{Jun}
(27) 
_{Jul}
(34) 
_{Aug}
(26) 
_{Sep}
(21) 
_{Oct}
(45) 
_{Nov}
(23) 
_{Dec}
(73) 
2015 
_{Jan}
(33) 
_{Feb}
(8) 
_{Mar}
(24) 
_{Apr}
(45) 
_{May}
(27) 
_{Jun}
(19) 
_{Jul}
(21) 
_{Aug}
(51) 
_{Sep}
(43) 
_{Oct}
(29) 
_{Nov}
(61) 
_{Dec}
(86) 
2016 
_{Jan}
(99) 
_{Feb}
(52) 
_{Mar}
(80) 
_{Apr}
(61) 
_{May}
(24) 
_{Jun}
(23) 
_{Jul}
(36) 
_{Aug}
(30) 
_{Sep}
(41) 
_{Oct}
(43) 
_{Nov}
(27) 
_{Dec}
(46) 
2017 
_{Jan}
(57) 
_{Feb}
(34) 
_{Mar}
(40) 
_{Apr}
(31) 
_{May}
(78) 
_{Jun}
(49) 
_{Jul}
(72) 
_{Aug}
(33) 
_{Sep}
(26) 
_{Oct}
(82) 
_{Nov}
(50) 
_{Dec}

S  M  T  W  T  F  S 



1
(1) 
2
(3) 
3
(2) 
4
(6) 
5
(2) 
6
(8) 
7
(4) 
8
(7) 
9
(8) 
10
(1) 
11
(7) 
12
(2) 
13
(23) 
14
(1) 
15
(3) 
16
(1) 
17

18
(2) 
19
(1) 
20
(1) 
21
(2) 
22
(3) 
23
(5) 
24
(1) 
25
(1) 
26
(2) 
27
(17) 
28
(7) 





From: Raymond Toy <rtoy@us...>  20050222 22:57:49

Update of /cvsroot/maxima/maxima/src In directory sc8prcvs1.sourceforge.net:/tmp/cvsserv16070/src Modified Files: hypgeo.lisp Log Message: o Add some comments, reindent some code. o Change how DEFINTEGRATE behaves. Currently, DEFINTEGRATE enables $EXPONENTIALIZE for everything. I think this is not good, so we now $EXPONENTIALIZE only when expanding EXP. DISTRDEFEXECINIT no longer is callled with $EXPONENTIALIZE true. If some function wants it, it needs to set it itself. I've tested this change and all tests pass. And the Laplace transform for formula 50, p. 188 is now expressed in terms of tan and sec instead of having converted tan and sec to exponential form. Index: hypgeo.lisp =================================================================== RCS file: /cvsroot/maxima/maxima/src/hypgeo.lisp,v retrieving revision 1.12 retrieving revision 1.13 diff u d r1.12 r1.13  hypgeo.lisp 21 Feb 2005 17:46:44 0000 1.12 +++ hypgeo.lisp 22 Feb 2005 22:57:39 0000 1.13 @@ 499,8 +499,8 @@ ((coeffpp)(a zerp))) nil)) (defun oney  (exp) +;; Recognize u*bessel_y(v,w) +(defun oney (exp) (m2 exp '((mplus) ((coeffpt) @@ 729,12 +729,23 @@ +#+nil (defun defintegrate (exp) (prog ($exponentialize) (setq $exponentialize t) (return (distrdefexecinit ($expand (ssimplifya exp)))))) +(defun defintegrate (exp) + ;; This used to have $exponentialize enabled for everything, but I + ;; don't think we should do that. If various routines want + ;; $exponentialize, let them set it themselves. So, for here, we + ;; want to expand the form with $exponentialize to convert trig and + ;; hyperbolic functions to exponential functions that we can handle. + (let ((form (let (($exponentialize t)) + ($expand (ssimplifya exp))))) + (distrdefexecinit form))) + (defun defexec (exp var) @@ 745,19 +756,14 @@ (return (negtest l a)))) (return 'otherdefinttofollowdefexec))) (defun negtest  (l a)  (prog(u e f c) +(defun negtest (l a) + (prog (u e f c) (cond ((eq (checksigntm ($realpart a)) '$negative)  (setq u  (cdras 'u l)  e  (cdras 'e l)  f  (cdras 'f l)  c  (cdras 'c l))  (cond ((zerp e)(setq f 1))) + (setq u (cdras 'u l) + e (cdras 'e l) + f (cdras 'f l) + c (cdras 'c l)) + (cond ((zerp e) (setq f 1))) (return (maximasubstitute (mul 1 a) 'psey (ltscale u @@ 774,8 +780,9 @@ (mul* (power '$%e c) (substl (sub *par* par0) *par* (ltexec exp e f)))) (defun defltep  (exp) +;; I think this is trying to match EXP to u*%e^(a*x+e*f+c) +;; where a, c, and e are free of x, f is free of p. +(defun defltep (exp) (m2 exp '((mplus) ((coeffpt) @@ 856,9 +863,11 @@ (defun t^1(exp)(m2 exp '((mexpt)(t varp) 1) nil)) (defun f24p146test  (c v a)  (cond ((not (or (neginp a)(neginp v)))(f24p146 c v a)) +;; Check if conditions for f24p146 hold +(defun f24p146test (c v a) + (cond ((not (or (neginp a) + (neginp v))) + (f24p146 c v a)) (t 'failonf24p146test))) (defun f35p147test @@ 876,9 +885,16 @@ (cond ((not (neginp (add pow 1)))(f1p137 pow)) (t 'failinarbpow))) (defun f1p137  (pow)  (mul* (gm (add pow 1))(power *par* (sub (mul 1 pow) 1)))) +;; Table of Integral Transforms +;; +;; p. 137, formula 1: +;; +;; t^u*exp(p*t) +;; > gamma(u+1)*p^(u1) +;; +(defun f1p137 (pow) + (mul* (gm (add pow 1)) + (power *par* (sub (mul 1 pow) 1)))) ;; Table of Integral Transforms ;; @@ 939,8 +955,12 @@ (t (simpktf z v)))) (power (mul* a *par*)(1//2)))) (defun dtford  (z v) +;; Express a parabolic cylinder function as either a parabolic +;; cylinder function or as hypergeometric function. +;; +;; D[v](z) = 2^(v/2+1/2)*z^(1/2)*W[v/2+1/4,1/4](z^2/2) +;; +(defun dtford (z v) (cond (((lambda(inv4) (whittindtest (add (div v 2) inv4) inv4)) (inv 4)) @@ 948,6 +968,7 @@ (t (simpdtf z v)))) +;; Express parabolic cylinder function as a hypergeometric function. (defun simpdtf (z v) ((lambda(inv2 pow) @@ 1694,9 +1715,15 @@ (slommeltjandy i1 i11 a1))))) (t 'yofnofractindex))) (defun lt1yref  (rest arg1 index1)  (cond ((maximaintegerp index1)(lt1y rest arg1 index1)) +;; Laplace transform of a single Bessel Y function. +;; +;; REST is the multiplier, ARG1 is the arg, and INDEX1 is the order of +;; the Bessel Y function. +(defun lt1yref (rest arg1 index1) + ;; If the index is an integer, use LT1Y. Otherwise, convert Bessel + ;; Y to Bessel J and compute the transform of that. + (cond ((maximaintegerp index1) + (lt1y rest arg1 index1)) (t (fractest2 rest arg1 index1 nil 'ytj)))) (defun pjactest @@ 1732,8 +1759,7 @@ (t (distrexecinit ($expand (mul (init r) (wtm a i1 i2))))))) (defun whittindtest  (i1 i2) +(defun whittindtest (i1 i2) (or (maximaintegerp (add i2 i2)) (neginp (sub (sub (1//2) i2) i1)) (neginp (sub (add (1//2) i2) i1)))) @@ 1988,7 +2014,8 @@ (defun lt1j(rest arg index)(ltltp 'onej rest arg index)) (defun lt1y(rest arg index)(ltltp 'oney rest arg index)) +(defun lt1y (rest arg index) + (ltltp 'oney rest arg index)) (defun lt2j (rest arg1 arg2 index1 index2) 
From: Robert Dodier <robert_dodier@us...>  20050222 04:53:04

Update of /cvsroot/maxima/maxima/doc/info In directory sc8prcvs1.sourceforge.net:/tmp/cvsserv5008 Modified Files: Affine.texi Log Message: Strike out obsolete, commentedout texinfo tags; change uppercase to lowercase; enclose names in @var or @code as appropriate; minor revisions for clarity. Work on this file is limited because I havent been able to load the affine package completely. All items need examples. File needs more work. Index: Affine.texi =================================================================== RCS file: /cvsroot/maxima/maxima/doc/info/Affine.texi,v retrieving revision 1.6 retrieving revision 1.7 diff u d r1.6 r1.7  Affine.texi 16 Nov 2004 21:53:01 0000 1.6 +++ Affine.texi 22 Feb 2005 04:52:55 0000 1.7 @@ 5,129 +5,129 @@ @node Definitions for Affine, , Affine, Affine @section Definitions for Affine @... @node FAST_LINSOLVE @... @unnumberedsec phony @... FAST_LINSOLVE (eqns,variables) Solves the linear system of equations EQNS for the variables VARIABLES and returns a result suitable to SUBLIS. The function is faster than linsolve for system of equations which + +@defun fast_linsolve ([@var{expr_1}, ..., @var{expr_m}], [@var{x_1}, ..., @var{x_n}]) +Solves the simultaneous linear equations @var{expr_1}, ..., @var{expr_m} +for the variables @var{x_1}, ..., @var{x_n}. +Each @var{expr_i} may be an equation or a general expression; +if given as a general expression, it is treated as an equation of the form @code{@var{expr_i} = 0}. + +The return value is a list of equations of the form +@code{[@var{x_1} = @var{a_1}, ..., @var{x_n} = @var{a_n}]} +where @var{a_1}, ..., @var{a_n} are all free of @var{x_1}, ..., @var{x_n}. + +@code{fast_linsolve} is faster than @code{linsolve} for system of equations which are sparse. @end defun @... @node GROBNER_BASIS @... @unnumberedsec phony @... GROBNER_BASIS (eqns) Takes as argument a list of equations and returns a grobner basis for them. The function POLYSIMP may now + +@defun grobner_basis ([@var{expr_1}, ..., @var{expr_m}]) +Returns a Groebner basis for the equations @var{expr_1}, ..., @var{expr_m}. +The function @code{polysimp} can then be used to simplify other functions relative to the equations. GROBNER_BASIS([3*X^2+1,Y*X])$ +@example +grobner_basis ([3*x^2+1, y*x])$ POLYSIMP(Y^2*X+X^3*9+2)==> 3*x+2 +polysimp (y^2*x + x^3*9 + 2) ==> 3*x + 2 +@end example Polysimp(f)==> 0 if and only if f is in the ideal generated by the EQNS ie. if and only if f is a polynomial combination of the elements of EQNS. +@code{polysimp(f)} yields 0 if and only if @var{f} is in the ideal generated by +@var{expr_1}, ..., @var{expr_m}, that is, +if and only if @var{f} is a polynomial combination of the elements of +@var{expr_1}, ..., @var{expr_m}. @end defun @... @node SET_UP_DOT_SIMPLIFICATIONS @... @unnumberedsec phony @... SET_UP_DOT_SIMPLIFICATIONS (eqns,[checkthrudegree]) + +@defun set_up_dot_simplifications (eqns, [checkthrudegree]) The eqns are polynomial equations in non commutative variables. The value of CURRENT_VARIABLES is the +The value of @code{current_variables} is the list of variables used for computing degrees. The equations must be homogeneous, in order for the procedure to terminate. If you have checked overlapping simplifications in DOT_SIMPLIFICATIONS +If you have checked overlapping simplifications in @code{dot_simplifications} above the degree of f, then the following is true: DOTSIMP(f)==> 0 if and only if f is in the ideal generated by the EQNS ie. if and only if f is a polynomial combination of the elements of EQNS. +@code{dotsimp (f)} yields 0 if and only if @var{f} is in the ideal generated by the equations, i.e., +if and only if @var{f} is a polynomial combination of the elements of the equations. The degree is that returned by NC_DEGREE. This in turn is influenced by +The degree is that returned by @code{nc_degree}. This in turn is influenced by the weights of individual variables. @end defun @... @node DECLARE_WEIGHT @... @unnumberedsec phony @... DECLARE_WEIGHT (var1,wt1,var2,wt2,...) Assigns VAR1 weight WT1, VAR2 weight wt2.. These are the weights used in computing NC_DEGREE. + +@defun declare_weight (@var{x_1}, @var{w_1}, ..., @var{x_n}, @var{w_n}) +Assigns weights @var{w_1}, ..., @var{w_n} to @var{x_1}, ..., @var{x_n}, respectively. +These are the weights used in computing @code{nc_degree}. @end defun @... @node NC_DEGREE @... @unnumberedsec phony @... NC_DEGREE (poly) Degree of a non commutative polynomial. See DECLARE_WEIGHTS. + +@defun nc_degree (@var{p}) +Returns the degree of a noncommutative polynomial @var{p}. See @code{declare_weights}. @end defun @... @node DOTSIMP @... @unnumberedsec phony @... DOTSIMP (f) ==> 0 if and only if f is in the ideal generated by the EQNS ie. if and only if f is a polynomial combination of the elements of EQNS. + +@defun dotsimp (f) +Returns 0 if and only if @var{f} is in the ideal generated by the equations, i.e., +if and only if @var{f} is a polynomial combination of the elements of the equations. @end defun @... @node FAST_CENTRAL_ELEMENTS @... @unnumberedsec phony @... FAST_CENTRAL_ELEMENTS (variables,degree) if SET_UP_DOT_SIMPLIFICATIONS has been previously done, finds the central polynomials in the variables in the given degree, + +@defun fast_central_elements ([@var{x_1}, ..., @var{x_n}], @var{n}) +If @code{set_up_dot_simplifications} has been previously done, finds the central polynomials +in the variables @var{x_1}, ..., @var{x_n} in the given degree, @var{n}. + For example: @example set_up_dot_simplifications([y.x+x.y],3); fast_central_elements([x,y],2); [y.y,x.x]; +set_up_dot_simplifications ([y.x + x.y], 3); +fast_central_elements ([x, y], 2); +[y.y, x.x]; @end example + @end defun @... @node CHECK_OVERLAPS @... @unnumberedsec phony @... CHECK_OVERLAPS (degree,addtosimps) checks the overlaps thru degree, + +@c THIS IS NOT AT ALL CLEAR +@defun check_overlaps (@var{n}, @var{addtosimps}) +Checks the overlaps thru degree @var{n}, making sure that you have sufficient simplification rules in each degree, for dotsimp to work correctly. This process can be speeded +degree, for @code{dotsimp} to work correctly. This process can be speeded up if you know before hand what the dimension of the space of monomials is. If it is of finite global dimension, then HILBERT should be used. If you don't know the monomial dimensions, do not specify a RANK_FUNCTIION. An optional third argument RESET, false says don't bother to query +If it is of finite global dimension, then @code{hilbert} should be used. If you +don't know the monomial dimensions, do not specify a @code{rank_functiion}. +An optional third argument @code{reset}, @code{false} says don't bother to query about resetting things. @end defun @... @node MONO @... @unnumberedsec phony @... MONO (vari,n) VARI is a list of variables. Returns the list of independent monomials relative to the current dot_simplifications, in degree N @... defun @... @node MONOMIAL_DIMENSIONS @... @unnumberedsec phony @... MONOMIAL_DIMENSIONS (n) +@defun mono ([@var{x_1}, ..., @var{x_n}], @var{n}) +Returns the list of independent +monomials relative to the current dot simplifications of degree @var{n} +in the variables @var{x_1}, ..., @var{x_n}. Compute the hilbert series through degreen n for the current algebra. +@end defun +@defun monomial_dimensions (@var{n}) +Compute the Hilbert series through degree @var{n} for the current algebra. @end defun @... @node EXTRACT_LINEAR_EQUATIONS @... @unnumberedsec phony @... EXTRACT_LINEAR_EQUATIONS (List_nc_polys,monoms) Makes a list of the coefficients of the polynomials in list_nc_polys of the monoms. MONOMS is a list of noncommutative monomials. The coefficients should be scalars. Use LIST_NC_MONOMIALS to build the list of monoms. +@defun extract_linear_equations ([@var{p_1}, ..., @var{p_n}], [@var{m_1}, ..., @var{m_n}]) + +Makes a list of the coefficients of the noncommutative polynomials @var{p_1}, ..., @var{p_n} +of the noncommutative monomials @var{m_1}, ..., @var{m_n}. +The coefficients should be scalars. Use @code{list_nc_monomials} to build the list of +monomials. @end defun @... @node LIST_NC_MONOMIALS @... @unnumberedsec phony @... LIST_NC_MONOMIALS (polys_or_list) + +@defun list_nc_monomials (polys_or_list) returns a list of the non commutative monomials occurring in a polynomial or a collection of polynomials. @end defun @... @node PCOEFF @... @unnumberedsec phony @... PCOEFF (poly monom [variablestoexcludefromcof (listvariables monom)]) + +@defun pcoeff (poly monom [variablestoexcludefromcof (listvariables monom)]) This function is called from Lisp level, and uses internal poly format. @@ 147,9 +147,8 @@ like substituting them to be zero. @end defun @... @node NEWDISREP @... @unnumberedsec phony @... NEWDISREP (poly) + +@defun newdisrep (poly) From Lisp this returns the general Maxima format for an arg which is in strat form: @@ 158,39 +157,36 @@ (displa(newdisrep (setq me (strat #$x^2*u+y+1$)))) 2 Y + U X + 1  +y + u x + 1 @end example + @end defun @... @node CREATE_LIST @... @unnumberedsec phony @... CREATE_LIST (form,var1,list1,var2,list2,...) Create a list by evaluating FORM with VAR1 bound to each element of LIST1, and for each such binding bind VAR2 to each element of LIST2,... +@defun create_list (@var{form}, @var{x_1}, @var{list_1}, @var{x_2}, @var{list_2}, ...) + +Create a list by evaluating @var{form} with @var{x_1} bound to +each element of @var{list_1}, and for each such binding bind @var{x_2} +to each element of @var{list_2}, .... The number of elements in the result will be length(list1)*length(list2)*... Each VARn must actually be a symbolit will not be evaluated. The LISTn args will be evaluated once at the beginning of the +the product of the number of elements in each list. +Each variable @var{x_i} must actually be a symbolit will not be evaluated. +The list arguments will be evaluated once at the beginning of the iteration.   @example  (%i82) create_list1(x^i,i,[1,3,7]); (%o82) [X,X^3,X^7] +(%o82) [x,x^3,x^7] @end example @... +@noindent With a double iteration: + @example (%i79) create_list([i,j],i,[a,b],j,[e,f,h]); (%o79) [[A,E],[A,F],[A,H],[B,E],[B,F],[B,H]] +(%o79) [[a,e],[a,f],[a,h],[b,e],[b,f],[b,h]] @end example Instead of LISTn two args maybe supplied each of which should +Instead of @var{list_i} two args may be supplied each of which should evaluate to a number. These will be the inclusive lower and upper bounds for the iteration. @@ 199,24 +195,21 @@ (%o81) [[1,1],[2,1],[2,2],[3,1],[3,2],[3,3]] @end example  Note that the limits or list for the j variable can depend on the current value of i. +Note that the limits or list for the @var{j} variable can +depend on the current value of @var{i}. @end defun @... @node ALL_DOTSIMP_DENOMS @... @unnumberedsec phony @... ALL_DOTSIMP_DENOMS if its value is FALSE the denominators encountered in getting dotsimps will not be collected. To collect the denoms @... ALL_DOTSIMP_DENOMS:[]; @... example @... and they will be nconc'd onto the end of the list. +@defvar all_dotsimp_denoms +Default value: @code{false} +When @code{all_dotsimp_denoms} is a list, +the denominators encountered by @code{dotsimp} are appended to the list. +@code{all_dotsimp_denoms} may be initialized to an empty list @code{[]} +before calling @code{dotsimp}. + +By default, denominators are not collected by @code{dotsimp}. @end defvar 
From: Robert Dodier <robert_dodier@us...>  20050222 02:18:15

Update of /cvsroot/maxima/maxima/doc/info In directory sc8prcvs1.sourceforge.net:/tmp/cvsserv32109 Modified Files: Contexts.texi Log Message: Strike out obsolete, commentedout texinfo tags; change uppercase to lowercase; enclose names in @var or @code as appropriate; revise for clarity. Most items still need examples. Index: Contexts.texi =================================================================== RCS file: /cvsroot/maxima/maxima/doc/info/Contexts.texi,v retrieving revision 1.4 retrieving revision 1.5 diff u d r1.4 r1.5  Contexts.texi 4 Nov 2004 05:12:25 0000 1.4 +++ Contexts.texi 22 Feb 2005 02:18:02 0000 1.5 @@ 5,200 +5,318 @@ @node Definitions for Contexts, , Contexts, Contexts @section Definitions for Contexts @... @node ACTIVATE @... @unnumberedsec phony @... ACTIVATE (cont1, cont2, ...) causes the specified contexts conti to be activated. The facts in these contexts are used in making deductions and retrieving information. The facts in these contexts are not listed when FACTS(); is done. The variable ACTIVECONTEXTS is the list of contexts which are active by way of the ACTIVATE function. + +@defun activate (@var{context_1}, ..., @var{context_n}) +Activates the contexts @var{context_1}, ..., @var{context_n}. +The facts in these contexts are then available to +make deductions and retrieve information. +The facts in these contexts are not listed by @code{facts ()}. + +The variable @code{activecontexts} is the list +of contexts which are active by way of the @code{activate} function. @end defun @... @node ACTIVECONTEXTS @... @unnumberedsec phony @... ACTIVECONTEXTS  default: [] is a list of the contexts which are active by way of the ACTIVATE function, as opposed to being active because + +@defvar activecontexts +Default value: @code{[]} + +@code{activecontexts} is a list of the contexts which are active +by way of the @code{activate} function, as opposed to being active because they are subcontexts of the current context. @end defvar +@defun assume (@var{pred_1}, ..., @var{pred_n}) +Adds predicates @var{pred_1}, ..., @var{pred_n} to the current database, +after checking for redundancy and inconsistency. +If the predicates are consistent and nonredundant, they are added to the +data base; if inconsistent or redundant, no action is taken. @... @node ASSUME @... @unnumberedsec phony @... ASSUME (pred1, pred2, ...) First checks the specified predicates for redundancy and consistency with the current data base. If the predicates are consistent and nonredundant, they are added to the data base; if inconsistent or redundant, no action is taken. ASSUME returns a list whose entries are the predicates added to the data base and the atoms REDUNDANT or INCONSISTENT where applicable. +@code{assume} returns a list whose elements are the predicates added to the database +and the atoms @code{redundant} or @code{inconsistent} where applicable. @end defun @... @node ASSUMESCALAR @... @unnumberedsec phony @... ASSUMESCALAR  default: [TRUE]  helps govern whether expressions @code{exp} for which @... NONSCALARP(exp) is FALSE @... example +@defvar assumescalar +Default value: @code{true} +@code{assumescalar} helps govern whether expressions @code{expr} +for which @code{nonscalarp (expr)} is @code{false} are assumed to behave like scalars for certain transformations as follows: Let @code{exp} represent any nonlist/nonmatrix, and @code{[1,2,3]} any list or matrix. @... exp.[1,2,3]; ==>  [exp,2*exp,3*exp] @... example if ASSUMESCALAR is TRUE or SCALARP(exp) is TRUE or CONSTANTP(exp) is TRUE. If ASSUMESCALAR is TRUE, such expressions will behave like scalars only for the commutative operators, but not for ".". If ASSUMESCALAR is FALSE, such expressions will behave like nonscalars. If ASSUMESCALAR is ALL, +for certain transformations. + +Let @code{expr} represent any expression other than a list or a matrix, +and let @code{[1, 2, 3]} represent any list or matrix. +Then @code{expr . [1, 2, 3]} yields @code{[expr, 2 expr, 3 expr]} +if @code{assumescalar} is @code{true}, or @code{scalarp (expr)} is +@code{true}, or @code{constantp (expr)} is @code{true}. + +If @code{assumescalar} is @code{true}, such +expressions will behave like scalars only for commutative +operators, but not for noncommutative multiplication @code{.}. + +When @code{assumescalar} is @code{false}, such +expressions will behave like nonscalars. + +When @code{assumescalar} is @code{all}, such expressions will behave like scalars for all the operators listed above. + @end defvar @... @node ASSUME_POS @... @unnumberedsec phony @... ASSUME_POS  default:[FALSE]  When using INTEGRATE, etc. one often introduces parameters which are real and positive or one's calculations can often be constructed so that this is true. There is a switch ASSUME_POS (default FALSE) such that if set to TRUE, Maxima will assume one's parameters are positive. The intention here is to cut down on the number of questions Maxima needs to ask. Obviously, ASSUME information or any contextual information present will take precedence. The user can control what is considered to be a parameter for this purpose. Parameters by default are those which satisfy SYMBOLP(x) OR SUBVARP(x). The user can change this by setting the option ASSUME_POS_PRED [default FALSE] to the name of a predicate function of one argument. E.g. if you want only symbols to be parameters, you can do ASSUME_POS:TRUE$ ASSUME_POS_PRED:'SYMBOLP$ SIGN(A); > POS, SIGN(A[1]); > PNZ. + +@defvar assume_pos +Default value: @code{false} + +When @code{assume_pos} is @code{true} +and the sign of a parameter @var{x} cannot be determined from the @code{assume} database +or other considerations, +@code{sign} and @code{asksign (@var{x})} return @code{true}. +This may forestall some automaticallygenerated @code{asksign} queries, +such as may arise from @code{integrate} or other computations. + +By default, a parameter is @var{x} such that @code{symbolp (x)} or @code{subvarp (x)}. +The class of expressions considered parameters can be modified to some extent +via the variable @code{assume_pos_pred}. + +@code{sign} and @code{asksign} attempt to deduce the sign of expressions +from the sign of operands within the expression. +For example, if @code{a} and @code{b} are both positive, +then @code{a + b} is also positive. + +However, there is no way to bypass all @code{asksign} queries. +In particular, when the @code{asksign} argument is a +difference @code{@var{x}  @var{y}} or a logarithm @code{log(@var{x})}, +@code{asksign} always requests an input from the user, +even when @code{assume_pos} is @code{true} and @code{assume_pos_pred} is +a function which returns @code{true} for all arguments. + +@c NEED EXAMPLES HERE @end defvar @... @node ASSUME_POS_PRED @... @unnumberedsec phony @... ASSUME_POS_PRED  default:[FALSE]  may be set to one argument to control what will be considered a parameter for the "assumptions" that INTEGRATE will make... see ASSUME and ASSUME_POS . + +@defvar assume_pos_pred +Default value: @code{false} + +When @code{assume_pos_pred} is assigned the name of a function +or a lambda expression of one argument @var{x}, +that function is called to determine +whether @var{x} is considered a parameter for the purpose of @code{assume_pos}. +@code{assume_pos_pred} is ignored when @code{assume_pos} is @code{false}. + +The @code{assume_pos_pred} function is called by @code{sign} and @code{asksign} +with an argument @var{x} +which is either an atom, a subscripted variable, or a function call expression. +If the @code{assume_pos_pred} function returns @code{true}, +@var{x} is considered a parameter for the purpose of @code{assume_pos}. + +By default, a parameter is @var{x} such that @code{symbolp (x)} or @code{subvarp (x)}. + +See also @code{assume} and @code{assume_pos}. + +Examples: +@c EXAMPLE OUTPUT GENERATED FROM: +@c assume_pos: true$ +@c assume_pos_pred: symbolp$ +@c sign (a); +@c sign (a[1]); +@c assume_pos_pred: lambda ([x], display (x), true)$ +@c asksign (a); +@c asksign (a[1]); +@c asksign (foo (a)); +@c asksign (foo (a) + bar (b)); +@c asksign (log (a)); +@c asksign (a  b); + +@example +(%i1) assume_pos: true$ +(%i2) assume_pos_pred: symbolp$ +(%i3) sign (a); +(%o3) pos +(%i4) sign (a[1]); +(%o4) pnz +(%i5) assume_pos_pred: lambda ([x], display (x), true)$ +(%i6) asksign (a); + x = a + +(%o6) pos +(%i7) asksign (a[1]); + x = a + 1 + +(%o7) pos +(%i8) asksign (foo (a)); + x = foo(a) + +(%o8) pos +(%i9) asksign (foo (a) + bar (b)); + x = foo(a) + + x = bar(b) + +(%o9) pos +(%i10) asksign (log (a)); + x = a + +Is a  1 positive, negative, or zero? + +p; +(%o10) pos +(%i11) asksign (a  b); + x = a + + x = b + + x = a + + x = b + +Is b  a positive, negative, or zero? + +p; +(%o11) neg +@end example + @end defvar @... @node CONTEXT @... @unnumberedsec phony @... CONTEXT  default: INITIAL. Whenever a user assumes a new fact, it is placed in the context named as the current value of the variable CONTEXT. Similarly, FORGET references the current value of CONTEXT. To change contexts, simply bind CONTEXT to the desired context. If the specified context does not exist it will be created by an invisible call to NEWCONTEXT. The context specified by the value of CONTEXT is automatically activated. (Do DESCRIBE(CONTEXTS); for a general description of the CONTEXT mechanism.) + +@defvar context +Default value: @code{initial} + +@code{context} names the collection of facts maintained by @code{assume} and @code{forget}. +@code{assume} adds facts to the collection named by @code{context}, +while @code{forget} removes facts. + +Binding @code{context} to a name @var{foo} changes the current context to @var{foo}. +If the specified context @var{foo} does not yet exist, +it is created automatically by a call to @code{newcontext}. +@c ISN'T THIS NEXT BIT EQUIVALENT TO THE FIRST ?? +The specified context is activated automatically. + +See @code{context} for a general description of the context mechanism. @end defvar @... @node CONTEXTS @... @unnumberedsec phony @... CONTEXTS  default: [INITIAL,GLOBAL] is a list of the contexts which + +@c UMM, I'M HAVING TROUBLE GETTING THE CONTEXTSWITCHING STUFF TO BEHAVE AS EXPECTED +@c SOME EXAMPLES WILL HELP A LOT HERE +@defvar contexts +Default value: @code{[initial, global]} + +@code{contexts} is a list of the contexts which currently exist, including the currently active context. + The context mechanism makes it possible for a user to bind together and name a selected portion of his data base, called a context. Once this is done, the user can have Maxima assume or forget large numbers of facts merely by activating or deactivating their context. Any symbolic atom can be a context, and the facts contained in that context will be retained in storage until the user destroys them individually by using FORGET or destroys them as a whole by using KILL +and name a selected portion of his database, called a context. +Once this is done, the user can have Maxima assume or forget large numbers +of facts merely by activating or deactivating their context. + +Any symbolic atom can be a context, and the facts contained in that +context will be retained in storage until destroyed one by one +by calling @code{forget} or destroyed as a whole by calling @code{kill} to destroy the context to which they belong.  Contexts exist in a formal hierarchy, with the root always being the context GLOBAL, which contains information about Maxima that some + +Contexts exist in a hierarchy, with the root always being +the context @code{global}, which contains information about Maxima that some functions need. When in a given context, all the facts in that context are "active" (meaning that they are used in deductions and retrievals) as are all the facts in any context which is an inferior of that context. When a fresh Maxima is started up, the user is in a context called INITIAL, which has GLOBAL as a subcontext. The functions which deal with contexts are: FACTS, NEWCONTEXT, SUPCONTEXT, KILLCONTEXT, ACTIVATE, DEACTIVATE, ASSUME, and FORGET. +retrievals) as are all the facts in any context which is a subcontext +of the active context. + +When a fresh Maxima is started up, the user is in a +context called @code{initial}, which has @code{global} as a subcontext. + +See also @code{facts}, @code{newcontext}, +@code{supcontext}, @code{killcontext}, @code{activate}, @code{deactivate}, @code{assume}, and @code{forget}. @end defvar @... @node DEACTIVATE @... @unnumberedsec phony @... DEACTIVATE (cont1, cont2, ...) causes the specified contexts conti to be deactivated. + +@defun deactivate (@var{context_1}, ..., @var{context_n}) +Deactivates the specified contexts @var{context_1}, ..., @var{context_n}. @end defun @... @node FACTS @... @unnumberedsec phony @... FACTS (item) If 'item' is the name of a context then FACTS returns a list of the facts in the specified context. If no argument is given, it lists the current context. If 'item' is not the name of a context then it returns a list of the facts known about 'item' in the current context. Facts that are active, but in a different context, are not listed. + +@defun facts (@var{item}) +@defunx facts () +If @var{item} is the name of a context, +@code{facts (@var{item})} returns a list +of the facts in the specified context. + +If @var{item} is not the name of a context, +@code{facts (@var{item})} returns a list of the facts known about @var{item} in the current +context. Facts that are active, but in a different context, are not listed. + +@code{facts ()} (i.e., without an argument) lists the current context. @end defun @... @node declaration @... @unnumberedsec phony @... declaration FEATURES   Maxima has builtin properties which are handled by the data base. These are called FEATURES. One can do DECLARE(N,INTEGER), etc. One can also DECLARE one's own FEATURES by e.g. DECLARE( INCREASING, FEATURE); which will then allow one to say DECLARE(F, INCREASING);. One can then check if F is INCREASING by using the predicate FEATUREP via FEATUREP(F, INCREASING). There is an infolist FEATURES which is a list of known FEATURES. At present known FEATURES are: INTEGER, NONINTEGER, EVEN, ODD, RATIONAL, IRRATIONAL, REAL, IMAGINARY, COMPLEX, ANALYTIC, INCREASING, DECREASING, ODDFUN, EVENFUN, POSFUN, COMMUTATIVE, LASSOCIATIVE, RASSOCIATIVE, SYMMETRIC, and ANTISYMMETRIC. [Note: system "features" may be checked with STATUS(FEATURE, ...); See DESCRIBE(STATUS); or DESCRIBE(FEATURE); for details.] + +@defvr declaration features +Maxima recognizes certain mathematical properties of functions and variables. +These are called "features". + +@code{declare (@var{x}, @var{foo})} gives the property @var{foo} to the function or variable @code{x}. + +@code{declare (@var{foo}, feature)} declares a new feature @var{foo}. +For example, +@code{declare ([red, green, blue], feature)} +declares three new features, @code{red}, @code{green}, and @code{blue}. + +The predicate @code{featurep (@var{x}, @var{foo})} +returns @code{true} if @var{x} has the @var{foo} property, +and @code{false} otherwise. + +The infolist @code{features} is a list of known features. +These are +@code{integer}, @code{noninteger}, @code{even}, @code{odd}, @code{rational}, +@code{irrational}, @code{real}, @code{imaginary}, @code{complex}, @code{analytic}, @code{increasing}, +@code{decreasing}, @code{oddfun}, @code{evenfun}, @code{posfun}, @code{commutative}, @code{lassociative}, +@code{rassociative}, @code{symmetric}, and @code{antisymmetric}, +plus any userdefined features. + +@code{features} is a list of mathematical features. +There is also a list of nonmathematical, systemdependent features. See @code{status}. @end defvr @... @node FORGET @... @unnumberedsec phony @... FORGET (pred1, pred2, ...) removes relations established by ASSUME. The predicates may be expressions equivalent to (but not necessarily identical to) those previously ASSUMEd. FORGET(list) is also a legal form. + +@defun forget (@var{pred_1}, ..., @var{pred_n}) +@defunx forget (@var{L}) +Removes predicates established by @code{assume}. +The predicates may be expressions equivalent to (but not necessarily identical to) +those previously assumed. + +@code{forget (@var{L})}, where @var{L} is a list of predicates, +forgets each item on the list. @end defun @... @node KILLCONTEXT @... @unnumberedsec phony @... KILLCONTEXT (context1,context2,...,contextn) kills the specified contexts. If one of them is the current context, the new current + +@defun killcontext (@var{context_1}, ..., @var{context_n}) +Kills the contexts @var{context_1}, ..., @var{context_n}. + +If one of the contexts is the current context, the new current context will become the first available subcontext of the current context which has not been killed. If the first available unkilled context is GLOBAL then INITIAL is used instead. If the INITIAL context is killed, a new INITIAL is created, which is empty of facts. KILLCONTEXT doesn't allow the user to kill a context which is +context is @code{global} then @code{initial} is used instead. If the @code{initial} +context is killed, a new, empty @code{initial} context is created. + +@code{killcontext} refuses to kill a context which is currently active, either because it is a subcontext of the current context, or by use of the function ACTIVATE. +context, or by use of the function @code{activate}. @end defun @... @node NEWCONTEXT @... @unnumberedsec phony @... NEWCONTEXT (name) creates a new (empty) context, called name, which has GLOBAL as its only subcontext. The new context created will become the currently active context. + +@defun newcontext (@var{name}) +Creates a new, empty context, called @var{name}, which +has @code{global} as its only subcontext. The newlycreated context +becomes the currently active context. @end defun @... @node SUPCONTEXT @... @unnumberedsec phony @... SUPCONTEXT (name,context) will create a new context (called name) whose subcontext is context. If context is not specified, the current context will be assumed. If it is specified, context must exist. + +@defun supcontext (@var{name}, @var{context}) +@defunx supcontext (@var{name}) +Creates a new context, called @var{name}, +which has @var{context} as a subcontext. +@var{context} must exist. + +If @var{context} is not specified, the current context is assumed. @end defun 