mirrors/emacs
1
Fork 0
mirror of git://git.sv.gnu.org/emacs.git synced 2026-01-08 04:30:45 -08:00
Code Issues Projects Releases Wiki Activity

Merge from emacs--devo--0

Browse source 
Revision: emacs@sv.gnu.org/emacs--unicode--0--patch-307
This commit is contained in:
Miles Bader 2007-12-29 02:51:57 +00:00
commit e97d3ec018
14 changed files with 802 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

5
doc/misc/ChangeLog
View file

@ -1,3 +1,8 @@
2007-12-29 Jay Belanger <jay.p.belanger@gmail.com>
* calc.tex (Yacas Language, Maxima Language, Giac Language):
New sections.
2007-12-29 Reiner Steib <Reiner.Steib@gmx.de>
* gnus.texi (Group Parameters): Reorder the text and add a note about

108
doc/misc/calc.texi
View file

@ -13802,6 +13802,9 @@ shifted letter key.
* C FORTRAN Pascal::
* TeX and LaTeX Language Modes::
* Eqn Language Mode::
* Yacas Language Mode::
* Maxima Language Mode::
* Giac Language Mode::
* Mathematica Language Mode::
* Maple Language Mode::
* Compositions::
@ -13965,13 +13968,13 @@ entered this way or using square brackets. Since FORTRAN uses round
parentheses for both function calls and array subscripts, Calc displays
both in the same way; @samp{a(i)} is interpreted as a function call
upon reading, and subscripts must be entered as @samp{subscr(a, i)}.
Also, if the variable @code{a} has been declared to have type
@code{vector} or @code{matrix} then @samp{a(i)} will be parsed as a
subscript. (@xref{Declarations}.) Usually it doesn't matter, though;
if you enter the subscript expression @samp{a(i)} and Calc interprets
it as a function call, you'll never know the difference unless you
switch to another language mode or replace @code{a} with an actual
vector (or unless @code{a} happens to be the name of a built-in
If the variable @code{a} has been declared to have type
@code{vector} or @code{matrix}, however, then @samp{a(i)} will be
parsed as a subscript. (@xref{Declarations}.) Usually it doesn't
matter, though; if you enter the subscript expression @samp{a(i)} and
Calc interprets it as a function call, you'll never know the difference
unless you switch to another language mode or replace @code{a} with an
actual vector (or unless @code{a} happens to be the name of a built-in
function!).
Underscores are allowed in variable and function names in all of these
@ -14404,7 +14407,7 @@ $$ \pmatrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
@sp 2
@end iftex
@node Eqn Language Mode, Mathematica Language Mode, TeX and LaTeX Language Modes, Language Modes
@node Eqn Language Mode, Yacas Language Mode, TeX and LaTeX Language Modes, Language Modes
@subsection Eqn Language Mode
@noindent
@ -14480,7 +14483,87 @@ The words @code{lcol} and @code{rcol} are recognized as synonyms
for @code{ccol} during input, and are generated instead of @code{ccol}
if the matrix justification mode so specifies.
@node Mathematica Language Mode, Maple Language Mode, Eqn Language Mode, Language Modes
@node Yacas Language Mode, Maxima Language Mode, Eqn Language Mode, Language Modes
@subsection Yacas Language Mode
@noindent
@kindex d Y
@pindex calc-yacas-language
@cindex Yacas language
The @kbd{d Y} (@code{calc-yacas-language}) command selects the
conventions of Yacas, a free computer algebra system. While the
operators and functions in Yacas are similar to those of Calc, the names
of built-in functions in Yacas are capitalized. The Calc formula
@samp{sin(2 x)}, for example, is entered and displayed @samp{Sin(2 x)}
in Yacas mode, and `@samp{arcsin(x^2)} is @samp{ArcSin(x^2)} in Yacas
mode. Complex numbers are written are written @samp{3 + 4 I}.
The standard special constants are written @code{Pi}, @code{E},
@code{I}, @code{GoldenRatio} and @code{Gamma}. @code{Infinity}
represents both @code{inf} and @code{uinf}, and @code{Undefined}
represents @code{nan}.
Certain operators on functions, such as @code{D} for differentiation
and @code{Integrate} for integration, take a prefix form in Yacas. For
example, the derivative of @w{@samp{e^x sin(x)}} can be computed with
@w{@samp{D(x) Exp(x)*Sin(x)}}.
Other notable differences between Yacas and standard Calc expressions
are that vectors and matrices use curly braces in Yacas, and subscripts
use square brackets. If, for example, @samp{A} represents the list
@samp{@{a,2,c,4@}}, then @samp{A[3]} would equal @samp{c}.
@node Maxima Language Mode, Giac Language Mode, Yacas Language Mode, Language Modes
@subsection Maxima Language Mode
@noindent
@kindex d X
@pindex calc-maxima-language
@cindex Maxima language
The @kbd{d X} (@code{calc-maxima-language}) command selects the
conventions of Maxima, another free computer algebra system. The
function names in Maxima are similar, but not always identical, to Calc.
For example, instead of @samp{arcsin(x)}, Maxima will use
@samp{asin(x)}. Complex numbers are written @samp{3 + 4 %i}. The
standard special constants are written @code{%pi}, @code{%e},
@code{%i}, @code{%phi} and @code{%gamma}. In Maxima, @code{inf} means
the same as in Calc, but @code{infinity} represents Calc's @code{uinf}.
Underscores as well as percent signs are allowed in function and
variable names in Maxima mode. The underscore again is equivalent to
the @samp{#} in Normal mode, and the percent sign is equivalent to
@samp{o'o}.
Maxima uses square brackets for lists and vectors, and matrices are
written as calls to the function @code{matrix}, given the row vectors of
the matrix as arguments. Square brackets are also used as subscripts.
@node Giac Language Mode, Mathematica Language Mode, Maxima Language Mode, Language Modes
@subsection Giac Language Mode
@noindent
@kindex d A
@pindex calc-giac-language
@cindex Giac language
The @kbd{d A} (@code{calc-giac-language}) command selects the
conventions of Giac, another free computer algebra system. The function
names in Giac are similar to Maxima. Complex numbers are written
@samp{3 + 4 i}. The standard special constants in Giac are the same as
in Calc, except that @code{infinity} represents both Calc's @code{inf}
and @code{uinf}.
Underscores are allowed in function and variable names in Giac mode.
Brackets are used for subscripts. In Giac, indexing of lists begins at
0, instead of 1 as in Calc. So if @samp{A} represents the list
@samp{[a,2,c,4]}, then @samp{A[2]} would equal @samp{c}. In general,
@samp{A[n]} in Giac mode corresponds to @samp{A_(n+1)} in Normal mode.
The Giac interval notation @samp{2 .. 3} has no surrounding brackets;
Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]} and
writes any kind of interval as @samp{2 .. 3}. This means you cannot see
the difference between an open and a closed interval while in Giac mode.
@node Mathematica Language Mode, Maple Language Mode, Giac Language Mode, Language Modes
@subsection Mathematica Language Mode
@noindent
@ -14525,11 +14608,8 @@ pass through Calc. As a special case, matrices are written as calls
to the function @code{matrix}, given a list of lists as the argument,
and can be read in this form or with all-capitals @code{MATRIX}.
The Maple interval notation @samp{2 .. 3} has no surrounding brackets;
Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]}, and
writes any kind of interval as @samp{2 .. 3}. This means you cannot
see the difference between an open and a closed interval while in
Maple display mode.
The Maple interval notation @samp{2 .. 3} is like Giac's interval
notation, and is handled the same by Calc.
Maple writes complex numbers as @samp{3 + 4*I}. Its special constants
are @code{Pi}, @code{E}, @code{I}, and @code{infinity} (all three of

40
lisp/ChangeLog
View file

@ -1,3 +1,43 @@
2007-12-29 Jay Belanger <jay.p.belanger@gmail.com>
* calc/calc-aent.el (math-read-token): Fix misplaced
parentheses.
* calc/calc-lang.el (calc-yacas-language, calc-maxima-language)
(calc-giac-language, math-yacas-parse-Sum, math-yacas-compose-sum)
(math-yacas-compose-deriv, math-yacas-compose-taylor)
(math-maxima-parse-subst, math-maxima-parse-taylor)
(math-maxima-compose-taylor, math-maxima-compose-subst)
(math-maxima-compose-if, math-lang-switch-args)
(math-lang-compose-switch-args, math-read-giac-subscr):
New functions.
(calc-lang-allow-underscores, calc-lang-allow-percentsigns)
(calc-lang-brackets-are-subscripts, calc-lang-c-type-hex):
Add languages.
(math-vector-brackets, math-complex-format, math-variable-table)
(math-parse-table, math-oper-table, math-function-table)
(math-special-function-table, math-compose-subscr):
Add values for new languages.
* calc/calccomp.el (math-compose-expr): Add new languages.
* calc/calc.el (calc-language): Add languages to docstring.
* calc/calc-ext.el (calc-init-extensions): Add keybindings
for new languages. Autoload commands to change languages.
* calc/calc-help.el (calc-d-prefix-help): Add new languages.
* calc/calc-menu.el (calc-modes-menu): Add new languages.
2007-12-28 Dan Nicolaescu <dann@ics.uci.edu>
* vc-hg.el (vc-hg-registered): Return the false when vc-hg-state
returns 'ignored or 'unregistered.
(vc-hg-state): Pass "-A" to the status command and deal with the
output.
(vc-hg-dir-state): Pass "-A" to the status command.
2007-12-29 Richard Stallman <rms@gnu.org>
* progmodes/compile.el (compilation-start): Set initial visible

2
lisp/calc/README
View file

@ -72,6 +72,8 @@ opinions.
Summary of changes to "Calc"
------- -- ------- -- ----
* Added support for Yacas, Maxima and Giac languages.
* Added a menu.
* Added logistic non-linear curves to curve-fitting.

4
lisp/calc/calc-aent.el
View file

@ -775,9 +775,9 @@ in Calc algebraic input.")
(setq math-exp-token 'string
math-expr-data (math-match-substring math-exp-str 1)
math-exp-pos (match-end 0)))
((and (setq adfn (get calc-language 'math-lang-read)))
((and (setq adfn (get calc-language 'math-lang-read))
(eval (nth 0 adfn))
(eval (nth 1 adfn)))
(eval (nth 1 adfn))))
((eq (string-match "%%.*$" math-exp-str math-exp-pos) math-exp-pos)
(setq math-exp-pos (match-end 0))
(math-read-token))

4
lisp/calc/calc-ext.el
View file

@ -256,6 +256,7 @@
(define-key calc-mode-map "dt" 'calc-truncate-stack)
(define-key calc-mode-map "dw" 'calc-auto-why)
(define-key calc-mode-map "dz" 'calc-leading-zeros)
(define-key calc-mode-map "dA" 'calc-giac-language)
(define-key calc-mode-map "dB" 'calc-big-language)
(define-key calc-mode-map "dD" 'calc-redo)
(define-key calc-mode-map "dC" 'calc-c-language)
@ -269,6 +270,8 @@
(define-key calc-mode-map "dL" 'calc-latex-language)
(define-key calc-mode-map "dU" 'calc-unformatted-language)
(define-key calc-mode-map "dW" 'calc-maple-language)
(define-key calc-mode-map "dX" 'calc-maxima-language)
(define-key calc-mode-map "dY" 'calc-yacas-language)
(define-key calc-mode-map "d[" 'calc-truncate-up)
(define-key calc-mode-map "d]" 'calc-truncate-down)
(define-key calc-mode-map "d." 'calc-point-char)
@ -1053,6 +1056,7 @@ calc-keypad-press)
("calc-lang" calc-big-language calc-c-language calc-eqn-language
calc-flat-language calc-fortran-language calc-maple-language
calc-yacas-language calc-maxima-language calc-giac-language
calc-mathematica-language calc-normal-language calc-pascal-language
calc-tex-language calc-latex-language calc-unformatted-language)

1
lisp/calc/calc-help.el
View file

@ -601,6 +601,7 @@ C-w Describe how there is no warranty for Calc."
"\" (strings); Truncate, [, ]; SPC (refresh), RET, @"
"SHIFT + language: Normal, One-line, Big, Unformatted"
"SHIFT + language: C, Pascal, Fortran; TeX, LaTeX, Eqn"
"SHIFT + language: Yacas, X=Maxima, A=Giac"
"SHIFT + language: Mathematica, W=Maple")
"display" ?d))

618
lisp/calc/calc-lang.el
View file

@ -1164,6 +1164,624 @@
(if (memq (nth 1 a) '(0 2)) ")" "]")))
;;; Yacas
(defun calc-yacas-language ()
"Change the Calc language to be Yacas-like."
(interactive)
(calc-wrapper
(calc-set-language 'yacas)
(message "`Yacas' language mode")))
(put 'yacas 'math-vector-brackets "{}")
(put 'yacas 'math-complex-format 'I)
(add-to-list 'calc-lang-brackets-are-subscripts 'yacas)
(put 'yacas 'math-variable-table
'(( Infinity . var-inf)
( Infinity . var-uinf)
( Undefined . var-nan)
( Pi . var-pi)
( E . var-e) ;; Not really in Yacas
( GoldenRatio . var-phi)
( Gamma . var-gamma)))
(put 'yacas 'math-parse-table
'((("Deriv(" 0 ")" 0)
calcFunc-deriv (var ArgB var-ArgB) (var ArgA var-ArgA))
(("D(" 0 ")" 0)
calcFunc-deriv (var ArgB var-ArgB) (var ArgA var-ArgA))
(("Integrate(" 0 ")" 0)
calcFunc-integ (var ArgB var-ArgB)(var ArgA var-ArgA))
(("Integrate(" 0 "," 0 "," 0 ")" 0)
calcFunc-integ (var ArgD var-ArgD) (var ArgA var-ArgA)
(var ArgB var-ArgB) (var ArgC var-ArgC))
(("Subst(" 0 "," 0 ")" 0)
calcFunc-subst (var ArgC var-ArgC) (var ArgA var-ArgA)
(var ArgB var-ArgB))
(("Taylor(" 0 "," 0 "," 0 ")" 0)
calcFunc-taylor (var ArgD var-ArgD)
(calcFunc-eq (var ArgA var-ArgA) (var ArgB var-ArgB))
(var ArgC var-ArgC))))
(put 'yacas 'math-oper-table
'(("+" + 30 30)
("-" - 30 60)
("*" * 60 60)
("/" / 70 70)
("u-" neg -1 60)
("^" ^ 80 80)
("u+" ident -1 30)
("<<" calcFunc-lsh 80 80)
(">>" calcFunc-rsh 80 80)
("!" calcFunc-fact 80 -1)
("!!" calcFunc-dfact 80 -1)
("X" calcFunc-cross 70 70)
("=" calcFunc-eq 10 10)
("!=" calcFunc-neq 10 10)
("<" calcFunc-lt 10 10)
(">" calcFunc-gt 10 10)
("<=" calcFunc-leq 10 10)
(">=" calcFunc-geq 10 10)
("And" calcFunc-land 5 5)
("Or" calcFunc-or 4 4)
("Not" calcFunc-lnot -1 3)
(":=" calcFunc-assign 1 1)))
(put 'yacas 'math-function-table
'(( Div . calcFunc-idiv)
( Mod . calcFunc-mod)
( Abs . calcFunc-abs)
( Sign . calcFunc-sign)
( Sqrt . calcFunc-sqrt)
( Max . calcFunc-max)
( Min . calcFunc-min)
( Floor . calcFunc-floor)
( Ceil . calcFunc-ceil)
( Round . calcFunc-round)
( Conjugate . calcFunc-conj)
( Arg . calcFunc-arg)
( Re . calcFunc-re)
( Im . calcFunc-im)
( Rationalize . calcFunc-pfrac)
( Sin . calcFunc-sin)
( Cos . calcFunc-cos)
( Tan . calcFunc-tan)
( Sec . calcFunc-sec)
( Csc . calcFunc-csc)
( Cot . calcFunc-cot)
( ArcSin . calcFunc-arcsin)
( ArcCos . calcFunc-arccos)
( ArcTan . calcFunc-arctan)
( Sinh . calcFunc-sinh)
( Cosh . calcFunc-cosh)
( Tanh . calcFunc-tanh)
( Sech . calcFunc-sech)
( Csch . calcFunc-csch)
( Coth . calcFunc-coth)
( ArcSinh . calcFunc-arcsinh)
( ArcCosh . calcFunc-arccosh)
( ArcTanh . calcFunc-arctanh)
( Ln . calcFunc-ln)
( Exp . calcFunc-exp)
( Gamma . calcFunc-gamma)
( Gcd . calcFunc-gcd)
( Lcm . calcFunc-lcm)
( Bin . calcFunc-choose)
( Bernoulli . calcFunc-bern)
( Euler . calcFunc-euler)
( StirlingNumber1 . calcFunc-stir1)
( StirlingNumber2 . calcFunc-stir2)
( IsPrime . calcFunc-prime)
( Factors . calcFunc-prfac)
( NextPrime . calcFunc-nextprime)
( Moebius . calcFunc-moebius)
( Random . calcFunc-random)
( Concat . calcFunc-vconcat)
( Head . calcFunc-head)
( Tail . calcFunc-tail)
( Length . calcFunc-vlen)
( Reverse . calcFunc-rev)
( CrossProduct . calcFunc-cross)
( Dot . calcFunc-mul)
( DiagonalMatrix . calcFunc-diag)
( Transpose . calcFunc-trn)
( Inverse . calcFunc-inv)
( Determinant . calcFunc-det)
( Trace . calcFunc-tr)
( RemoveDuplicates . calcFunc-rdup)
( Union . calcFunc-vunion)
( Intersection . calcFunc-vint)
( Difference . calcFunc-vdiff)
( Apply . calcFunc-apply)
( Map . calcFunc-map)
( Simplify . calcFunc-simplify)
( ExpandBrackets . calcFunc-expand)
( Solve . calcFunc-solve)
( Degree . calcFunc-pdeg)
( If . calcFunc-if)
( Contains . (math-lang-switch-args calcFunc-in))
( Sum . (math-yacas-parse-Sum calcFunc-sum))
( Factorize . (math-yacas-parse-Sum calcFunc-prod))))
(put 'yacas 'math-special-function-table
'(( calcFunc-sum . (math-yacas-compose-sum "Sum"))
( calcFunc-prod . (math-yacas-compose-sum "Factorize"))
( calcFunc-deriv . (math-yacas-compose-deriv "Deriv"))
( calcFunc-integ . (math-yacas-compose-deriv "Integrate"))
( calcFunc-taylor . math-yacas-compose-taylor)
( calcFunc-in . (math-lang-compose-switch-args "Contains"))))
(put 'yacas 'math-compose-subscr
(function
(lambda (a)
(let ((args (cdr (cdr a))))
(list 'horiz
(math-compose-expr (nth 1 a) 1000)
"["
(math-compose-vector args ", " 0)
"]")))))
(defun math-yacas-parse-Sum (f val)
"Read in the arguments to \"Sum\" in Calc's Yacas mode."
(let ((args (math-read-expr-list)))
(math-read-token)
(list (nth 2 f)
(nth 3 args)
(nth 0 args)
(nth 1 args)
(nth 2 args))))
(defun math-yacas-compose-sum (a fn)
"Compose the \"Sum\" function in Calc's Yacas mode."
(list 'horiz
(nth 1 fn)
"("
(math-compose-expr (nth 2 a) -1)
","
(math-compose-expr (nth 3 a) -1)
","
(math-compose-expr (nth 4 a) -1)
","
(math-compose-expr (nth 1 a) -1)
")"))
(defun math-yacas-compose-deriv (a fn)
"Compose the \"Deriv\" function in Calc's Yacas mode."
(list 'horiz
(nth 1 fn)
"("
(math-compose-expr (nth 2 a) -1)
(if (not (nth 3 a))
")"
(concat
","
(math-compose-expr (nth 3 a) -1)
","
(math-compose-expr (nth 4 a) -1)
")"))
" "
(math-compose-expr (nth 1 a) -1)))
(defun math-yacas-compose-taylor (a)
"Compose the \"Taylor\" function in Calc's Yacas mode."
(list 'horiz
"Taylor("
(if (eq (car-safe (nth 2 a)) 'calcFunc-eq)
(concat (math-compose-expr (nth 1 (nth 2 a)) -1)
","
(math-compose-expr (nth 2 (nth 2 a)) -1))
(concat (math-compose-expr (nth 2 a) -1) ",0"))
","
(math-compose-expr (nth 3 a) -1)
") "
(math-compose-expr (nth 1 a) -1)))
;;; Maxima
(defun calc-maxima-language ()
"Change the Calc language to be Maxima-like."
(interactive)
(calc-wrapper
(calc-set-language 'maxima)
(message "`Maxima' language mode")))
(put 'maxima 'math-oper-table
'(("+" + 100 100)
("-" - 100 134)
("*" * 120 120)
("." * 130 129)
("/" / 120 120)
("u-" neg -1 180)
("u+" ident -1 180)
("^" ^ 140 139)
("**" ^ 140 139)
("!" calcFunc-fact 160 -1)
("!!" calcFunc-dfact 160 -1)
("=" calcFunc-eq 80 80)
("#" calcFunc-neq 80 80)
("<" calcFunc-lt 80 80)
(">" calcFunc-gt 80 80)
("<=" calcFunc-leq 80 80)
(">=" calcFunc-geq 80 80)
("and" calcFunc-land 65 65)
("or" calcFunc-or 60 60)
("not" calcFunc-lnot -1 70)
(":" calcFunc-assign 180 20)))
(put 'maxima 'math-function-table
'(( matrix . vec)
( abs . calcFunc-abs)
( cabs . calcFunc-abs)
( signum . calcFunc-sign)
( floor . calcFunc-floor)
( entier . calcFunc-floor)
( fix . calcFunc-floor)
( conjugate . calcFunc-conj )
( carg . calcFunc-arg)
( realpart . calcFunc-re)
( imagpart . calcFunc-im)
( rationalize . calcFunc-pfrac)
( asin . calcFunc-arcsin)
( acos . calcFunc-arccos)
( atan . calcFunc-arctan)
( atan2 . calcFunc-arctan2)
( asinh . calcFunc-arcsinh)
( acosh . calcFunc-arccosh)
( atanh . calcFunc-arctanh)
( log . calcFunc-ln)
( plog . calcFunc-ln)
( bessel_j . calcFunc-besJ)
( bessel_y . calcFunc-besY)
( factorial . calcFunc-fact)
( binomial . calcFunc-choose)
( primep . calcFunc-prime)
( next_prime . calcFunc-nextprime)
( prev_prime . calcFunc-prevprime)
( append . calcFunc-vconcat)
( rest . calcFunc-tail)
( reverse . calcFunc-rev)
( innerproduct . calcFunc-mul)
( inprod . calcFunc-mul)
( row . calcFunc-mrow)
( columnvector . calcFunc-mcol)
( covect . calcFunc-mcol)
( transpose . calcFunc-trn)
( invert . calcFunc-inv)
( determinant . calcFunc-det)
( mattrace . calcFunc-tr)
( member . calcFunc-in)
( lmax . calcFunc-vmax)
( lmin . calcFunc-vmin)
( distrib . calcFunc-expand)
( partfrac . calcFunc-apart)
( rat . calcFunc-nrat)
( product . calcFunc-prod)
( diff . calcFunc-deriv)
( integrate . calcFunc-integ)
( quotient . calcFunc-pdiv)
( remainder . calcFunc-prem)
( divide . calcFunc-pdivrem)
( equal . calcFunc-eq)
( notequal . calcFunc-neq)
( rhs . calcFunc-rmeq)
( subst . (math-maxima-parse-subst))
( substitute . (math-maxima-parse-subst))
( taylor . (math-maxima-parse-taylor))))
(defun math-maxima-parse-subst (f val)
"Read in the arguments to \"subst\" in Calc's Maxima mode."
(let ((args (math-read-expr-list)))
(math-read-token)
(list 'calcFunc-subst
(nth 1 args)
(nth 2 args)
(nth 0 args))))
(defun math-maxima-parse-taylor (f val)
"Read in the arguments to \"taylor\" in Calc's Maxima mode."
(let ((args (math-read-expr-list)))
(math-read-token)
(list 'calcFunc-taylor
(nth 0 args)
(list 'calcFunc-eq
(nth 1 args)
(nth 2 args))
(nth 3 args))))
(put 'maxima 'math-parse-table
'((("if" 0 "then" 0 "else" 0)
calcFunc-if
(var ArgA var-ArgA)
(var ArgB var-ArgB)
(var ArgC var-ArgC))))
(put 'maxima 'math-special-function-table
'(( calcFunc-taylor . math-maxima-compose-taylor)
( calcFunc-subst . math-maxima-compose-subst)
( calcFunc-if . math-maxima-compose-if)))
(defun math-maxima-compose-taylor (a)
"Compose the \"taylor\" function in Calc's Maxima mode."
(list 'horiz
"taylor("
(math-compose-expr (nth 1 a) -1)
","
(if (eq (car-safe (nth 2 a)) 'calcFunc-eq)
(concat (math-compose-expr (nth 1 (nth 2 a)) -1)
","
(math-compose-expr (nth 2 (nth 2 a)) -1))
(concat (math-compose-expr (nth 2 a) -1) ",0"))
","
(math-compose-expr (nth 3 a) -1)
")"))
(defun math-maxima-compose-subst (a)
"Compose the \"subst\" function in Calc's Maxima mode."
(list 'horiz
"substitute("
(math-compose-expr (nth 2 a) -1)
","
(math-compose-expr (nth 3 a) -1)
","
(math-compose-expr (nth 1 a) -1)
")"))
(defun math-maxima-compose-if (a)
"Compose the \"if\" function in Calc's Maxima mode."
(list 'horiz
"if "
(math-compose-expr (nth 1 a) -1)
" then "
(math-compose-expr (nth 2 a) -1)
" else "
(math-compose-expr (nth 3 a) -1)))
(put 'maxima 'math-variable-table
'(( infinity . var-uinf)
( %pi . var-pi)
( %e . var-e)
( %i . var-i)
( %phi . var-phi)
( %gamma . var-gamma)))
(put 'maxima 'math-complex-format '%i)
(add-to-list 'calc-lang-allow-underscores 'maxima)
(add-to-list 'calc-lang-allow-percentsigns 'maxima)
(add-to-list 'calc-lang-brackets-are-subscripts 'maxima)
(put 'maxima 'math-compose-subscr
(function
(lambda (a)
(let ((args (cdr (cdr a))))
(list 'horiz
(math-compose-expr (nth 1 a) 1000)
"["
(math-compose-vector args ", " 0)
"]")))))
(put 'maxima 'math-matrix-formatter
(function
(lambda (a)
(list 'horiz
"matrix("
(math-compose-vector (cdr a)
(concat math-comp-comma " ")
math-comp-vector-prec)
")"))))
;;; Giac
(defun calc-giac-language ()
"Change the Calc language to be Giac-like."
(interactive)
(calc-wrapper
(calc-set-language 'giac)
(message "`Giac' language mode")))
(put 'giac 'math-oper-table
'( ( "[" (math-read-giac-subscr) 250 -1 )
( "+" + 180 181 )
( "-" - 180 181 )
( "/" / 191 192 )
( "*" * 191 192 )
( "^" ^ 201 200 )
( "u+" ident -1 197 )
( "u-" neg -1 197 )
( "!" calcFunc-fact 210 -1 )
( ".." (math-read-maple-dots) 165 165 )
( "\\dots" (math-read-maple-dots) 165 165 )
( "intersect" calcFunc-vint 191 192 )
( "union" calcFunc-vunion 180 181 )
( "minus" calcFunc-vdiff 180 181 )
( "<" calcFunc-lt 160 160 )
( ">" calcFunc-gt 160 160 )
( "<=" calcFunc-leq 160 160 )
( ">=" calcFunc-geq 160 160 )
( "=" calcFunc-eq 160 160 )
( "==" calcFunc-eq 160 160 )
( "!=" calcFunc-neq 160 160 )
( "and" calcFunc-land 110 111 )
( "or" calcFunc-lor 100 101 )
( "&&" calcFunc-land 110 111 )
( "||" calcFunc-lor 100 101 )
( "not" calcFunc-lnot -1 121 )
( ":=" calcFunc-assign 51 50 )))
(put 'giac 'math-function-table
'(( rdiv . calcFunc-div)
( iquo . calcFunc-idiv)
( irem . calcFunc-mod)
( remain . calcFunc-mod)
( floor . calcFunc-floor)
( iPart . calcFunc-floor)
( ceil . calcFunc-ceil)
( ceiling . calcFunc-ceil)
( re . calcFunc-re)
( real . calcFunc-re)
( im . calcFunc-im)
( imag . calcFunc-im)
( float2rational . calcFunc-pfrac)
( exact . calcFunc-pfrac)
( evalf . calcFunc-pfloat)
( bitand . calcFunc-and)
( bitor . calcFunc-or)
( bitxor . calcFunc-xor)
( asin . calcFunc-arcsin)
( acos . calcFunc-arccos)
( atan . calcFunc-arctan)
( asinh . calcFunc-arcsinh)
( acosh . calcFunc-arccosh)
( atanh . calcFunc-arctanh)
( log . calcFunc-ln)
( logb . calcFunc-log)
( factorial . calcFunc-fact)
( comb . calcFunc-choose)
( binomial . calcFunc-choose)
( nCr . calcFunc-choose)
( perm . calcFunc-perm)
( nPr . calcFunc-perm)
( bernoulli . calcFunc-bern)
( is_prime . calcFunc-prime)
( isprime . calcFunc-prime)
( isPrime . calcFunc-prime)
( ifactors . calcFunc-prfac)
( euler . calcFunc-totient)
( phi . calcFunc-totient)
( rand . calcFunc-random)
( concat . calcFunc-vconcat)
( augment . calcFunc-vconcat)
( mid . calcFunc-subvec)
( length . calcFunc-length)
( size . calcFunc-length)
( nops . calcFunc-length)
( SortA . calcFunc-sort)
( SortB . calcFunc-rsort)
( revlist . calcFunc-rev)
( cross . calcFunc-cross)
( crossP . calcFunc-cross)
( crossproduct . calcFunc-cross)
( mul . calcFunc-mul)
( dot . calcFunc-mul)
( dotprod . calcFunc-mul)
( dotP . calcFunc-mul)
( scalar_product . calcFunc-mul)
( scalar_Product . calcFunc-mul)
( row . calcFunc-mrow)
( col . calcFunc-mcol)
( dim . calcFunc-mdims)
( tran . calcFunc-trn)
( transpose . calcFunc-trn)
( lu . calcFunc-lud)
( trace . calcFunc-tr)
( member . calcFunc-in)
( sum . calcFunc-vsum)
( add . calcFunc-vsum)
( product . calcFunc-vprod)
( mean . calcFunc-vmean)
( median . calcFunc-vmedian)
( stddev . calcFunc-vsdev)
( stddevp . calcFunc-vpsdev)
( variance . calcFunc-vpvar)
( map . calcFunc-map)
( apply . calcFunc-map)
( of . calcFunc-map)
( zip . calcFunc-map)
( expand . calcFunc-expand)
( fdistrib . calcFunc-expand)
( partfrac . calcFunc-apart)
( ratnormal . calcFunc-nrat)
( diff . calcFunc-deriv)
( derive . calcFunc-deriv)
( integrate . calcFunc-integ)
( int . calcFunc-integ)
( Int . calcFunc-integ)
( romberg . calcFunc-ninteg)
( nInt . calcFunc-ninteg)
( lcoeff . calcFunc-plead)
( content . calcFunc-pcont)
( primpart . calcFunc-pprim)
( quo . calcFunc-pdiv)
( rem . calcFunc-prem)
( quorem . calcFunc-pdivrem)
( divide . calcFunc-pdivrem)
( equal . calcFunc-eq)
( ifte . calcFunc-if)
( not . calcFunc-lnot)
( rhs . calcFunc-rmeq)
( right . calcFunc-rmeq)
( prepend . (math-lang-switch-args calcFunc-cons))
( contains . (math-lang-switch-args calcFunc-in))
( has . (math-lang-switch-args calcFunc-refers))))
(defun math-lang-switch-args (f val)
"Read the arguments to a Calc function in reverse order.
This is used for various language modes which have functions in reverse
order to Calc's."
(let ((args (math-read-expr-list)))
(math-read-token)
(list (nth 2 f)
(nth 1 args)
(nth 0 args))))
(put 'giac 'math-parse-table
'((("set" 0)
calcFunc-rdup
(var ArgA var-ArgA))))
(put 'giac 'math-special-function-table
'((calcFunc-cons . (math-lang-compose-switch-args "prepend"))
(calcFunc-in . (math-lang-compose-switch-args "contains"))
(calcFunc-refers . (math-lang-compose-switch-args "has"))
(intv . math-compose-maple-intv)))
(defun math-lang-compose-switch-args (a fn)
"Compose the arguments to a Calc function in reverse order.
This is used for various language modes which have functions in reverse
order to Calc's."
(list 'horiz (nth 1 fn)
"("
(math-compose-expr (nth 2 a) 0)
","
(math-compose-expr (nth 1 a) 0)
")"))
(put 'giac 'math-variable-table
'(( infinity . var-inf)
( infinity . var-uinf)))
(add-to-list 'calc-lang-allow-underscores 'giac)
(put 'giac 'math-compose-subscr
(function
(lambda (a)
(let ((args (cdr (cdr a))))
(list 'horiz
(math-compose-expr (nth 1 a) 1000)
"["
(math-compose-expr
(calc-normalize (list '- (nth 2 a) 1)) 0)
"]")))))
(defun math-read-giac-subscr (x op)
(let ((idx (math-read-expr-level 0)))
(or (equal math-expr-data "]")
(throw 'syntax "Expected ']'"))
(math-read-token)
(list 'calcFunc-subscr x (calc-normalize (list '+ idx 1)))))
(add-to-list 'calc-lang-c-type-hex 'giac)
(defun calc-mathematica-language ()
(interactive)
(calc-wrapper

23
lisp/calc/calc-menu.el
View file

@ -1157,7 +1157,28 @@
(call-interactively 'calc-eqn-language))
:keys "d E"
:style radio
:selected (eq calc-language 'eqn)])
:selected (eq calc-language 'eqn)]
["Yacas"
(progn
(require 'calc-lang)
(call-interactively 'calc-yacas-language))
:keys "d Y"
:style radio
:selected (eq calc-language 'yacas)]
["Maxima"
(progn
(require 'calc-lang)
(call-interactively 'calc-maxima-language))
:keys "d X"
:style radio
:selected (eq calc-language 'maxima)]
["Giac"
(progn
(require 'calc-lang)
(call-interactively 'calc-giac-language))
:keys "d A"
:style radio
:selected (eq calc-language 'giac)])
"----"
["Save mode settings" calc-save-modes :keys "m m"]
"----"

3
lisp/calc/calc.el
View file

@ -685,6 +685,9 @@ If `C' is present, display outer brackets for matrices (centered).")
tex Use TeX notation.
latex Use LaTeX notation.
eqn Use eqn notation.
yacas Use Yacas notation.
maxima Use Maxima notation.
giac Use Giac notation.
math Use Mathematica(tm) notation.
maple Use Maple notation.")

3
lisp/calc/calccomp.el
View file

@ -781,6 +781,9 @@
( tex . math-compose-tex )
( latex . math-compose-latex )
( eqn . math-compose-eqn )
( yacas . math-compose-yacas )
( maxima . math-compose-maxima )
( giac . math-compose-giac )
( math . math-compose-math )
( maple . math-compose-maple ))))
(setq op (get (car a) (cdr op)))

12
lisp/vc-hg.el
View file

@ -147,7 +147,9 @@
(defun vc-hg-registered (file)
"Return non-nil if FILE is registered with hg."
(when (vc-hg-root file) ; short cut
(vc-file-setprop file 'vc-state (vc-hg-state file)))) ; expensive
(let ((state (vc-hg-state file))) ; expensive
(vc-file-setprop file 'vc-state state)
(not (memq state '(ignored unregistered))))))
(defun vc-hg-state (file)
"Hg-specific version of `vc-state'."
@ -162,26 +164,26 @@
;; Ignore all errors.
(call-process
"hg" nil t nil "--cwd" (file-name-directory file)
"status" (file-name-nondirectory file))
"status" "-A" (file-name-nondirectory file))
;; Some problem happened. E.g. We can't find an `hg'
;; executable.
(error nil)))))))
(when (eq 0 status)
(if (eq 0 (length out)) 'up-to-date
(when (null (string-match ".*: No such file or directory$" out))
(let ((state (aref out 0)))
(cond
((eq state ?C) 'up-to-date)
((eq state ?A) 'edited)
((eq state ?M) 'edited)
((eq state ?I) 'ignored)
((eq state ?R) 'unregistered)
((eq state ??) 'unregistered)
(t 'up-to-date))))))))
(t 'up-to-date)))))))
(defun vc-hg-dir-state (dir)
(with-temp-buffer
(buffer-disable-undo) ;; Because these buffers can get huge
(vc-hg-command (current-buffer) nil nil "status")
(vc-hg-command (current-buffer) nil nil "status" "-A")
(goto-char (point-min))
(let ((status-char nil)
(file nil))

3
src/ChangeLog
View file

@ -1,8 +1,5 @@
2007-12-24 YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
* process.c (make_process): Initialize pty_flag to Qnil instead of 0
as it is not a bit field on Emacs 22 yet.
* xdisp.c (phys_cursor_in_rect_p): Check if cursor is in fringe area.
2007-12-22 Eli Zaretskii <eliz@gnu.org>

2
src/process.c
View file

@ -631,7 +631,7 @@ make_process (name)
p->tick = 0;
p->update_tick = 0;
p->pid = 0;
p->pty_flag = Qnil;
p->pty_flag = 0;
p->raw_status_new = 0;
p->status = Qrun;
p->mark = Fmake_marker ();