Maxima is a computer algebra system, implemented in Lisp.
Maxima is derived from the Macsyma system, developed at MIT in the years 1968 through 1982 as part of Project MAC. MIT turned over a copy of the Macsyma source code to the Department of Energy in 1982; that version is now known as DOE Macsyma. A copy of DOE Macsyma was maintained by Professor William F. Schelter of the University of Texas from 1982 until his death in 2001. In 1998, Schelter obtained permission from the Department of Energy to release the DOE Macsyma source code under the GNU Public License, and in 2000 he initiated the Maxima project at SourceForge to maintain and develop DOE Macsyma, now called Maxima.
ctensor
<function name>
<filename>
Start Maxima with the command "maxima". Maxima will display version
information and a prompt. End each Maxima command with a semicolon.
End the session with the command "quit();
". Here’s a sample session:
$ maxima Maxima 5.45.1 https://maxima.sourceforge.io using Lisp SBCL 2.0.1.debian Distributed under the GNU Public License. See the file COPYING. Dedicated to the memory of William Schelter. The function bug_report() provides bug reporting information. (%i1) factor(10!); 8 4 2 (%o1) 2 3 5 7 (%i2) expand ((x + y)^6); 6 5 2 4 3 3 4 2 5 6 (%o2) y + 6 x y + 15 x y + 20 x y + 15 x y + 6 x y + x (%i3) factor (x^6 - 1); 2 2 (%o3) (x - 1) (x + 1) (x - x + 1) (x + x + 1) (%i4) quit(); $
Maxima can search the info pages. Use the describe
command to show
information about the command or all the commands and variables containing
a string.
The question mark ?
(exact search) and double question mark ??
(inexact search) are abbreviations for describe
:
(%i1) ?? integ 0: Functions and Variables for Elliptic Integrals 1: Functions and Variables for Integration 2: Introduction to Elliptic Functions and Integrals 3: Introduction to Integration 4: askinteger (Functions and Variables for Simplification) 5: integerp (Functions and Variables for Miscellaneous Options) 6: integer_partitions (Functions and Variables for Sets) 7: integrate (Functions and Variables for Integration) 8: integrate_use_rootsof (Functions and Variables for Integration) 9: integration_constant_counter (Functions and Variables for Integration) 10: nonnegintegerp (Functions and Variables for linearalgebra) Enter space-separated numbers, `all' or `none': 5 4 -- Function: integerp (<expr>) Returns `true' if <expr> is a literal numeric integer, otherwise `false'. `integerp' returns false if its argument is a symbol, even if the argument is declared integer. Examples: (%i1) integerp (0); (%o1) true (%i2) integerp (1); (%o2) true (%i3) integerp (-17); (%o3) true (%i4) integerp (0.0); (%o4) false (%i5) integerp (1.0); (%o5) false (%i6) integerp (%pi); (%o6) false (%i7) integerp (n); (%o7) false (%i8) declare (n, integer); (%o8) done (%i9) integerp (n); (%o9) false -- Function: askinteger (<expr>, integer) -- Function: askinteger (<expr>) -- Function: askinteger (<expr>, even) -- Function: askinteger (<expr>, odd) `askinteger (<expr>, integer)' attempts to determine from the `assume' database whether <expr> is an integer. `askinteger' prompts the user if it cannot tell otherwise, and attempt to install the information in the database if possible. `askinteger (<expr>)' is equivalent to `askinteger (<expr>, integer)'. `askinteger (<expr>, even)' and `askinteger (<expr>, odd)' likewise attempt to determine if <expr> is an even integer or odd integer, respectively. (%o1) true
To use a result in later calculations, you can assign it to a variable or
refer to it by its automatically supplied label. In addition, %
refers to the most recent calculated result:
(%i1) u: expand ((x + y)^6); 6 5 2 4 3 3 4 2 5 6 (%o1) y + 6 x y + 15 x y + 20 x y + 15 x y + 6 x y + x (%i2) diff (u, x); 5 4 2 3 3 2 4 5 (%o2) 6 y + 30 x y + 60 x y + 60 x y + 30 x y + 6 x (%i3) factor (%o2); 5 (%o3) 6 (y + x)
Maxima knows about complex numbers and numerical constants:
(%i1) cos(%pi); (%o1) - 1 (%i2) exp(%i*%pi); (%o2) - 1
Maxima can do differential and integral calculus:
(%i1) u: expand ((x + y)^6); 6 5 2 4 3 3 4 2 5 6 (%o1) y + 6 x y + 15 x y + 20 x y + 15 x y + 6 x y + x (%i2) diff (%, x); 5 4 2 3 3 2 4 5 (%o2) 6 y + 30 x y + 60 x y + 60 x y + 30 x y + 6 x (%i3) integrate (1/(1 + x^3), x); 2 x - 1 2 atan(-------) log(x - x + 1) sqrt(3) log(x + 1) (%o3) - --------------- + ------------- + ---------- 6 sqrt(3) 3
Maxima can solve linear systems and cubic equations:
(%i1) linsolve ([3*x + 4*y = 7, 2*x + a*y = 13], [x, y]); 7 a - 52 25 (%o1) [x = --------, y = -------] 3 a - 8 3 a - 8 (%i2) solve (x^3 - 3*x^2 + 5*x = 15, x); (%o2) [x = - sqrt(5) %i, x = sqrt(5) %i, x = 3]
Maxima can solve nonlinear sets of equations. Note that if you don’t want a result printed, you can finish your command with $ instead of ;.
(%i1) eq_1: x^2 + 3*x*y + y^2 = 0$ (%i2) eq_2: 3*x + y = 1$ (%i3) solve ([eq_1, eq_2]); 3 sqrt(5) + 7 sqrt(5) + 3 (%o3) [[y = - -------------, x = -----------], 2 2 3 sqrt(5) - 7 sqrt(5) - 3 [y = -------------, x = - -----------]] 2 2
Maxima can generate plots of one or more functions:
(%i1) plot2d (sin(x)/x, [x, -20, 20])$
(%i2) plot2d ([atan(x), erf(x), tanh(x)], [x, -5, 5], [y, -1.5, 2])$
(%i3) plot3d (sin(sqrt(x^2 + y^2))/sqrt(x^2 + y^2), [x, -12, 12], [y, -12, 12])$
Run the Maxima test suite. Tests producing the desired answer are considered “passes,” as are tests that do not produce the desired answer, but are marked as known bugs.
run_testsuite
takes the following optional keyword arguments
display_all
Display all tests. Normally, the tests are not displayed, unless the test
fails. (Defaults to false
).
display_known_bugs
Displays tests that are marked as known bugs. (Default is false
).
tests
This is a single test or a list of tests that should be run. Each test can be specified by
either a string or a symbol. By default, all tests are run. The complete set
of tests is specified by testsuite_files
.
time
Display time information. If true
, the time taken for each
test file is displayed. If all
, the time for each individual
test is shown if display_all
is true
. The default is
false
, so no timing information is shown.
share_tests
Load additional tests for the share
directory. If true
,
these additional tests are run as a part of the testsuite. If
false
, no tests from the share
directory are run. If
only
, only the tests from the share
directory are run.
Of course, the actual set of test that are run can be controlled by
the tests
option. The default is false
.
For example run_testsuite(display_known_bugs = true, tests=[rtest5])
runs just test rtest5
and displays the test that are marked as
known bugs.
run_testsuite(display_all = true, tests=["rtest1", rtest1a])
will
run tests rtest1
and rtest2
, and displays each test.
run_testsuite
changes the Maxima environment.
Typically a test script executes kill
to establish a known environment
(namely one without user-defined functions and variables)
and then defines functions and variables appropriate to the test.
run_testsuite
returns done
.
testsuite_files
is the set of tests to be run by
run_testsuite
. It is a list of names of the files containing
the tests to run. If some of the tests in a file are known to fail,
then instead of listing the name of the file, a list containing the
file name and the test numbers that fail is used.
For example, this is a part of the default set of tests:
["rtest13s", ["rtest14", 57, 63]]
This specifies the testsuite consists of the files "rtest13s" and "rtest14", but "rtest14" contains two tests that are known to fail: 57 and 63.
share_testsuite_files
is the set of tests from the share
directory that is run as a part of the test suite by
run_testsuite
..
Prints out Maxima and Lisp version numbers, and gives a link
to the Maxima project bug report web page.
The version information is the same as reported by build_info
.
When a bug is reported, it is helpful to copy the Maxima and Lisp version information into the bug report.
bug_report
returns an empty string ""
.
Returns a summary of the parameters of the Maxima build,
as a Maxima structure (defined by defstruct
).
The fields of the structure are:
version
, timestamp
, host
, lisp_name
, and lisp_version
.
When the pretty-printer is enabled (via display2d
),
the structure is displayed as a short table.
See also bug_report
.
Examples:
(%i1) build_info (); (%o1) Maxima version: "5.36.1" Maxima build date: "2015-06-02 11:26:48" Host type: "x86_64-unknown-linux-gnu" Lisp implementation type: "GNU Common Lisp (GCL)" Lisp implementation version: "GCL 2.6.12"
(%i2) x : build_info ()$
(%i3) x@version; (%o3) 5.36.1
(%i4) x@timestamp; (%o4) 2015-06-02 11:26:48
(%i5) x@host; (%o5) x86_64-unknown-linux-gnu
(%i6) x@lisp_name; (%o6) GNU Common Lisp (GCL)
(%i7) x@lisp_version; (%o7) GCL 2.6.12
(%i8) x; (%o8) Maxima version: "5.36.1" Maxima build date: "2015-06-02 11:26:48" Host type: "x86_64-unknown-linux-gnu" Lisp implementation type: "GNU Common Lisp (GCL)" Lisp implementation version: "GCL 2.6.12"
The Maxima version string can (here 5.36.1) can look very different:
(%i1) build_info(); (%o1) Maxima version: "branch_5_37_base_331_g8322940_dirty" Maxima build date: "2016-01-01 15:37:35" Host type: "x86_64-unknown-linux-gnu" Lisp implementation type: "CLISP" Lisp implementation version: "2.49 (2010-07-07) (built 3605577779) (memory 3660647857)"
In that case, Maxima was not build from a released sourcecode, but directly from the GIT-checkout of the sourcecode. In the example, the checkout is 331 commits after the latest GIT tag (usually a Maxima (major) release (5.37 in our example)) and the abbreviated commit hash of the last commit was "8322940".
Front-ends for maxima can add information about currently being used
by setting the variables maxima_frontend
and
maxima_frontend_version
accordingly.
The Maxima on-line user’s manual can be viewed in different forms. From the
Maxima interactive prompt, the user’s manual is viewed as plain text by the
?
command (i.e., the describe
function). The user’s manual is
viewed as info
hypertext by the info
viewer program and as a
web page by any ordinary web browser.
example
displays examples for many Maxima functions. For example,
(%i1) example (integrate);
yields
(%i2) test(f):=block([u],u:integrate(f,x),ratsimp(f-diff(u,x))) (%o2) test(f) := block([u], u : integrate(f, x), ratsimp(f - diff(u, x))) (%i3) test(sin(x)) (%o3) 0 (%i4) test(1/(x+1)) (%o4) 0 (%i5) test(1/(x^2+1)) (%o5) 0
and additional output.
Searches for Maxima names which have name appearing anywhere
within them; name must be a string or symbol. Thus, apropos
(exp)
returns a list of all the flags and functions which have
exp
as part of their names, such as expand
, exp
,
and exponentialize
. So, if you can only remember part of the name
of a Maxima command or variable, you can use this command to find the
rest of the name. Similarly, you can type apropos (tr_)
to find
a list of many of the switches relating to the translator, most of which
begin with tr_
.
apropos("")
returns a list with all Maxima names.
apropos
returns the empty list []
, if no name is found.
Example:
Show all Maxima symbols which have gamma
in the name:
(%i1) apropos("gamma"); (%o1) [%gamma, Gamma, gamma_expand, gammalim, makegamma, prefer_gamma_incomplete, gamma, gamma-incomplete, gamma_incomplete, gamma_incomplete_generalized, gamma_incomplete_generalized_regularized, gamma_incomplete_lower, gamma_incomplete_regularized, log_gamma]
The same example, using the symbol gamma
, rather than the string:
(%i2) apropos(gamma); (%o2) [%gamma, Gamma, gamma_expand, gammalim, makegamma, prefer_gamma_incomplete, gamma, gamma-incomplete, gamma_incomplete, gamma_incomplete_generalized, gamma_incomplete_generalized_regularized, gamma_incomplete_lower, gamma_incomplete_regularized, log_gamma]
The number of symbols in the current Maxima session. This will vary.
(%i3) length(apropos("")); (%o3) 2338
Evaluates Maxima expressions in filename and displays the results.
demo
pauses after evaluating each expression and continues after the
user enters a carriage return. (If running in Xmaxima, demo
may need
to see a semicolon ;
followed by a carriage return.)
demo
searches the list of directories file_search_demo
to find
filename
. If the file has the suffix dem
, the suffix may be
omitted. See also file_search
.
demo
evaluates its argument.
demo
returns the name of the demonstration file.
Example:
(%i1) demo ("disol"); batching /home/wfs/maxima/share/simplification/disol.dem At the _ prompt, type ';' followed by enter to get next demo (%i2) load("disol") _ (%i3) exp1 : a (e (g + f) + b (d + c)) (%o3) a (e (g + f) + b (d + c)) _ (%i4) disolate(exp1, a, b, e) (%t4) d + c (%t5) g + f (%o5) a (%t5 e + %t4 b) _
describe
(string) describe
(string, exact) describe
(string, inexact) ¶describe(string)
is equivalent to
describe(string, exact)
.
describe(string, exact)
finds an item with title equal
(case-insensitive) to string, if there is any such item.
describe(string, inexact)
finds all documented items which contain
string in their titles. If there is more than one such item, Maxima asks
the user to select an item or items to display.
At the interactive prompt, ? foo
(with a space between ?
and
foo
) is equivalent to describe("foo", exact)
, and ?? foo
is equivalent to describe("foo", inexact)
.
describe("", inexact)
yields a list of all topics documented in the
on-line manual.
describe
quotes its argument. describe
returns true
if
some documentation is found, otherwise false
.
To display the topics using a browser see output_format_for_help. Also see browser and url_base to configure how to display the HTML files.
See also Documentation.
Example:
(%i1) ?? integ 0: Functions and Variables for Elliptic Integrals 1: Functions and Variables for Integration 2: Introduction to Elliptic Functions and Integrals 3: Introduction to Integration 4: askinteger (Functions and Variables for Simplification) 5: integerp (Functions and Variables for Miscellaneous Options) 6: integer_partitions (Functions and Variables for Sets) 7: integrate (Functions and Variables for Integration) 8: integrate_use_rootsof (Functions and Variables for Integration) 9: integration_constant_counter (Functions and Variables for Integration) 10: nonnegintegerp (Functions and Variables for linearalgebra) Enter space-separated numbers, `all' or `none': 7 8 -- Function: integrate (<expr>, <x>) -- Function: integrate (<expr>, <x>, <a>, <b>) Attempts to symbolically compute the integral of <expr> with respect to <x>. `integrate (<expr>, <x>)' is an indefinite integral, while `integrate (<expr>, <x>, <a>, <b>)' is a definite integral, [...] -- Option variable: integrate_use_rootsof Default value: `false' When `integrate_use_rootsof' is `true' and the denominator of a rational function cannot be factored, `integrate' returns the integral in a form which is a sum over the roots (not yet known) of the denominator. [...]
In this example, items 7 and 8 were selected (output is shortened as indicated
by [...]
). All or none of the items could have been selected by entering
all
or none
, which can be abbreviated a
or n
,
respectively.
Default value: text
output_format_for_help
controls how describe
displays
help.
output_format_for_help
can be set to one of the following
values:
text
Help is displayed as plain text sent to a terminal. This is the default.
html
Help is displayed using a browser to display the HTML version of the manual.
frontend
Help is displayed using the frontend’s help system. If no frontend is running then an error is signaled. For example, wxMaxima and xmaxima are some frontends for maxima.
Any other value is a error.
See also browser
, and url_base
.
This specifies the command to use to open an HTML file. This is a
format string of the form <cmd> ~A
where ~A
is replaced
by the URL of the HTML file and <cmd>
is some program that
takes an arg and opens up a browser to the given URL.
On windows, the default setting is "start ~A"
,
which uses the default browser to display the html file. You may replace
it with e.g. start firefox ~A
, start chrome ~A
or start iexplore ~A
if you want to use Firefox, Chrome, or Internet Explorer
instead of the default browser.
On other OSes, the user’s default browser should be used
automatically (using xdg-open
on Linux/Unix and open
on MacOS).
You can also set the browser
variable to use
a non default browser, e.g.
browser:"firefox '~A'";
or browser:"chromium '~A'";
See also output_format_for_help
, and url_base
.
When displaying help using a browser, url_base
defines the URL
to use. It defaults to a file://
path pointing to the
directory containing the html files for documentation. However, you
could use http://localhost:8080/
or some other URL that has the HTML
help files. But this requires those URLs to have exactly the same
HTML files in the info directory because a table is needed to
translate a topic to the appropriate location in an html file.
See also output_format_for_help and browser
.
example
(topic) example
() ¶example (topic)
displays some examples of topic, which is a
symbol or a string. To get examples for operators like if
, do
,
or lambda
the argument must be a string, e.g. example ("do")
.
example
is not case sensitive. Most topics are function names.
example ()
returns the list of all recognized topics.
The name of the file containing the examples is given by the global option
variable manual_demo
, which defaults to "manual.demo"
.
example
quotes its argument. example
returns done
unless
no examples are found or there is no argument, in which case example
returns the list of all recognized topics.
Examples:
(%i1) example(append); (%i2) append([y+x,0,-3.2],[2.5e+20,x]) (%o2) [y + x, 0, - 3.2, 2.5e+20, x] (%o2) done
(%i3) example("lambda"); (%i4) lambda([x,y,z],x^2+y^2+z^2) 2 2 2 (%o4) lambda([x, y, z], x + y + z ) (%i5) %(1,2,a) 2 (%o5) a + 5 (%i6) 1+2+a (%o6) a + 3 (%o6) done
Default value: "manual.demo"
manual_demo
specifies the name of the file containing the examples for
the function example
. See example
.
__
is the input expression currently being evaluated. That is, while an
input expression expr is being evaluated, __
is expr.
__
is assigned the input expression before the input is simplified or
evaluated. However, the value of __
is simplified (but not evaluated)
when it is displayed.
__
is recognized by batch
and load
. In a file processed
by batch
, __
has the same meaning as at the interactive prompt.
In a file processed by load
, __
is bound to the input expression
most recently entered at the interactive prompt or in a batch file; __
is not bound to the input expressions in the file being processed. In
particular, when load (filename)
is called from the interactive
prompt, __
is bound to load (filename)
while the file is
being processed.
Examples:
(%i1) print ("I was called as", __); I was called as print(I was called as, __) (%o1) print(I was called as, __)
(%i2) foo (__); (%o2) foo(foo(__))
(%i3) g (x) := (print ("Current input expression =", __), 0); (%o3) g(x) := (print("Current input expression =", __), 0)
(%i4) [aa : 1, bb : 2, cc : 3]; (%o4) [1, 2, 3]
(%i5) (aa + bb + cc)/(dd + ee + g(x)); cc + bb + aa Current input expression = -------------- g(x) + ee + dd 6 (%o5) ------- ee + dd
_
is the most recent input expression (e.g., %i1
, %i2
,
%i3
, …).
_
is assigned the input expression before the input is simplified or
evaluated. However, the value of _
is simplified (but not evaluated)
when it is displayed.
_
is recognized by batch
and load
. In a file processed
by batch
, _
has the same meaning as at the interactive prompt.
In a file processed by load
, _
is bound to the input expression
most recently evaluated at the interactive prompt or in a batch file; _
is not bound to the input expressions in the file being processed.
Examples:
(%i1) 13 + 29; (%o1) 42
(%i2) :lisp $_ ((MPLUS) 13 29)
(%i2) _; (%o2) 42
(%i3) sin (%pi/2); (%o3) 1
(%i4) :lisp $_ ((%SIN) ((MQUOTIENT) $%PI 2))
(%i4) _; (%o4) 1
(%i5) a: 13$ (%i6) b: 29$
(%i7) a + b; (%o7) 42
(%i8) :lisp $_ ((MPLUS) $A $B)
(%i8) _; (%o8) b + a
(%i9) a + b; (%o9) 42
(%i10) ev (_); (%o10) 42
%
is the output expression (e.g., %o1
, %o2
, %o3
,
…) most recently computed by Maxima, whether or not it was displayed.
%
is recognized by batch
and load
. In a file processed
by batch
, %
has the same meaning as at the interactive prompt.
In a file processed by load
, %
is bound to the output expression
most recently computed at the interactive prompt or in a batch file; %
is not bound to output expressions in the file being processed.
In compound statements, namely block
, lambda
, or
(s_1, ..., s_n)
, %%
is the value of the previous
statement.
At the first statement in a compound statement, or outside of a compound
statement, %%
is undefined.
%%
is recognized by batch
and load
, and it has the
same meaning as at the interactive prompt.
See also %
.
Examples:
The following two examples yield the same result.
(%i1) block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1)); 21 (%o1) -- 2 (%i2) block ([prev], prev: integrate (x^5, x), ev (prev, x=2) - ev (prev, x=1)); 21 (%o2) -- 2
A compound statement may comprise other compound statements. Whether a
statement be simple or compound, %%
is the value of the previous
statement.
(%i3) block (block (a^n, %%*42), %%/6); n (%o3) 7 a
Within a compound statement, the value of %%
may be inspected at a break
prompt, which is opened by executing the break
function. For example,
entering %%;
in the following example yields 42
.
(%i4) block (a: 42, break ())$ Entering a Maxima break point. Type 'exit;' to resume. _%%; 42 _
The value of the i’th previous output expression. That is, if the next
expression to be computed is the n’th output, %th (m)
is the
(n - m)’th output.
%th
is recognized by batch
and load
. In a file processed
by batch
, %th
has the same meaning as at the interactive prompt.
In a file processed by load
, %th
refers to output expressions most
recently computed at the interactive prompt or in a batch file; %th
does
not refer to output expressions in the file being processed.
Example:
%th
is useful in batch
files or for referring to a group of
output expressions. This example sets s
to the sum of the last five
output expressions.
(%i1) 1;2;3;4;5; (%o1) 1 (%o2) 2 (%o3) 3 (%o4) 4 (%o5) 5 (%i6) block (s: 0, for i:1 thru 5 do s: s + %th(i), s); (%o6) 15
As prefix to a function or variable name, ?
signifies that the name is a
Lisp name, not a Maxima name. For example, ?round
signifies the Lisp
function ROUND
. See Lisp and Maxima for more on this point.
The notation ? word
(a question mark followed a word, separated by
whitespace) is equivalent to describe("word")
. The question mark must
occur at the beginning of an input line; otherwise it is not recognized as a
request for documentation. See also describe
.
The notation ?? word
(??
followed a word, separated by whitespace)
is equivalent to describe("word", inexact)
. The question mark must occur
at the beginning of an input line; otherwise it is not recognized as a request
for documentation. See also describe
.
The dollar sign $
terminates an input expression,
and the most recent output %
and an output label, e.g. %o1
,
are assigned the result, but the result is not displayed.
See also ;
.
Example:
(%i1) 1 + 2 + 3 $
(%i2) %; (%o2) 6
(%i3) %o1; (%o3) 6
The semicolon ;
terminates an input expression,
and the resulting output is displayed.
See also $
.
Example:
(%i1) 1 + 2 + 3; (%o1) 6
Default value: %i
inchar
is the prefix of the labels of expressions entered by the user.
Maxima automatically constructs a label for each input expression by
concatenating inchar
and linenum
.
inchar
may be assigned any string or symbol, not necessarily a single
character. Because Maxima internally takes into account only the first char of
the prefix, the prefixes inchar
, outchar
, and
linechar
should have a different first char. Otherwise some commands
like kill(inlabels)
do not work as expected.
See also labels
.
Example:
(%i1) inchar: "input"; (%o1) input
(input2) expand((a+b)^3); 3 2 2 3 (%o2) b + 3 a b + 3 a b + a
Default value: []
infolists
is a list of the names of all of the information
lists in Maxima. These are:
labels
All bound %i
, %o
, and %t
labels.
values
All bound atoms which are user variables, not Maxima options or switches,
created by :
or ::
or functional binding.
functions
arrays
All arrays, hashed arrays
and memoizing functions
.
macros
All user-defined macro functions, created by ::=
.
myoptions
All options ever reset by the user (whether or not they are later reset to their default values).
rules
All user-defined pattern matching and simplification rules, created
by tellsimp
, tellsimpafter
, defmatch
, or
defrule
.
aliases
All atoms which have a user-defined alias, created by the alias
,
ordergreat
, orderless
functions or by declaring the atom as a
noun
with declare
.
dependencies
All atoms which have functional dependencies, created by the
depends
, dependencies
, or gradef
functions.
gradefs
All functions which have user-defined derivatives, created by the
gradef
function.
props
All atoms which have any property other than those mentioned above, such as
properties established by atvalue
or matchdeclare
, etc.,
as well as properties established in the declare
function.
structures
All structs defined using defstruct
.
let_rule_packages
All user-defined let
rule packages
plus the special package default_let_rule_package
.
(default_let_rule_package
is the name of the rule package used when
one is not explicitly set by the user.)
kill
(a_1, …, a_n) kill
(labels) kill
(inlabels, outlabels, linelabels) kill
(n) kill
([m, n]) kill
(values, functions, arrays, …) kill
(all) kill
(allbut (a_1, …, a_n)) ¶Removes all bindings (value, function, array, or rule) from the arguments
a_1, …, a_n. An argument a_k may be a symbol or a
single array element. When a_k is a single array element, kill
unbinds that element without affecting any other elements of the array.
Several special arguments are recognized. Different kinds of arguments
may be combined, e.g., kill (inlabels, functions, allbut (foo, bar))
.
kill (labels)
unbinds all input, output, and intermediate expression
labels created so far. kill (inlabels)
unbinds only input labels which
begin with the current value of inchar
. Likewise,
kill (outlabels)
unbinds only output labels which begin with the current
value of outchar
, and kill (linelabels)
unbinds only
intermediate expression labels which begin with the current value of
linechar
.
kill (n)
, where n is an integer,
unbinds the n most recent input and output labels.
kill ([m, n])
unbinds input and output labels m through
n.
kill (infolist)
, where infolist is any item in
infolists
(such as values
, functions
, or
arrays
) unbinds all items in infolist.
See also infolists
.
kill (all)
unbinds all items on all infolists. kill (all)
does
not reset global variables to their default values; see reset
on this
point.
kill (allbut (a_1, ..., a_n))
unbinds all items on all
infolists except for a_1, …, a_n.
kill (allbut (infolist))
unbinds all items except for the ones on
infolist, where infolist is values
,
functions
, arrays
, etc.
The memory taken up by a bound property is not released until all symbols are unbound from it. In particular, to release the memory taken up by the value of a symbol, one unbinds the output label which shows the bound value, as well as unbinding the symbol itself.
kill
quotes its arguments. The quote-quote operator ''
defeats quotation.
kill (symbol)
unbinds all properties of symbol. In contrast,
the functions remvalue
, remfunction
,
remarray
, and remrule
unbind a specific property.
Note that facts declared by assume
don’t require a symbol they apply to,
therefore aren’t stored as properties of symbols and therefore aren’t affected
by kill
.
kill
always returns done
, even if an argument has no binding.
Returns the list of input, output, or intermediate expression labels which begin
with symbol. Typically symbol is the value of
inchar
, outchar
, or linechar
.
If no labels begin with symbol, labels
returns an empty list.
By default, Maxima displays the result of each user input expression, giving the
result an output label. The output display is suppressed by terminating the
input with $
(dollar sign) instead of ;
(semicolon). An output
label is constructed and bound to the result, but not displayed, and the label
may be referenced in the same way as displayed output labels. See also
%
, %%
, and %th
.
Intermediate expression labels can be generated by some functions. The option
variable programmode
controls whether solve
and some other
functions generate intermediate expression labels instead of returning a list of
expressions. Some other functions, such as ldisplay
, always generate
intermediate expression labels.
See also inchar
, outchar
, linechar
, and
infolists
.
The variable labels
is the list of input, output, and intermediate
expression labels, including all previous labels if inchar
,
outchar
, or linechar
were redefined.
Default value: %t
linechar
is the prefix of the labels of intermediate expressions
generated by Maxima. Maxima constructs a label for each intermediate expression
(if displayed) by concatenating linechar
and linenum
.
linechar
may be assigned any string or symbol, not necessarily a single
character. Because Maxima internally takes into account only the first char of
the prefix, the prefixes inchar
, outchar
, and
linechar
should have a different first char. Otherwise some commands
like kill(inlabels)
do not work as expected.
Intermediate expressions might or might not be displayed.
See programmode
and labels
.
The line number of the current pair of input and output expressions.
Default value: []
myoptions
is the list of all options ever reset by the user,
whether or not they get reset to their default value.
Default value: false
When nolabels
is true
, input and output result labels (%i
and %o
, respectively) are displayed, but the labels are not bound to
results, and the labels are not appended to the labels
list. Since
labels are not bound to results, garbage collection can recover the memory taken
up by the results.
Otherwise input and output result labels are bound to results, and the labels
are appended to the labels
list.
Intermediate expression labels (%t
) are not affected by nolabels
;
whether nolabels
is true
or false
, intermediate expression
labels are bound and appended to the labels
list.
See also batch
, load
, and labels
.
Default value: false
When optionset
is true
, Maxima prints out a message whenever a
Maxima option is reset. This is useful if the user is doubtful of the spelling
of some option and wants to make sure that the variable he assigned a value to
was truly an option variable.
Example:
(%i1) optionset:true; assignment: assigning to option optionset (%o1) true (%i2) gamma_expand:true; assignment: assigning to option gamma_expand (%o2) true
Default value: %o
outchar
is the prefix of the labels of expressions computed by Maxima.
Maxima automatically constructs a label for each computed expression by
concatenating outchar
and linenum
.
outchar
may be assigned any string or symbol, not necessarily a single
character. Because Maxima internally takes into account only the first char of
the prefix, the prefixes inchar
, outchar
and
linechar
should have a different first char. Otherwise some commands
like kill(inlabels)
do not work as expected.
See also labels
.
Example:
(%i1) outchar: "output"; (output1) output
(%i2) expand((a+b)^3); 3 2 2 3 (output2) b + 3 a b + 3 a b + a
playback
() playback
(n) playback
([m, n]) playback
([m]) playback
(input) playback
(slow) playback
(time) playback
(grind) ¶Displays input, output, and intermediate expressions, without recomputing them.
playback
only displays the expressions bound to labels; any other output
(such as text printed by print
or describe
, or error messages)
is not displayed. See also labels
.
playback
quotes its arguments. The quote-quote operator ''
defeats quotation. playback
always returns done
.
playback ()
(with no arguments) displays all input, output, and
intermediate expressions generated so far. An output expression is displayed
even if it was suppressed by the $
terminator when it was originally
computed.
playback (n)
displays the most recent n expressions.
Each input, output, and intermediate expression counts as one.
playback ([m, n])
displays input, output, and intermediate
expressions with numbers from m through n, inclusive.
playback ([m])
is equivalent to
playback ([m, m])
; this usually prints one pair of input and
output expressions.
playback (input)
displays all input expressions generated so far.
playback (slow)
pauses between expressions and waits for the user to
press enter
. This behavior is similar to demo
.
playback (slow)
is useful in conjunction with save
or
stringout
when creating a secondary-storage file in order to pick out
useful expressions.
playback (time)
displays the computation time for each expression.
playback (grind)
displays input expressions in the same format as the
grind
function. Output expressions are not affected by the grind
option. See grind
.
Arguments may be combined, e.g., playback ([5, 10], grind, time, slow)
.
Default value: _
prompt
is the prompt symbol of the demo
function,
playback (slow)
mode, and the Maxima break loop (as invoked by
break
).
Terminates the Maxima session. Note that the function must be invoked as
quit();
or quit()$
, not quit
by itself.
quit
supports returning an exit code to the shell for Lisps and
OSes that support exit codes. The default exit code is 0 (usually
indicating no errors encountered). Thus quit(1)
indicates to the
shell that maxima exited with some kind of failure. This is useful in
scripts where maxima can indicate to the shell that maxima failed to
compute something or some other bad thing happened.
To stop a lengthy computation, type control-C
. The default action is to
return to the Maxima prompt. If *debugger-hook*
is nil
,
control-C
opens the Lisp debugger. See also Debugging.
Prints expr_1, …, expr_n, then reads one expression from the
console and returns the evaluated expression. The expression is terminated with
a semicolon ;
or dollar sign $
.
See also readonly
Example:
(%i1) foo: 42$ (%i2) foo: read ("foo is", foo, " -- enter new value.")$ foo is 42 -- enter new value. (a+b)^3; (%i3) foo; 3 (%o3) (b + a)
Prints expr_1, …, expr_n, then reads one expression from the
console and returns the expression (without evaluation). The expression is
terminated with a ;
(semicolon) or $
(dollar sign).
See also read
.
Examples:
(%i1) aa: 7$ (%i2) foo: readonly ("Enter an expression:"); Enter an expression: 2^aa; aa (%o2) 2 (%i3) foo: read ("Enter an expression:"); Enter an expression: 2^aa; (%o3) 128
Resets many global variables and options, and some other variables, to their default values.
reset
processes the variables on the Lisp list
*variable-initial-values*
. The Lisp macro defmvar
puts variables
on this list (among other actions). Many, but not all, global variables and
options are defined by defmvar
, and some variables defined by
defmvar
are not global variables or options.
Default value: false
When showtime
is true
, the computation time and elapsed time is
printed with each output expression.
The computation time is always recorded, so time
and playback
can
display the computation time even when showtime
is false
.
See also timer
.
Enters the Lisp system under Maxima. (to-maxima)
returns to Maxima.
Example:
Define a function and enter the Lisp system under Maxima. The definition is
inspected on the property list, then the function definition is extracted,
factored and stored in the variable $result
. The variable can be used in Maxima
after returning to Maxima.
(%i1) f(x):=x^2+x; 2 (%o1) f(x) := x + x (%i2) to_lisp(); Type (to-maxima) to restart, ($quit) to quit Maxima. MAXIMA> (symbol-plist '$f) (MPROPS (NIL MEXPR ((LAMBDA) ((MLIST) $X) ((MPLUS) ((MEXPT) $X 2) $X)))) MAXIMA> (setq $result ($factor (caddr (mget '$f 'mexpr)))) ((MTIMES SIMP FACTORED) $X ((MPLUS SIMP IRREDUCIBLE) 1 $X)) MAXIMA> (to-maxima) Returning to Maxima (%o2) true (%i3) result; (%o3) x (x + 1)
Sequentially read lisp forms from the string str and evaluate them. Any values produced from the last form are returned as a Maxima list.
Examples:
(%i1) eval_string_lisp (""); (%o1) []
(%i2) eval_string_lisp ("(values)"); (%o2) []
(%i3) eval_string_lisp ("69"); (%o3) [69]
(%i4) eval_string_lisp ("1 2 3"); (%o4) [3]
(%i5) eval_string_lisp ("(values 1 2 3)"); (%o5) [1,2,3]
(%i6) eval_string_lisp ("(defun $foo (x) (* 2 x))"); (%o6) [foo]
(%i7) foo (5); (%o7) 10
See also eval_string.
Initial value: []
values
is a list of all bound user variables (not Maxima options or
switches). The list comprises symbols bound by :
, or ::
.
If the value of a variable is removed with the commands kill
,
remove
, or remvalue
the variable is deleted from
values
.
See functions
for a list of user defined functions.
Examples:
First, values
shows the symbols a
, b
, and c
, but
not d
, it is not bound to a value, and not the user function f
.
The values are removed from the variables. values
is the empty list.
(%i1) [a:99, b:: a-90, c:a-b, d, f(x):=x^2]; 2 (%o1) [99, 9, 90, d, f(x) := x ]
(%i2) values; (%o2) [a, b, c]
(%i3) [kill(a), remove(b,value), remvalue(c)]; (%o3) [done, done, [c]]
(%i4) values; (%o4) []
Default value: false
When %edispflag
is true
, Maxima displays %e
to a negative
exponent as a quotient. For example, %e^-x
is displayed as
1/%e^x
. See also exptdispflag
.
Example:
(%i1) %e^-10; - 10 (%o1) %e
(%i2) %edispflag:true$
(%i3) %e^-10; 1 (%o3) ---- 10 %e
Default value: !
absboxchar
is the character used to draw absolute value
signs around expressions which are more than one line tall.
Example:
(%i1) abs((x^3+1)); ! 3 ! (%o1) !x + 1!
Declares the properties of indices applied to the symbol a or each of the of symbols a, b, c, .... If multiple symbols are given, the whole list of properties applies to each symbol.
Given a symbol with indices, a[i_1, i_2, i_3, ...]
,
the k
-th property p_k applies to the k
-th index i_k.
There may be any number of index properties, in any order.
Each property p_k must one of these four recognized properties:
postsubscript
, postsuperscript
, presuperscript
, or presubscript
,
to denote indices which are displayed, respectively,
to the right and below, to the right and above, to the left and above, or to the left and below.
Index properties apply only to the 2-dimensional display of indexed variables
(i.e., when display2d
is true
)
and TeX output via tex
.
Otherwise, index properties are ignored.
Index properties do not change the input of indexed variables,
do not change the algebraic properties of indexed variables,
and do not change the 1-dimensional display of indexed variables.
declare_index_properties
quotes (does not evaluate) its arguments.
remove_index_properties
removes index properties.
kill
also removes index properties (and all other properties).
get_index_properties
retrieves index properties.
Examples:
Given a symbol with indices, a[i_1, i_2, i_3, ...]
,
the k
-th property p_k applies to the k
-th index i_k.
There may be any number of index properties, in any order.
(%i1) declare_index_properties (A, [presubscript, postsubscript]); (%o1) done
(%i2) declare_index_properties (B, [postsuperscript, postsuperscript, presuperscript]); (%o2) done
(%i3) declare_index_properties (C, [postsuperscript, presubscript, presubscript, presuperscript]); (%o3) done
(%i4) A[w, x]; (%o4) A w x
(%i5) B[w, x, y]; y w, x (%o5) B
(%i6) C[w, x, y, z]; z w (%o6) C x, y
Index properties apply only to the 2-dimensional display of indexed variables and TeX output. Otherwise, index properties are ignored.
(%i1) declare_index_properties (A, [presubscript, postsubscript]); (%o1) done
(%i2) A[w, x]; (%o2) A w x
(%i3) tex (A[w, x]); $${}_{w}A_{x}$$ (%o3) false
(%i4) display2d: false $
(%i5) A[w, x]; (%o5) A[w,x]
(%i6) display2d: true $
(%i7) grind (A[w, x]); A[w,x]$ (%o7) done
(%i8) stringdisp: true $
(%i9) string (A[w, x]); (%o9) "A[w,x]"
Returns the properties for a established by declare_index_properties
.
See also remove_index_properties
.
Removes the properties established by declare_index_properties
.
All index properties are removed from each symbol a, b, c, ....
remove_index_properties
quotes (does not evaluate) its arguments.
When a symbol A has index display properties declared via declare_index_properties
,
the value of the property display_index_separator
is the string or other expression which is displayed between indices.
The value of display_index_separator
is assigned by put(A, S, display_index_separator)
,
where S is a string or other expression.
The assigned value is retrieved by get(A, display_index_separator)
.
The display index separator S can be a string, including an empty string,
or false
, indicating the default separator, or any expression.
If not a string and not false
, the property value is coerced to a string via string
.
If no display index separator is assigned, the default separator is used. The default separator is a comma. There is no way to change the default separator.
Each symbol has its own value of display_index_separator
.
See also put
, get
, and declare_index_properties
.
Examples:
When a symbol A has index display properties,
the value of the property display_index_separator
is the string or other expression which is displayed between indices.
The value is assigned by put(A, S, display_index_separator)
,
(%i1) declare_index_properties (A, [postsuperscript, postsuperscript, presubscript, presubscript]); (%o1) done
(%i2) put (A, ";", display_index_separator); (%o2) ;
(%i3) A[w, x, y, z]; w;x (%o3) A y;z
The assigned value is retrieved by get(A, display_index_separator)
.
(%i1) declare_index_properties (A, [postsuperscript, postsuperscript, presubscript, presubscript]); (%o1) done
(%i2) put (A, ";", display_index_separator); (%o2) ;
(%i3) get (A, display_index_separator); (%o3) ;
The display index separator S can be a string, including an empty string,
or false
, indicating the default separator, or any expression.
(%i1) declare_index_properties (A, [postsuperscript, postsuperscript, presubscript, presubscript]); (%o1) done
(%i2) A[w, x, y, z]; w, x (%o2) A y, z
(%i3) put (A, "-", display_index_separator); (%o3) -
(%i4) A[w, x, y, z]; w-x (%o4) A y-z
(%i5) put (A, " ", display_index_separator); (%o5)
(%i6) A[w, x, y, z]; w x (%o6) A y z
(%i7) put (A, "", display_index_separator); (%o7)
(%i8) A[w, x, y, z]; wx (%o8) A yz
(%i9) put (A, false, display_index_separator); (%o9) false
(%i10) A[w, x, y, z]; w, x (%o10) A y, z
(%i11) put (A, 'foo, display_index_separator); (%o11) foo
(%i12) A[w, x, y, z]; wfoox (%o12) A yfooz
If no display index separator is assigned, the default separator is used. The default separator is a comma.
(%i1) declare_index_properties (A, [postsuperscript, postsuperscript, presubscript, presubscript]); (%o1) done
(%i2) A[w, x, y, z]; w, x (%o2) A y, z
Each symbol has its own value of display_index_separator
.
(%i1) declare_index_properties (A, [postsuperscript, postsuperscript, presubscript, presubscript]); (%o1) done
(%i2) put (A, " ", display_index_separator); (%o2)
(%i3) declare_index_properties (B, [postsuperscript, postsuperscript, presubscript, presubscript]); (%o3) done
(%i4) put (B, ";", display_index_separator); (%o4) ;
(%i5) A[w, x, y, z] + B[w, x, y, z]; w;x w x (%o5) B + A y;z y z
is like display
but only the value of the arguments are displayed rather
than equations. This is useful for complicated arguments which don’t have names
or where only the value of the argument is of interest and not the name.
Example:
(%i1) b[1,2]:x-x^2$ (%i2) x:123$
(%i3) disp(x, b[1,2], sin(1.0)); 123 2 x - x 0.8414709848078965 (%o3) done
Displays equations whose left side is expr_i unevaluated, and whose right
side is the value of the expression centered on the line. This function is
useful in blocks and for
statements in order to have intermediate results
displayed. The arguments to display
are usually atoms, subscripted
variables, or function calls.
See also ldisplay
, disp
, and ldisp
.
Example:
(%i1) b[1,2]:x-x^2$ (%i2) x:123$
(%i3) display(x, b[1,2], sin(1.0)); x = 123 2 b = x - x 1, 2 sin(1.0) = 0.8414709848078965 (%o3) done
Default value: true
When display2d
is true
,
the console display is an attempt to present mathematical expressions
as they might appear in books and articles,
using only letters, numbers, and some punctuation characters.
This display is sometimes called the "pretty printer" display.
When display2d
is true
,
Maxima attempts to honor the global variable for line length, linel
.
When an atom (symbol, number, or string) would otherwise cause a line to exceed linel
,
the atom may be printed in pieces on successive lines,
with a continuation character (backslash, \
) at the end of the leading piece;
however, in some cases, such atoms are printed without a line break,
and the length of the line is greater than linel
.
When display2d
is false
,
the console display is a 1-dimensional or linear form
which is the same as the output produced by grind
.
When display2d
is false
,
the value of stringdisp
is ignored,
and strings are always displayed with quote marks.
When display2d
is false
,
Maxima attempts to honor linel
,
but atoms are not broken across lines,
and the actual length of an output line may exceed linel
.
See also leftjust
to switch between a left justified and a centered
display of equations.
Example:
(%i1) x/(x^2+1); x (%o1) ------ 2 x + 1
(%i2) display2d:false$
(%i3) x/(x^2+1); (%o3) x/(x^2+1)
Default value: false
When display_format_internal
is true
, expressions are displayed
without being transformed in ways that hide the internal mathematical
representation. The display then corresponds to what inpart
returns
rather than part
.
Examples:
User part inpart a-b; a - b a + (- 1) b a - 1 a/b; - a b b 1/2 sqrt(x); sqrt(x) x 4 X 4 X*4/3; --- - X 3 3
While maxima by default realizes 2d Output using ASCII-Art some frontend
change that to TeX, MathML or a specific XML dialect that better suits
the needs for this specific frontend. with_default_2d_display
temporarily switches maxima to the default 2D ASCII Art formatter for
outputting the result of expr
.
See also set_alt_display
and display2d
.
Displays expr in parts one below the other. That is, first the operator
of expr is displayed, then each term in a sum, or factor in a product, or
part of a more general expression is displayed separately. This is useful if
expr is too large to be otherwise displayed. For example if P1
,
P2
, … are very large expressions then the display program may run
out of storage space in trying to display P1 + P2 + ...
all at once.
However, dispterms (P1 + P2 + ...)
displays P1
, then below it
P2
, etc. When not using dispterms
, if an exponential expression
is too wide to be displayed as A^B
it appears as expt (A, B)
(or
as ncexpt (A, B)
in the case of A^^B
).
Example:
(%i1) dispterms(2*a*sin(x)+%e^x); + 2 a sin(x) x %e (%o1) done
If an exponential expression is too wide to be displayed as
a^b
it appears as expt (a, b)
(or as
ncexpt (a, b)
in the case of a^^b
).
expt
and ncexpt
are not recognized in input.
Default value: true
When exptdispflag
is true
, Maxima displays expressions
with negative exponents using quotients. See also %edispflag
.
Example:
(%i1) exptdispflag:true; (%o1) true (%i2) 10^-x; 1 (%o2) --- x 10 (%i3) exptdispflag:false; (%o3) false (%i4) 10^-x; - x (%o4) 10
The function grind
prints expr to the console in a form suitable
for input to Maxima. grind
always returns done
.
When expr is the name of a function or macro, grind
prints the
function or macro definition instead of just the name.
See also string
, which returns a string instead of printing its
output. grind
attempts to print the expression in a manner which makes
it slightly easier to read than the output of string
.
grind
evaluates its argument.
Examples:
(%i1) aa + 1729; (%o1) aa + 1729
(%i2) grind (%); aa+1729$ (%o2) done
(%i3) [aa, 1729, aa + 1729]; (%o3) [aa, 1729, aa + 1729]
(%i4) grind (%); [aa,1729,aa+1729]$ (%o4) done
(%i5) matrix ([aa, 17], [29, bb]); [ aa 17 ] (%o5) [ ] [ 29 bb ]
(%i6) grind (%); matrix([aa,17],[29,bb])$ (%o6) done
(%i7) set (aa, 17, 29, bb); (%o7) {17, 29, aa, bb}
(%i8) grind (%); {17,29,aa,bb}$ (%o8) done
(%i9) exp (aa / (bb + 17)^29); aa ----------- 29 (bb + 17) (%o9) %e
(%i10) grind (%); %e^(aa/(bb+17)^29)$ (%o10) done
(%i11) expr: expand ((aa + bb)^10); 10 9 2 8 3 7 4 6 (%o11) bb + 10 aa bb + 45 aa bb + 120 aa bb + 210 aa bb 5 5 6 4 7 3 8 2 + 252 aa bb + 210 aa bb + 120 aa bb + 45 aa bb 9 10 + 10 aa bb + aa
(%i12) grind (expr); bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6 +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2 +10*aa^9*bb+aa^10$ (%o12) done
(%i13) string (expr); (%o13) bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6\ +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2+10*aa^9*\ bb+aa^10
(%i14) cholesky (A):= block ([n : length (A), L : copymatrix (A), p : makelist (0, i, 1, length (A))], for i thru n do for j : i thru n do (x : L[i, j], x : x - sum (L[j, k] * L[i, k], k, 1, i - 1), if i = j then p[i] : 1 / sqrt(x) else L[j, i] : x * p[i]), for i thru n do L[i, i] : 1 / p[i], for i thru n do for j : i + 1 thru n do L[i, j] : 0, L)$ define: warning: redefining the built-in function cholesky
(%i15) grind (cholesky); cholesky(A):=block( [n:length(A),L:copymatrix(A), p:makelist(0,i,1,length(A))], for i thru n do (for j from i thru n do (x:L[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1), if i = j then p[i]:1/sqrt(x) else L[j,i]:x*p[i])), for i thru n do L[i,i]:1/p[i], for i thru n do (for j from i+1 thru n do L[i,j]:0),L)$ (%o15) done
(%i16) string (fundef (cholesky)); (%o16) cholesky(A):=block([n:length(A),L:copymatrix(A),p:makelis\ t(0,i,1,length(A))],for i thru n do (for j from i thru n do (x:L\ [i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),if i = j then p[i]:1/sqrt(x\ ) else L[j,i]:x*p[i])),for i thru n do L[i,i]:1/p[i],for i thru \ n do (for j from i+1 thru n do L[i,j]:0),L)
When the variable grind
is true
, the output of string
and
stringout
has the same format as that of grind
; otherwise no
attempt is made to specially format the output of those functions. The default
value of the variable grind
is false
.
grind
can also be specified as an argument of playback
. When
grind
is present, playback
prints input expressions in the same
format as the grind
function. Otherwise, no attempt is made to specially
format input expressions.
Default value: 10
ibase
is the base for integers read by Maxima.
ibase
may be assigned any integer between 2 and 36 (decimal), inclusive.
When ibase
is greater than 10,
the numerals comprise the decimal numerals 0 through 9
plus letters of the alphabet A
, B
, C
, …,
as needed to make ibase
digits in all.
Letters are interpreted as digits only if the first digit is 0 through 9.
Uppercase and lowercase letters are not distinguished.
The numerals for base 36, the largest acceptable base,
comprise 0 through 9 and A
through Z
.
Whatever the value of ibase
,
when an integer is terminated by a decimal point,
it is interpreted in base 10.
See also obase
.
Examples:
ibase
less than 10 (for example binary numbers).
(%i1) ibase : 2 $
(%i2) obase; (%o2) 10
(%i3) 1111111111111111; (%o3) 65535
ibase
greater than 10.
Letters are interpreted as digits only if the first digit is 0
through 9 which means that hexadecimal numbers might need to
be prepended by a 0.
(%i1) ibase : 16 $
(%i2) obase; (%o2) 10
(%i3) 1000; (%o3) 4096
(%i4) abcd; (%o4) abcd
(%i5) symbolp (abcd); (%o5) true
(%i6) 0abcd; (%o6) 43981
(%i7) symbolp (0abcd); (%o7) false
When an integer is terminated by a decimal point, it is interpreted in base 10.
(%i1) ibase : 36 $
(%i2) obase; (%o2) 10
(%i3) 1234; (%o3) 49360
(%i4) 1234.; (%o4) 1234
Displays expressions expr_1, …, expr_n to the console as
printed output. ldisp
assigns an intermediate expression label to each
argument and returns the list of labels.
See also disp
, display
, and ldisplay
.
Examples:
(%i1) e: (a+b)^3; 3 (%o1) (b + a) (%i2) f: expand (e); 3 2 2 3 (%o2) b + 3 a b + 3 a b + a (%i3) ldisp (e, f); 3 (%t3) (b + a) 3 2 2 3 (%t4) b + 3 a b + 3 a b + a (%o4) [%t3, %t4] (%i4) %t3; 3 (%o4) (b + a) (%i5) %t4; 3 2 2 3 (%o5) b + 3 a b + 3 a b + a
Displays expressions expr_1, …, expr_n to the console as
printed output. Each expression is printed as an equation of the form
lhs = rhs
in which lhs
is one of the arguments of ldisplay
and rhs
is its value. Typically each argument is a variable.
ldisp
assigns an intermediate expression label to each equation and
returns the list of labels.
See also display
, disp
, and ldisp
.
Examples:
(%i1) e: (a+b)^3; 3 (%o1) (b + a) (%i2) f: expand (e); 3 2 2 3 (%o2) b + 3 a b + 3 a b + a (%i3) ldisplay (e, f); 3 (%t3) e = (b + a) 3 2 2 3 (%t4) f = b + 3 a b + 3 a b + a (%o4) [%t3, %t4] (%i4) %t3; 3 (%o4) e = (b + a) (%i5) %t4; 3 2 2 3 (%o5) f = b + 3 a b + 3 a b + a
Default value: false
When leftjust
is true
, equations in 2D-display are drawn left
justified rather than centered.
See also display2d
to switch between 1D- and 2D-display.
Example:
(%i1) expand((x+1)^3); 3 2 (%o1) x + 3 x + 3 x + 1 (%i2) leftjust:true$ (%i3) expand((x+1)^3); 3 2 (%o3) x + 3 x + 3 x + 1
Default value: 79
linel
is the assumed width (in characters) of the console display for the
purpose of displaying expressions. linel
may be assigned any value by
the user, although very small or very large values may be impractical. Text
printed by built-in Maxima functions, such as error messages and the output of
describe
, is not affected by linel
.
Default value: false
When lispdisp
is true
, Lisp symbols are displayed with a leading
question mark ?
. Otherwise, Lisp symbols are displayed with no leading
mark. This has the same effect for 1-d and 2-d display.
Examples:
(%i1) lispdisp: false$
(%i2) ?foo + ?bar; (%o2) foo + bar
(%i3) lispdisp: true$
(%i4) ?foo + ?bar; (%o4) ?foo + ?bar
Default value: true
When negsumdispflag
is true
, x - y
displays as x - y
instead of as - y + x
. Setting it to false
causes the special
check in display for the difference of two expressions to not be done. One
application is that thus a + %i*b
and a - %i*b
may both be
displayed the same way.
Default value: 10
obase
is the base for integers displayed by Maxima.
obase
may be assigned any integer between 2 and 36 (decimal), inclusive.
When obase
is greater than 10,
the numerals comprise the decimal numerals 0 through 9
plus capital letters of the alphabet A, B, C, …, as needed.
A leading 0 digit is displayed if the leading digit is otherwise a letter.
The numerals for base 36, the largest acceptable base,
comprise 0 through 9, and A through Z.
See also ibase
.
Examples:
(%i1) obase : 2; (%o1) 10
(%i10) 2^8 - 1; (%o10) 11111111
(%i11) obase : 8; (%o3) 10
(%i4) 8^8 - 1; (%o4) 77777777
(%i5) obase : 16; (%o5) 10
(%i6) 16^8 - 1; (%o6) 0FFFFFFFF
(%i7) obase : 36; (%o7) 10
(%i8) 36^8 - 1; (%o8) 0ZZZZZZZZ
Default value: false
When pfeformat
is true
, a ratio of integers is displayed with the
solidus (forward slash) character, and an integer denominator n
is
displayed as a leading multiplicative term 1/n
.
Examples:
(%i1) pfeformat: false$ (%i2) 2^16/7^3; 65536 (%o2) ----- 343 (%i3) (a+b)/8; b + a (%o3) ----- 8 (%i4) pfeformat: true$ (%i5) 2^16/7^3; (%o5) 65536/343 (%i6) (a+b)/8; (%o6) 1/8 (b + a)
Default value: false
When powerdisp
is true
,
a sum is displayed with its terms in order of increasing power.
Thus a polynomial is displayed as a truncated power series,
with the constant term first and the highest power last.
By default, terms of a sum are displayed in order of decreasing power.
Example:
(%i1) powerdisp:true; (%o1) true (%i2) x^2+x^3+x^4; 2 3 4 (%o2) x + x + x (%i3) powerdisp:false; (%o3) false (%i4) x^2+x^3+x^4; 4 3 2 (%o4) x + x + x
Evaluates and displays expr_1, …, expr_n one after another, from left to right, starting at the left edge of the console display.
The value returned by print
is the value of its last argument.
print
does not generate intermediate expression labels.
See also display
, disp
, ldisplay
, and
ldisp
. Those functions display one expression per line, while
print
attempts to display two or more expressions per line.
To display the contents of a file, see printfile
.
Examples:
(%i1) r: print ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is", radcan (log (a^10/b)))$ 3 2 2 3 (a+b)^3 is b + 3 a b + 3 a b + a log (a^10/b) is 10 log(a) - log(b) (%i2) r; (%o2) 10 log(a) - log(b) (%i3) disp ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is", radcan (log (a^10/b)))$ (a+b)^3 is 3 2 2 3 b + 3 a b + 3 a b + a log (a^10/b) is 10 log(a) - log(b)
Default value: true
When sqrtdispflag
is false
, causes sqrt
to display with
exponent 1/2.
Default value: false
When stardisp
is true
, multiplication is
displayed with an asterisk *
between operands.
Default value: false
When ttyoff
is true
, output expressions are not displayed.
Output expressions are still computed and assigned labels. See labels
.
Text printed by built-in Maxima functions, such as error messages and the output
of describe
, is not affected by ttyoff
.
A complex expression is specified in Maxima by adding the real part of the
expression to %i
times the imaginary part. Thus the roots of the
equation x^2 - 4*x + 13 = 0
are 2 + 3*%i
and 2 - 3*%i
.
Note that simplification of products of complex expressions can be effected by
expanding the product. Simplification of quotients, roots, and other functions
of complex expressions can usually be accomplished by using the realpart
,
imagpart
, rectform
, polarform
, abs
, carg
functions.
bfloat
replaces integers, rationals, floating point numbers, and some symbolic constants
in expr with bigfloat (variable-precision floating point) numbers.
The constants %e
, %gamma
, %phi
, and %pi
are replaced by a numerical approximation.
However, %e
in %e^x
is not replaced by a numeric value
unless bfloat(x)
is a number.
bfloat
also causes numerical evaluation of some built-in functions,
namely trigonometric functions, exponential functions, abs
, and log
.
The number of significant digits in the resulting bigfloats is specified by the
global variable fpprec
.
Bigfloats already present in expr are replaced with values which have
precision specified by the current value of fpprec
.
When float2bf
is false
, a warning message is printed when
a floating point number is replaced by a bigfloat number with less precision.
Examples:
bfloat
replaces integers, rationals, floating point numbers, and some symbolic constants
in expr with bigfloat numbers.
(%i1) bfloat([123, 17/29, 1.75]); (%o1) [1.23b2, 5.862068965517241b-1, 1.75b0] (%i2) bfloat([%e, %gamma, %phi, %pi]); (%o2) [2.718281828459045b0, 5.772156649015329b-1, 1.618033988749895b0, 3.141592653589793b0] (%i3) bfloat((f(123) + g(h(17/29)))/(x + %gamma)); 1.0b0 (g(h(5.862068965517241b-1)) + f(1.23b2)) (%o3) ---------------------------------------------- x + 5.772156649015329b-1
bfloat
also causes numerical evaluation of some built-in functions.
(%i1) bfloat(sin(17/29)); (%o1) 5.532051841609784b-1 (%i2) bfloat(exp(%pi)); (%o2) 2.314069263277927b1 (%i3) bfloat(abs(-%gamma)); (%o3) 5.772156649015329b-1 (%i4) bfloat(log(%phi)); (%o4) 4.812118250596035b-1
Returns true
if expr is a bigfloat number, otherwise false
.
Default value: false
bftorat
controls the conversion of bfloats to rational numbers. When
bftorat
is false
, ratepsilon
will be used to control the
conversion (this results in relatively small rational numbers). When
bftorat
is true
, the rational number generated will accurately
represent the bfloat.
Note: bftorat
has no effect on the transformation to rational numbers
with the function rationalize
.
Example:
(%i1) ratepsilon:1e-4; (%o1) 1.0e-4 (%i2) rat(bfloat(11111/111111)), bftorat:false; `rat' replaced 9.99990999991B-2 by 1/10 = 1.0B-1 1 (%o2)/R/ -- 10 (%i3) rat(bfloat(11111/111111)), bftorat:true; `rat' replaced 9.99990999991B-2 by 11111/111111 = 9.99990999991B-2 11111 (%o3)/R/ ------ 111111
Default value: true
bftrunc
causes trailing zeroes in non-zero bigfloat numbers not to be
displayed. Thus, if bftrunc
is false
, bfloat (1)
displays as 1.000000000000000B0
. Otherwise, this is displayed as
1.0B0
.
Returns the number of bits of precision in a bigfloat number. This
value depends, of course, on the value of fpprec
.
(%i1) fpprec:16; (%o1) 16 (%i2) bigfloat_bits(); (%o2) 56 (%i3) fpprec:32; (%o3) 32 (%i4) bigfloat_bits(); (%o4) 109
Returns the smallest bigfloat value, eps
, such that
1+eps
is not equal to 1. The value depends on fpprec
,
of course.
(%i1) fpprec:16; (%o1) 16 (%i2) bigfloat_eps(); (%o2) 1.387778780781446b-17 (%i3) fpprec:32; (%o3) 32 (%i4) bigfloat_eps(); (%o4) 1.5407439555097886824447823540679b-33
Returns true
if expr is a literal even integer, otherwise
false
.
evenp
returns false
if expr is a symbol, even if expr
is declared even
.
Converts integers, rational numbers and bigfloats in expr to floating
point numbers. It is also an evflag
, float
causes
non-integral rational numbers and bigfloat numbers to be converted to floating
point.
Default value: true
When float2bf
is false
, a warning message is printed when
a floating point number is replaced by a bigfloat number with less precision.
Returns the number of bits of precision of a floating-point number.
Returns the smallest floating-point value, eps
, such that
1+eps
is not equal to 1.
Returns true
if expr is a floating point number, otherwise
false
.
Default value: 16
fpprec
is the number of significant digits for arithmetic on bigfloat
numbers. fpprec
does not affect computations on ordinary floating point
numbers.
See also bfloat
and fpprintprec
.
Default value: 0
fpprintprec
is the number of digits to print when printing an ordinary
float or bigfloat number.
For ordinary floating point numbers,
when fpprintprec
has a value between 2 and 16 (inclusive),
the number of digits printed is equal to fpprintprec
.
Otherwise, fpprintprec
is 0, or greater than 16,
and the number of digits printed is 16.
For bigfloat numbers,
when fpprintprec
has a value between 2 and fpprec
(inclusive),
the number of digits printed is equal to fpprintprec
.
Otherwise, fpprintprec
is 0, or greater than fpprec
,
and the number of digits printed is equal to fpprec
.
For both ordinary floats and bigfloats,
trailing zero digits are suppressed.
The actual number of digits printed is less than fpprintprec
if there are trailing zero digits.
fpprintprec
cannot be 1.
Returns true
if expr is a literal numeric integer, otherwise
false
.
integerp
returns false
if expr is a symbol, even if expr
is declared integer
.
Examples:
(%i1) integerp (0); (%o1) true (%i2) integerp (1); (%o2) true (%i3) integerp (-17); (%o3) true (%i4) integerp (0.0); (%o4) false (%i5) integerp (1.0); (%o5) false (%i6) integerp (%pi); (%o6) false (%i7) integerp (n); (%o7) false (%i8) declare (n, integer); (%o8) done (%i9) integerp (n); (%o9) false
Default value: false
m1pbranch
is the principal branch for -1
to a power.
Quantities such as (-1)^(1/3)
(that is, an "odd" rational exponent) and
(-1)^(1/4)
(that is, an "even" rational exponent) are handled as follows:
domain:real (-1)^(1/3): -1 (-1)^(1/4): (-1)^(1/4) domain:complex m1pbranch:false m1pbranch:true (-1)^(1/3) 1/2+%i*sqrt(3)/2 (-1)^(1/4) sqrt(2)/2+%i*sqrt(2)/2
Return true
if and only if n >= 0
and n is an integer.
Returns true
if expr is a literal integer, rational number,
floating point number, or bigfloat, otherwise false
.
numberp
returns false
if expr is a symbol, even if expr
is a symbolic number such as %pi
or %i
, or declared to be
even
, odd
, integer
, rational
, irrational
,
real
, imaginary
, or complex
.
Examples:
(%i1) numberp (42); (%o1) true (%i2) numberp (-13/19); (%o2) true (%i3) numberp (3.14159); (%o3) true (%i4) numberp (-1729b-4); (%o4) true (%i5) map (numberp, [%e, %pi, %i, %phi, inf, minf]); (%o5) [false, false, false, false, false, false] (%i6) declare (a, even, b, odd, c, integer, d, rational, e, irrational, f, real, g, imaginary, h, complex); (%o6) done (%i7) map (numberp, [a, b, c, d, e, f, g, h]); (%o7) [false, false, false, false, false, false, false, false]
numer
causes some mathematical functions (including exponentiation)
with numerical arguments to be evaluated in floating point. It causes
variables in expr
which have been given numerals to be replaced by
their values. It also sets the float
switch on.
See also %enumer
.
Examples:
(%i1) [sqrt(2), sin(1), 1/(1+sqrt(3))]; 1 (%o1) [sqrt(2), sin(1), -----------] sqrt(3) + 1
(%i2) [sqrt(2), sin(1), 1/(1+sqrt(3))],numer; (%o2) [1.414213562373095, 0.8414709848078965, 0.3660254037844387]
Default value: false
The option variable numer_pbranch
controls the numerical evaluation of
the power of a negative integer, rational, or floating point number. When
numer_pbranch
is true
and the exponent is a floating point number
or the option variable numer
is true
too, Maxima evaluates
the numerical result using the principal branch. Otherwise a simplified, but
not an evaluated result is returned.
Examples:
(%i1) (-2)^0.75; 0.75 (%o1) (- 2)
(%i2) (-2)^0.75,numer_pbranch:true; (%o2) 1.189207115002721 %i - 1.189207115002721
(%i3) (-2)^(3/4); 3/4 3/4 (%o3) (- 1) 2
(%i4) (-2)^(3/4),numer; 0.75 (%o4) 1.681792830507429 (- 1)
(%i5) (-2)^(3/4),numer,numer_pbranch:true; (%o5) 1.189207115002721 %i - 1.189207115002721
Declares the variables x_1
, …, x_n to have
numeric values equal to expr_1
, …, expr_n
.
The numeric value is evaluated and substituted for the variable
in any expressions in which the variable occurs if the numer
flag is
true
. See also ev
.
The expressions expr_1
, …, expr_n
can be any expressions,
not necessarily numeric.
Returns true
if expr is a literal odd integer, otherwise
false
.
oddp
returns false
if expr is a symbol, even if expr
is declared odd
.
Default value: 2.0e-15
ratepsilon
is the tolerance used in the conversion
of floating point numbers to rational numbers, when the option variable
bftorat
has the value false
. See bftorat
for an example.
Convert all double floats and big floats in the Maxima expression expr to
their exact rational equivalents. If you are not familiar with the binary
representation of floating point numbers, you might be surprised that
rationalize (0.1)
does not equal 1/10. This behavior isn’t special to
Maxima – the number 1/10 has a repeating, not a terminating, binary
representation.
(%i1) rationalize (0.5); 1 (%o1) - 2
(%i2) rationalize (0.1); 3602879701896397 (%o2) ----------------- 36028797018963968
(%i3) fpprec : 5$
(%i4) rationalize (0.1b0); 209715 (%o4) ------- 2097152
(%i5) fpprec : 20$
(%i6) rationalize (0.1b0); 236118324143482260685 (%o6) ---------------------- 2361183241434822606848
(%i7) rationalize (sin (0.1*x + 5.6)); 3602879701896397 x 3152519739159347 (%o7) sin(------------------ + ----------------) 36028797018963968 562949953421312
Returns true
if expr is a literal integer or ratio of literal
integers, otherwise false
.
Strings (quoted character sequences) are enclosed in double quote marks "
for input, and displayed with or without the quote marks, depending on the
global variable stringdisp
.
Strings may contain any characters, including embedded tab, newline, and
carriage return characters. The sequence \"
is recognized as a literal
double quote, and \\
as a literal backslash. When backslash appears at
the end of a line, the backslash and the line termination (either newline or
carriage return and newline) are ignored, so that the string continues with the
next line. No other special combinations of backslash with another character
are recognized; when backslash appears before any character other than "
,
\
, or a line termination, the backslash is ignored. There is no way to
represent a special character (such as tab, newline, or carriage return)
except by embedding the literal character in the string.
There is no character type in Maxima; a single character is represented as a one-character string.
The stringproc
add-on package contains many functions for working with
strings.
Examples:
(%i1) s_1 : "This is a string."; (%o1) This is a string.
(%i2) s_2 : "Embedded \"double quotes\" and backslash \\ characters."; (%o2) Embedded "double quotes" and backslash \ characters.
(%i3) s_3 : "Embedded line termination in this string."; (%o3) Embedded line termination in this string.
(%i4) s_4 : "Ignore the \ line termination \ characters in \ this string."; (%o4) Ignore the line termination characters in this string.
(%i5) stringdisp : false; (%o5) false
(%i6) s_1; (%o6) This is a string.
(%i7) stringdisp : true; (%o7) true
(%i8) s_1; (%o8) "This is a string."
Concatenates its arguments. The arguments must evaluate to atoms. The return value is a symbol if the first argument is a symbol and a string otherwise.
concat
evaluates its arguments. The single quote '
prevents
evaluation.
See also sconcat
, that works on non-atoms, too, simplode
,
string
and eval_string
.
For complex string conversions see also printf
.
(%i1) y: 7$ (%i2) z: 88$ (%i3) concat (y, z/2); (%o3) 744 (%i4) concat ('y, z/2); (%o4) y44
A symbol constructed by concat
may be assigned a value and appear in
expressions. The ::
(double colon) assignment operator evaluates its
left-hand side.
(%i5) a: concat ('y, z/2); (%o5) y44 (%i6) a:: 123; (%o6) 123 (%i7) y44; (%o7) 123 (%i8) b^a; y44 (%o8) b (%i9) %, numer; 123 (%o9) b
Note that although concat (1, 2)
looks like a number, it is a string.
(%i10) concat (1, 2) + 3; (%o10) 12 + 3
Concatenates its arguments into a string. Unlike concat
, the
arguments do not need to be atoms.
See also concat
, simplode
, string
and eval_string
.
For complex string conversions see also printf
.
(%i1) sconcat ("xx[", 3, "]:", expand ((x+y)^3)); (%o1) xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
Another purpose for sconcat
is to convert arbitrary objects to strings.
(%i1) sconcat (x); (%o1) x
(%i2) stringp(%); (%o2) true
Converts expr
to Maxima’s linear notation just as if it had been typed
in.
The return value of string
is a string, and thus it cannot be used in a
computation.
See also concat
, sconcat
, simplode
and
eval_string
.
Default value: false
When stringdisp
is true
, strings are displayed enclosed in double
quote marks. Otherwise, quote marks are not displayed.
stringdisp
is always true
when displaying a function definition.
Examples:
(%i1) stringdisp: false$
(%i2) "This is an example string."; (%o2) This is an example string.
(%i3) foo () := print ("This is a string in a function definition."); (%o3) foo() := print("This is a string in a function definition.")
(%i4) stringdisp: true$
(%i5) "This is an example string."; (%o5) "This is an example string."
%e
represents the base of the natural logarithm, also known as Euler’s
number. The numeric value of %e
is the double-precision floating-point
value 2.718281828459045d0. (See A&S eqn 4.1.16, A&S 4.1.17.)
false
represents the Boolean constant of the same name.
Maxima implements false
by the value NIL
in Lisp.
The Euler-Mascheroni constant, 0.5772156649015329.... It is defined by (A&S eqn 6.1.3 and DLMF 5.2.ii)
ind
represents a bounded, indefinite result.
See also limit
.
Example:
(%i1) limit (sin(1/x), x, 0); (%o1) ind
The most positive floating-point number in Maxima.
The most negative floating-point number in Maxima.
The least negative floating-point number in Maxima. That is, the negative floating-point number closest to 0.
The least negative normalized floating-point number in Maxima. That is, the negative normalized floating-point number closest to 0.
The least positive floating-point number in Maxima. That is, the positive floating-point number closest to 0.
The least positive normalized floating-point number in Maxima. That is, the positive normalized floating-point number closest to 0.
%phi
represents the so-called golden mean,
\((1+\sqrt{5})/2\)
.
The numeric value of %phi
is the double-precision floating-point value
1.618033988749895d0.
fibtophi
expresses Fibonacci numbers fib(n)
in terms of
%phi
.
By default, Maxima does not know the algebraic properties of %phi
.
After evaluating tellrat(%phi^2 - %phi - 1)
and algebraic: true
,
ratsimp
can simplify some expressions containing %phi
.
Examples:
fibtophi
expresses Fibonacci numbers fib(n)
in terms of %phi
.
(%i1) fibtophi (fib (n)); n n %phi - (1 - %phi) (%o1) ------------------- 2 %phi - 1 (%i2) fib (n-1) + fib (n) - fib (n+1); (%o2) - fib(n + 1) + fib(n) + fib(n - 1) (%i3) fibtophi (%); n + 1 n + 1 n n %phi - (1 - %phi) %phi - (1 - %phi) (%o3) - --------------------------- + ------------------- 2 %phi - 1 2 %phi - 1 n - 1 n - 1 %phi - (1 - %phi) + --------------------------- 2 %phi - 1 (%i4) ratsimp (%); (%o4) 0
By default, Maxima does not know the algebraic properties of %phi
.
After evaluating tellrat (%phi^2 - %phi - 1)
and algebraic: true
,
ratsimp
can simplify some expressions containing %phi
.
(%i1) e : expand ((%phi^2 - %phi - 1) * (A + 1)); 2 2 (%o1) %phi A - %phi A - A + %phi - %phi - 1 (%i2) ratsimp (e); 2 2 (%o2) (%phi - %phi - 1) A + %phi - %phi - 1 (%i3) tellrat (%phi^2 - %phi - 1); 2 (%o3) [%phi - %phi - 1] (%i4) algebraic : true; (%o4) true (%i5) ratsimp (e); (%o5) 0
%pi
represents the ratio of the perimeter of a circle to its diameter.
The numeric value of %pi
is the double-precision floating-point value
3.141592653589793d0.
true
represents the Boolean constant of the same name.
Maxima implements true
by the value T
in Lisp.
und
represents an undefined result.
See also limit
.
Example:
(%i1) limit (x*sin(x), x, inf); (%o1) und
zeroa
represents an infinitesimal above zero. zeroa
can be used
in expressions. limit
simplifies expressions which contain
infinitesimals.
Example:
limit
simplifies expressions which contain infinitesimals:
(%i1) limit(zeroa); (%o1) 0 (%i2) limit(x+zeroa); (%o2) x
zerob
represents an infinitesimal below zero. zerob
can be used
in expressions. limit
simplifies expressions which contain
infinitesimals.
Lists are the basic building block for Maxima and Lisp. All data types
other than arrays, hashed arrays
and numbers are represented as Lisp lists,
These Lisp lists have the form
((MPLUS) $A 2)
to indicate an expression a+2
. At Maxima level one would see
the infix notation a+2
. Maxima also has lists which are printed
as
[1, 2, 7, x+y]
for a list with 4 elements. Internally this corresponds to a Lisp list of the form
((MLIST) 1 2 7 ((MPLUS) $X $Y))
The flag which denotes the type field of the Maxima expression is a list itself, since after it has been through the simplifier the list would become
((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y))
[
and ]
mark the beginning and end, respectively, of a list.
[
and ]
also enclose the subscripts of
a list, array, hashed array
, or memoizing function
. Note that
other than for arrays accessing the n
th element of a list
may need an amount of time that is roughly proportional to n
,
See Performance considerations for Lists.
Note that if an element of a subscripted variable is written to before
a list or an array of this name is declared a hashed array
(see Arrays) is created, not a list.
Examples:
(%i1) x: [a, b, c]; (%o1) [a, b, c]
(%i2) x[3]; (%o2) c
(%i3) array (y, fixnum, 3); (%o3) y
(%i4) y[2]: %pi; (%o4) %pi
(%i5) y[2]; (%o5) %pi
(%i6) z['foo]: 'bar; (%o6) bar
(%i7) z['foo]; (%o7) bar
(%i8) g[k] := 1/(k^2+1); 1 (%o8) g := ------ k 2 k + 1
(%i9) g[10]; 1 (%o9) --- 101
Returns a single list of the elements of list_1 followed
by the elements of list_2, … append
also works on
general expressions, e.g. append (f(a,b), f(c,d,e));
yields
f(a,b,c,d,e)
.
See also addrow
, addcol
and join
.
Do example(append);
for an example.
assoc
(key, e, default) assoc
(key, e) ¶assoc
searches for key as the first part of an argument of e
and returns the second part of the first match, if any.
key may be any expression.
e must be a nonatomic expression,
and every argument of e must have exactly two parts.
assoc
returns the second part of the first matching argument of e.
Matches are determined by is(key = first(a))
where a is an argument of e.
If there are two or more matches, only the first is returned.
If there are no matches, default is returned, if specified.
Otherwise, false
is returned.
Examples:
key may be any expression.
e must be a nonatomic expression,
and every argument of e must have exactly two parts.
assoc
returns the second part of the first matching argument of e.
(%i1) assoc (f(x), foo(g(x) = y, f(x) = z + 1, h(x) = 2*u)); (%o1) z + 1
If there are two or more matches, only the first is returned.
(%i1) assoc (yy, [xx = 111, yy = 222, yy = 333, yy = 444]); (%o1) 222
If there are no matches, default is returned, if specified.
Otherwise, false
is returned.
(%i1) assoc (abc, [[x, 111], [y, 222], [z, 333]], none); (%o1) none (%i2) assoc (abc, [[x, 111], [y, 222], [z, 333]]); (%o2) false
cons
(expr, list) cons
(expr_1, expr_2) ¶cons (expr, list)
returns a new list constructed of the element
expr as its first element, followed by the elements of list. This is
analogous to the Lisp language construction operation "cons".
The Maxima function cons
can also be used where the second argument is other
than a list and this might be useful. In this case, cons (expr_1, expr_2)
returns an expression with same operator as expr_2 but with argument cons(expr_1, args(expr_2))
.
Examples:
(%i1) cons(a,[b,c,d]); (%o1) [a, b, c, d]
(%i2) cons(a,f(b,c,d)); (%o2) f(a, b, c, d)
In general, cons
applied to a nonlist doesn’t make sense. For instance, cons(a,b^c)
results in an illegal expression, since ’^’ cannot take three arguments.
When inflag
is true, cons
operates on the internal structure of an expression, otherwise
cons
operates on the displayed form. Especially when inflag
is true, cons
applied
to a nonlist sometimes gives a surprising result; for example
(%i1) cons(a,-a), inflag : true; 2 (%o1) - a
(%i2) cons(a,-a), inflag : false; (%o2) 0
Create a list by evaluating form with x_1 bound to each element of list_1, and for each such binding bind x_2 to each element of list_2, … The number of elements in the result will be the product of the number of elements in each list. Each variable x_i must actually be a symbol – it will not be evaluated. The list arguments will be evaluated once at the beginning of the iteration.
(%i1) create_list (x^i, i, [1, 3, 7]); 3 7 (%o1) [x, x , x ]
With a double iteration:
(%i1) create_list ([i, j], i, [a, b], j, [e, f, h]); (%o1) [[a, e], [a, f], [a, h], [b, e], [b, f], [b, h]]
Instead of 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.
(%i1) create_list ([i, j], i, [1, 2, 3], j, 1, i); (%o1) [[1, 1], [2, 1], [2, 2], [3, 1], [3, 2], [3, 3]]
Note that the limits or list for the j
variable can
depend on the current value of i
.
delete
(expr_1, expr_2) delete
(expr_1, expr_2, n) ¶delete(expr_1, expr_2)
removes from expr_2 any arguments of its top-level operator
which are the same (as determined by "=") as expr_1.
Note that "=" tests for formal equality, not equivalence.
Note also that arguments of subexpressions are not affected.
expr_1 may be an atom or a non-atomic expression.
expr_2 may be any non-atomic expression.
delete
returns a new expression;
it does not modify expr_2.
delete(expr_1, expr_2, n)
removes from expr_2 the first n arguments of the top-level operator
which are the same as expr_1.
If there are fewer than n such arguments,
then all such arguments are removed.
Examples:
Removing elements from a list.
(%i1) delete (y, [w, x, y, z, z, y, x, w]); (%o1) [w, x, z, z, x, w]
Removing terms from a sum.
(%i1) delete (sin(x), x + sin(x) + y); (%o1) y + x
Removing factors from a product.
(%i1) delete (u - x, (u - w)*(u - x)*(u - y)*(u - z)); (%o1) (u - w) (u - y) (u - z)
Removing arguments from an arbitrary expression.
(%i1) delete (a, foo (a, b, c, d, a)); (%o1) foo(b, c, d)
Limit the number of removed arguments.
(%i1) delete (a, foo (a, b, a, c, d, a), 2); (%o1) foo(b, c, d, a)
Whether arguments are the same as expr_1 is determined by "=".
Arguments which are equal
but not "=" are not removed.
(%i1) [is (equal (0, 0)), is (equal (0, 0.0)), is (equal (0, 0b0))]; (%o1) [true, true, true]
(%i2) [is (0 = 0), is (0 = 0.0), is (0 = 0b0)]; (%o2) [true, false, false]
(%i3) delete (0, [0, 0.0, 0b0]); (%o3) [0.0, 0.0b0]
(%i4) is (equal ((x + y)*(x - y), x^2 - y^2)); (%o4) true
(%i5) is ((x + y)*(x - y) = x^2 - y^2); (%o5) false
(%i6) delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]); 2 2 (%o6) [x - y ]
Returns the 8th item of expression or list expr.
See first
for more details.
endcons
(expr, list) endcons
(expr_1, expr_2) ¶endcons (expr, list)
returns a new list constructed of the elements of
list followed by expr. The Maxima function endcons
can also be used where
the second argument is other than a list and this might be useful. In this case,
endcons (expr_1, expr_2)
returns an expression with same operator as
expr_2 but with argument endcons(expr_1, args(expr_2))
. Examples:
(%i1) endcons(a,[b,c,d]); (%o1) [b, c, d, a]
(%i2) endcons(a,f(b,c,d)); (%o2) f(b, c, d, a)
In general, endcons
applied to a nonlist doesn’t make sense. For instance, endcons(a,b^c)
results in an illegal expression, since ’^’ cannot take three arguments.
When inflag
is true, endcons
operates on the internal structure of an expression, otherwise
endcons
operates on the displayed form. Especially when inflag
is true, endcons
applied
to a nonlist sometimes gives a surprising result; for example
(%i1) endcons(a,-a), inflag : true; 2 (%o1) - a
(%i2) endcons(a,-a), inflag : false; (%o2) 0
Returns the 5th item of expression or list expr.
See first
for more details.
Returns the first part of expr which may result in the first element of a list, the first row of a matrix, the first term of a sum, etc.:
(%i1) matrix([1,2],[3,4]); [ 1 2 ] (%o1) [ ] [ 3 4 ] (%i2) first(%); (%o2) [1,2] (%i3) first(%); (%o3) 1 (%i4) first(a*b/c+d+e/x); a b (%o4) --- c (%i5) first(a=b/c+d+e/x); (%o5) a
Note that
first
and its related functions, rest
and last
, work
on the form of expr which is displayed not the form which is typed on
input. If the variable inflag
is set to true
however, these
functions will look at the internal form of expr. One reason why this may
make a difference is that the simplifier re-orders expressions:
(%i1) x+y; (%o1) y+1 (%i2) first(x+y),inflag : true; (%o2) x (%i3) first(x+y),inflag : false; (%o3) y
The functions second
…
tenth
yield the second through the tenth part of their input argument.
Returns the first count arguments of expr, if expr has at least count arguments. Returns expr if expr has less than count arguments.
expr may be any nonatomic expression.
When expr is something other than a list,
firstn
returns an expression which has the same operator as expr.
count must be a nonnegative integer.
firstn
honors the global flag inflag
,
which governs whether the internal form of an expression is processed (when inflag
is true)
or the displayed form (when inflag
is false).
Note that firstn(expr, 1)
,
which returns a nonatomic expression containing the first argument,
is not the same as first(expr)
,
which returns the first argument by itself.
Examples:
firstn
returns the first count elements of expr, if expr has at least count elements.
(%i1) mylist : [1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)]; (%o1) [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)]
(%i2) firstn (mylist, 0); (%o2) []
(%i3) firstn (mylist, 1); (%o3) [1]
(%i4) firstn (mylist, 2); (%o4) [1, a]
(%i5) firstn (mylist, 7); (%o5) [1, a, 2, b, 3, x, 4 - y]
firstn
returns expr if expr has less than count elements.
(%i1) mylist : [1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)]; (%o1) [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)]
(%i2) firstn (mylist, 100); (%o2) [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)]
expr may be any nonatomic expression.
(%i1) myfoo : foo(1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)); (%o1) foo(1, a, 2, b, 3, x, 4 - y, 2 z + sin(u))
(%i2) firstn (myfoo, 4); (%o2) foo(1, a, 2, b)
(%i3) mybar : bar[m, n](1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)); (%o3) bar (1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)) m, n
(%i4) firstn (mybar, 4); (%o4) bar (1, a, 2, b) m, n
(%i5) mymatrix : genmatrix (lambda ([i, j], 10*i + j), 10, 4) $
(%i6) firstn (mymatrix, 3); [ 11 12 13 14 ] [ ] (%o6) [ 21 22 23 24 ] [ ] [ 31 32 33 34 ]
firstn
honors the global flag inflag
.
(%i1) myexpr : a + b + c + d + e; (%o1) e + d + c + b + a
(%i2) firstn (myexpr, 3), inflag=true; (%o2) c + b + a
(%i3) firstn (myexpr, 3), inflag=false; (%o3) e + d + c
Note that firstn(expr, 1)
is not the same as first(expr)
.
(%i1) firstn ([w, x, y, z], 1); (%o1) [w]
(%i2) first ([w, x, y, z]); (%o2) w
Returns the 4th item of expression or list expr.
See first
for more details.
Creates a new list containing the elements of lists l and m,
interspersed. The result has elements [l[1], m[1],
l[2], m[2], ...]
. The lists l and m may contain any
type of elements.
If the lists are different lengths, join
ignores elements of the longer
list.
Maxima complains if l or m is not a list.
See also append
.
Examples:
(%i1) L1: [a, sin(b), c!, d - 1]; (%o1) [a, sin(b), c!, d - 1]
(%i2) join (L1, [1, 2, 3, 4]); (%o2) [a, 1, sin(b), 2, c!, 3, d - 1, 4]
(%i3) join (L1, [aa, bb, cc, dd, ee, ff]); (%o3) [a, aa, sin(b), bb, c!, cc, d - 1, dd]
Returns the last part (term, row, element, etc.) of the expr.
See also lastn
.
Returns the last count arguments of expr, if expr has at least count arguments. Returns expr if expr has less than count arguments.
expr may be any nonatomic expression.
When expr is something other than a list,
lastn
returns an expression which has the same operator as expr.
count must be a nonnegative integer.
lastn
honors the global flag inflag
,
which governs whether the internal form of an expression is processed (when inflag
is true)
or the displayed form (when inflag
is false).
Note that lastn(expr, 1)
,
which returns a nonatomic expression containing the last argument,
is not the same as last(expr)
,
which returns the last argument by itself.
Examples:
lastn
returns the last count elements of expr, if expr has at least count elements.
(%i1) mylist : [1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)]; (%o1) [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)]
(%i2) lastn (mylist, 0); (%o2) []
(%i3) lastn (mylist, 1); (%o3) [2 z + sin(u)]
(%i4) lastn (mylist, 2); (%o4) [4 - y, 2 z + sin(u)]
(%i5) lastn (mylist, 7); (%o5) [a, 2, b, 3, x, 4 - y, 2 z + sin(u)]
lastn
returns expr if expr has less than count elements.
(%i1) mylist : [1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)]; (%o1) [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)]
(%i2) lastn (mylist, 100); (%o2) [1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)]
expr may be any nonatomic expression.
(%i1) myfoo : foo(1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)); (%o1) foo(1, a, 2, b, 3, x, 4 - y, 2 z + sin(u))
(%i2) lastn (myfoo, 4); (%o2) foo(3, x, 4 - y, 2 z + sin(u))
(%i3) mybar : bar[m, n](1, a, 2, b, 3, x, 4 - y, 2*z + sin(u)); (%o3) bar (1, a, 2, b, 3, x, 4 - y, 2 z + sin(u)) m, n
(%i4) lastn (mybar, 4); (%o4) bar (3, x, 4 - y, 2 z + sin(u)) m, n
(%i5) mymatrix : genmatrix (lambda ([i, j], 10*i + j), 10, 4) $
(%i6) lastn (mymatrix, 3); [ 81 82 83 84 ] [ ] (%o6) [ 91 92 93 94 ] [ ] [ 101 102 103 104 ]
lastn
honors the global flag inflag
.
(%i1) myexpr : a + b + c + d + e; (%o1) e + d + c + b + a
(%i2) lastn (myexpr, 3), inflag=true; (%o2) e + d + c
(%i3) lastn (myexpr, 3), inflag=false; (%o3) c + b + a
Note that lastn(expr, 1)
is not the same as last(expr)
.
(%i1) lastn ([w, x, y, z], 1); (%o1) [z]
(%i2) last ([w, x, y, z]); (%o2) z
Returns (by default) the number of parts in the external
(displayed) form of expr. For lists this is the number of elements,
for matrices it is the number of rows, and for sums it is the number
of terms (see dispform
).
The length
command is affected by the inflag
switch. So, e.g.
length(a/(b*c));
gives 2 if inflag
is false
(Assuming
exptdispflag
is true
), but 3 if inflag
is true
(the
internal representation is essentially a*b^-1*c^-1
).
Determining a list’s length typically needs an amount of time proportional to the number of elements in the list. If the length of a list is used inside a loop it therefore might drastically increase the performance if the length is calculated outside the loop instead.
Default value: true
If false
causes any arithmetic operations with lists to be suppressed;
when true
, list-matrix operations are contagious causing lists to be
converted to matrices yielding a result which is always a matrix. However,
list-list operations should return lists.
Returns true
if expr is a list else false
.
lreduce
(F, s) lreduce
(F, s, s_0) ¶Extends the binary function F to an n-ary function by composition, where s is a list.
lreduce(F, s)
returns F(... F(F(s_1, s_2), s_3), ... s_n)
.
When the optional argument s_0 is present,
the result is equivalent to lreduce(F, cons(s_0, s))
.
The function F is first applied to the leftmost list elements, thus the name "lreduce".
See also rreduce
, xreduce
, and tree_reduce
.
Examples:
lreduce
without the optional argument.
(%i1) lreduce (f, [1, 2, 3]); (%o1) f(f(1, 2), 3)
(%i2) lreduce (f, [1, 2, 3, 4]); (%o2) f(f(f(1, 2), 3), 4)
lreduce
with the optional argument.
(%i1) lreduce (f, [1, 2, 3], 4); (%o1) f(f(f(4, 1), 2), 3)
lreduce
applied to built-in binary operators.
/
is the division operator.
(%i1) lreduce ("^", args ({a, b, c, d})); b c d (%o1) ((a ) )
(%i2) lreduce ("/", args ({a, b, c, d})); a (%o2) ----- b c d
makelist
() makelist
(expr, n) makelist
(expr, i, i_max) makelist
(expr, i, i_0, i_max) makelist
(expr, i, i_0, i_max, step) makelist
(expr, x, list) ¶The first form, makelist ()
, creates an empty list. The second form,
makelist (expr)
, creates a list with expr as its single
element. makelist (expr, n)
creates a list of n
elements generated from expr.
The most general form, makelist (expr, i, i_0,
i_max, step)
, returns the list of elements obtained when
ev (expr, i=j)
is applied to the elements
j of the sequence: i_0, i_0 + step, i_0 +
2*step, ..., with |j| less than or equal to |i_max|.
The increment step can be a number (positive or negative) or an expression. If it is omitted, the default value 1 will be used. If both i_0 and step are omitted, they will both have a default value of 1.
makelist (expr, x, list)
returns a list, the
j
th element of which is equal to
ev (expr, x=list[j])
for j
equal to 1 through
length (list)
.
Examples:
(%i1) makelist (concat (x,i), i, 6); (%o1) [x1, x2, x3, x4, x5, x6]
(%i2) makelist (x=y, y, [a, b, c]); (%o2) [x = a, x = b, x = c]
(%i3) makelist (x^2, x, 3, 2*%pi, 2); (%o3) [9, 25]
(%i4) makelist (random(6), 4); (%o4) [2, 0, 2, 5]
(%i5) flatten (makelist (makelist (i^2, 3), i, 4)); (%o5) [1, 1, 1, 4, 4, 4, 9, 9, 9, 16, 16, 16]
(%i6) flatten (makelist (makelist (i^2, i, 3), 4)); (%o6) [1, 4, 9, 1, 4, 9, 1, 4, 9, 1, 4, 9]
Returns true
if is(expr_1 = a)
for some element a in args(expr_2)
,
otherwise returns false
.
expr_2
is typically a list, in which case
args(expr_2) = expr_2
and is(expr_1 = a)
for some element a in expr_2
is the test.
member
does not inspect parts of the arguments of expr_2
, so it
may return false
even if expr_1
is a part of some argument of
expr_2
.
See also elementp
.
Examples:
(%i1) member (8, [8, 8.0, 8b0]); (%o1) true
(%i2) member (8, [8.0, 8b0]); (%o2) false
(%i3) member (b, [a, b, c]); (%o3) true
(%i4) member (b, [[a, b], [b, c]]); (%o4) false
(%i5) member ([b, c], [[a, b], [b, c]]); (%o5) true
(%i6) F (1, 1/2, 1/4, 1/8); 1 1 1 (%o6) F(1, -, -, -) 2 4 8
(%i7) member (1/8, %); (%o7) true
(%i8) member ("ab", ["aa", "ab", sin(1), a + b]); (%o8) true
Returns the 9th item of expression or list expr.
See first
for more details.
pop
removes and returns the first element from the list list. The argument
list must be a mapatom that is bound to a nonempty list. If the argument list is
not bound to a nonempty list, Maxima signals an error. For examples, see push
.
push
prepends the item item to the list list and returns a copy of the new list.
The second argument list must be a mapatom that is bound to a list. The first argument item
can be any Maxima symbol or expression. If the argument list is not bound to a list, Maxima
signals an error.
To remove the first item from a list, see pop
.
Examples:
(%i1) ll: []; (%o1) []
(%i2) push (x, ll); (%o2) [x]
(%i3) push (x^2+y, ll); 2 (%o3) [y + x , x]
(%i4) a: push ("string", ll); 2 (%o4) [string, y + x , x]
(%i5) pop (ll); (%o5) string
(%i6) pop (ll); 2 (%o6) y + x
(%i7) pop (ll); (%o7) x
(%i8) ll; (%o8) []
(%i9) a; 2 (%o9) [string, y + x , x]
rest
(expr, n) rest
(expr) ¶Returns expr with its first n elements removed if n
is positive and its last - n
elements removed if n
is negative. If n is 1 it may be omitted. The first argument
expr may be a list, matrix, or other expression. When expr
is an atom, rest
signals an error; when expr is an empty
list and partswitch
is false, rest
signals an error. When
expr is an empty list and partswitch
is true, rest
returns end
.
Applying rest
to expression such as f(a,b,c)
returns
f(b,c)
. In general, applying rest
to a nonlist doesn’t
make sense. For example, because ’^’ requires two arguments,
rest(a^b)
results in an error message. The functions
args
and op
may be useful as well, since args(a^b)
returns [a,b]
and op(a^b)
returns ^.
(%i1) rest(a+b+c); (%o1) b+a (%i2) rest(a+b+c,2); (%o2) a (%i3) rest(a+b+c,-2); (%o3) c
Reverses the order of the members of the list (not
the members themselves). reverse
also works on general expressions,
e.g. reverse(a=b);
gives b=a
.
See also sreverse
.
rreduce
(F, s) rreduce
(F, s, s_{n + 1}) ¶Extends the binary function F to an n-ary function by composition, where s is a list.
rreduce(F, s)
returns F(s_1, ... F(s_{n - 2}, F(s_{n - 1}, s_n)))
.
When the optional argument s_{n + 1} is present,
the result is equivalent to rreduce(F, endcons(s_{n + 1}, s))
.
The function F is first applied to the rightmost list elements, thus the name "rreduce".
See also lreduce
, tree_reduce
, and xreduce
.
Examples:
rreduce
without the optional argument.
(%i1) rreduce (f, [1, 2, 3]); (%o1) f(1, f(2, 3))
(%i2) rreduce (f, [1, 2, 3, 4]); (%o2) f(1, f(2, f(3, 4)))
rreduce
with the optional argument.
(%i1) rreduce (f, [1, 2, 3], 4); (%o1) f(1, f(2, f(3, 4)))
rreduce
applied to built-in binary operators.
/
is the division operator.
(%i1) rreduce ("^", args ({a, b, c, d})); d c b (%o1) a
(%i2) rreduce ("/", args ({a, b, c, d})); a c (%o2) --- b d
Returns the 2nd item of expression or list expr.
See first
for more details.
Returns the 7th item of expression or list expr.
See first
for more details.
Returns the 6th item of expression or list expr.
See first
for more details.
sort
(L, P) sort
(L) ¶sort(L, P)
sorts a list L according to a predicate P
of two arguments
which defines a strict weak order on the elements of L.
If P(a, b)
is true
, then a
appears before b
in the result.
If neither P(a, b)
nor P(b, a)
are true
,
then a
and b
are equivalent, and appear in the result in the same order as in the input.
That is, sort
is a stable sort.
If P(a, b)
and P(b, a)
are both true
for some elements of L,
then P is not a valid sort predicate, and the result is undefined.
If P(a, b)
is something other than true
or false
, sort
signals an error.
The predicate may be specified as the name of a function
or binary infix operator, or as a lambda
expression. If specified as
the name of an operator, the name must be enclosed in double quotes.
The sorted list is returned as a new object; the argument L is not modified.
sort(L)
is equivalent to sort(L, orderlessp)
.
The default sorting order is ascending, as determined by orderlessp
. The predicate ordergreatp
sorts a list in descending order.
All Maxima atoms and expressions are comparable under orderlessp
and ordergreatp
.
Operators <
and >
order numbers, constants, and constant expressions by magnitude.
Note that orderlessp
and ordergreatp
do not order numbers, constants, and constant expressions by magnitude.
ordermagnitudep
orders numbers, constants, and constant expressions the same as <
,
and all other elements the same as orderlessp
.
Examples:
sort
sorts a list according to a predicate of two arguments
which defines a strict weak order on the elements of the list.
(%i1) sort ([1, a, b, 2, 3, c], 'orderlessp); (%o1) [1, 2, 3, a, b, c]
(%i2) sort ([1, a, b, 2, 3, c], 'ordergreatp); (%o2) [c, b, a, 3, 2, 1]
The predicate may be specified as the name of a function
or binary infix operator, or as a lambda
expression. If specified as
the name of an operator, the name must be enclosed in double quotes.
(%i1) L : [[1, x], [3, y], [4, w], [2, z]]; (%o1) [[1, x], [3, y], [4, w], [2, z]]
(%i2) foo (a, b) := a[1] > b[1]; (%o2) foo(a, b) := a > b 1 1
(%i3) sort (L, 'foo); (%o3) [[4, w], [3, y], [2, z], [1, x]]
(%i4) infix (">>"); (%o4) >>
(%i5) a >> b := a[1] > b[1]; (%o5) (a >> b) := a > b 1 1
(%i6) sort (L, ">>"); (%o6) [[4, w], [3, y], [2, z], [1, x]]
(%i7) sort (L, lambda ([a, b], a[1] > b[1])); (%o7) [[4, w], [3, y], [2, z], [1, x]]
sort(L)
is equivalent to sort(L, orderlessp)
.
(%i1) L : [a, 2*b, -5, 7, 1 + %e, %pi]; (%o1) [a, 2 b, - 5, 7, %e + 1, %pi]
(%i2) sort (L); (%o2) [- 5, 7, %e + 1, %pi, a, 2 b]
(%i3) sort (L, 'orderlessp); (%o3) [- 5, 7, %e + 1, %pi, a, 2 b]
The default sorting order is ascending, as determined by orderlessp
. The predicate ordergreatp
sorts a list in descending order.
(%i1) L : [a, 2*b, -5, 7, 1 + %e, %pi]; (%o1) [a, 2 b, - 5, 7, %e + 1, %pi]
(%i2) sort (L); (%o2) [- 5, 7, %e + 1, %pi, a, 2 b]
(%i3) sort (L, 'ordergreatp); (%o3) [2 b, a, %pi, %e + 1, 7, - 5]
All Maxima atoms and expressions are comparable under orderlessp
and ordergreatp
.
(%i1) L : [11, -17, 29b0, 9*c, 7.55, foo(x, y), -5/2, b + a]; 5 (%o1) [11, - 17, 2.9b1, 9 c, 7.55, foo(x, y), - -, b + a] 2
(%i2) sort (L, orderlessp); 5 (%o2) [- 17, - -, 7.55, 11, 2.9b1, b + a, 9 c, foo(x, y)] 2
(%i3) sort (L, ordergreatp); 5 (%o3) [foo(x, y), 9 c, b + a, 2.9b1, 11, 7.55, - -, - 17] 2
Operators <
and >
order numbers, constants, and constant expressions by magnitude.
Note that orderlessp
and ordergreatp
do not order numbers, constants, and constant expressions by magnitude.
(%i1) L : [%pi, 3, 4, %e, %gamma]; (%o1) [%pi, 3, 4, %e, %gamma]
(%i2) sort (L, ">"); (%o2) [4, %pi, 3, %e, %gamma]
(%i3) sort (L, ordergreatp); (%o3) [%pi, %gamma, %e, 4, 3]
ordermagnitudep
orders numbers, constants, and constant expressions the same as <
,
and all other elements the same as orderlessp
.
(%i1) L: [%i, 1+%i, 2*x, minf, inf, %e, sin(1), 0,1,2,3, 1.0, 1.0b0]; (%o1) [%i, %i + 1, 2 x, minf, inf, %e, sin(1), 0, 1, 2, 3, 1.0, 1.0b0]
(%i2) sort (L, ordermagnitudep); (%o2) [minf, 0, sin(1), 1, 1.0, 1.0b0, 2, %e, 3, inf, %i, %i + 1, 2 x]
(%i3) sort (L, orderlessp); (%o3) [0, 1, 1.0, 2, 3, sin(1), 1.0b0, %e, %i, %i + 1, inf, minf, 2 x]
Returns the list of elements of list for which the predicate p
returns true
.
Example:
(%i1) L: [1, 2, 3, 4, 5, 6]; (%o1) [1, 2, 3, 4, 5, 6]
(%i2) sublist (L, evenp); (%o2) [2, 4, 6]
Returns the indices of the elements x
of the list L for which
the predicate maybe(P(x))
returns true
;
this excludes unknown
as well as false
.
P may be the name of a function or a lambda expression.
L must be a literal list.
Examples:
(%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], lambda ([x], x='b)); (%o1) [2, 3, 7, 9]
(%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp); (%o2) [1, 2, 3, 4, 7, 9]
(%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0], identity); (%o3) [1, 4, 5]
(%i4) assume (x < -1); (%o4) [x < - 1]
(%i5) map (maybe, [x > 0, x < 0, x < -2]); (%o5) [false, true, unknown]
(%i6) sublist_indices ([x > 0, x < 0, x < -2], identity); (%o6) [2]
Returns the 10th item of expression or list expr.
See first
for more details.
Returns the 3rd item of expression or list expr.
See first
for more details.
tree_reduce
(F, s) tree_reduce
(F, s, s_0) ¶Extends the binary function F to an n-ary function by composition, where s is a set or list.
tree_reduce
is equivalent to the following:
Apply F to successive pairs of elements
to form a new list [F(s_1, s_2), F(s_3, s_4), ...]
,
carrying the final element unchanged if there are an odd number of elements.
Then repeat until the list is reduced to a single element, which is the return value.
When the optional argument s_0 is present,
the result is equivalent tree_reduce(F, cons(s_0, s))
.
For addition of floating point numbers,
tree_reduce
may return a sum that has a smaller rounding error
than either rreduce
or lreduce
.
The elements of s and the partial results may be arranged in a minimum-depth binary tree, thus the name "tree_reduce".
Examples:
tree_reduce
applied to a list with an even number of elements.
(%i1) tree_reduce (f, [a, b, c, d]); (%o1) f(f(a, b), f(c, d))
tree_reduce
applied to a list with an odd number of elements.
(%i1) tree_reduce (f, [a, b, c, d, e]); (%o1) f(f(f(a, b), f(c, d)), e)
Returns the unique elements of the list L.
When all the elements of L are unique,
unique
returns a shallow copy of L,
not L itself.
If L is not a list, unique
returns L.
Example:
(%i1) unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]); (%o1) [1, 2, %e, %pi, [1], b + a]
xreduce
(F, s) xreduce
(F, s, s_0) ¶Extends the function F to an n-ary function by composition,
or, if F is already n-ary, applies F to s.
When F is not n-ary, xreduce
is the same as lreduce
.
The argument s is a list.
Functions known to be n-ary include
addition +
, multiplication *
, and
, or
, max
,
min
, and append
.
Functions may also be declared n-ary by declare(F, nary)
.
For these functions,
xreduce
is expected to be faster than either rreduce
or lreduce
.
When the optional argument s_0 is present,
the result is equivalent to xreduce(s, cons(s_0, s))
.
Floating point addition is not exactly associative; be that as it may,
xreduce
applies Maxima’s n-ary addition when s contains floating point numbers.
Examples:
xreduce
applied to a function known to be n-ary.
F
is called once, with all arguments.
(%i1) declare (F, nary); (%o1) done
(%i2) F ([L]) := L; (%o2) F([L]) := L
(%i3) xreduce (F, [a, b, c, d, e]); (%o3) [a, b, c, d, e]
xreduce
applied to a function not known to be n-ary.
G
is called several times, with two arguments each time.
(%i1) G ([L]) := L; (%o1) G([L]) := L
(%i2) xreduce (G, [a, b, c, d, e]); (%o2) [[[[a, b], c], d], e]
(%i3) lreduce (G, [a, b, c, d, e]); (%o3) [[[[a, b], c], d], e]
Lists provide efficient ways of appending and removing elements. They can be created without knowing their final dimensions. Lisp provides efficient means of copying and handling lists. Also nested lists do not need to be strictly rectangular. These advantages over declared arrays come with the drawback that the amount of time needed for accessing a random element within a list may be roughly proportional to the element’s distance from its beginning. Efficient traversal of lists is still possible, though, by using the list as a stack or a fifo:
(%i1) l:[Test,1,2,3,4]; (%o1) [Test, 1, 2, 3, 4]
(%i2) while l # [] do disp(pop(l)); Test 1 2 3 4 (%o2) done
Another even faster example would be:
(%i1) l:[Test,1,2,3,4]; (%o1) [Test, 1, 2, 3, 4]
(%i2) for i in l do disp(pop(l)); Test 1 2 3 4 (%o2) done
Beginning traversal with the last element of a list is possible after
reversing the list using reverse ()
.
If the elements of a long list need to be processed in a different
order performance might be increased by converting the list into a
declared array first.
Note also that the ending condition of for
loops
is tested for every iteration which means that the result of a
length
should be cached if it is used in the ending
condition:
(%i1) l:makelist(i,i,1,100000)$
(%i2) lngth:length(l); (%o2) 100000
(%i3) x:1; (%o3) 1
(%i4) for i:1 thru lngth do x:x+1$
(%i5) x; (%o5) 100001
Maxima supports 3 array-like constructs:
(%i1) a["feww"]:1; (%o1) 1
(%i2) a[qqwdqwd]:3; (%o2) 3
(%i3) a[5]:99; (%o3) 99
(%i4) a[qqwdqwd]; (%o4) 3
(%i5) a[5]; (%o5) 99
(%i6) a["feww"]; (%o6) 1
Since lisp handles hashed arrays and memoizing functions
similar to arrays
many of the functions that can be applied to arrays can be applied to them, as well.
makelist
allow for fast addition and removal
of elements, can be created without knowing their final size.
array
(name, dim_1, …, dim_n) array
(name, type, dim_1, …, dim_n) array
([name_1, …, name_m], dim_1, …, dim_n) ¶Creates an \(n\)-dimensional array. \(n\) may be less than or equal to 5. The subscripts for the \(i\)’th dimension are the integers running from 0 to dim_i.
array (name, dim_1, ..., dim_n)
creates a general
array.
array (name, type, dim_1, ..., dim_n)
creates
an array, with elements of a specified type. type can be fixnum
for integers of limited size or flonum
for floating-point numbers.
array ([name_1, ..., name_m], dim_1, ..., dim_n)
creates \(m\) arrays, all of the same dimensions.
See also arraymake
, arrayinfo
and make_array
.
Evaluates A [i_1, ..., i_n]
,
where A is an array and i_1, …, i_n are integers.
This is reminiscent of apply
, except the first argument is an array
instead of a function.
Returns information about the array A.
The argument A may be a declared array, a hashed array
,
a memoizing function
, or a subscripted function.
For declared arrays, arrayinfo
returns a list comprising the atom
declared
, the number of dimensions, and the size of each dimension.
The elements of the array, both bound and unbound, are returned by
listarray
.
For undeclared arrays (hashed arrays), arrayinfo
returns a list
comprising the atom hashed
, the number of subscripts,
and the subscripts of every element which has a value.
The values are returned by listarray
.
For memoizing functions
, arrayinfo
returns a list comprising the atom
hashed
, the number of subscripts,
and any subscript values for which there are stored function values.
The stored function values are returned by listarray
.
For subscripted functions, arrayinfo
returns a list comprising the atom
hashed
, the number of subscripts,
and any subscript values for which there are lambda expressions.
The lambda expressions are returned by listarray
.
See also listarray
.
Examples:
arrayinfo
and listarray
applied to a declared array.
(%i1) array (aa, 2, 3); (%o1) aa
(%i2) aa [2, 3] : %pi; (%o2) %pi
(%i3) aa [1, 2] : %e; (%o3) %e
(%i4) arrayinfo (aa); (%o4) [declared, 2, [2, 3]]
(%i5) listarray (aa); (%o5) [#####, #####, #####, #####, #####, #####, %e, #####, #####, #####, #####, %pi]
arrayinfo
and listarray
applied to an undeclared array (hashed array
.).
(%i1) bb [FOO] : (a + b)^2; 2 (%o1) (b + a)
(%i2) bb [BAR] : (c - d)^3; 3 (%o2) (c - d)
(%i3) arrayinfo (bb); (%o3) [hashed, 1, [BAR], [FOO]]
(%i4) listarray (bb); 3 2 (%o4) [(c - d) , (b + a) ]
arrayinfo
and listarray
applied to a memoizing function
.
(%i1) cc [x, y] := y / x; y (%o1) cc := - x, y x
(%i2) cc [u, v]; v (%o2) - u
(%i3) cc [4, z]; z (%o3) - 4
(%i4) arrayinfo (cc); (%o4) [hashed, 2, [4, z], [u, v]]
(%i5) listarray (cc); z v (%o5) [-, -] 4 u
Using arrayinfo
in order to convert an undeclared array to a declared array:
(%i1) for i:0 thru 10 do a[i]:i^2$
(%i2) indices:map(first,rest(rest(arrayinfo(a)))); (%o2) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
(%i3) array(A,fixnum,length(indices)-1)$ (%i4) fillarray(A,map(lambda([x],a[x]),indices))$
(%i5) listarray(A); (%o5) [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
arrayinfo
and listarray
applied to a subscripted function.
(%i1) dd [x] (y) := y ^ x; x (%o1) dd (y) := y x
(%i2) dd [a + b]; b + a (%o2) lambda([y], y )
(%i3) dd [v - u]; v - u (%o3) lambda([y], y )
(%i4) arrayinfo (dd); (%o4) [hashed, 1, [b + a], [v - u]]
(%i5) listarray (dd); b + a v - u (%o5) [lambda([y], y ), lambda([y], y )]
Returns the expression A[i_1, ..., i_n]
.
The result is an unevaluated array reference.
arraymake
is reminiscent of funmake
, except the return value
is an unevaluated array reference instead of an unevaluated function call.
Examples:
(%i1) arraymake (A, [1]); (%o1) A 1
(%i2) arraymake (A, [k]); (%o2) A k
(%i3) arraymake (A, [i, j, 3]); (%o3) A i, j, 3
(%i4) array (A, fixnum, 10); (%o4) A
(%i5) fillarray (A, makelist (i^2, i, 1, 11)); (%o5) A
(%i6) arraymake (A, [5]); (%o6) A 5
(%i7) ''%; (%o7) 36
(%i8) L : [a, b, c, d, e]; (%o8) [a, b, c, d, e]
(%i9) arraymake ('L, [n]); (%o9) L n
(%i10) ''%, n = 3; (%o10) c
(%i11) A2 : make_array (fixnum, 10); (%o11) {Lisp Array: #(0 0 0 0 0 0 0 0 0 0)}
(%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); (%o12) {Lisp Array: #(1 2 3 4 5 6 7 8 9 10)}
(%i13) arraymake ('A2, [8]); (%o13) A2 8
(%i14) ''%; (%o14) 9
Default value: []
arrays
is a list of arrays that have been allocated.
These comprise arrays declared by array
, hashed arrays
that can be
constructed by implicit definition (assigning something to an element that isn’t yet
declared as a list or an array),
and memoizing functions
defined by :=
and define
.
Arrays defined by make_array
are not included.
See also
array
, arrayapply
, arrayinfo
,
arraymake
, fillarray
, listarray
, and
rearray
.
Examples:
(%i1) array (aa, 5, 7); (%o1) aa
(%i2) bb [FOO] : (a + b)^2; 2 (%o2) (b + a)
(%i3) cc [x] := x/100; x (%o3) cc := --- x 100
(%i4) dd : make_array ('any, 7); (%o4) {Lisp Array: #(NIL NIL NIL NIL NIL NIL NIL)}
(%i5) arrays; (%o5) [aa, bb, cc]
Assigns x to A[i_1, ..., i_n]
,
where A is an array and i_1, …, i_n are integers.
arraysetapply
evaluates its arguments.
Fills array A from B, which is a list or an array.
If a specific type was declared for A when it was created, it can only be filled with elements of that same type; it is an error if an attempt is made to copy an element of a different type.
If the dimensions of the arrays A and B are different, A is filled in row-major order. If there are not enough elements in B the last element is used to fill out the rest of A. If there are too many, the remaining ones are ignored.
fillarray
returns its first argument.
Examples:
Create an array of 9 elements and fill it from a list.
(%i1) array (a1, fixnum, 8); (%o1) a1
(%i2) listarray (a1); (%o2) [0, 0, 0, 0, 0, 0, 0, 0, 0]
(%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]); (%o3) a1
(%i4) listarray (a1); (%o4) [1, 2, 3, 4, 5, 6, 7, 8, 9]
When there are too few elements to fill the array, the last element is repeated. When there are too many elements, the extra elements are ignored.
(%i1) a2 : make_array (fixnum, 8); (%o1) {Lisp Array: #(0 0 0 0 0 0 0 0)}
(%i2) fillarray (a2, [1, 2, 3, 4, 5]); (%o2) {Lisp Array: #(1 2 3 4 5 5 5 5)}
(%i3) fillarray (a2, [4]); (%o3) {Lisp Array: #(4 4 4 4 4 4 4 4)}
(%i4) fillarray (a2, makelist (i, i, 1, 100)); (%o4) {Lisp Array: #(1 2 3 4 5 6 7 8)}
Multiple-dimension arrays are filled in row-major order.
(%i1) a3 : make_array (fixnum, 2, 5); (%o1) {Lisp Array: #2A((0 0 0 0 0) (0 0 0 0 0))}
(%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); (%o2) {Lisp Array: #2A((1 2 3 4 5) (6 7 8 9 10))}
(%i3) a4 : make_array (fixnum, 5, 2); (%o3) {Lisp Array: #2A((0 0) (0 0) (0 0) (0 0) (0 0))}
(%i4) fillarray (a4, a3); (%o4) {Lisp Array: #2A((1 2) (3 4) (5 6) (7 8) (9 10))}
Returns a list of the elements of the array A.
The argument A may be an array, an undeclared array (hashed array
),
a memoizing function
, or a subscripted function.
Elements are listed in row-major order.
That is, elements are sorted according to the first index, then according to
the second index, and so on. The sorting order of index values is the same as
the order established by orderless
.
For undeclared arrays (hashed arrays
), memoizing functions
, and subscripted functions,
the elements correspond to the index values returned by arrayinfo
.
Unbound elements of general arrays (that is, not fixnum
and not
flonum
) are returned as #####
.
Unbound elements of fixnum
or flonum
arrays
are returned as 0 or 0.0, respectively.
Unbound elements of hashed arrays, memoizing functions
,
and subscripted functions are not returned.
Examples:
listarray
and arrayinfo
applied to a declared array.
(%i1) array (aa, 2, 3); (%o1) aa
(%i2) aa [2, 3] : %pi; (%o2) %pi
(%i3) aa [1, 2] : %e; (%o3) %e
(%i4) listarray (aa); (%o4) [#####, #####, #####, #####, #####, #####, %e, #####, #####, #####, #####, %pi]
(%i5) arrayinfo (aa); (%o5) [declared, 2, [2, 3]]
listarray
and arrayinfo
applied to an undeclared array (hashed array
).
(%i1) bb [FOO] : (a + b)^2; 2 (%o1) (b + a)
(%i2) bb [BAR] : (c - d)^3; 3 (%o2) (c - d)
(%i3) listarray (bb); 3 2 (%o3) [(c - d) , (b + a) ]
(%i4) arrayinfo (bb); (%o4) [hashed, 1, [BAR], [FOO]]
listarray
and arrayinfo
applied to a memoizing function
.
(%i1) cc [x, y] := y / x; y (%o1) cc := - x, y x
(%i2) cc [u, v]; v (%o2) - u
(%i3) cc [4, z]; z (%o3) - 4
(%i4) listarray (cc); z v (%o4) [-, -] 4 u
(%i5) arrayinfo (cc); (%o5) [hashed, 2, [4, z], [u, v]]
listarray
and arrayinfo
applied to a subscripted function.
(%i1) dd [x] (y) := y ^ x; x (%o1) dd (y) := y x
(%i2) dd [a + b]; b + a (%o2) lambda([y], y )
(%i3) dd [v - u]; v - u (%o3) lambda([y], y )
(%i4) listarray (dd); b + a v - u (%o4) [lambda([y], y ), lambda([y], y )]
(%i5) arrayinfo (dd); (%o5) [hashed, 1, [b + a], [v - u]]
Creates and returns a Lisp array. type may
be any
, flonum
, fixnum
, hashed
or
functional
.
There are \(n\) indices,
and the \(i\)’th index runs from 0 to \(\mathit{dim_i} - 1\).
The advantage of make_array
over array
is that the return value
doesn’t have a name, and once a pointer to it goes away, it will also go away.
For example, if y: make_array (...)
then y
points to an object
which takes up space, but after y: false
, y
no longer
points to that object, so the object can be garbage collected.
Examples:
(%i1) A1 : make_array (fixnum, 10); (%o1) {Lisp Array: #(0 0 0 0 0 0 0 0 0 0)}
(%i2) A1 [8] : 1729; (%o2) 1729
(%i3) A1; (%o3) {Lisp Array: #(0 0 0 0 0 0 0 0 1729 0)}
(%i4) A2 : make_array (flonum, 10); (%o4) {Lisp Array: #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
(%i5) A2 [2] : 2.718281828; (%o5) 2.718281828
(%i6) A2; (%o6) {Lisp Array: #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
(%i7) A3 : make_array (any, 10); (%o7) {Lisp Array: #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)}
(%i8) A3 [4] : x - y - z; (%o8) (- z) - y + x
(%i9) A3; (%o9) {Lisp Array: #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP) -1 $Y) ((MTIMES S\ IMP) -1 $Z)) NIL NIL NIL NIL NIL)}
(%i10) A4 : make_array (fixnum, 2, 3, 5); (%o10) {Lisp Array: #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)) ((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)))}
(%i11) fillarray (A4, makelist (i, i, 1, 2*3*5)); (%o11) {Lisp Array: #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 1\ 5)) ((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29\ 30)))}
(%i12) A4 [0, 2, 1]; (%o12) 12
Changes the dimensions of an array.
The new array will be filled with the elements of the old one in
row-major order. If the old array was too small,
the remaining elements are filled with
false
, 0.0
or 0
,
depending on the type of the array. The type of the array cannot be
changed.
remarray
(A_1, …, A_n) remarray
(all) ¶Removes arrays and array associated functions and frees the storage occupied.
The arguments may be declared arrays, hashed arrays
, array
functions, and subscripted functions.
remarray (all)
removes all items in the global list arrays
.
It may be necessary to use this function if it is
desired to clear the cache of a memoizing function
.
remarray
returns the list of arrays removed.
remarray
quotes its arguments.
Evaluates the subscripted expression x[i]
.
subvar
evaluates its arguments.
arraymake (x, [i])
constructs the expression
x[i]
, but does not evaluate it.
Examples:
(%i1) x : foo $ (%i2) i : 3 $
(%i3) subvar (x, i); (%o3) foo 3
(%i4) foo : [aa, bb, cc, dd, ee]$
(%i5) subvar (x, i); (%o5) cc
(%i6) arraymake (x, [i]); (%o6) foo 3
(%i7) ''%; (%o7) cc
Returns true
if expr is a subscripted variable, for example
a[i]
.
Default value: false
When use_fast_arrays
is true
,
arrays declared by array
are values instead of properties,
and undeclared arrays (hashed arrays
) are implemented as Lisp hashed arrays.
When use_fast_arrays
is false
,
arrays declared by array
are properties,
and undeclared arrays are implemented with Maxima’s own hashed array implementation.
Note that the code use_fast_arrays
switches to is not necessarily faster
than the default one; Arrays created by make_array
are not affected by
use_fast_arrays
.
See also translate_fast_arrays
.
Default value: false
When translate_fast_arrays
is true
,
the Maxima-to-Lisp translator generates code that assumes arrays are values instead of properties,
as if use_fast_arrays
were true
.
When translate_fast_arrays
is false
,
the Maxima-to-Lisp translator generates code that assumes arrays are properties,
as if use_fast_arrays
were false
.
Maxima provides a simple data aggregate called a structure. A structure is an expression in which arguments are identified by name (the field name) and the expression as a whole is identified by its operator (the structure name). A field value can be any expression.
A structure is defined by the defstruct
function;
the global variable structures
is the list of user-defined structures.
The function new
creates instances of structures.
The @
operator refers to fields.
kill(S)
removes the structure definition S,
and kill(x@ a)
unbinds the field a of the structure instance x.
In the pretty-printing console display (with display2d
equal to true
),
structure instances are displayed with the value of each field
represented as an equation, with the field name on the left-hand side
and the value on the right-hand side.
(The equation is only a display construct; only the value is actually stored.)
In 1-dimensional display (via grind
or with display2d
equal to false
),
structure instances are displayed without the field names.
There is no way to use a field name as a function name, although a field value can be a lambda expression. Nor can the values of fields be restricted to certain types; any field can be assigned any kind of expression. There is no way to make some fields accessible or inaccessible in different contexts; all fields are always visible.
structures
is the list of user-defined structures defined by defstruct
.
defstruct
(S(a_1, …, a_n)) defstruct
(S(a_1 = v_1, …, a_n = v_n)) ¶Define a structure, which is a list of named fields a_1, …,
a_n associated with a symbol S.
An instance of a structure is just an expression which has operator S
and exactly n
arguments.
new(S)
creates a new instance of structure S.
An argument which is just a symbol a specifies the name of a field.
An argument which is an equation a = v
specifies the field name a
and its default value v.
The default value can be any expression.
defstruct
puts S on the list of user-defined structures, structures
.
kill(S)
removes S from the list of user-defined structures,
and removes the structure definition.
Examples:
(%i1) defstruct (foo (a, b, c)); (%o1) [foo(a, b, c)] (%i2) structures; (%o2) [foo(a, b, c)] (%i3) new (foo); (%o3) foo(a, b, c) (%i4) defstruct (bar (v, w, x = 123, y = %pi)); (%o4) [bar(v, w, x = 123, y = %pi)] (%i5) structures; (%o5) [foo(a, b, c), bar(v, w, x = 123, y = %pi)] (%i6) new (bar); (%o6) bar(v, w, x = 123, y = %pi) (%i7) kill (foo); (%o7) done (%i8) structures; (%o8) [bar(v, w, x = 123, y = %pi)]
new
(S) new
(S (v_1, …, v_n)) ¶new
creates new instances of structures.
new(S)
creates a new instance of structure S
in which each field is assigned its default value, if any,
or no value at all if no default was specified in the structure definition.
new(S(v_1, ..., v_n))
creates a new instance of S
in which fields are assigned the values v_1, …, v_n.
Examples:
(%i1) defstruct (foo (w, x = %e, y = 42, z)); (%o1) [foo(w, x = %e, y = 42, z)] (%i2) new (foo); (%o2) foo(w, x = %e, y = 42, z) (%i3) new (foo (1, 2, 4, 8)); (%o3) foo(w = 1, x = 2, y = 4, z = 8)
@
is the structure field access operator.
The expression x@ a
refers to the value of field a of the structure instance x.
The field name is not evaluated.
If the field a in x has not been assigned a value,
x@ a
evaluates to itself.
kill(x@ a)
removes the value of field a in x.
Examples:
(%i1) defstruct (foo (x, y, z)); (%o1) [foo(x, y, z)] (%i2) u : new (foo (123, a - b, %pi)); (%o2) foo(x = 123, y = a - b, z = %pi) (%i3) u@z; (%o3) %pi (%i4) u@z : %e; (%o4) %e (%i5) u; (%o5) foo(x = 123, y = a - b, z = %e) (%i6) kill (u@z); (%o6) done (%i7) u; (%o7) foo(x = 123, y = a - b, z) (%i8) u@z; (%o8) u@z
The field name is not evaluated.
(%i1) defstruct (bar (g, h)); (%o1) [bar(g, h)] (%i2) x : new (bar); (%o2) bar(g, h) (%i3) x@h : 42; (%o3) 42 (%i4) h : 123; (%o4) 123 (%i5) x@h; (%o5) 42 (%i6) x@h : 19; (%o6) 19 (%i7) x; (%o7) bar(g, h = 19) (%i8) h; (%o8) 123
There are a number of reserved words which should not be used as variable names. Their use would cause a possibly cryptic syntax error.
integrate next from diff in at limit sum for and elseif then else do or if unless product while thru step
Most things in Maxima are expressions. A sequence of expressions can be made into an expression by separating them by commas and putting parentheses around them. This is similar to the C comma expression.
(%i1) x: 3$ (%i2) (x: x+1, x: x^2); (%o2) 16 (%i3) (if (x > 17) then 2 else 4); (%o3) 4 (%i4) (if (x > 17) then x: 2 else y: 4, y+x); (%o4) 20
Even loops in Maxima are expressions, although the value they
return is the not too useful done
.
(%i1) y: (x: 1, for i from 1 thru 10 do (x: x*i))$ (%i2) y; (%o2) done
Whereas what you really want is probably to include a third term in the comma expression which actually gives back the value.
(%i3) y: (x: 1, for i from 1 thru 10 do (x: x*i), x)$ (%i4) y; (%o4) 3628800
Maxima distinguishes between operators which are "nouns" and operators which are
"verbs". A verb is an operator which can be executed. A noun is an operator
which appears as a symbol in an expression, without being executed. By default,
function names are verbs. A verb can be changed into a noun by quoting the
function name or applying the nounify
function. A noun can be changed
into a verb by applying the verbify
function. The evaluation flag
nouns
causes ev
to evaluate nouns in an expression.
The verb form is distinguished by a leading dollar sign $
on the
corresponding Lisp symbol. In contrast, the noun form is distinguished by a
leading percent sign %
on the corresponding Lisp symbol. Some nouns have
special display properties, such as 'integrate
and 'derivative
(returned by diff
), but most do not. By default, the noun and verb forms
of a function are identical when displayed. The global flag noundisp
causes Maxima to display nouns with a leading quote mark '
.
See also noun
, nouns
, nounify
, and
verbify
.
Examples:
(%i1) foo (x) := x^2; 2 (%o1) foo(x) := x
(%i2) foo (42); (%o2) 1764
(%i3) 'foo (42); (%o3) foo(42)
(%i4) 'foo (42), nouns; (%o4) 1764
(%i5) declare (bar, noun); (%o5) done
(%i6) bar (x) := x/17; x (%o6) bar(x) := -- 17
(%i7) bar (52); (%o7) bar(52)
(%i8) bar (52), nouns; (%o8) bar(52)
(%i9) integrate (1/x, x, 1, 42); (%o9) log(42)
(%i10) 'integrate (1/x, x, 1, 42); 42 / [ 1 (%o10) I - dx ] x / 1
(%i11) ev (%, nouns); (%o11) log(42)
Maxima identifiers may comprise alphabetic characters, plus the numerals 0
through 9, plus any other character preceded by the backslash \
character.
A numeral may be the first character of an identifier if it is preceded by a backslash. Numerals which are the second or later characters need not be preceded by a backslash.
The alphabetic characters are initially %
, _
,
and all characters for which the Lisp function
ALPHA-CHAR-P
returns true
.
Characters may be declared alphabetic by the declare
function.
If so declared, they need not be preceded by a backslash in an identifier.
Maxima is case-sensitive. The identifiers foo
, FOO
, and
Foo
are distinct. See Lisp and Maxima for more on this point.
A Maxima identifier is a Lisp symbol which begins with a dollar sign $
.
Any other Lisp symbol is preceded by a question mark ?
when it appears
in Maxima. See Lisp and Maxima for more on this point.
Examples:
(%i1) %an_ordinary_identifier42; (%o1) %an_ordinary_identifier42
(%i2) embedded\ spaces\ in\ an\ identifier; (%o2) embedded spaces in an identifier
(%i3) symbolp (%); (%o3) true
(%i4) [foo+bar, foo\+bar]; (%o4) [foo + bar, foo+bar]
(%i5) [1729, \1729]; (%o5) [1729, 1729]
(%i6) [symbolp (foo\+bar), symbolp (\1729)]; (%o6) [true, true]
(%i7) [is (foo\+bar = foo+bar), is (\1729 = 1729)]; (%o7) [false, false]
(%i8) baz\~quux; (%o8) baz~quux
(%i9) declare ("~", alphabetic); (%o9) done
(%i10) baz~quux; (%o10) baz~quux
(%i11) [is (foo = FOO), is (FOO = Foo), is (Foo = foo)]; (%o11) [false, false, false]
(%i12) :lisp (defvar *my-lisp-variable* '$foo) *MY-LISP-VARIABLE*
(%i12) ?\*my\-lisp\-variable\*; (%o12) foo
Maxima has the inequality operators <
, <=
, >=
, >
,
#
, and notequal
. See if for a description of conditional
expressions.
provides an alternate name for a (user or system) function, variable, array, etc. Any even number of arguments may be used.
Default value: []
aliases
is the list of atoms which have a user defined alias (set up by
the alias
, ordergreat
, orderless
functions or by
declaring the atom a noun
with declare
.)
works with the part
commands (i.e. part
,
inpart
, substpart
, substinpart
,
dpart
, and lpart
).
For example,
(%i1) expr : e + d + c + b + a; (%o1) e + d + c + b + a
(%i2) part (expr, [2, 5]); (%o2) d + a
while
(%i1) expr : e + d + c + b + a; (%o1) e + d + c + b + a
(%i2) part (expr, allbut (2, 5)); (%o2) e + c + b
allbut
is also recognized by kill
.
(%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55]; (%o1) [11, 22, 33, 44, 55]
(%i2) kill (allbut (cc, dd)); (%o0) done
(%i1) [aa, bb, cc, dd]; (%o1) [aa, bb, 33, 44]
kill(allbut(a_1, a_2, ...))
has the effect of
kill(all)
except that it does not kill the symbols a_1, a_2,
…
Returns the list of arguments of expr
, which may be any kind of
expression other than an atom. Only the arguments of the top-level operator
are extracted; subexpressions of expr
appear as elements or
subexpressions of elements of the list of arguments.
The order of the items in the list may depend on the global flag
inflag
.
args (expr)
is equivalent to substpart ("[", expr, 0)
.
See also substpart
, apply
, funmake
, and op
.
How to convert a matrix to a nested list:
(%i1) M:matrix([1,2],[3,4]); [ 1 2 ] (%o1) [ ] [ 3 4 ]
(%i2) args(M); (%o2) [[1, 2], [3, 4]]
Since maxima internally treats a sum of n
terms as a summation command
with n
arguments args() can extract the list of terms in a sum:
(%i1) a+b+c; (%o1) c + b + a
(%i2) args(%); (%o2) [c, b, a]
Returns true
if expr is atomic (i.e. a number, name or string) else
false
. Thus atom(5)
is true
while atom(a[1])
and
atom(sin(x))
are false
(assuming a[1]
and x
are
unbound).
box
(expr) box
(expr, a) ¶Returns expr enclosed in a box. The return value is an expression with
box
as the operator and expr as the argument. A box is drawn on
the display when display2d
is true
.
box (expr, a)
encloses expr in a box labelled by the
symbol a. The label is truncated if it is longer than the width of the
box.
box
evaluates its argument. However, a boxed expression does not
evaluate to its content, so boxed expressions are effectively excluded from
computations. rembox
removes the box again.
boxchar
is the character used to draw the box in box
and in the
dpart
and lpart
functions.
See also rembox
, dpart
and lpart
.
Examples:
(%i1) box (a^2 + b^2); """"""""" " 2 2" (%o1) "b + a " """""""""
(%i2) a : 1234; (%o2) 1234
(%i3) b : c - d; (%o3) c - d
(%i4) box (a^2 + b^2); """""""""""""""""""" " 2 " (%o4) "(c - d) + 1522756" """"""""""""""""""""
(%i5) box (a^2 + b^2, term_1); term_1"""""""""""""" " 2 " (%o5) "(c - d) + 1522756" """"""""""""""""""""
(%i6) 1729 - box (1729); """""" (%o6) 1729 - "1729" """"""
(%i7) boxchar: "-"; (%o7) -
(%i8) box (sin(x) + cos(y)); ----------------- (%o8) -cos(y) + sin(x)- -----------------
Default value: "
boxchar
is the character used to draw the box in the box
and in the dpart
and lpart
functions.
All boxes in an expression are drawn with the current value of boxchar
;
the drawing character is not stored with the box expression.
Collapses expr by causing all of its common (i.e., equal) subexpressions
to share (i.e., use the same cells), thereby saving space. (collapse
is
a subroutine used by the optimize
command.) Thus, calling
collapse
may be useful after loading in a save
file. You can
collapse several expressions together by using
collapse ([expr_1, ..., expr_n])
. Similarly, you can
collapse the elements of the array A
by doing
collapse (listarray ('A))
.
Return a copy of the Maxima expression e. Although e can be any Maxima expression, the copy function is the most useful when e is either a list or a matrix; consider:
(%i1) m : [1,[2,3]]$ (%i2) mm : m$ (%i3) mm[2][1] : x$
(%i4) m; (%o4) [1, [x, 3]]
(%i5) mm; (%o5) [1, [x, 3]]
Let’s try the same experiment, but this time let mm be a copy of m
(%i1) m : [1,[2,3]]$ (%i2) mm : copy(m)$ (%i3) mm[2][1] : x$
(%i4) m; (%o4) [1, [2, 3]]
(%i5) mm; (%o5) [1, [x, 3]]
This time, the assignment to mm does not change the value of m.
is similar to isolate
(expr, x)
except that it enables the
user to isolate more than one variable simultaneously. This might be useful,
for example, if one were attempting to change variables in a multiple
integration, and that variable change involved two or more of the integration
variables. This function is autoloaded from simplification/disol.mac.
A demo is available by demo("disol")$
.
dispform
(expr) dispform
(expr, all) ¶Returns the external representation of expr.
dispform(expr)
returns the external representation with respect to
the main (top-level) operator. dispform(expr, all)
returns the
external representation with respect to all operators in expr.
See also part
, inpart
, and inflag
.
Examples:
The internal representation of - x
is "negative one times x
"
while the external representation is "minus x
".
(%i1) - x; (%o1) - x
(%i2) ?format (true, "~S~%", %); ((MTIMES SIMP) -1 $X) (%o2) false
(%i3) dispform (- x); (%o3) - x
(%i4) ?format (true, "~S~%", %); ((MMINUS SIMP) $X) (%o4) false
The internal representation of sqrt(x)
is "x
to the power 1/2"
while the external representation is "square root of x
".
(%i1) sqrt (x); (%o1) sqrt(x)
(%i2) ?format (true, "~S~%", %); ((MEXPT SIMP) $X ((RAT SIMP) 1 2)) (%o2) false
(%i3) dispform (sqrt (x)); (%o3) sqrt(x)
(%i4) ?format (true, "~S~%", %); ((%SQRT SIMP) $X) (%o4) false
Use of the optional argument all
.
(%i1) expr : sin (sqrt (x)); (%o1) sin(sqrt(x))
(%i2) freeof (sqrt, expr); (%o2) true
(%i3) freeof (sqrt, dispform (expr)); (%o3) true
(%i4) freeof (sqrt, dispform (expr, all)); (%o4) false
Selects the same subexpression as part
, but instead of just returning
that subexpression as its value, it returns the whole expression with the
selected subexpression displayed inside a box. The box is actually part of the
expression.
(%i1) dpart (x+y/z^2, 1, 2, 1); y (%o1) ---- + x 2 """ "z" """
Default value: false
exptisolate
, when true
, causes isolate (expr, var)
to
examine exponents of atoms (such as %e
) which contain var
.
Default value: false
exptsubst
, when true
, permits substitutions such as y
for %e^x
in %e^(a x)
.
(%i1) %e^(a*x); a x (%o1) %e
(%i2) exptsubst; (%o2) false
(%i3) subst(y, %e^x, %e^(a*x)); a x (%o3) %e
(%i4) exptsubst: not exptsubst; (%o4) true
(%i5) subst(y, %e^x, %e^(a*x)); a (%o5) y
freeof (x_1, expr)
returns true
if no subexpression of
expr is equal to x_1 or if x_1 occurs only as a dummy variable
in expr, or if x_1 is neither the noun nor verb form of any operator
in expr, and returns false
otherwise.
freeof (x_1, ..., x_n, expr)
is equivalent to
freeof (x_1, expr) and ... and freeof (x_n,
expr)
.
The arguments x_1, …, x_n may be names of functions and
variables, subscripted names, operators (enclosed in double quotes), or general
expressions. freeof
evaluates its arguments.
freeof
operates only on expr as it stands (after simplification and
evaluation) and does not attempt to determine if some equivalent expression
would give a different result. In particular, simplification may yield an
equivalent but different expression which comprises some different elements than
the original form of expr.
A variable is a dummy variable in an expression if it has no binding outside of
the expression. Dummy variables recognized by freeof
are the index of a
sum or product, the limit variable in limit
, the integration variable
in the definite integral form of integrate
, the original variable in
laplace
, formal variables in at
expressions, and arguments in
lambda
expressions.
The indefinite form of integrate
is not free of its variable of
integration.
Examples:
Arguments are names of functions, variables, subscripted names, operators, and
expressions. freeof (a, b, expr)
is equivalent to
freeof (a, expr) and freeof (b, expr)
.
(%i1) expr: z^3 * cos (a[1]) * b^(c+d); d + c 3 (%o1) cos(a ) b z 1 (%i2) freeof (z, expr); (%o2) false (%i3) freeof (cos, expr); (%o3) false (%i4) freeof (a[1], expr); (%o4) false (%i5) freeof (cos (a[1]), expr); (%o5) false (%i6) freeof (b^(c+d), expr); (%o6) false (%i7) freeof ("^", expr); (%o7) false (%i8) freeof (w, sin, a[2], sin (a[2]), b*(c+d), expr); (%o8) true
freeof
evaluates its arguments.
(%i1) expr: (a+b)^5$ (%i2) c: a$ (%i3) freeof (c, expr); (%o3) false
freeof
does not consider equivalent expressions.
Simplification may yield an equivalent but different expression.
(%i1) expr: (a+b)^5$ (%i2) expand (expr); 5 4 2 3 3 2 4 5 (%o2) b + 5 a b + 10 a b + 10 a b + 5 a b + a (%i3) freeof (a+b, %); (%o3) true (%i4) freeof (a+b, expr); (%o4) false (%i5) exp (x); x (%o5) %e (%i6) freeof (exp, exp (x)); (%o6) true
A summation or definite integral is free of its dummy variable. An indefinite integral is not free of its variable of integration.
(%i1) freeof (i, 'sum (f(i), i, 0, n)); (%o1) true (%i2) freeof (x, 'integrate (x^2, x, 0, 1)); (%o2) true (%i3) freeof (x, 'integrate (x^2, x)); (%o3) false
Default value: false
When inflag
is true
, functions for part extraction inspect the
internal form of expr
.
Note that the simplifier re-orders expressions. Thus first (x + y)
returns x
if inflag
is true
and y
if inflag
is false
. (first (y + x)
gives the same results.)
Also, setting inflag
to true
and calling part
or
substpart
is the same as calling inpart
or substinpart
.
Functions affected by the setting of inflag
are: part
,
substpart
, first
, rest
, last
,
length
, the for
… in
construct,
map
, fullmap
, maplist
, reveal
and
pickapart
.
is similar to part
but works on the internal representation of the
expression rather than the displayed form and thus may be faster since no
formatting is done. Care should be taken with respect to the order of
subexpressions in sums and products (since the order of variables in the
internal form is often different from that in the displayed form) and in dealing
with unary minus, subtraction, and division (since these operators are removed
from the expression). part (x+y, 0)
or inpart (x+y, 0)
yield
+
, though in order to refer to the operator it must be enclosed in "s.
For example ... if inpart (%o9,0) = "+" then ...
.
Examples:
(%i1) x + y + w*z; (%o1) w z + y + x (%i2) inpart (%, 3, 2); (%o2) z (%i3) part (%th (2), 1, 2); (%o3) z (%i4) 'limit (f(x)^g(x+1), x, 0, minus); g(x + 1) (%o4) limit f(x) x -> 0- (%i5) inpart (%, 1, 2); (%o5) g(x + 1)
Returns expr with subexpressions which are sums and which do not contain
var replaced by intermediate expression labels (these being atomic symbols
like %t1
, %t2
, …). This is often useful to avoid
unnecessary expansion of subexpressions which don’t contain the variable of
interest. Since the intermediate labels are bound to the subexpressions they
can all be substituted back by evaluating the expression in which they occur.
exptisolate
(default value: false
) if true
will cause
isolate
to examine exponents of atoms (like %e
) which contain
var.
isolate_wrt_times
if true
, then isolate
will also isolate
with respect to products. See isolate_wrt_times
. See also disolate
.
Do example (isolate)
for examples.
Default value: false
When isolate_wrt_times
is true
, isolate
will also isolate
with respect to products. E.g. compare both settings of the switch on
(%i1) isolate_wrt_times: true$ (%i2) isolate (expand ((a+b+c)^2), c); (%t2) 2 a (%t3) 2 b 2 2 (%t4) b + 2 a b + a 2 (%o4) c + %t3 c + %t2 c + %t4 (%i4) isolate_wrt_times: false$ (%i5) isolate (expand ((a+b+c)^2), c); 2 (%o5) c + 2 b c + 2 a c + %t4
Default value: false
When listconstvars
is true
the list returned by
listofvars
contains constant variables, such as %e
,
%pi
, %i
or any variables declared as constant that
occur in expr. A variable is declared as constant
type via declare
, and constantp
returns true
for all variables declared as constant
. The default is to
omit constant variables from listofvars
return value.
Default value: true
When listdummyvars
is false
, "dummy variables" in the expression
will not be included in the list returned by listofvars
. (The meaning
of "dummy variables" is as given in freeof
. "Dummy variables" are
mathematical things like the index of a sum or product, the limit variable,
and the definite integration variable.)
Example:
(%i1) listdummyvars: true$ (%i2) listofvars ('sum(f(i), i, 0, n)); (%o2) [i, n] (%i3) listdummyvars: false$ (%i4) listofvars ('sum(f(i), i, 0, n)); (%o4) [n]
Returns a list of the variables in expr.
listconstvars
if true
causes listofvars
to include
%e
, %pi
, %i
, and any variables declared constant in the
list it returns if they appear in expr. The default is to omit these.
See also the option variable listdummyvars
to exclude or include
"dummy variables" in the list of variables.
(%i1) listofvars (f (x[1]+y) / g^(2+a)); (%o1) [g, a, x , y] 1
For each member m of list, calls
freeof (m, expr)
. It returns false
if any call to
freeof
does and true
otherwise.
Example:
(%i1) lfreeof ([ a, x], x^2+b); (%o1) false
(%i2) lfreeof ([ b, x], x^2+b); (%o2) false
(%i3) lfreeof ([ a, y], x^2+b); (%o3) true
is similar to dpart
but uses a labelled box. A labelled box is similar
to the one produced by dpart
but it has a name in the top line.
You may declare variables to be mainvar
. The ordering scale for atoms is
essentially: numbers <
constants (e.g., %e
, %pi
) <
scalars <
other
variables <
mainvars. E.g., compare expand ((X+Y)^4)
with
(declare (x, mainvar), expand ((x+y)^4))
. (Note: Care should be taken if
you elect to use the above feature. E.g., if you subtract an expression in
which x
is a mainvar
from one in which x
isn’t a
mainvar
, resimplification e.g. with ev (expr, simp)
may be
necessary if cancellation is to occur. Also, if you save an expression in which
x
is a mainvar
, you probably should also save x
.)
noun
is one of the options of the declare
command. It makes a
function so declared a "noun", meaning that it won’t be evaluated
automatically.
Example:
(%i1) factor (12345678); 2 (%o1) 2 3 47 14593
(%i2) declare (factor, noun); (%o2) done
(%i3) factor (12345678); (%o3) factor(12345678)
(%i4) ''%, nouns; 2 (%o4) 2 3 47 14593
Default value: false
When noundisp
is true
, nouns display with
a single quote. This switch is always true
when displaying function
definitions.
Returns the noun form of the function name f. This is needed if one wishes to refer to the name of a verb function as if it were a noun. Note that some verb functions will return their noun forms if they can’t be evaluated for certain arguments. This is also the form returned if a function call is preceded by a quote.
See also verbify
.
Returns the number of terms that expr would have if it were fully
expanded out and no cancellations or combination of terms occurred.
Note that expressions like sin (expr)
, sqrt (expr)
,
exp (expr)
, etc. count as just one term regardless of how many
terms expr has (if it is a sum).
Returns the main operator of the expression expr.
op (expr)
is equivalent to part (expr, 0)
.
op
returns a string if the main operator is a built-in or user-defined
prefix, binary or n-ary infix, postfix, matchfix, or nofix operator.
Otherwise, if expr is a subscripted function expression, op
returns the subscripted function; in this case the return value is not an atom.
Otherwise, expr is a memoizing function
or ordinary function expression,
and op
returns a symbol.
op
observes the value of the global flag inflag
.
op
evaluates it argument.
See also args
.
Examples:
(%i1) stringdisp: true$
(%i2) op (a * b * c); (%o2) "*"
(%i3) op (a * b + c); (%o3) "+"
(%i4) op ('sin (a + b)); (%o4) sin
(%i5) op (a!); (%o5) "!"
(%i6) op (-a); (%o6) "-"
(%i7) op ([a, b, c]); (%o7) "["
(%i8) op ('(if a > b then c else d)); (%o8) "if"
(%i9) op ('foo (a)); (%o9) foo
(%i10) prefix (foo); (%o10) "foo"
(%i11) op (foo a); (%o11) "foo"
(%i12) op (F [x, y] (a, b, c)); (%o12) F x, y
(%i13) op (G [u, v, w]); (%o13) G
operatorp
(expr, op) operatorp
(expr, [op_1, …, op_n]) ¶operatorp (expr, op)
returns true
if op is equal to the operator of expr.
operatorp (expr, [op_1, ..., op_n])
returns
true
if some element op_1, …, op_n is equal to the
operator of expr.
Default value: true
When opsubst
is false
, subst
does not attempt to
substitute into the operator of an expression. E.g.,
(opsubst: false, subst (x^2, r, r+r[0]))
will work.
(%i1) r+r[0]; (%o1) r + r 0
(%i2) opsubst; (%o2) true
(%i3) subst (x^2, r, r+r[0]); 2 2 (%o3) x + (x ) 0
(%i4) opsubst: not opsubst; (%o4) false
(%i5) subst (x^2, r, r+r[0]); 2 (%o5) x + r 0
Returns an expression that produces the same value and
side effects as expr but does so more efficiently by avoiding the
recomputation of common subexpressions. optimize
also has the side
effect of "collapsing" its argument so that all common subexpressions
are shared. Do example (optimize)
for examples.
Default value: %
optimprefix
is the prefix used for generated symbols by
the optimize
command.
ordergreat
changes the canonical ordering of Maxima expressions
such that v_1 succeeds v_2 succeeds … succeeds v_n,
and v_n succeeds any other symbol not mentioned as an argument.
orderless
changes the canonical ordering of Maxima expressions
such that v_1 precedes v_2 precedes … precedes v_n,
and v_n precedes any other variable not mentioned as an argument.
The order established by ordergreat
and orderless
is dissolved
by unorder
. ordergreat
and orderless
can be called only
once each, unless unorder
is called; only the last call to
ordergreat
and orderless
has any effect.
See also ordergreatp
.
ordergreatp
returns true
if expr_1 succeeds expr_2 in
the canonical ordering of Maxima expressions, and false
otherwise.
orderlessp
returns true
if expr_1 precedes expr_2 in
the canonical ordering of Maxima expressions, and false
otherwise.
All Maxima atoms and expressions are comparable under ordergreatp
and
orderlessp
, although there are isolated examples of expressions for which
these predicates are not transitive; that is a bug.
The canonical ordering of atoms (symbols, literal numbers, and strings) is the following.
(integers and floats) precede (bigfloats) precede
(declared constants) precede (strings) precede (declared scalars)
precede (first argument to orderless
) precedes … precedes
(last argument to orderless
) precedes (other symbols) precede
(last argument to ordergreat
) precedes … precedes
(first argument to ordergreat
) precedes (declared main variables)
For non-atomic expressions, the canonical ordering is derived from the ordering
for atoms. For the built-in +
*
and ^
operators,
the ordering is not easily summarized. For other built-in operators and all
other functions and operators, expressions are ordered by their arguments
(beginning with the first argument), then by the name of the operator or
function. In the case of subscripted expressions, the subscripted symbol is
considered the operator and the subscript is considered an argument.
The canonical ordering of expressions is modified by the functions
ordergreat
and orderless
, and the mainvar
,
constant
, and scalar
declarations.
See also sort
.
Examples:
Ordering ordinary symbols and constants.
Note that %pi
is not ordered according to its numerical value.
(%i1) stringdisp : true; (%o1) true
(%i2) sort ([%pi, 3b0, 3.0, x, X, "foo", 3, a, 4, "bar", 4.0, 4b0]); (%o2) [3, 3.0, 4, 4.0, 3.0b0, 4.0b0, %pi, "bar", "foo", X, a, x]
Effect of ordergreat
and orderless
functions.
(%i1) sort ([M, H, K, T, E, W, G, A, P, J, S]); (%o1) [A, E, G, H, J, K, M, P, S, T, W]
(%i2) ordergreat (S, J); (%o2) done
(%i3) orderless (M, H); (%o3) done
(%i4) sort ([M, H, K, T, E, W, G, A, P, J, S]); (%o4) [M, H, A, E, G, K, P, T, W, J, S]
Effect of mainvar
, constant
, and scalar
declarations.
(%i1) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]); (%o1) [A1, B1, C1, aa, bar, baz, bb, cc, dd, foo, quux]
(%i2) declare (aa, mainvar); (%o2) done
(%i3) declare ([baz, quux], constant); (%o3) done
(%i4) declare ([A1, B1], scalar); (%o4) done
(%i5) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]); (%o5) [baz, quux, A1, B1, C1, bar, bb, cc, dd, foo, aa]
Ordering non-atomic expressions.
(%i1) sort ([1, 2, n, f(1), f(2), f(2, 1), g(1), g(1, 2), g(n), f(n, 1)]); (%o1) [1, 2, f(1), g(1), g(1, 2), f(2), f(2, 1), n, g(n), f(n, 1)]
(%i2) sort ([foo(1), X[1], X[k], foo(k), 1, k]); (%o2) [1, X , foo(1), k, X , foo(k)] 1 k
Returns parts of the displayed form of expr
. It obtains the part of
expr
as specified by the indices n_1, …, n_k. First
part n_1 of expr
is obtained, then part n_2 of that, etc.
The result is part n_k of … part n_2 of part n_1 of
expr
. If no indices are specified expr
is returned.
part
can be used to obtain an element of a list, a row of a matrix, etc.
If the last argument to a part
function is a list of indices then
several subexpressions are picked out, each one corresponding to an
index of the list. Thus part (x + y + z, [1, 3])
is z+x
.
piece
holds the last expression selected when using the part
functions. It is set during the execution of the function and thus
may be referred to in the function itself as shown below.
If partswitch
is set to true
then end
is returned when a
selected part of an expression doesn’t exist, otherwise an error message is
given.
See also inpart
, substpart
, substinpart
,
dpart
, and lpart
.
Examples:
(%i1) part(z+2*y+a,2); (%o1) 2 y
(%i2) part(z+2*y+a,[1,3]); (%o2) z + a
(%i3) part(z+2*y+a,2,1); (%o3) 2
example (part)
displays additional examples.
Returns a list of two expressions. They are (1) the factors of expr (if it is a product), the terms of expr (if it is a sum), or the list (if it is a list) which don’t contain x and, (2) the factors, terms, or list which do.
Examples:
(%i1) partition (2*a*x*f(x), x); (%o1) [2 a, x f(x)] (%i2) partition (a+b, x); (%o2) [b + a, 0] (%i3) partition ([a, b, f(a), c], a); (%o3) [[b, c], [a, f(a)]]
Default value: false
When partswitch
is true
, end
is returned
when a selected part of an expression doesn’t exist, otherwise an
error message is given.
Assigns intermediate expression labels to subexpressions of expr at depth
n, an integer. Subexpressions at greater or lesser depths are not
assigned labels. pickapart
returns an expression in terms of
intermediate expressions equivalent to the original expression expr.
See also part
, dpart
, lpart
,
inpart
, and reveal
.
Examples:
(%i1) expr: (a+b)/2 + sin (x^2)/3 - log (1 + sqrt(x+1)); 2 sin(x ) b + a (%o1) - log(sqrt(x + 1) + 1) + ------- + ----- 3 2 (%i2) pickapart (expr, 0);
2 sin(x ) b + a (%t2) - log(sqrt(x + 1) + 1) + ------- + ----- 3 2
(%o2) %t2 (%i3) pickapart (expr, 1); (%t3) - log(sqrt(x + 1) + 1) 2 sin(x ) (%t4) ------- 3 b + a (%t5) ----- 2 (%o5) %t5 + %t4 + %t3 (%i5) pickapart (expr, 2); (%t6) log(sqrt(x + 1) + 1) 2 (%t7) sin(x ) (%t8) b + a %t8 %t7 (%o8) --- + --- - %t6 2 3 (%i8) pickapart (expr, 3); (%t9) sqrt(x + 1) + 1 2 (%t10) x b + a sin(%t10) (%o10) ----- - log(%t9) + --------- 2 3 (%i10) pickapart (expr, 4); (%t11) sqrt(x + 1)
2 sin(x ) b + a (%o11) ------- + ----- - log(%t11 + 1) 3 2
(%i11) pickapart (expr, 5); (%t12) x + 1 2 sin(x ) b + a (%o12) ------- + ----- - log(sqrt(%t12) + 1) 3 2 (%i12) pickapart (expr, 6); 2 sin(x ) b + a (%o12) ------- + ----- - log(sqrt(x + 1) + 1) 3 2
Holds the last expression selected when using the part
functions.
It is set during the execution of the function and thus may be referred to in
the function itself.
psubst
(list, expr) psubst
(a, b, expr) ¶psubst(a, b, expr)
is similar to subst
. See
subst
.
In distinction from subst
the function psubst
makes parallel
substitutions, if the first argument list is a list of equations.
See also sublis
for making parallel substitutions and let
and
letsimp
for others ways to do substitutions.
Example:
The first example shows parallel substitution with psubst
. The second
example shows the result for the function subst
, which does a serial
substitution.
(%i1) psubst ([a^2=b, b=a], sin(a^2) + sin(b)); (%o1) sin(b) + sin(a)
(%i2) subst ([a^2=b, b=a], sin(a^2) + sin(b)); (%o2) 2 sin(a)
rembox
(expr, unlabelled) rembox
(expr, label) rembox
(expr) ¶Removes boxes from expr.
rembox (expr, unlabelled)
removes all unlabelled boxes from
expr.
rembox (expr, label)
removes only boxes bearing label.
rembox (expr)
removes all boxes, labelled and unlabelled.
Boxes are drawn by the box
, dpart
, and lpart
functions.
Examples:
(%i1) expr: (a*d - b*c)/h^2 + sin(%pi*x); a d - b c (%o1) sin(%pi x) + --------- 2 h
(%i2) dpart (dpart (expr, 1, 1), 2, 2); dpart: fell off the end. -- an error. To debug this try: debugmode(true);
(%i3) expr2: lpart (BAR, lpart (FOO, %, 1), 2); BAR"""""""" FOO""""""""" "a d - b c" (%o3) "sin(%pi x)" + "---------" """""""""""" " 2 " " h " """""""""""
(%i4) rembox (expr2, unlabelled); BAR"""""""" FOO""""""""" "a d - b c" (%o4) "sin(%pi x)" + "---------" """""""""""" " 2 " " h " """""""""""
(%i5) rembox (expr2, FOO); BAR"""""""" "a d - b c" (%o5) sin(%pi x) + "---------" " 2 " " h " """""""""""
(%i6) rembox (expr2, BAR); FOO""""""""" a d - b c (%o6) "sin(%pi x)" + --------- """""""""""" 2 h
(%i7) rembox (expr2); a d - b c (%o7) sin(%pi x) + --------- 2 h
Replaces parts of expr at the specified integer depth with descriptive summaries.
Sum(n)
where n is the number of operands of the sum.
Product(n)
where n is the number of operands of the product.
Expt
.
Quotient
.
Negterm
.
List(n)
where n is the number of
elements of the list.
When depth is greater than or equal to the maximum depth of expr,
reveal (expr, depth)
returns expr unmodified.
reveal
evaluates its arguments.
reveal
returns the summarized expression.
Example:
(%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2); 2 2 b - 2 a b + a (%o1) ------------------------- b + a 2 b 2 a 2 %e + %e + %e (%i2) reveal (e, 1); (%o2) Quotient (%i3) reveal (e, 2); Sum(3) (%o3) ------ Sum(3) (%i4) reveal (e, 3);
Expt + Negterm + Expt (%o4) ------------------------ Product(2) + Expt + Expt
(%i5) reveal (e, 4); 2 2 b - Product(3) + a (%o5) ------------------------------------ Product(2) Product(2) 2 Expt + %e + %e (%i6) reveal (e, 5); 2 2 b - 2 a b + a (%o6) -------------------------- Sum(2) 2 b 2 a 2 %e + %e + %e (%i7) reveal (e, 6); 2 2 b - 2 a b + a (%o7) ------------------------- b + a 2 b 2 a 2 %e + %e + %e
Denests sqrt
of simple, numerical, binomial surds, where possible. E.g.
(%i1) sqrt(sqrt(3)/2+1)/sqrt(11*sqrt(2)-12); sqrt(3) sqrt(------- + 1) 2 (%o1) --------------------- sqrt(11 sqrt(2) - 12)
(%i2) sqrtdenest(%); sqrt(3) 1 ------- + - 2 2 (%o2) ------------- 1/4 3/4 3 2 - 2
Sometimes it helps to apply sqrtdenest
more than once, on such as
(19601-13860 sqrt(2))^(7/4)
.
Makes multiple parallel substitutions into an expression. list is a list of equations. The left hand side of the equations must be an atom.
The variable sublis_apply_lambda
controls simplification after
sublis
.
See also psubst
for making parallel substitutions.
Example:
(%i1) sublis ([a=b, b=a], sin(a) + cos(b)); (%o1) sin(b) + cos(a)
Default value: true
Controls whether lambda
’s substituted are applied in simplification after
sublis
is used or whether you have to do an ev
to get things to
apply. true
means do the application.
Default value: false
If true
then the functions subst
and psubst
can substitute
a subscripted variable f[x]
with a number, when only the symbol f
is given.
See also subst
.
(%i1) subst(100,g,g[x]+2); subst: cannot substitute 100 for operator g in expression g x -- an error. To debug this try: debugmode(true); (%i2) subst(100,g,g[x]+2),subnumsimp:true; (%o2) 102
Substitutes a for b in c. b must be an atom or a
complete subexpression of c. For example, x+y+z
is a complete
subexpression of 2*(x+y+z)/w
while x+y
is not. When b does
not have these characteristics, one may sometimes use substpart
or
ratsubst
(see below). Alternatively, if b is of the form
e/f
then one could use subst (a*f, e, c)
while if b is of
the form e^(1/f)
then one could use subst (a^f, e, c)
. The
subst
command also discerns the x^y
in x^-y
so that
subst (a, sqrt(x), 1/sqrt(x))
yields 1/a
. a and b
may also be operators of an expression enclosed in double-quotes "
or
they may be function names. If one wishes to substitute for the independent
variable in derivative forms then the at
function (see below) should be
used.
subst
is an alias for substitute
.
The commands subst (eq_1, expr)
or
subst ([eq_1, ..., eq_k], expr)
are other permissible
forms. The eq_i are equations indicating substitutions to be made.
For each equation, the right side will be substituted for the left in the
expression expr. The equations are substituted in serial from left to
right in expr. See the functions sublis
and psubst
for
making parallel substitutions.
exptsubst
if true
permits substitutions
like y
for %e^x
in %e^(a*x)
to take place.
When opsubst
is false
,
subst
will not attempt to substitute into the operator of an expression.
E.g. (opsubst: false, subst (x^2, r, r+r[0]))
will work.
See also at
, ev
and psubst
, as well as let
and letsimp
.
Examples:
(%i1) subst (a, x+y, x + (x+y)^2 + y); 2 (%o1) y + x + a
(%i2) subst (-%i, %i, a + b*%i); (%o2) a - %i b
The substitution is done in serial for a list of equations. Compare this with a parallel substitution:
(%i1) subst([a=b, b=c], a+b); (%o1) 2 c
(%i2) sublis([a=b, b=c], a+b); (%o2) c + b
Single-character Operators like +
and -
have to be quoted in
order to be replaced by subst. It is to note, though, that a+b-c
might be expressed as a+b+(-1*c)
internally.
(%i3) subst(["+"="-"],a+b-c); (%o3) c-b+a
The difference between subst
and at
can be seen in the
following example:
(%i1) g1:y(t)=a*x(t)+b*diff(x(t),t); d (%o1) y(t) = b (-- (x(t))) + a x(t) dt
(%i2) subst('diff(x(t),t)=1,g1); (%o2) y(t) = a x(t) + b
(%i3) at(g1,'diff(x(t),t)=1); ! d ! (%o3) y(t) = b (-- (x(t))! ) + a x(t) dt !d !-- (x(t)) = 1 dt
For further examples, do example (subst)
.
Similar to substpart
, but substinpart
works on the
internal representation of expr.
Examples:
(%i1) x . 'diff (f(x), x, 2); 2 d (%o1) x . (--- (f(x))) 2 dx
(%i2) substinpart (d^2, %, 2); 2 (%o2) x . d
(%i3) substinpart (f1, f[1](x + 1), 0); (%o3) f1(x + 1)
If the last argument to a part
function is a list of indices then
several subexpressions are picked out, each one corresponding to an
index of the list. Thus
(%i1) part (x + y + z, [1, 3]); (%o1) z + x
piece
holds the value of the last expression selected when using the
part
functions. It is set during the execution of the function and
thus may be referred to in the function itself as shown below.
If partswitch
is set to true
then end
is returned when a
selected part of an expression doesn’t exist, otherwise an error
message is given.
(%i1) expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1; 3 2 2 3 (%o1) 27 y + 54 x y + 36 x y + y + 8 x + x + 1
(%i2) part (expr, 2, [1, 3]); 2 (%o2) 54 y
(%i3) sqrt (piece/54); (%o3) abs(y)
(%i4) substpart (factor (piece), expr, [1, 2, 3, 5]); 3 (%o4) (3 y + 2 x) + y + x + 1
(%i5) expr: 1/x + y/x - 1/z; 1 y 1 (%o5) (- -) + - + - z x x
(%i6) substpart (xthru (piece), expr, [2, 3]); y + 1 1 (%o6) ----- - - x z
Also, setting the option inflag
to true
and calling part
or substpart
is the same as calling inpart
or substinpart
.
Substitutes x for the subexpression picked out by the rest of the
arguments as in part
. It returns the new value of expr. x
may be some operator to be substituted for an operator of expr. In some
cases x needs to be enclosed in double-quotes "
(e.g.
substpart ("+", a*b, 0)
yields b + a
).
Example:
(%i1) 1/(x^2 + 2); 1 (%o1) ------ 2 x + 2
(%i2) substpart (3/2, %, 2, 1, 2); 1 (%o2) -------- 3/2 x + 2
(%i3) a*x + f(b, y); (%o3) a x + f(b, y)
(%i4) substpart ("+", %, 1, 0); (%o4) x + f(b, y) + a
Also, setting the option inflag
to true
and calling part
or substpart
is the same as calling inpart
or
substinpart
.
Returns true
if expr is a symbol, else false
.
See also Identifiers.
Disables the aliasing created by the last use of the ordering commands
ordergreat
and orderless
. ordergreat
and orderless
may not be used more than one time each without calling unorder
.
unorder
does not substitute back in expressions the original symbols for
the aliases introduced by ordergreat
and orderless
. Therefore,
after execution of unorder
the aliases appear in previous expressions.
See also ordergreat
and orderless
.
Examples:
ordergreat(a)
introduces an alias for the symbol a
. Therefore,
the difference of %o2
and %o4
does not vanish. unorder
does not substitute back the symbol a
and the alias appears in the
output %o7
.
(%i1) unorder(); (%o1) []
(%i2) b*x + a^2; 2 (%o2) b x + a
(%i3) ordergreat (a); (%o3) done
(%i4) b*x + a^2; %th(1) - %th(3); 2 (%o4) a + b x
(%i5) unorder(); 2 2 (%o5) a - a
(%i6) %th(2); (%o6) [a]
Returns the verb form of the function name f.
See also verb
, noun
, and nounify
.
Examples:
(%i1) verbify ('foo); (%o1) foo
(%i2) :lisp $% $FOO
(%i2) nounify (foo); (%o2) foo
(%i3) :lisp $% %FOO
It is possible to define new operators with specified precedence, to undefine existing operators, or to redefine the precedence of existing operators. An operator may be unary prefix or unary postfix, binary infix, n-ary infix, matchfix, or nofix. "Matchfix" means a pair of symbols which enclose their argument or arguments, and "nofix" means an operator which takes no arguments. As examples of the different types of operators, there are the following.
negation - a
factorial a!
exponentiation a^b
addition a + b
list construction [a, b]
(There are no built-in nofix operators; for an example of such an operator,
see nofix
.)
The mechanism to define a new operator is straightforward. It is only necessary to declare a function as an operator; the operator function might or might not be defined.
An example of user-defined operators is the following. Note that the explicit
function call "dd" (a)
is equivalent to dd a
, likewise
"<-" (a, b)
is equivalent to a <- b
. Note also that the functions
"dd"
and "<-"
are undefined in this example.
(%i1) prefix ("dd"); (%o1) dd (%i2) dd a; (%o2) dd a (%i3) "dd" (a); (%o3) dd a (%i4) infix ("<-"); (%o4) <- (%i5) a <- dd b; (%o5) a <- dd b (%i6) "<-" (a, "dd" (b)); (%o6) a <- dd b
The Maxima functions which define new operators are summarized in this table, stating the default left and right binding powers (lbp and rbp, respectively). (Binding power determines operator precedence. However, since left and right binding powers can differ, binding power is somewhat more complicated than precedence.) Some of the operation definition functions take additional arguments; see the function descriptions for details.
prefix
rbp=180
postfix
lbp=180
infix
lbp=180, rbp=180
nary
lbp=180, rbp=180
matchfix
(binding power not applicable)
nofix
(binding power not applicable)
For comparison, here are some built-in operators and their left and right binding powers.
Operator lbp rbp : 180 20 :: 180 20 := 180 20 ::= 180 20 ! 160 !! 160 ^ 140 139 . 130 129 * 120 / 120 120 + 100 100 - 100 134 = 80 80 # 80 80 > 80 80 >= 80 80 < 80 80 <= 80 80 not 70 and 65 or 60 , 10 $ -1 ; -1
remove
and kill
remove operator properties from an atom.
remove ("a", op)
removes only the operator properties of a.
kill ("a")
removes all properties of a, including the
operator properties. Note that the name of the operator must be enclosed in
quotation marks.
(%i1) infix ("##"); (%o1) ## (%i2) "##" (a, b) := a^b; b (%o2) a ## b := a (%i3) 5 ## 3; (%o3) 125 (%i4) remove ("##", op); (%o4) done (%i5) 5 ## 3; Incorrect syntax: # is not a prefix operator 5 ## ^ (%i5) "##" (5, 3); (%o5) 125 (%i6) infix ("##"); (%o6) ## (%i7) 5 ## 3; (%o7) 125 (%i8) kill ("##"); (%o8) done (%i9) 5 ## 3; Incorrect syntax: # is not a prefix operator 5 ## ^ (%i9) "##" (5, 3); (%o9) ##(5, 3)
The symbols +
*
/
and ^
represent addition,
multiplication, division, and exponentiation, respectively. The names of these
operators are "+"
"*"
"/"
and "^"
, which may appear
where the name of a function or operator is required.
The symbols +
and -
represent unary addition and negation,
respectively, and the names of these operators are "+"
and "-"
,
respectively.
Subtraction a - b
is represented within Maxima as addition,
a + (- b)
. Expressions such as a + (- b)
are displayed as
subtraction. Maxima recognizes "-"
only as the name of the unary
negation operator, and not as the name of the binary subtraction operator.
Division a / b
is represented within Maxima as multiplication,
a * b^(- 1)
. Expressions such as a * b^(- 1)
are displayed as
division. Maxima recognizes "/"
as the name of the division operator.
Addition and multiplication are n-ary, commutative operators. Division and exponentiation are binary, noncommutative operators.
Maxima sorts the operands of commutative operators to construct a canonical
representation. For internal storage, the ordering is determined by
orderlessp
. For display, the ordering for addition is determined by
ordergreatp
, and for multiplication, it is the same as the internal
ordering.
Arithmetic computations are carried out on literal numbers (integers, rationals,
ordinary floats, and bigfloats). Except for exponentiation, all arithmetic
operations on numbers are simplified to numbers. Exponentiation is simplified
to a number if either operand is an ordinary float or bigfloat or if the result
is an exact integer or rational; otherwise an exponentiation may be simplified
to sqrt
or another exponentiation or left unchanged.
Floating-point contagion applies to arithmetic computations: if any operand is a bigfloat, the result is a bigfloat; otherwise, if any operand is an ordinary float, the result is an ordinary float; otherwise, the operands are rationals or integers and the result is a rational or integer.
Arithmetic computations are a simplification, not an evaluation. Thus arithmetic is carried out in quoted (but simplified) expressions.
Arithmetic operations are applied element-by-element to lists when the global
flag listarith
is true
, and always applied element-by-element to
matrices. When one operand is a list or matrix and another is an operand of
some other type, the other operand is combined with each of the elements of the
list or matrix.
Examples:
Addition and multiplication are n-ary, commutative operators.
Maxima sorts the operands to construct a canonical representation.
The names of these operators are "+"
and "*"
.
(%i1) c + g + d + a + b + e + f; (%o1) g + f + e + d + c + b + a (%i2) [op (%), args (%)]; (%o2) [+, [g, f, e, d, c, b, a]] (%i3) c * g * d * a * b * e * f; (%o3) a b c d e f g (%i4) [op (%), args (%)]; (%o4) [*, [a, b, c, d, e, f, g]] (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]); (%o5) 3 x + 2 a + 19 (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]); 2 3 (%o6) 144 a x
Division and exponentiation are binary, noncommutative operators.
The names of these operators are "/"
and "^"
.
(%i1) [a / b, a ^ b]; a b (%o1) [-, a ] b (%i2) [map (op, %), map (args, %)]; (%o2) [[/, ^], [[a, b], [a, b]]] (%i3) [apply ("/", [a, b]), apply ("^", [a, b])]; a b (%o3) [-, a ] b
Subtraction and division are represented internally in terms of addition and multiplication, respectively.
(%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)]; (%o1) [+, a, - b] (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)]; 1 (%o2) [*, a, -] b
Computations are carried out on literal numbers. Floating-point contagion applies.
(%i1) 17 + b - (1/2)*29 + 11^(2/4); 5 (%o1) b + sqrt(11) + - 2 (%i2) [17 + 29, 17 + 29.0, 17 + 29b0]; (%o2) [46, 46.0, 4.6b1]
Arithmetic computations are a simplification, not an evaluation.
(%i1) simp : false; (%o1) false (%i2) '(17 + 29*11/7 - 5^3); 29 11 3 (%o2) 17 + ----- - 5 7 (%i3) simp : true; (%o3) true (%i4) '(17 + 29*11/7 - 5^3); 437 (%o4) - --- 7
Arithmetic is carried out element-by-element for lists (depending on
listarith
) and matrices.
(%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
[ a - 1 x - 2 ] (%o1) [ ] [ h - 3 u - 4 ]
(%i2) 5 * matrix ([a, x], [h, u]); [ 5 a 5 x ] (%o2) [ ] [ 5 h 5 u ] (%i3) listarith : false; (%o3) false (%i4) [a, c, m, t] / [1, 7, 2, 9]; [a, c, m, t] (%o4) ------------ [1, 7, 2, 9] (%i5) [a, c, m, t] ^ x; x (%o5) [a, c, m, t] (%i6) listarith : true; (%o6) true (%i7) [a, c, m, t] / [1, 7, 2, 9]; c m t (%o7) [a, -, -, -] 7 2 9 (%i8) [a, c, m, t] ^ x; x x x x (%o8) [a , c , m , t ]
Exponentiation operator.
Maxima recognizes **
as the same operator as ^
in input,
and it is displayed as ^
in 1-dimensional output,
or by placing the exponent as a superscript in 2-dimensional output.
The fortran
function displays the exponentiation operator as **
,
whether it was input as **
or ^
.
Examples:
(%i1) is (a**b = a^b); (%o1) true (%i2) x**y + x^z; z y (%o2) x + x (%i3) string (x**y + x^z); (%o3) x^z+x^y (%i4) fortran (x**y + x^z); x**z+x**y (%o4) done
Noncommutative exponentiation operator.
^^
is the exponentiation operator corresponding to noncommutative
multiplication .
, just as the ordinary exponentiation operator ^
corresponds to commutative multiplication *
.
Noncommutative exponentiation is displayed by ^^
in 1-dimensional output,
and by placing the exponent as a superscript within angle brackets < >
in 2-dimensional output.
Examples:
(%i1) a . a . b . b . b + a * a * a * b * b; 3 2 <2> <3> (%o1) a b + a . b (%i2) string (a . a . b . b . b + a * a * a * b * b); (%o2) a^3*b^2+a^^2 . b^^3
The dot operator, for matrix (non-commutative) multiplication.
When "."
is used in this way, spaces should be left on both sides of
it, e.g. A . B
This distinguishes it plainly from a decimal point in
a floating point number.
See also
Dot
,
dot0nscsimp
,
dot0simp
,
dot1simp
,
dotassoc
,
dotconstrules
,
dotdistrib
,
dotexptsimp
,
dotident
,
and
dotscrules
.
The symbols <
<=
>=
and >
represent less than, less
than or equal, greater than or equal, and greater than, respectively. The names
of these operators are "<"
"<="
">="
and ">"
, which
may appear where the name of a function or operator is required.
These relational operators are all binary operators; constructs such as
a < b < c
are not recognized by Maxima.
Relational expressions are evaluated to Boolean values by the functions
is
and maybe
, and the programming constructs
if
, while
, and unless
. Relational expressions
are not otherwise evaluated or simplified to Boolean values, although the
arguments of relational expressions are evaluated (when evaluation is not
otherwise prevented by quotation).
When a relational expression cannot be evaluated to true
or false
,
the behavior of is
and if
are governed by the global flag
prederror
. When prederror
is true
, is
and
if
trigger an error. When prederror
is false
, is
returns unknown
, and if
returns a partially-evaluated conditional
expression.
maybe
always behaves as if prederror
were false
, and
while
and unless
always behave as if prederror
were
true
.
Relational operators do not distribute over lists or other aggregates.
See also =
, #
, equal
, and notequal
.
Examples:
Relational expressions are evaluated to Boolean values by some functions and programming constructs.
(%i1) [x, y, z] : [123, 456, 789]; (%o1) [123, 456, 789] (%i2) is (x < y); (%o2) true (%i3) maybe (y > z); (%o3) false (%i4) if x >= z then 1 else 0; (%o4) 0 (%i5) block ([S], S : 0, for i:1 while i <= 100 do S : S + i, return (S)); (%o5) 5050
Relational expressions are not otherwise evaluated or simplified to Boolean values, although the arguments of relational expressions are evaluated.
(%o1) [123, 456, 789] (%i2) [x < y, y <= z, z >= y, y > z]; (%o2) [123 < 456, 456 <= 789, 789 >= 456, 456 > 789] (%i3) map (is, %); (%o3) [true, true, true, false]
The logical conjunction operator. and
is an n-ary infix operator;
its operands are Boolean expressions, and its result is a Boolean value.
and
forces evaluation (like is
) of one or more operands,
and may force evaluation of all operands.
Operands are evaluated in the order in which they appear. and
evaluates
only as many of its operands as necessary to determine the result. If any
operand is false
, the result is false
and no further operands are
evaluated.
The global flag prederror
governs the behavior of and
when an
evaluated operand cannot be determined to be true
or false
.
and
prints an error message when prederror
is true
.
Otherwise, operands which do not evaluate to true
or false
are
accepted, and the result is a Boolean expression.
and
is not commutative: a and b
might not be equal to
b and a
due to the treatment of indeterminate operands.
The logical negation operator. not
is a prefix operator;
its operand is a Boolean expression, and its result is a Boolean value.
not
forces evaluation (like is
) of its operand.
The global flag prederror
governs the behavior of not
when its
operand cannot be determined to be true
or false
. not
prints an error message when prederror
is true
. Otherwise,
operands which do not evaluate to true
or false
are accepted,
and the result is a Boolean expression.
The logical disjunction operator. or
is an n-ary infix operator;
its operands are Boolean expressions, and its result is a Boolean value.
or
forces evaluation (like is
) of one or more operands,
and may force evaluation of all operands.
Operands are evaluated in the order in which they appear. or
evaluates
only as many of its operands as necessary to determine the result. If any
operand is true
, the result is true
and no further operands are
evaluated.
The global flag prederror
governs the behavior of or
when an
evaluated operand cannot be determined to be true
or false
.
or
prints an error message when prederror
is true
.
Otherwise, operands which do not evaluate to true
or false
are
accepted, and the result is a Boolean expression.
or
is not commutative: a or b
might not be equal to b or a
due to the treatment of indeterminate operands.
Represents the negation of syntactic equality =
.
Note that because of the rules for evaluation of predicate expressions
(in particular because not expr
causes evaluation of expr),
not a = b
is equivalent to is(a # b)
,
instead of a # b
.
Examples:
(%i1) a = b; (%o1) a = b (%i2) is (a = b); (%o2) false (%i3) a # b; (%o3) a # b (%i4) not a = b; (%o4) true (%i5) is (a # b); (%o5) true (%i6) is (not a = b); (%o6) true
The equation operator.
An expression a = b
, by itself, represents an unevaluated
equation, which might or might not hold. Unevaluated equations may appear as
arguments to solve
and algsys
or some other functions.
The function is
evaluates =
to a Boolean value.
is(a = b)
evaluates a = b
to true
when a and b are identical. That is, a and b are atoms
which are identical, or they are not atoms and their operators are identical and
their arguments are identical. Otherwise, is(a = b)
evaluates to false
; it never evaluates to unknown
. When
is(a = b)
is true
, a and b are said to be
syntactically equal, in contrast to equivalent expressions, for which
is(equal(a, b))
is true
. Expressions can be
equivalent and not syntactically equal.
The negation of =
is represented by #
.
As with =
, an expression a # b
, by itself, is not
evaluated. is(a # b)
evaluates a # b
to
true
or false
.
In addition to is
, some other operators evaluate =
and #
to true
or false
, namely if
, and
,
or
, and not
.
Note that because of the rules for evaluation of predicate expressions
(in particular because not expr
causes evaluation of expr),
not a = b
is equivalent to is(a # b)
,
instead of a # b
.
rhs
and lhs
return the right-hand and left-hand sides,
respectively, of an equation or inequation.
Examples:
An expression a = b
, by itself, represents
an unevaluated equation, which might or might not hold.
(%i1) eq_1 : a * x - 5 * y = 17; (%o1) a x - 5 y = 17 (%i2) eq_2 : b * x + 3 * y = 29; (%o2) 3 y + b x = 29 (%i3) solve ([eq_1, eq_2], [x, y]); 196 29 a - 17 b (%o3) [[x = ---------, y = -----------]] 5 b + 3 a 5 b + 3 a (%i4) subst (%, [eq_1, eq_2]);
196 a 5 (29 a - 17 b) (%o4) [--------- - --------------- = 17, 5 b + 3 a 5 b + 3 a 196 b 3 (29 a - 17 b) --------- + --------------- = 29] 5 b + 3 a 5 b + 3 a
(%i5) ratsimp (%); (%o5) [17 = 17, 29 = 29]
is(a = b)
evaluates a = b
to true
when a and b are syntactically equal (that is, identical).
Expressions can be equivalent and not syntactically equal.
(%i1) a : (x + 1) * (x - 1); (%o1) (x - 1) (x + 1) (%i2) b : x^2 - 1; 2 (%o2) x - 1 (%i3) [is (a = b), is (a # b)]; (%o3) [false, true] (%i4) [is (equal (a, b)), is (notequal (a, b))]; (%o4) [true, false]
Some operators evaluate =
and #
to true
or false
.
(%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else BAR; (%o1) FOO (%i2) eq_3 : 2 * x = 3 * x; (%o2) 2 x = 3 x (%i3) eq_4 : exp (2) = %e^2; 2 2 (%o3) %e = %e (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3]; (%o4) [false, true, true]
Because not expr
causes evaluation of expr,
not a = b
is equivalent to is(a # b)
.
(%i1) [2 * x # 3 * x, not (2 * x = 3 * x)]; (%o1) [2 x # 3 x, true] (%i2) is (2 * x # 3 * x); (%o2) true
Assignment operator.
When the left-hand side is a simple variable (not subscripted), :
evaluates its right-hand side and associates that value with the left-hand side.
When the left-hand side is a subscripted element of a list, matrix, declared Maxima array, or Lisp array, the right-hand side is assigned to that element. The subscript must name an existing element; such objects cannot be extended by naming nonexistent elements.
When the left-hand side is a subscripted element of a hashed array
,
the right-hand side is assigned to that element, if it already exists,
or a new element is allocated, if it does not already exist.
When the left-hand side is a list of simple and/or subscripted variables, the right-hand side must evaluate to a list, and the elements of the right-hand side are assigned to the elements of the left-hand side, in parallel.
See also kill
and remvalue
, which undo the association between
the left-hand side and its value.
Examples:
Assignment to a simple variable.
(%i1) a; (%o1) a (%i2) a : 123; (%o2) 123 (%i3) a; (%o3) 123
Assignment to an element of a list.
(%i1) b : [1, 2, 3]; (%o1) [1, 2, 3] (%i2) b[3] : 456; (%o2) 456 (%i3) b; (%o3) [1, 2, 456]
Assignment to a variable that neither is the name of a list nor of an array
creates a hashed array
.
(%i1) c[99] : 789; (%o1) 789 (%i2) c[99]; (%o2) 789 (%i3) c; (%o3) c (%i4) arrayinfo (c); (%o4) [hashed, 1, [99]] (%i5) listarray (c); (%o5) [789]
Multiple assignment.
(%i1) [a, b, c] : [45, 67, 89]; (%o1) [45, 67, 89] (%i2) a; (%o2) 45 (%i3) b; (%o3) 67 (%i4) c; (%o4) 89
Multiple assignment is carried out in parallel.
The values of a
and b
are exchanged in this example.
(%i1) [a, b] : [33, 55]; (%o1) [33, 55] (%i2) [a, b] : [b, a]; (%o2) [55, 33] (%i3) a; (%o3) 55 (%i4) b; (%o4) 33
Assignment operator.
::
is the same as :
(which see) except that ::
evaluates
its left-hand side as well as its right-hand side.
Examples:
(%i1) x : 'foo; (%o1) foo (%i2) x :: 123; (%o2) 123 (%i3) foo; (%o3) 123 (%i4) x : '[a, b, c]; (%o4) [a, b, c] (%i5) x :: [11, 22, 33]; (%o5) [11, 22, 33] (%i6) a; (%o6) 11 (%i7) b; (%o7) 22 (%i8) c; (%o8) 33
Macro function definition operator.
::=
defines a function (called a "macro" for historical reasons) which
quotes its arguments, and the expression which it returns (called the "macro
expansion") is evaluated in the context from which the macro was called.
A macro function is otherwise the same as an ordinary function.
macroexpand
returns a macro expansion (without evaluating it).
macroexpand (foo (x))
followed by ''%
is equivalent to
foo (x)
when foo
is a macro function.
::=
puts the name of the new macro function onto the global list
macros
. kill
, remove
, and remfunction
unbind macro function definitions and remove names from macros
.
fundef
or dispfun
return a macro function definition or assign it
to a label, respectively.
Macro functions commonly contain buildq
and splice
expressions to
construct an expression, which is then evaluated.
Examples
A macro function quotes its arguments, so message (1) shows y - z
, not
the value of y - z
. The macro expansion (the quoted expression
'(print ("(2) x is equal to", x))
) is evaluated in the context from which
the macro was called, printing message (2).
(%i1) x: %pi$ (%i2) y: 1234$ (%i3) z: 1729 * w$ (%i4) printq1 (x) ::= block (print ("(1) x is equal to", x), '(print ("(2) x is equal to", x)))$ (%i5) printq1 (y - z); (1) x is equal to y - z (2) x is equal to %pi (%o5) %pi
An ordinary function evaluates its arguments, so message (1) shows the value of
y - z
. The return value is not evaluated, so message (2) is not printed
until the explicit evaluation ''%
.
(%i1) x: %pi$ (%i2) y: 1234$ (%i3) z: 1729 * w$ (%i4) printe1 (x) := block (print ("(1) x is equal to", x), '(print ("(2) x is equal to", x)))$ (%i5) printe1 (y - z); (1) x is equal to 1234 - 1729 w (%o5) print((2) x is equal to, x) (%i6) ''%; (2) x is equal to %pi (%o6) %pi
macroexpand
returns a macro expansion.
macroexpand (foo (x))
followed by ''%
is equivalent to
foo (x)
when foo
is a macro function.
(%i1) x: %pi$ (%i2) y: 1234$ (%i3) z: 1729 * w$ (%i4) g (x) ::= buildq ([x], print ("x is equal to", x))$ (%i5) macroexpand (g (y - z)); (%o5) print(x is equal to, y - z) (%i6) ''%; x is equal to 1234 - 1729 w (%o6) 1234 - 1729 w (%i7) g (y - z); x is equal to 1234 - 1729 w (%o7) 1234 - 1729 w
The function definition operator.
f(x_1, ..., x_n) := expr
defines a function named
f with arguments x_1, …, x_n and function body
expr. :=
never evaluates the function body (unless explicitly
evaluated by quote-quote ''
).
The function body is evaluated every time the function is called.
f[x_1, ..., x_n] := expr
defines a so-called
memoizing function
.
Its function body is evaluated just once for each distinct value of its arguments,
and that value is returned, without evaluating the function body,
whenever the arguments have those values again.
(A function of this kind is also known as a “array function”.)
f[x_1, ..., x_n](y_1, ..., y_m) := expr
is a special case of a memoizing function
.
f[x_1, ..., x_n]
is a memoizing function
which returns a lambda expression
with arguments y_1, ..., y_m
.
The function body is evaluated once for each distinct value of x_1, ..., x_n
,
and the body of the lambda expression is that value.
When the last or only function argument x_n is a list of one element, the
function defined by :=
accepts a variable number of arguments. Actual
arguments are assigned one-to-one to formal arguments x_1, …,
x_(n - 1), and any further actual arguments, if present, are assigned to
x_n as a list.
All function definitions appear in the same namespace; defining a function
f
within another function g
does not automatically limit the scope
of f
to g
. However, local(f)
makes the definition of
function f
effective only within the block or other compound expression
in which local
appears.
If some formal argument x_k is a quoted symbol, the function defined by
:=
does not evaluate the corresponding actual argument. Otherwise all
actual arguments are evaluated.
Examples:
:=
never evaluates the function body (unless explicitly evaluated by
quote-quote).
(%i1) expr : cos(y) - sin(x); (%o1) cos(y) - sin(x) (%i2) F1 (x, y) := expr; (%o2) F1(x, y) := expr (%i3) F1 (a, b); (%o3) cos(y) - sin(x) (%i4) F2 (x, y) := ''expr; (%o4) F2(x, y) := cos(y) - sin(x) (%i5) F2 (a, b); (%o5) cos(b) - sin(a)
f(x_1, ..., x_n) := ...
defines an ordinary function.
(%i1) G1(x, y) := (print ("Evaluating G1 for x=", x, "and y=", y), x.y - y.x); (%o1) G1(x, y) := (print("Evaluating G1 for x=", x, "and y=", y), x . y - y . x) (%i2) G1([1, a], [2, b]); Evaluating G1 for x= [1, a] and y= [2, b] (%o2) 0 (%i3) G1([1, a], [2, b]); Evaluating G1 for x= [1, a] and y= [2, b] (%o3) 0
f[x_1, ..., x_n] := ...
defines a memoizing function
.
(%i1) G2[a] := (print ("Evaluating G2 for a=", a), a^2); 2 (%o1) G2 := (print("Evaluating G2 for a=", a), a ) a (%i2) G2[1234]; Evaluating G2 for a= 1234 (%o2) 1522756 (%i3) G2[1234]; (%o3) 1522756 (%i4) G2[2345]; Evaluating G2 for a= 2345 (%o4) 5499025 (%i5) arrayinfo (G2); (%o5) [hashed, 1, [1234], [2345]] (%i6) listarray (G2); (%o6) [1522756, 5499025]
f[x_1, ..., x_n](y_1, ..., y_m) := expr
is a special case of a memoizing function
.
(%i1) G3[n](x) := (print ("Evaluating G3 for n=", n), diff (sin(x)^2, x, n)); (%o1) G3 (x) := (print("Evaluating G3 for n=", n), n 2 diff(sin (x), x, n)) (%i2) G3[2]; Evaluating G3 for n= 2 2 2 (%o2) lambda([x], 2 cos (x) - 2 sin (x)) (%i3) G3[2]; 2 2 (%o3) lambda([x], 2 cos (x) - 2 sin (x)) (%i4) G3[2](1); 2 2 (%o4) 2 cos (1) - 2 sin (1) (%i5) arrayinfo (G3); (%o5) [hashed, 1, [2]] (%i6) listarray (G3); 2 2 (%o6) [lambda([x], 2 cos (x) - 2 sin (x))]
When the last or only function argument x_n is a list of one element,
the function defined by :=
accepts a variable number of arguments.
(%i1) H ([L]) := apply ("+", L); (%o1) H([L]) := apply("+", L) (%i2) H (a, b, c); (%o2) c + b + a
local
makes a local function definition.
(%i1) foo (x) := 1 - x; (%o1) foo(x) := 1 - x (%i2) foo (100); (%o2) - 99 (%i3) block (local (foo), foo (x) := 2 * x, foo (100)); (%o3) 200 (%i4) foo (100); (%o4) - 99
infix
(op) infix
(op, lbp, rbp) infix
(op, lbp, rbp, lpos, rpos, pos) ¶Declares op to be an infix operator. An infix operator is a function of
two arguments, with the name of the function written between the arguments.
For example, the subtraction operator -
is an infix operator.
infix (op)
declares op to be an infix operator with default
binding powers (left and right both equal to 180) and parts of speech (left and
right both equal to any
).
infix (op, lbp, rbp)
declares op to be an infix
operator with stated left and right binding powers and default parts of speech
(left and right both equal to any
).
infix (op, lbp, rbp, lpos, rpos, pos)
declares op to be an infix operator with stated left and right binding
powers and parts of speech lpos, rpos, and pos for the left
operand, the right operand, and the operator result, respectively.
"Part of speech", in reference to operator declarations, means expression type.
Three types are recognized: expr
, clause
, and any
,
indicating an algebraic expression, a Boolean expression, or any kind of
expression, respectively. Maxima can detect some syntax errors by comparing the
declared part of speech to an actual expression.
The precedence of op with respect to other operators derives from the left and right binding powers of the operators in question. If the left and right binding powers of op are both greater the left and right binding powers of some other operator, then op takes precedence over the other operator. If the binding powers are not both greater or less, some more complicated relation holds.
The associativity of op depends on its binding powers. Greater left binding power (lbp) implies an instance of op is evaluated before other operators to its left in an expression, while greater right binding power (rbp) implies an instance of op is evaluated before other operators to its right in an expression. Thus greater lbp makes op right-associative, while greater rbp makes op left-associative. If lbp is equal to rbp, op is left-associative.
See also Introduction to operators.
Examples:
If the left and right binding powers of op are both greater the left and right binding powers of some other operator, then op takes precedence over the other operator.
(%i1) :lisp (get '$+ 'lbp) 100 (%i1) :lisp (get '$+ 'rbp) 100 (%i1) infix ("##", 101, 101); (%o1) ## (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")"); (%o2) (a ## b) := sconcat("(", a, ",", b, ")") (%i3) 1 + a ## b + 2; (%o3) (a,b) + 3 (%i4) infix ("##", 99, 99); (%o4) ## (%i5) 1 + a ## b + 2; (%o5) (a+1,b+2)
Greater lbp makes op right-associative, while greater rbp makes op left-associative.
(%i1) infix ("##", 100, 99); (%o1) ## (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")")$ (%i3) foo ## bar ## baz; (%o3) (foo,(bar,baz)) (%i4) infix ("##", 100, 101); (%o4) ## (%i5) foo ## bar ## baz; (%o5) ((foo,bar),baz)
Maxima can detect some syntax errors by comparing the declared part of speech to an actual expression.
(%i1) infix ("##", 100, 99, expr, expr, expr); (%o1) ## (%i2) if x ## y then 1 else 0; Incorrect syntax: Found algebraic expression where logical expression expected if x ## y then ^ (%i2) infix ("##", 100, 99, expr, expr, clause); (%o2) ## (%i3) if x ## y then 1 else 0; (%o3) if x ## y then 1 else 0
matchfix
(ldelimiter, rdelimiter) matchfix
(ldelimiter, rdelimiter, arg_pos, pos) ¶Declares a matchfix operator with left and right delimiters ldelimiter and rdelimiter. The delimiters are specified as strings.
A "matchfix" operator is a function of any number of arguments,
such that the arguments occur between matching left and right delimiters.
The delimiters may be any strings, so long as the parser can
distinguish the delimiters from the operands
and other expressions and operators.
In practice this rules out unparseable delimiters such as
%
, ,
, $
and ;
,
and may require isolating the delimiters with white space.
The right delimiter can be the same or different from the left delimiter.
A left delimiter can be associated with only one right delimiter; two different matchfix operators cannot have the same left delimiter.
An existing operator may be redeclared as a matchfix operator
without changing its other properties.
In particular, built-in operators such as addition +
can
be declared matchfix,
but operator functions cannot be defined for built-in operators.
The command matchfix (ldelimiter, rdelimiter, arg_pos,
pos)
declares the argument part-of-speech arg_pos and result
part-of-speech pos, and the delimiters ldelimiter and
rdelimiter.
"Part of speech", in reference to operator declarations, means expression type.
Three types are recognized: expr
, clause
, and any
,
indicating an algebraic expression, a Boolean expression, or any kind of
expression, respectively.
Maxima can detect some syntax errors by comparing the
declared part of speech to an actual expression.
The function to carry out a matchfix operation is an ordinary
user-defined function.
The operator function is defined
in the usual way
with the function definition operator :=
or define
.
The arguments may be written between the delimiters,
or with the left delimiter as a quoted string and the arguments
following in parentheses.
dispfun (ldelimiter)
displays the function definition.
The only built-in matchfix operator is the list constructor [ ]
.
Parentheses ( )
and double-quotes " "
act like matchfix operators,
but are not treated as such by the Maxima parser.
matchfix
evaluates its arguments.
matchfix
returns its first argument, ldelimiter.
Examples:
Delimiters may be almost any strings.
(%i1) matchfix ("@@", "~"); (%o1) @@ (%i2) @@ a, b, c ~; (%o2) @@a, b, c~ (%i3) matchfix (">>", "<<"); (%o3) >> (%i4) >> a, b, c <<; (%o4) >>a, b, c<< (%i5) matchfix ("foo", "oof"); (%o5) foo (%i6) foo a, b, c oof; (%o6) fooa, b, coof (%i7) >> w + foo x, y oof + z << / @@ p, q ~; >>z + foox, yoof + w<< (%o7) ---------------------- @@p, q~
Matchfix operators are ordinary user-defined functions.
(%i1) matchfix ("!-", "-!"); (%o1) "!-" (%i2) !- x, y -! := x/y - y/x; x y (%o2) !-x, y-! := - - - y x (%i3) define (!-x, y-!, x/y - y/x); x y (%o3) !-x, y-! := - - - y x (%i4) define ("!-" (x, y), x/y - y/x); x y (%o4) !-x, y-! := - - - y x (%i5) dispfun ("!-"); x y (%t5) !-x, y-! := - - - y x (%o5) done (%i6) !-3, 5-!; 16 (%o6) - -- 15 (%i7) "!-" (3, 5); 16 (%o7) - -- 15
nary
(op) nary
(op, bp, arg_pos, pos) ¶An nary
operator is used to denote a function of any number of arguments,
each of which is separated by an occurrence of the operator, e.g. A+B or A+B+C.
The nary("x")
function is a syntax extension function to declare x
to be an nary
operator. Functions may be declared to be nary
. If
declare(j,nary);
is done, this tells the simplifier to simplify, e.g.
j(j(a,b),j(c,d))
to j(a, b, c, d)
.
See also Introduction to operators.
nofix
(op) nofix
(op, pos) ¶nofix
operators are used to denote functions of no arguments.
The mere presence of such an operator in a command will cause the
corresponding function to be evaluated. For example, when one types
"exit;" to exit from a Maxima break, "exit" is behaving similar to a
nofix
operator. The function nofix("x")
is a syntax extension
function which declares x
to be a nofix
operator.
See also Introduction to operators.
postfix
(op) postfix
(op, lbp, lpos, pos) ¶postfix
operators like the prefix
variety denote functions of a
single argument, but in this case the argument immediately precedes an
occurrence of the operator in the input string, e.g. 3!. The
postfix("x")
function is a syntax extension function to declare x
to be a postfix
operator.
See also Introduction to operators.
prefix
(op) prefix
(op, rbp, rpos, pos) ¶A prefix
operator is one which signifies a function of one argument,
which argument immediately follows an occurrence of the operator.
prefix("x")
is a syntax extension function to declare x
to be a
prefix
operator.
See also Introduction to operators.
The single quote operator '
prevents evaluation.
Applied to a symbol, the single quote prevents evaluation of the symbol.
Applied to a function call, the single quote prevents evaluation of the function call, although the arguments of the function are still evaluated (if evaluation is not otherwise prevented). The result is the noun form of the function call.
Applied to a parenthesized expression, the single quote prevents evaluation of
all symbols and function calls in the expression.
E.g., '(f(x))
means do not evaluate the expression f(x)
.
'f(x)
(with the single quote applied to f
instead of f(x)
)
means return the noun form of f
applied to [x]
.
The single quote does not prevent simplification.
When the global flag noundisp
is true
, nouns display with a single
quote. This switch is always true
when displaying function definitions.
See also the quote-quote operator ''
and nouns
.
Examples:
Applied to a symbol, the single quote prevents evaluation of the symbol.
(%i1) aa: 1024; (%o1) 1024 (%i2) aa^2; (%o2) 1048576 (%i3) 'aa^2; 2 (%o3) aa (%i4) ''%; (%o4) 1048576
Applied to a function call, the single quote prevents evaluation of the function call. The result is the noun form of the function call.
(%i1) x0: 5; (%o1) 5 (%i2) x1: 7; (%o2) 7 (%i3) integrate (x^2, x, x0, x1); 218 (%o3) --- 3 (%i4) 'integrate (x^2, x, x0, x1);
7 / [ 2 (%o4) I x dx ] / 5
(%i5) %, nouns; 218 (%o5) --- 3
Applied to a parenthesized expression, the single quote prevents evaluation of all symbols and function calls in the expression.
(%i1) aa: 1024; (%o1) 1024 (%i2) bb: 19; (%o2) 19 (%i3) sqrt(aa) + bb; (%o3) 51 (%i4) '(sqrt(aa) + bb); (%o4) bb + sqrt(aa) (%i5) ''%; (%o5) 51
The single quote does not prevent simplification.
(%i1) sin (17 * %pi) + cos (17 * %pi); (%o1) - 1 (%i2) '(sin (17 * %pi) + cos (17 * %pi)); (%o2) - 1
Maxima considers floating point operations by its in-built mathematical functions to be a simplification.
(%i1) sin(1.0); (%o1) .8414709848078965 (%i2) '(sin(1.0)); (%o2) .8414709848078965
When the global flag noundisp
is true
, nouns display with a single
quote.
(%i1) x:%pi; (%o1) %pi (%i2) bfloat(x); (%o2) 3.141592653589793b0 (%i3) sin(x); (%o3) 0 (%i4) noundisp; (%o4) false (%i5) 'bfloat(x); (%o5) bfloat(%pi) (%i6) bfloat('x); (%o6) x (%i7) 'sin(x); (%o7) 0 (%i8) sin('x); (%o8) sin(x) (%i9) noundisp : not noundisp; (%o9) true (%i10) 'bfloat(x); (%o10) 'bfloat(%pi) (%i11) bfloat('x); (%o11) x (%i12) 'sin(x); (%o12) 0 (%i13) sin('x); (%o13) sin(x) (%i14)
The quote-quote operator ''
(two single quote marks) modifies
evaluation in input expressions.
Applied to a general expression expr, quote-quote causes the value of expr to be substituted for expr in the input expression.
Applied to the operator of an expression, quote-quote changes the operator from a noun to a verb (if it is not already a verb).
The quote-quote operator is applied by the input parser; it is not stored as
part of a parsed input expression. The quote-quote operator is always applied
as soon as it is parsed, and cannot be quoted. Thus quote-quote causes
evaluation when evaluation is otherwise suppressed, such as in function
definitions, lambda expressions, and expressions quoted by single quote
'
.
Quote-quote is recognized by batch
and load
.
See also ev
, the single-quote operator '
and nouns
.
Examples:
Applied to a general expression expr, quote-quote causes the value of expr to be substituted for expr in the input expression.
(%i1) expand ((a + b)^3); 3 2 2 3 (%o1) b + 3 a b + 3 a b + a (%i2) [_, ''_]; 3 3 2 2 3 (%o2) [expand((b + a) ), b + 3 a b + 3 a b + a ] (%i3) [%i1, ''%i1]; 3 3 2 2 3 (%o3) [expand((b + a) ), b + 3 a b + 3 a b + a ] (%i4) [aa : cc, bb : dd, cc : 17, dd : 29]; (%o4) [cc, dd, 17, 29] (%i5) foo_1 (x) := aa - bb * x; (%o5) foo_1(x) := aa - bb x (%i6) foo_1 (10); (%o6) cc - 10 dd (%i7) ''%; (%o7) - 273 (%i8) ''(foo_1 (10)); (%o8) - 273 (%i9) foo_2 (x) := ''aa - ''bb * x; (%o9) foo_2(x) := cc - dd x (%i10) foo_2 (10); (%o10) - 273 (%i11) [x0 : x1, x1 : x2, x2 : x3]; (%o11) [x1, x2, x3] (%i12) x0; (%o12) x1 (%i13) ''x0; (%o13) x2 (%i14) '' ''x0; (%o14) x3
Applied to the operator of an expression, quote-quote changes the operator from a noun to a verb (if it is not already a verb).
(%i1) declare (foo, noun); (%o1) done (%i2) foo (x) := x - 1729; (%o2) ''foo(x) := x - 1729 (%i3) foo (100); (%o3) foo(100) (%i4) ''foo (100); (%o4) - 1629
The quote-quote operator is applied by the input parser; it is not stored as part of a parsed input expression.
(%i1) [aa : bb, cc : dd, bb : 1234, dd : 5678]; (%o1) [bb, dd, 1234, 5678] (%i2) aa + cc; (%o2) dd + bb (%i3) display (_, op (_), args (_)); _ = cc + aa op(cc + aa) = + args(cc + aa) = [cc, aa] (%o3) done (%i4) ''(aa + cc); (%o4) 6912 (%i5) display (_, op (_), args (_)); _ = dd + bb op(dd + bb) = + args(dd + bb) = [dd, bb] (%o5) done
Quote-quote causes evaluation when evaluation is otherwise suppressed, such as
in function definitions, lambda expressions, and expressions quoted by single
quote '
.
(%i1) foo_1a (x) := ''(integrate (log (x), x)); (%o1) foo_1a(x) := x log(x) - x (%i2) foo_1b (x) := integrate (log (x), x); (%o2) foo_1b(x) := integrate(log(x), x) (%i3) dispfun (foo_1a, foo_1b); (%t3) foo_1a(x) := x log(x) - x (%t4) foo_1b(x) := integrate(log(x), x) (%o4) [%t3, %t4] (%i5) integrate (log (x), x); (%o5) x log(x) - x (%i6) foo_2a (x) := ''%; (%o6) foo_2a(x) := x log(x) - x (%i7) foo_2b (x) := %; (%o7) foo_2b(x) := % (%i8) dispfun (foo_2a, foo_2b); (%t8) foo_2a(x) := x log(x) - x (%t9) foo_2b(x) := % (%o9) [%t7, %t8] (%i10) F : lambda ([u], diff (sin (u), u)); (%o10) lambda([u], diff(sin(u), u)) (%i11) G : lambda ([u], ''(diff (sin (u), u))); (%o11) lambda([u], cos(u)) (%i12) '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3)); (%o12) sum(b , k, 1, 3) + sum(a , k, 1, 3) k k (%i13) '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3))); (%o13) b + a + b + a + b + a 3 3 2 2 1 1
Evaluates the expression expr in the environment specified by the
arguments arg_1, …, arg_n. The arguments are switches
(Boolean flags), assignments, equations, and functions. ev
returns the
result (another expression) of the evaluation.
The evaluation is carried out in steps, as follows.
simp
causes expr to be simplified regardless of the setting of the
switch simp
which inhibits simplification if false
.
noeval
suppresses the evaluation phase of ev
(see step (4) below).
This is useful in conjunction with the other switches and in causing
expr to be resimplified without being reevaluated.
nouns
causes the evaluation of noun forms (typically unevaluated
functions such as 'integrate
or 'diff
) in expr.
expand
causes expansion.
expand (m, n)
causes expansion, setting the values of
maxposex
and maxnegex
to m and n respectively.
detout
causes any matrix inverses computed in expr to have their
determinant kept outside of the inverse rather than dividing through
each element.
diff
causes all differentiations indicated in expr to be performed.
derivlist (x, y, z, ...)
causes only differentiations
with respect to the indicated variables. See also derivlist
.
risch
causes integrals in expr to be evaluated using the Risch
algorithm. See risch
. The standard integration routine is invoked
when using the special symbol nouns
.
float
causes non-integral rational numbers to be converted to floating
point.
numer
causes some mathematical functions (including exponentiation)
with numerical arguments to be evaluated in floating point. It causes
variables in expr which have been given numervals to be replaced by
their values. It also sets the float
switch on.
pred
causes predicates (expressions which evaluate to true
or
false
) to be evaluated.
eval
causes an extra post-evaluation of expr to occur.
(See step (5) below.)
eval
may occur multiple times. For each instance of eval
, the
expression is evaluated again.
A
where A
is an atom declared to be an evaluation flag
evflag
causes A
to be bound to true
during the evaluation
of expr.
V: expression
(or alternately V=expression
) causes V
to be
bound to the value of expression
during the evaluation of expr.
Note that if V
is a Maxima option, then expression
is used for
its value during the evaluation of expr. If more than one argument to
ev
is of this type then the binding is done in parallel. If V
is
a non-atomic expression then a substitution rather than a binding is performed.
F
where F
, a function name, has been declared to be an evaluation
function evfun
causes F
to be applied to expr.
sum
, cause evaluation of occurrences
of those names in expr as though they were verbs.
F(x)
) may be defined
locally for the purpose of this evaluation of expr by giving
F(x) := expression
as an argument to ev
.
ev
. This permits a list of equations to be
given (e.g. [X=1, Y=A**2]
) or a list of names of equations (e.g.,
[%t1, %t2]
where %t1
and %t2
are equations) such as that
returned by solve
.
The arguments of ev
may be given in any order with the exception of
substitution equations which are handled in sequence, left to right, and
evaluation functions which are composed, e.g., ev (expr, ratsimp,
realpart)
is handled as realpart (ratsimp (expr))
.
The simp
, numer
, and float
switches may also be set
locally in a block, or globally in Maxima so that they will remain in effect
until being reset.
If expr is a canonical rational expression (CRE), then the expression
returned by ev
is also a CRE, provided the numer
and float
switches are not both true
.
memoizing functions
as well as non-subscripted variables) in the
expression expr are replaced by their global values, except for those
appearing in this list. Usually, expr is just a label or %
(as in
%i2
in the example below), so this step simply retrieves the expression
named by the label, so that ev
may work on it.
noeval
) and simplified according to the arguments. Note that any
function calls in expr will be carried out after the variables in it are
evaluated and that ev(F(x))
thus may behave like F(ev(x))
.
eval
in the arguments, steps (3) and (4) are
repeated.
Examples:
(%i1) sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w); d 2 (%o1) cos(y) + sin(x) + -- (sin(w)) + (w + 1) dw (%i2) ev (%, numer, expand, diff, x=2, y=1); 2 (%o2) cos(w) + w + 2 w + 2.449599732693821
An alternate top level syntax has been provided for ev
, whereby one
may just type in its arguments, without the ev()
. That is, one may
write simply
expr, arg_1, ..., arg_n
This is not permitted as part of another expression, e.g., in functions, blocks, etc.
Notice the parallel binding process in the following example.
(%i3) programmode: false; (%o3) false (%i4) x+y, x: a+y, y: 2; (%o4) y + a + 2 (%i5) 2*x - 3*y = 3$ (%i6) -3*x + 2*y = -4$ (%i7) solve ([%o5, %o6]); Solution 1 (%t7) y = - - 5 6 (%t8) x = - 5 (%o8) [[%t7, %t8]] (%i8) %o6, %o8; (%o8) - 4 = - 4 (%i9) x + 1/x > gamma (1/2); 1 (%o9) x + - > sqrt(%pi) x (%i10) %, numer, x=1/2; (%o10) 2.5 > 1.772453850905516 (%i11) %, pred; (%o11) true
As an argument in a call to ev (expr)
, eval
causes an extra
evaluation of expr. See ev
.
Example:
(%i1) [a:b,b:c,c:d,d:e]; (%o1) [b, c, d, e] (%i2) a; (%o2) b (%i3) ev(a); (%o3) c (%i4) ev(a),eval; (%o4) e (%i5) a,eval,eval; (%o5) e
When a symbol x has the evflag
property, the expressions
ev(expr, x)
and expr, x
(at the
interactive prompt) are equivalent to ev(expr, x = true)
.
That is, x is bound to true
while expr is evaluated.
The expression declare(x, evflag)
gives the evflag
property
to the variable x.
The flags which have the evflag
property by default are the following:
algebraic cauchysum demoivre dotscrules %emode %enumer exponentialize exptisolate factorflag float halfangles infeval isolate_wrt_times keepfloat letrat listarith logabs logarc logexpand lognegint m1pbranch numer_pbranch programmode radexpand ratalgdenom ratfac ratmx ratsimpexpons simp simpproduct simpsum sumexpand trigexpand
Examples:
(%i1) sin (1/2); 1 (%o1) sin(-) 2 (%i2) sin (1/2), float; (%o2) 0.479425538604203 (%i3) sin (1/2), float=true; (%o3) 0.479425538604203 (%i4) simp : false; (%o4) false (%i5) 1 + 1; (%o5) 1 + 1 (%i6) 1 + 1, simp; (%o6) 2 (%i7) simp : true; (%o7) true (%i8) sum (1/k^2, k, 1, inf); inf ==== \ 1 (%o8) > -- / 2 ==== k k = 1 (%i9) sum (1/k^2, k, 1, inf), simpsum; 2 %pi (%o9) ---- 6 (%i10) declare (aa, evflag); (%o10) done (%i11) if aa = true then YES else NO; (%o11) NO (%i12) if aa = true then YES else NO, aa; (%o12) YES
When a function F has the evfun
property, the expressions
ev(expr, F)
and expr, F
(at the
interactive prompt) are equivalent to F(ev(expr))
.
If two or more evfun
functions F, G, etc., are specified,
the functions are applied in the order that they are specified.
The expression declare(F, evfun)
gives the evfun
property
to the function F. The functions which have the evfun
property by
default are the following:
bfloat factor fullratsimp logcontract polarform radcan ratexpand ratsimp rectform rootscontract trigexpand trigreduce
Examples:
(%i1) x^3 - 1; 3 (%o1) x - 1 (%i2) x^3 - 1, factor; 2 (%o2) (x - 1) (x + x + 1) (%i3) factor (x^3 - 1); 2 (%o3) (x - 1) (x + x + 1) (%i4) cos(4 * x) / sin(x)^4;
cos(4 x) (%o4) -------- 4 sin (x)
(%i5) cos(4 * x) / sin(x)^4, trigexpand; 4 2 2 4 sin (x) - 6 cos (x) sin (x) + cos (x) (%o5) ------------------------------------- 4 sin (x) (%i6) cos(4 * x) / sin(x)^4, trigexpand, ratexpand; 2 4 6 cos (x) cos (x) (%o6) - --------- + ------- + 1 2 4 sin (x) sin (x) (%i7) ratexpand (trigexpand (cos(4 * x) / sin(x)^4)); 2 4 6 cos (x) cos (x) (%o7) - --------- + ------- + 1 2 4 sin (x) sin (x) (%i8) declare ([F, G], evfun); (%o8) done (%i9) (aa : bb, bb : cc, cc : dd); (%o9) dd (%i10) aa; (%o10) bb (%i11) aa, F; (%o11) F(cc) (%i12) F (aa); (%o12) F(bb) (%i13) F (ev (aa)); (%o13) F(cc) (%i14) aa, F, G; (%o14) G(F(cc)) (%i15) G (F (ev (aa))); (%o15) G(F(cc))
Enables "infinite evaluation" mode. ev
repeatedly evaluates an
expression until it stops changing. To prevent a variable, say X
, from
being evaluated away in this mode, simply include X='X
as an argument to
ev
. Of course expressions such as ev (X, X=X+1, infeval)
will
generate an infinite loop.
noeval
suppresses the evaluation phase of ev
. This is useful in
conjunction with other switches and in causing expressions
to be resimplified without being reevaluated.
nouns
is an evflag
. When used as an option to the ev
command, nouns
converts all "noun" forms occurring in the expression
being ev
’d to "verbs", i.e., evaluates them. See also
noun
, nounify
, verb
, and verbify
.
As an argument in a call to ev (expr)
, pred
causes
predicates (expressions which evaluate to true
or false
) to be
evaluated. See ev
.
Example:
(%i1) 1<2; (%o1) 1 < 2 (%i2) 1<2,pred; (%o2) true
Maxima interacts with the user through a cycle of actions called the read-eval-print loop (REPL). This consists of three steps: reading and parsing, evaluating and simplifying, and outputting. Parsing converts a syntactically valid sequence of typed characters into a internal data structure. Evaluation replaces variable and function names with their values and simplification rewrites expressions to be easier for the user or other programs to understand. Output displays results in a variety of different formats and notations.
Evaluation and simplification sometimes appear to have similar functionality, and
Maxima uses simplification in many cases where other systems use evaluation.
For example, arithmetic both on numbers and on symbolic expressions is simplification, not evaluation:
2+2
simplifies to 4
, 2+x+x
simplifies to 2+2*x
, and
sqrt(7)^4
simplifies to 49
.
Evaluation and simplification are interleaved.
For example, factor(integrate(x+1,x))
first calls the built-in function integrate
,
giving x+x*x*2^-1
;
that simplifies to x+(1/2)*x^2
; this in turn is passed to the factor
function,
which returns (x*(x+2))/2
.
Evaluation is what makes Maxima a programming language: it implements functions, subroutines, variables, values, loops, assignments and so on. Evaluation replaces built-in or user-defined function names by their definitions and variables by their values. This is largely the same as activities of a conventional programming language, but extended to work with symbolic mathematical data. The system has various optional "flags" which the user can set to control the details of evaluation. See Functions and Variables for Evaluation.
Simplification maintains the value of an expression
while re-formulating its form to be smaller, simpler to understand, or to
conform to a particular specification (like expanded). For
example, sin(%pi/2)
to 1
, and x+x
to 2*x
.
There are many flags which control simplification. For example,
with triginverses:true
, atan(tan(x))
does not simplify to x
,
but with triginverses:all
, it does.
Simplification can be provided in three ways:
simplifying
subsystem.
The internal simplifier belongs to the heart of Maxima. It is a large and complicated collection of programs, and it has been refined over many years and by thousands of users. Nevertheless, especially if you are trying out novel ideas or unconventional notation, you may find it helpful to make small (or large) changes to the program yourself. For details see for example the paper at the end of https://people.eecs.berkeley.edu/~fateman/papers/intro5.txt.
Maxima internally represents expressions as "trees" with operators or "roots"
like +
, *
, =
and operands ("leaves") which are variables like
x, y, z, functions
or sub-trees, like x*y
. Each operator has a simplification program
associated with it. +
(which also covers binary -
since
a-b = a+(-1)*b)
and *
(which also covers /
since a/b = a*b^(-1)
) have rather elaborate simplification programs. These
simplification programs (simplus, simptimes, simpexpt, etc.) are called whenever
the simplifier encounters the respective arithmetic operators in an expression
tree to be analyzed.
The structure of the simplifier dates back to 1965, and many hands have worked on it through the years. It is data-directed, or object-oriented in the sense that it dispatches to the appropriate routine depending on the root of some sub-tree of the expression, recursively. This general approach means that modifications to simplification are generally localized. In many cases it is straightforward to add an operator and its simplification routine without disturbing existing code.
Maxima also provides a variety of transformation routines that can change the form of an
expression, including factor
(polynomial factorization), horner
(reorganize a polynomial using Horner’s rule), partfrac
(rewrite a rational function as partial fractions),
trigexpand
(apply the sum formulas for trigonometric functions),
and so on.
Users can also write routines that change the form of an expression.
Besides this general simplifier operating on algebraic
expression trees, there are several other representations of expressions in
Maxima which have separate methods. For example, the
rat
function converts polynomials to vectors of coefficients to
assist in rapid manipulation of such forms. Other representations include
Taylor series and the (rarely used) Poisson series.
All operators introduced by the user initially have no simplification
programs associated with them. Maxima does not know anything about
function "f" and so typing f(a,b)
will result in simplifying
a,b, but not f
.
Even some built-in operators have no simplifications. For example,
=
does not "simplify" – it is a place-holder with no
simplification semantics other
than to simplify its two arguments, in this case referred to as the left and
right sides. Other parts of Maxima such as the solve program take special
note of equations, that is, trees with =
as the root.
(Note – in Maxima, the assignment operation is :
. That is, q: 4
sets the value of the symbol q to 4
.
Function definition is done with :=
. )
The general simplifier returns results with an internal flag indicating the expression and each sub-expression has been simplified. This does not guarantee that it is unique over all possible equivalent expressions. That’s too hard (theoretically, not possible given the generality of what can be expressed in Maxima). However, some aspects of the expression, such as the ordering of terms in a sum or product, are made uniform. This is important for the other programs to work properly.
A number of option variables control simplification. Indeed, simplification
can be turned off entirely using simp:false
. However, many
internal routines will not operate correctly with simp:false
.
(About the only time it seems plausible to turn off the simplifier
is in the rare case that you want to over-ride a built-in simplification.
In that case you might temporarily disable the simplifier, put in the new
transformation via tellsimp
, and then re-enable the simplifier
by simp:true
.)
It is more plausible for you to associate user-defined symbolic function names
or operators with properties (additive
,
lassociative
, oddfun
, antisymmetric
,
linear
, outative
, commutative
,
multiplicative
, rassociative
, evenfun
,
nary
and symmetric
). These options steer
the simplifier processing in systematic directions.
For example, declare(f,oddfun)
specifies that f
is an odd function.
Maxima will simplify f(-x)
to -f(x)
. In the case of an even
function, that is declare(g,evenfun)
,
Maxima will simplify g(-x)
to g(x)
. You can also associate a
programming function with a name such as h(x):=x^2+1
. In that case the
evaluator will immediately replace
h(3)
by 10
, and h(a+1)
by (a+1)^2+1
, so any properties
of h
will be ignored.
In addition to these directly related properties set up by the user, facts and properties from the actual context may have an impact on the simplifier’s behavior, too. See Introduction to Maxima’s Database.
Example: sin(n*%pi)
is simplified to zero, if n is an integer.
(%i1) sin(n*%pi); (%o1) sin(%pi n)
(%i2) declare(n, integer); (%o2) done
(%i3) sin(n*%pi); (%o3) 0
If automated simplification is not sufficient, you can consider a variety of
built-in, but explicitly called simplfication functions (ratsimp
,
expand
, factor
, radcan
and others). There are
also flags that will push simplification into one or another direction.
Given demoivre:true
the simplifier rewrites
complex exponentials as trigonometric forms. Given exponentialize:true
the simplifier tries to do the reverse: rewrite trigonometric forms as complex
exponentials.
As everywhere in Maxima, by writing your own functions (be it in the Maxima user language or in the implementation language Lisp) and explicitly calling them at selected places in the program, you can respond to your individual simplification needs. Lisp gives you a handle on all the internal mechanisms, but you rarely need this full generality. "Tellsimp" is designed to generate much of the Lisp internal interface into the simplifier automatically. See See Rules and Patterns.
Over the years (Maxima/Macsyma’s origins date back to about 1966!) users have contributed numerous application packages and tools to extend or alter its functional behavior. Various non-standard and "share" packages exist to modify or extend simplification as well. You are invited to look into this more experimental material where work is still in progress See simplification.
The following appended material is optional on a first reading, and reading it
is not necessary for productive use of Maxima. It is for the curious user who
wants to understand what is going on, or the ambitious programmer who might
wish to change the (open-source) code. Experimentation with redefining Maxima
Lisp code is easily possible: to change the definition of a Lisp program (say
the one that simplifies cos()
, named simp%cos
), you simply
load into Maxima a text file that will overwrite the simp%cos
function
from the maxima package.
If declare(f,additive)
has been executed, then:
(1) If f
is univariate, whenever the simplifier encounters f
applied to a sum, f
will be distributed over that sum. I.e.
f(y+x)
will simplify to f(y)+f(x)
.
(2) If f
is a function of 2 or more arguments, additivity is defined as
additivity in the first argument to f
, as in the case of sum
or
integrate
, i.e. f(h(x)+g(x),x)
will simplify to
f(h(x),x)+f(g(x),x)
. This simplification does not occur when f
is
applied to expressions of the form sum(x[i],i,lower-limit,upper-limit)
.
Example:
(%i1) F3 (a + b + c); (%o1) F3(c + b + a)
(%i2) declare (F3, additive); (%o2) done
(%i3) F3 (a + b + c); (%o3) F3(c) + F3(b) + F3(a)
If declare(h,antisymmetric)
is done, this tells the simplifier that
h
is antisymmetric. E.g. h(x,z,y)
will simplify to
- h(x, y, z)
. That is, it will give (-1)^n times the result given by
symmetric
or commutative
, where n is the number of interchanges
of two arguments necessary to convert it to that form.
Examples:
(%i1) S (b, a); (%o1) S(b, a)
(%i2) declare (S, symmetric); (%o2) done
(%i3) S (b, a); (%o3) S(a, b)
(%i4) S (a, c, e, d, b); (%o4) S(a, b, c, d, e)
(%i5) T (b, a); (%o5) T(b, a)
(%i6) declare (T, antisymmetric); (%o6) done
(%i7) T (b, a); (%o7) - T(a, b)
(%i8) T (a, c, e, d, b); (%o8) T(a, b, c, d, e)
Simplifies the sum expr by combining terms with the same denominator into a single term.
See also: rncombine
.
Example:
(%i1) 1*f/2*b + 2*c/3*a + 3*f/4*b +c/5*b*a; 5 b f a b c 2 a c (%o1) ----- + ----- + ----- 4 5 3
(%i2) combine (%); 75 b f + 4 (3 a b c + 10 a c) (%o2) ----------------------------- 60
If declare(h, commutative)
is done, this tells the simplifier that
h
is a commutative function. E.g. h(x, z, y)
will simplify to
h(x, y, z)
. This is the same as symmetric
.
Example:
(%i1) S (b, a); (%o1) S(b, a)
(%i2) S (a, b) + S (b, a); (%o2) S(b, a) + S(a, b)
(%i3) declare (S, commutative); (%o3) done
(%i4) S (b, a); (%o4) S(a, b)
(%i5) S (a, b) + S (b, a); (%o5) 2 S(a, b)
(%i6) S (a, c, e, d, b); (%o6) S(a, b, c, d, e)
The function demoivre (expr)
converts one expression
without setting the global variable demoivre
.
When the variable demoivre
is true
, complex exponentials are
converted into equivalent expressions in terms of circular functions:
exp (a + b*%i)
simplifies to %e^a * (cos(b) + %i*sin(b))
if b
is free of %i
. a
and b
are not expanded.
The default value of demoivre
is false
.
exponentialize
converts circular and hyperbolic functions to exponential
form. demoivre
and exponentialize
cannot both be true at the same
time.
Distributes sums over products. It differs from expand
in that it works
at only the top level of an expression, i.e., it doesn’t recurse and it is
faster than expand
. It differs from multthru
in that it expands
all sums at that level.
Examples:
(%i1) distrib ((a+b) * (c+d)); (%o1) b d + a d + b c + a c (%i2) multthru ((a+b) * (c+d)); (%o2) (b + a) d + (b + a) c (%i3) distrib (1/((a+b) * (c+d))); 1 (%o3) --------------- (b + a) (d + c) (%i4) expand (1/((a+b) * (c+d)), 1, 0); 1 (%o4) --------------------- b d + a d + b c + a c
Default value: true
distribute_over
controls the mapping of functions over bags like lists,
matrices, and equations. At this time not all Maxima functions have this
property. It is possible to look up this property with the command
properties
.
The mapping of functions is switched off, when setting distribute_over
to the value false
.
Examples:
The sin
function maps over a list:
(%i1) sin([x,1,1.0]); (%o1) [sin(x), sin(1), 0.8414709848078965]
mod
is a function with two arguments which maps over lists. Mapping over
nested lists is possible too:
(%i1) mod([x,11,2*a],10); (%o1) [mod(x, 10), 1, 2 mod(a, 5)]
(%i2) mod([[x,y,z],11,2*a],10); (%o2) [[mod(x, 10), mod(y, 10), mod(z, 10)], 1, 2 mod(a, 5)]
Mapping of the floor
function over a matrix and an equation:
(%i1) floor(matrix([a,b],[c,d])); [ floor(a) floor(b) ] (%o1) [ ] [ floor(c) floor(d) ]
(%i2) floor(a=b); (%o2) floor(a) = floor(b)
Functions with more than one argument map over any of the arguments or all arguments:
(%i1) expintegral_e([1,2],[x,y]); (%o1) [[expintegral_e(1, x), expintegral_e(1, y)], [expintegral_e(2, x), expintegral_e(2, y)]]
Check if a function has the property distribute_over:
(%i1) properties(abs); (%o1) [integral, rule, distributes over bags, noun, gradef, system function]
The mapping of functions is switched off, when setting distribute_over
to the value false
.
(%i1) distribute_over; (%o1) true
(%i2) sin([x,1,1.0]); (%o2) [sin(x), sin(1), 0.8414709848078965]
(%i3) distribute_over : not distribute_over; (%o3) false
(%i4) sin([x,1,1.0]); (%o4) sin([x, 1, 1.0])
Default value: real
When domain
is set to complex
, sqrt (x^2)
will remain
sqrt (x^2)
instead of returning abs(x)
.
declare(f, evenfun)
or declare(f, oddfun)
tells Maxima to recognize
the function f
as an even or odd function.
Examples:
(%i1) o (- x) + o (x); (%o1) o(x) + o(- x) (%i2) declare (o, oddfun); (%o2) done (%i3) o (- x) + o (x); (%o3) 0 (%i4) e (- x) - e (x); (%o4) e(- x) - e(x) (%i5) declare (e, evenfun); (%o5) done (%i6) e (- x) - e (x); (%o6) 0
expand
(expr) expand
(expr, p, n) ¶Expand expression expr. Products of sums and exponentiated sums are multiplied out, numerators of rational expressions which are sums are split into their respective terms, and multiplication (commutative and non-commutative) are distributed over addition at all levels of expr.
For polynomials one should usually use ratexpand
which uses a
more efficient algorithm.
maxnegex
and maxposex
control the maximum negative and
positive exponents, respectively, which will expand.
expand (expr, p, n)
expands expr,
using p for maxposex
and n for maxnegex
.
This is useful in order to expand part but not all of an expression.
expon
- the exponent of the largest negative power which is
automatically expanded (independent of calls to expand
). For example
if expon
is 4 then (x+1)^(-5)
will not be automatically expanded.
expop
- the highest positive exponent which is automatically expanded.
Thus (x+1)^3
, when typed, will be automatically expanded only if
expop
is greater than or equal to 3. If it is desired to have
(x+1)^n
expanded where n
is greater than expop
then
executing expand ((x+1)^n)
will work only if maxposex
is not
less than n
.
expand(expr, 0, 0)
causes a resimplification of expr
. expr
is not reevaluated. In distinction from ev(expr, noeval)
a special
representation (e. g. a CRE form) is removed. See also ev
.
The expand
flag used with ev
causes expansion.
The file share/simplification/facexp.mac
contains several related functions (in particular facsum
,
factorfacsum
and collectterms
, which are autoloaded) and variables
(nextlayerfactor
and facsum_combine
) that provide the user with
the ability to structure expressions by controlled expansion.
Brief function descriptions are available in simplification/facexp.usg.
A demo is available by doing demo("facexp")
.
Examples:
(%i1) expr:(x+1)^2*(y+1)^3; 2 3 (%o1) (x + 1) (y + 1)
(%i2) expand(expr); 2 3 3 3 2 2 2 2 2 (%o2) x y + 2 x y + y + 3 x y + 6 x y + 3 y + 3 x y 2 + 6 x y + 3 y + x + 2 x + 1
(%i3) expand(expr,2); 2 3 3 3 (%o3) x (y + 1) + 2 x (y + 1) + (y + 1)
(%i4) expr:(x+1)^-2*(y+1)^3; 3 (y + 1) (%o4) -------- 2 (x + 1)
(%i5) expand(expr); 3 2 y 3 y 3 y 1 (%o5) ------------ + ------------ + ------------ + ------------ 2 2 2 2 x + 2 x + 1 x + 2 x + 1 x + 2 x + 1 x + 2 x + 1
(%i6) expand(expr,2,2); 3 (y + 1) (%o6) ------------ 2 x + 2 x + 1
Resimplify an expression without expansion:
(%i1) expr:(1+x)^2*sin(x); 2 (%o1) (x + 1) sin(x)
(%i2) exponentialize:true; (%o2) true
(%i3) expand(expr,0,0); 2 %i x - %i x %i (x + 1) (%e - %e ) (%o3) - ------------------------------- 2
Expands expression expr
with respect to the
variables x_1, …, x_n.
All products involving the variables appear explicitly. The form returned
will be free of products of sums of expressions that are not free of
the variables. x_1, …, x_n
may be variables, operators, or expressions.
By default, denominators are not expanded, but this can be controlled by
means of the switch expandwrt_denom
.
This function is autoloaded from simplification/stopex.mac.
Default value: false
expandwrt_denom
controls the treatment of rational
expressions by expandwrt
. If true
, then both the numerator and
denominator of the expression will be expanded according to the
arguments of expandwrt
, but if expandwrt_denom
is false
,
then only the numerator will be expanded in that way.
is similar to expandwrt
, but treats expressions that are products
somewhat differently. expandwrt_factored
expands only on those factors
of expr
that contain the variables x_1, …, x_n.
This function is autoloaded from simplification/stopex.mac.
Default value: 0
expon
is the exponent of the largest negative power which
is automatically expanded (independent of calls to expand
). For
example, if expon
is 4 then (x+1)^(-5)
will not be automatically
expanded.
The function exponentialize (expr)
converts
circular and hyperbolic functions in expr to exponentials,
without setting the global variable exponentialize
.
When the variable exponentialize
is true
,
all circular and hyperbolic functions are converted to exponential form.
The default value is false
.
demoivre
converts complex exponentials into circular functions.
exponentialize
and demoivre
cannot
both be true at the same time.
Default value: 0
expop
is the highest positive exponent which is automatically expanded.
Thus (x + 1)^3
, when typed, will be automatically expanded only if
expop
is greater than or equal to 3. If it is desired to have
(x + 1)^n
expanded where n
is greater than expop
then
executing expand ((x + 1)^n)
will work only if maxposex
is not
less than n.
declare (g, lassociative)
tells the Maxima simplifier that g
is
left-associative. E.g., g (g (a, b), g (c, d))
will simplify to
g (g (g (a, b), c), d)
.
One of Maxima’s operator properties. For univariate f
so
declared, "expansion" f(x + y)
yields f(x) + f(y)
,
f(a*x)
yields a*f(x)
takes
place where a
is a "constant". For functions of two or more arguments,
"linearity" is defined to be as in the case of sum
or integrate
,
i.e., f (a*x + b, x)
yields a*f(x,x) + b*f(1,x)
for a
and b
free of x
.
Example:
(%i1) declare (f, linear); (%o1) done
(%i2) f(x+y); (%o2) f(y) + f(x)
(%i3) declare (a, constant); (%o3) done
(%i4) f(a*x); (%o4) a f(x)
linear
is equivalent to additive
and outative
.
See also opproperties
.
Example:
(%i1) 'sum (F(k) + G(k), k, 1, inf); inf ==== \ (%o1) > (G(k) + F(k)) / ==== k = 1
(%i2) declare (nounify (sum), linear); (%o2) done
(%i3) 'sum (F(k) + G(k), k, 1, inf); inf inf ==== ==== \ \ (%o3) > G(k) + > F(k) / / ==== ==== k = 1 k = 1
Default value: 1000
maxnegex
is the largest negative exponent which will
be expanded by the expand
command, see also maxposex
.
Default value: 1000
maxposex
is the largest exponent which will be
expanded with the expand
command, see also maxnegex
.
declare(f, multiplicative)
tells the Maxima simplifier that f
is multiplicative.
f
is univariate, whenever the simplifier encounters f
applied
to a product, f
distributes over that product. E.g., f(x*y)
simplifies to f(x)*f(y)
.
This simplification is not applied to expressions of the form f('product(...))
.
f
is a function of 2 or more arguments, multiplicativity is
defined as multiplicativity in the first argument to f
, e.g.,
f (g(x) * h(x), x)
simplifies to f (g(x) ,x) * f (h(x), x)
.
declare(nounify(product), multiplicative)
tells Maxima to simplify symbolic products.
Example:
(%i1) F2 (a * b * c); (%o1) F2(a b c)
(%i2) declare (F2, multiplicative); (%o2) done
(%i3) F2 (a * b * c); (%o3) F2(a) F2(b) F2(c)
declare(nounify(product), multiplicative)
tells Maxima to simplify symbolic products.
(%i1) product (a[i] * b[i], i, 1, n); n /===\ ! ! (%o1) ! ! a b ! ! i i i = 1
(%i2) declare (nounify (product), multiplicative); (%o2) done
(%i3) product (a[i] * b[i], i, 1, n); n n /===\ /===\ ! ! ! ! (%o3) ( ! ! a ) ! ! b ! ! i ! ! i i = 1 i = 1
multthru
(expr) multthru
(expr_1, expr_2) ¶Multiplies a factor (which should be a sum) of expr by the other factors
of expr. That is, expr is f_1 f_2 ... f_n
where at least one factor, say f_i, is a sum of terms. Each term in that
sum is multiplied by the other factors in the product. (Namely all the factors
except f_i). multthru
does not expand exponentiated sums.
This function is the fastest way to distribute products (commutative or
noncommutative) over sums. Since quotients are represented as products
multthru
can be used to divide sums by products as well.
multthru (expr_1, expr_2)
multiplies each term in
expr_2 (which should be a sum or an equation) by expr_1. If
expr_1 is not itself a sum then this form is equivalent to
multthru (expr_1*expr_2)
.
(%i1) x/(x-y)^2 - 1/(x-y) - f(x)/(x-y)^3; 1 x f(x) (%o1) - ----- + -------- - -------- x - y 2 3 (x - y) (x - y) (%i2) multthru ((x-y)^3, %); 2 (%o2) - (x - y) + x (x - y) - f(x) (%i3) ratexpand (%); 2 (%o3) - y + x y - f(x) (%i4) ((a+b)^10*s^2 + 2*a*b*s + (a*b)^2)/(a*b*s^2); 10 2 2 2 (b + a) s + 2 a b s + a b (%o4) ------------------------------ 2 a b s (%i5) multthru (%); /* note that this does not expand (b+a)^10 */ 10 2 a b (b + a) (%o5) - + --- + --------- s 2 a b s (%i6) multthru (a.(b+c.(d+e)+f)); (%o6) a . f + a . c . (e + d) + a . b (%i7) expand (a.(b+c.(d+e)+f)); (%o7) a . f + a . c . e + a . c . d + a . b
declare(f, nary)
tells Maxima to recognize the function f
as an
n-ary function.
The nary
declaration is not the same as calling the
nary
function. The sole effect of
declare(f, nary)
is to instruct the Maxima simplifier to flatten nested
expressions, for example, to simplify foo(x, foo(y, z))
to
foo(x, y, z)
. See also declare
.
Example:
(%i1) H (H (a, b), H (c, H (d, e))); (%o1) H(H(a, b), H(c, H(d, e))) (%i2) declare (H, nary); (%o2) done (%i3) H (H (a, b), H (c, H (d, e))); (%o3) H(a, b, c, d, e)
Default value: true
When negdistrib
is true
, -1 distributes over an expression.
E.g., -(x + y)
becomes - y - x
. Setting it to false
will allow - (x + y)
to be displayed like that. This is sometimes useful
but be very careful: like the simp
flag, this is one flag you do not
want to set to false
as a matter of course or necessarily for other
than local use in your Maxima.
Example:
(%i1) negdistrib; (%o1) true
(%i2) -(x+y); (%o2) (- y) - x
(%i3) negdistrib : not negdistrib ; (%o3) false
(%i4) -(x+y); (%o4) - (y + x)
opproperties
is the list of the special operator properties recognized
by the Maxima simplifier.
Items are added to the opproperties
list by the function define_opproperty
.
Example:
(%i1) opproperties; (%o1) [linear, additive, multiplicative, outative, evenfun, oddfun, commutative, symmetric, antisymmetric, nary, lassociative, rassociative]
Declares the symbol property_name to be an operator property,
which is simplified by simplifier_fn,
which may be the name of a Maxima or Lisp function or a lambda expression.
After define_opproperty
is called,
functions and operators may be declared to have the property_name property,
and simplifier_fn is called to simplify them.
simplifier_fn must be a function of one argument, which is an expression in which the main operator is declared to have the property_name property.
simplifier_fn is called with the global flag simp
disabled.
Therefore simplifier_fn must be able to carry out its simplification
without making use of the general simplifier.
define_opproperty
appends property_name to the
global list opproperties
.
define_opproperty
returns done
.
Example:
Declare a new property, identity
, which is simplified by simplify_identity
.
Declare that f
and g
have the new property.
(%i1) define_opproperty (identity, simplify_identity); (%o1) done
(%i2) simplify_identity(e) := first(e); (%o2) simplify_identity(e) := first(e)
(%i3) declare ([f, g], identity); (%o3) done
(%i4) f(10 + t); (%o4) t + 10
(%i5) g(3*u) - f(2*u); (%o5) u
declare(f, outative)
tells the Maxima simplifier that constant factors
in the argument of f
can be pulled out.
f
is univariate, whenever the simplifier encounters f
applied
to a product, that product will be partitioned into factors that are constant
and factors that are not and the constant factors will be pulled out. E.g.,
f(a*x)
will simplify to a*f(x)
where a
is a constant.
Non-atomic constant factors will not be pulled out.
f
is a function of 2 or more arguments, outativity is defined as in
the case of sum
or integrate
, i.e., f (a*g(x), x)
will
simplify to a * f(g(x), x)
for a
free of x
.
sum
, integrate
, and limit
are all outative
.
Example:
(%i1) F1 (100 * x); (%o1) F1(100 x)
(%i2) declare (F1, outative); (%o2) done
(%i3) F1 (100 * x); (%o3) 100 F1(x)
(%i4) declare (zz, constant); (%o4) done
(%i5) F1 (zz * y); (%o5) zz F1(y)
Simplifies expr, which can contain logs, exponentials, and radicals, by
converting it into a form which is canonical over a large class of expressions
and a given ordering of variables; that is, all functionally equivalent forms
are mapped into a unique form. For a somewhat larger class of expressions,
radcan
produces a regular form. Two equivalent expressions in this class
do not necessarily have the same appearance, but their difference can be
simplified by radcan
to zero.
For some expressions radcan
is quite time consuming. This is the cost
of exploring certain relationships among the components of the expression for
simplifications based on factoring and partial-fraction expansions of exponents.
Examples:
(%i1) radcan((log(x+x^2)-log(x))^a/log(1+x)^(a/2)); a/2 (%o1) log(x + 1)
(%i2) radcan((log(1+2*a^x+a^(2*x))/log(1+a^x))); (%o2) 2
(%i3) radcan((%e^x-1)/(1+%e^(x/2))); x/2 (%o3) %e - 1
Default value: true
radexpand
controls some simplifications of radicals.
When radexpand
is all
, causes nth roots of factors of a product
which are powers of n to be pulled outside of the radical. E.g. if
radexpand
is all
, sqrt (16*x^2)
simplifies to 4*x
.
More particularly, consider sqrt (x^2)
.
radexpand
is all
or assume (x > 0)
has been executed,
sqrt(x^2)
simplifies to x
.
radexpand
is true
and domain
is real
(its default), sqrt(x^2)
simplifies to abs(x)
.
radexpand
is false
, or radexpand
is true
and
domain
is complex
, sqrt(x^2)
is not simplified.
Note that domain
only matters when radexpand
is true
.
declare (g, rassociative)
tells the Maxima
simplifier that g
is right-associative. E.g.,
g(g(a, b), g(c, d))
simplifies to g(a, g(b, g(c, d)))
.
Sequential Comparative Simplification (method due to Stoute).
scsimp
attempts to simplify expr
according to the rules rule_1, …, rule_n.
If a smaller expression is obtained, the process repeats. Otherwise after all
simplifications are tried, it returns the original answer.
example (scsimp)
displays some examples.
Default value: true
simp
enables simplification. This is the default. simp
is also
an evflag
, which is recognized by the function ev
. See ev
.
When simp
is used as an evflag
with a value false
, the
simplification is suppressed only during the evaluation phase of an expression.
The flag does not suppress the simplification which follows the evaluation
phase.
Many Maxima functions and operations require simplification to be enabled to work normally. When simplification is disabled, many results will be incomplete, and in addition there may be incorrect results or program errors.
Examples:
The simplification is switched off globally. The expression sin(1.0)
is
not simplified to its numerical value. The simp
-flag switches the
simplification on.
(%i1) simp:false; (%o1) false
(%i2) sin(1.0); (%o2) sin(1.0)
(%i3) sin(1.0),simp; (%o3) 0.8414709848078965
The simplification is switched on again. The simp
-flag cannot suppress
the simplification completely. The output shows a simplified expression, but
the variable x
has an unsimplified expression as a value, because the
assignment has occurred during the evaluation phase of the expression.
(%i1) simp:true; (%o1) true
(%i2) x:sin(1.0),simp:false; (%o2) 0.8414709848078965
(%i3) :lisp $x ((%SIN) 1.0)
declare (h, symmetric)
tells the Maxima
simplifier that h
is a symmetric function. E.g., h (x, z, y)
simplifies to h (x, y, z)
.
commutative
is synonymous with symmetric
.
Combines all terms of expr (which should be a sum) over a common
denominator without expanding products and exponentiated sums as ratsimp
does. xthru
cancels common factors in the numerator and denominator of
rational expressions but only if the factors are explicit.
Sometimes it is better to use xthru
before ratsimp
ing an
expression in order to cause explicit factors of the gcd of the numerator and
denominator to be canceled thus simplifying the expression to be
ratsimp
ed.
Examples:
(%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20; 20 1 (x + 2) - 2 y x (%o1) --------- + --------------- - --------- 19 20 20 (y + x) (y + x) (y + x)
(%i2) xthru (%); 20 (x + 2) - y (%o2) ------------- 20 (y + x)
The abs
function represents the mathematical absolute value function and
works for both numerical and symbolic values. If the argument, z, is a
real or complex number, abs
returns the absolute value of z. If
possible, symbolic expressions using the absolute value function are
also simplified.
Maxima can differentiate, integrate and calculate limits for expressions
containing abs
. The abs_integrate
package further extends
Maxima’s ability to calculate integrals involving the abs function. See
(%i12) in the examples below.
When applied to a list or matrix, abs
automatically distributes over
the terms. Similarly, it distributes over both sides of an
equation. To alter this behaviour, see the variable distribute_over
.
See also cabs
.
Examples:
Calculation of abs
for real and complex numbers, including numerical
constants and various infinities. The first example shows how abs
distributes over the elements of a list.
(%i1) abs([-4, 0, 1, 1+%i]); (%o1) [4, 0, 1, sqrt(2)] (%i2) abs((1+%i)*(1-%i)); (%o2) 2 (%i3) abs(%e+%i); 2 (%o3) sqrt(%e + 1) (%i4) abs([inf, infinity, minf]); (%o4) [inf, inf, inf]
Simplification of expressions containing abs
:
(%i5) abs(x^2); 2 (%o5) x (%i6) abs(x^3); 2 (%o6) x abs(x) (%i7) abs(abs(x)); (%o7) abs(x) (%i8) abs(conjugate(x)); (%o8) abs(x)
Integrating and differentiating with the abs
function. Note that more
integrals involving the abs
function can be performed, if the
abs_integrate
package is loaded. The last example shows the Laplace
transform of abs
: see laplace
.
(%i9) diff(x*abs(x),x),expand; (%o9) 2 abs(x) (%i10) integrate(abs(x),x); x abs(x) (%o10) -------- 2 (%i11) integrate(x*abs(x),x); / [ (%o11) I x abs(x) dx ] / (%i12) load("abs_integrate")$ (%i13) integrate(x*abs(x),x); 2 3 x abs(x) x signum(x) (%o13) --------- - ------------ 2 6 (%i14) integrate(abs(x),x,-2,%pi); 2 %pi (%o14) ---- + 2 2 (%i15) laplace(abs(x),x,s); 1 (%o15) -- 2 s
When x is a real number, return the least integer that is greater than or equal to x.
If x is a constant expression (10 * %pi
, for example),
ceiling
evaluates x using big floating point numbers, and
applies ceiling
to the resulting big float. Because ceiling
uses
floating point evaluation, it’s possible, although unlikely, that ceiling
could return an erroneous value for constant inputs. To guard against errors,
the floating point evaluation is done using three values for fpprec
.
For non-constant inputs, ceiling
tries to return a simplified value.
Here are examples of the simplifications that ceiling
knows about:
(%i1) ceiling (ceiling (x)); (%o1) ceiling(x)
(%i2) ceiling (floor (x)); (%o2) floor(x)
(%i3) declare (n, integer)$
(%i4) [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))]; (%o4) [n, abs(n), max(6, n)]
(%i5) assume (x > 0, x < 1)$
(%i6) ceiling (x); (%o6) 1
(%i7) tex (ceiling (a)); $$\left \lceil a \right \rceil$$ (%o7) false
The ceiling
function distributes over lists, matrices and equations.
See distribute_over
.
Finally, for all inputs that are manifestly complex, ceiling
returns
a noun form.
If the range of a function is a subset of the integers, it can be declared to
be integervalued
. Both the ceiling
and floor
functions
can use this information; for example:
(%i1) declare (f, integervalued)$
(%i2) floor (f(x)); (%o2) f(x)
(%i3) ceiling (f(x) - 1); (%o3) f(x) - 1
Example use:
(%i1) unitfrac(r) := block([uf : [], q], if not(ratnump(r)) then error("unitfrac: argument must be a rational number"), while r # 0 do ( uf : cons(q : 1/ceiling(1/r), uf), r : r - q), reverse(uf)); (%o1) unitfrac(r) := block([uf : [], q], if not ratnump(r) then error("unitfrac: argument must be a rational number"), 1 while r # 0 do (uf : cons(q : ----------, uf), r : r - q), 1 ceiling(-) r reverse(uf))
(%i2) unitfrac (9/10); 1 1 1 (%o2) [-, -, --] 2 3 15
(%i3) apply ("+", %); 9 (%o3) -- 10
(%i4) unitfrac (-9/10); 1 (%o4) [- 1, --] 10
(%i5) apply ("+", %); 9 (%o5) - -- 10
(%i6) unitfrac (36/37); 1 1 1 1 1 (%o6) [-, -, -, --, ----] 2 3 8 69 6808
(%i7) apply ("+", %); 36 (%o7) -- 37
Returns the largest integer less than or equal to x where x is
numeric. fix
(as in fixnum
) is a synonym for this, so
fix(x)
is precisely the same.
When x is a real number, return the largest integer that is less than or equal to x.
If x is a constant expression (10 * %pi
, for example), floor
evaluates x using big floating point numbers, and applies floor
to
the resulting big float. Because floor
uses floating point evaluation,
it’s possible, although unlikely, that floor
could return an erroneous
value for constant inputs. To guard against errors, the floating point
evaluation is done using three values for fpprec
.
For non-constant inputs, floor
tries to return a simplified value. Here
are examples of the simplifications that floor
knows about:
(%i1) floor (ceiling (x)); (%o1) ceiling(x)
(%i2) floor (floor (x)); (%o2) floor(x)
(%i3) declare (n, integer)$
(%i4) [floor (n), floor (abs (n)), floor (min (n, 6))]; (%o4) [n, abs(n), min(6, n)]
(%i5) assume (x > 0, x < 1)$
(%i6) floor (x); (%o6) 0
(%i7) tex (floor (a)); $$\left \lfloor a \right \rfloor$$ (%o7) false
The floor
function distributes over lists, matrices and equations.
See distribute_over
.
Finally, for all inputs that are manifestly complex, floor
returns
a noun form.
If the range of a function is a subset of the integers, it can be declared to
be integervalued
. Both the ceiling
and floor
functions
can use this information; for example:
(%i1) declare (f, integervalued)$
(%i2) floor (f(x)); (%o2) f(x)
(%i3) ceiling (f(x) - 1); (%o3) f(x) - 1
A synonym for entier (x)
.
The Heaviside unit step function, equal to 0 if x is negative, equal to 1 if x is positive and equal to 1/2 if x is equal to zero.
If you want a unit step function that takes on the value of 0 at x
equal to zero, use unit_step
.
When L is a list or a set, return apply ('max, args (L))
.
When L is not a list or a set, signal an error.
See also lmin
and max
.
When L is a list or a set, return apply ('min, args (L))
.
When L is not a list or a set, signal an error.
See also lmax
and min
.
Return a simplified value for the numerical maximum of the expressions x_1
through x_n. For an empty argument list, max
yields minf
.
The option variable maxmin_effort
controls which simplification methods are
applied. Using the default value of twelve for maxmin_effort
,
max
uses all available simplification methods. To to inhibit all
simplifications, set maxmin_effort
to zero.
When maxmin_effort
is one or more, for an explicit list of real numbers,
max
returns a number.
Unless max
needs to simplify a lengthy list of expressions, we suggest using
the default value of maxmin_effort
. Setting maxmin_effort
to zero
(no simplifications), will cause problems for some Maxima functions; accordingly,
generally maxmin_effort
should be nonzero.
See also min
, lmax
., and lmin
..
Examples:
In the first example, setting maxmin_effort
to zero suppresses simplifications.
(%i1) block([maxmin_effort : 0], max(1,2,x,x, max(a,b))); (%o1) max(1,2,max(a,b),x,x) (%i2) block([maxmin_effort : 1], max(1,2,x,x, max(a,b))); (%o2) max(2,a,b,x)
When maxmin_effort
is two or more, max
compares pairs of members:
(%i1) block([maxmin_effort : 1], max(x,x+1,x+3)); (%o1) max(x,x+1,x+3) (%i2) block([maxmin_effort : 2], max(x,x+1,x+3)); (%o2) x+3
Finally, when maxmin_effort
is three or more, max
compares triples
members and excludes those that are in between; for example
(%i1) block([maxmin_effort : 4], max(x, 2*x, 3*x, 4*x)); (%o1) max(x,4*x)
Return a simplified value for the numerical minimum of the expressions x_1
through x_n. For an empty argument list, minf
yields inf
.
The option variable maxmin_effort
controls which simplification methods are
applied. Using the default value of twelve for maxmin_effort
,
max
uses all available simplification methods. To to inhibit all
simplifications, set maxmin_effort
to zero.
When maxmin_effort
is one or more, for an explicit list of real numbers,
min
returns a number.
Unless min
needs to simplify a lengthy list of expressions, we suggest using
the default value of maxmin_effort
. Setting maxmin_effort
to zero
(no simplifications), will cause problems for some Maxima functions; accordingly,
generally maxmin_effort
should be nonzero.
See also max
, lmax
., and lmin
..
Examples:
In the first example, setting maxmin_effort
to zero suppresses simplifications.
(%i1) block([maxmin_effort : 0], min(1,2,x,x, min(a,b))); (%o1) min(1,2,a,b,x,x) (%i2) block([maxmin_effort : 1], min(1,2,x,x, min(a,b))); (%o2) min(1,a,b,x)
When maxmin_effort
is two or more, min
compares pairs of members:
(%i1) block([maxmin_effort : 1], min(x,x+1,x+3)); (%o1) min(x,x+1,x+3) (%i2) block([maxmin_effort : 2], min(x,x+1,x+3)); (%o2) x
Finally, when maxmin_effort
is three or more, min
compares triples
members and excludes those that are in between; for example
(%i1) block([maxmin_effort : 4], min(x, 2*x, 3*x, 4*x)); (%o1) max(x,4*x)
When x is a real number, returns the closest integer to x.
Multiples of 1/2 are rounded to the nearest even integer. Evaluation of
x is similar to floor
and ceiling
.
The round
function distributes over lists, matrices and equations.
See distribute_over
.
For either real or complex numbers x, the signum function returns
0 if x is zero; for a nonzero numeric input x, the signum function
returns x/abs(x)
.
For non-numeric inputs, Maxima attempts to determine the sign of the input.
When the sign is negative, zero, or positive, signum
returns -1,0, 1,
respectively. For all other values for the sign, signum
a simplified but
equivalent form. The simplifications include reflection (signum(-x)
gives -signum(x)
) and multiplicative identity (signum(x*y)
gives
signum(x) * signum(y)
).
The signum
function distributes over a list, a matrix, or an
equation. See sign
and distribute_over
.
When x is a real number, return the closest integer to x not
greater in absolute value than x. Evaluation of x is similar
to floor
and ceiling
.
The truncate
function distributes over lists, matrices and equations.
See distribute_over
.
Calculates the absolute value of an expression representing a complex
number. Unlike the function abs
, the cabs
function always
decomposes its argument into a real and an imaginary part. If x
and
y
represent real variables or expressions, the cabs
function
calculates the absolute value of x + %i*y
as
(%i1) cabs (1); (%o1) 1
(%i2) cabs (1 + %i); (%o2) sqrt(2)
(%i3) cabs (exp (%i)); (%o3) 1
(%i4) cabs (exp (%pi * %i)); (%o4) 1
(%i5) cabs (exp (3/2 * %pi * %i)); (%o5) 1
(%i6) cabs (17 * exp (2 * %i)); (%o6) 17
If cabs
returns a noun form this most commonly is caused by
some properties of the variables involved not being known:
(%i1) cabs (a+%i*b); 2 2 (%o1) sqrt(b + a )
(%i2) declare(a,real,b,real); (%o2) done
(%i3) cabs (a+%i*b); 2 2 (%o3) sqrt(b + a )
(%i4) assume(a>0,b>0); (%o4) [a > 0, b > 0]
(%i5) cabs (a+%i*b); 2 2 (%o5) sqrt(b + a )
The cabs
function can use known properties like symmetry properties of
complex functions to help it calculate the absolute value of an expression. If
such identities exist, they can be advertised to cabs
using function
properties. The symmetries that cabs
understands are: mirror symmetry,
conjugate function and complex characteristic.
cabs
is a verb function and is not suitable for symbolic
calculations. For such calculations (including integration,
differentiation and taking limits of expressions containing absolute
values), use abs
.
The result of cabs
can include the absolute value function,
abs
, and the arc tangent, atan2
.
When applied to a list or matrix, cabs
automatically distributes over
the terms. Similarly, it distributes over both sides of an equation.
For further ways to compute with complex numbers, see the functions
rectform
, realpart
, imagpart
,
carg
, conjugate
and polarform
.
Examples:
(%i1) cabs(sqrt(1+%i*x)); 2 1/4 (%o1) (x + 1) (%i2) cabs(sin(x+%i*y)); 2 2 2 2 (%o2) sqrt(cos (x) sinh (y) + sin (x) cosh (y))
The error function, erf
, has mirror symmetry, which is used here in
the calculation of the absolute value with a complex argument:
(%i3) cabs(erf(x+%i*y)); 2 (erf(%i y + x) - erf(%i y - x)) (%o3) sqrt(-------------------------------- 4 2 (erf(%i y + x) + erf(%i y - x)) - --------------------------------) 4
Maxima knows complex identities for the Bessel functions, which allow
it to compute the absolute value for complex arguments. Here is an
example for bessel_j
.
(%i4) cabs(bessel_j(1,%i)); (%o4) abs(bessel_j(1, %i))
Returns the complex argument of z. The complex argument is an angle
theta
in (-%pi, %pi]
such that r exp (theta %i) = z
where r
is the magnitude of z.
carg
is a computational function, not a simplifying function.
See also abs
(complex magnitude), polarform
,
rectform
, realpart
, and imagpart
.
Examples:
(%i1) carg (1); (%o1) 0
(%i2) carg (1 + %i); %pi (%o2) --- 4
(%i3) carg (exp (%i)); sin(1) (%o3) atan(------) cos(1)
(%i4) carg (exp (%pi * %i)); (%o4) %pi
(%i5) carg (exp (3/2 * %pi * %i)); %pi (%o5) - --- 2
(%i6) carg (17 * exp (2 * %i)); sin(2) (%o6) atan(------) + %pi cos(2)
If carg
returns a noun form this most commonly is caused by
some properties of the variables involved not being known:
(%i1) carg (a+%i*b); (%o1) atan2(b, a)
(%i2) declare(a,real,b,real); (%o2) done
(%i3) carg (a+%i*b); (%o3) atan2(b, a)
(%i4) assume(a>0,b>0); (%o4) [a > 0, b > 0]
(%i5) carg (a+%i*b); b (%o5) atan(-) a
Returns the complex conjugate of x.
(%i1) declare ([aa, bb], real, cc, complex, ii, imaginary); (%o1) done
(%i2) conjugate (aa + bb*%i); (%o2) aa - %i bb
(%i3) conjugate (cc); (%o3) conjugate(cc)
(%i4) conjugate (ii); (%o4) - ii
(%i5) conjugate (xx + yy); (%o5) yy + xx
Returns the imaginary part of the expression expr.
imagpart
is a computational function, not a simplifying function.
See also abs
, carg
, polarform
,
rectform
, and realpart
.
Example:
(%i1) imagpart (a+b*%i); (%o1) b
(%i2) imagpart (1+sqrt(2)*%i); (%o2) sqrt(2)
(%i3) imagpart (1); (%o3) 0
(%i4) imagpart (sqrt(2)*%i); (%o4) sqrt(2)
Returns an expression r %e^(%i theta)
equivalent to expr,
such that r
and theta
are purely real.
Example:
(%i1) polarform(a+b*%i); 2 2 %i atan2(b, a) (%o1) sqrt(b + a ) %e
(%i2) polarform(1+%i); %i %pi ------ 4 (%o2) sqrt(2) %e
(%i3) polarform(1+2*%i); %i atan(2) (%o3) sqrt(5) %e
Returns the real part of expr. realpart
and imagpart
will
work on expressions involving trigonometric and hyperbolic functions,
as well as square root, logarithm, and exponentiation.
Example:
(%i1) realpart (a+b*%i); (%o1) a
(%i2) realpart (1+sqrt(2)*%i); (%o2) 1
(%i3) realpart (sqrt(2)*%i); (%o3) 0
(%i4) realpart (1); (%o4) 1
Returns an expression a + b %i
equivalent to expr,
such that a and b are purely real.
Example:
(%i1) rectform(sqrt(2)*%e^(%i*%pi/4)); (%o1) %i + 1
(%i2) rectform(sqrt(b^2+a^2)*%e^(%i*atan2(b, a))); (%o2) %i b + a
(%i3) rectform(sqrt(5)*%e^(%i*atan(2))); (%o3) 2 %i + 1
The double factorial operator.
For an integer, float, or rational number n
, n!!
evaluates to the
product n (n-2) (n-4) (n-6) ... (n - 2 (k-1))
where k
is equal to
entier (n/2)
, that is, the largest integer less than or equal to
n/2
. Note that this definition does not coincide with other published
definitions for arguments which are not integers.
For an even (or odd) integer n
, n!!
evaluates to the product of
all the consecutive even (or odd) integers from 2 (or 1) through n
inclusive.
For an argument n
which is not an integer, float, or rational, n!!
yields a noun form genfact (n, n/2, 2)
.
The binomial coefficient x!/(y! (x - y)!)
.
If x and y are integers, then the numerical value of the binomial
coefficient is computed. If y, or x - y, is an integer, the
binomial coefficient is expressed as a polynomial.
Examples:
(%i1) binomial (11, 7); (%o1) 330
(%i2) 11! / 7! / (11 - 7)!; (%o2) 330
(%i3) binomial (x, 7); (x - 6) (x - 5) (x - 4) (x - 3) (x - 2) (x - 1) x (%o3) ------------------------------------------------- 5040
(%i4) binomial (x + 7, x); (x + 1) (x + 2) (x + 3) (x + 4) (x + 5) (x + 6) (x + 7) (%o4) ------------------------------------------------------- 5040
(%i5) binomial (11, y); (%o5) binomial(11, y)
Tries to combine the coefficients of factorials in expr
with the factorials themselves by converting, for example, (n + 1)*n!
into (n + 1)!
.
sumsplitfact
if set to false
will cause minfactorial
to be
applied after a factcomb
.
Example:
(%i1) sumsplitfact; (%o1) true
(%i2) (n + 1)*(n + 1)*n!; 2 (%o2) (n + 1) n!
(%i3) factcomb (%); (%o3) (n + 2)! - (n + 1)!
(%i4) sumsplitfact: not sumsplitfact; (%o4) false
(%i5) (n + 1)*(n + 1)*n!; 2 (%o5) (n + 1) n!
(%i6) factcomb (%); (%o6) n (n + 1)! + (n + 1)!
Represents the factorial function. Maxima treats factorial (x)
the same as x!
.
For any complex number x
, except for negative integers, x!
is
defined as gamma(x+1)
.
For an integer x
, x!
simplifies to the product of the integers
from 1 to x
inclusive. 0!
simplifies to 1. For a real or complex
number in float or bigfloat precision x
, x!
simplifies to the
value of gamma (x+1)
. For x
equal to n/2
where n
is
an odd integer, x!
simplifies to a rational factor times
sqrt (%pi)
(since gamma (1/2)
is equal to sqrt (%pi)
).
The option variables factlim
and gammalim
control the numerical
evaluation of factorials for integer and rational arguments. The functions
minfactorial
and factcomb
simplifies expressions containing
factorials.
The functions gamma
, bffac
, and cbffac
are
varieties of the gamma function. bffac
and cbffac
are called
internally by gamma
to evaluate the gamma function for real and complex
numbers in bigfloat precision.
makegamma
substitutes gamma
for factorials and related functions.
Maxima knows the derivative of the factorial function and the limits for specific values like negative integers.
The option variable factorial_expand
controls the simplification of
expressions like (n+x)!
, where n
is an integer.
See also binomial
.
The factorial of an integer is simplified to an exact number unless the operand
is greater than factlim
. The factorial for real and complex numbers is
evaluated in float or bigfloat precision.
(%i1) factlim : 10; (%o1) 10
(%i2) [0!, (7/2)!, 8!, 20!]; 105 sqrt(%pi) (%o2) [1, -------------, 40320, 20!] 16
(%i3) [4,77!, (1.0+%i)!]; (%o3) [4, 77!, 0.3430658398165453 %i + 0.6529654964201667]
(%i4) [2.86b0!, (1.0b0+%i)!]; (%o4) [5.046635586910012b0, 3.430658398165454b-1 %i + 6.529654964201667b-1]
The factorial of a known constant, or general expression is not simplified. Even so it may be possible to simplify the factorial after evaluating the operand.
(%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!]; (%o1) [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
(%i2) ev (%, numer, %enumer); (%o2) [0.3430658398165453 %i + 0.6529654964201667, 7.188082728976031, 4.260820476357003, 1.227580202486819]
Factorials are simplified, not evaluated.
Thus x!
may be replaced even in a quoted expression.
(%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]); 105 sqrt(%pi) (%o1) [1, -------------, 81.44668037931197, 40320, 16 2432902008176640000]
Maxima knows the derivative of the factorial function.
(%i1) diff(x!,x); (%o1) x! psi (x + 1) 0
The option variable factorial_expand
controls expansion and
simplification of expressions with the factorial function.
(%i1) (n+1)!/n!,factorial_expand:true; (%o1) n + 1
Default value: 100000
factlim
specifies the highest factorial which is
automatically expanded. If it is -1 then all integers are expanded.
Default value: false
The option variable factorial_expand
controls the simplification of
expressions like (x+n)!
, where n
is an integer.
See factorial
for an example.
Returns the generalized factorial, defined as
x (x-z) (x - 2 z) ... (x - (y - 1) z)
. Thus, when x is an integer,
genfact (x, x, 1) = x!
and genfact (x, x/2, 2) = x!!
.
Examines expr for occurrences of two factorials
which differ by an integer.
minfactorial
then turns one into a polynomial times the other.
(%i1) n!/(n+2)!; n! (%o1) -------- (n + 2)! (%i2) minfactorial (%); 1 (%o2) --------------- (n + 1) (n + 2)
Default value: true
When sumsplitfact
is false
,
minfactorial
is applied after a factcomb
.
(%i1) sumsplitfact; (%o1) true
(%i2) n!/(n+2)!; n! (%o2) -------- (n + 2)!
(%i3) factcomb(%); n! (%o3) -------- (n + 2)!
(%i4) sumsplitfact: not sumsplitfact ; (%o4) false
(%i5) n!/(n+2)!; n! (%o5) -------- (n + 2)!
(%i6) factcomb(%); 1 (%o6) --------------- (n + 1) (n + 2)
Default value: false
When true
, r
some rational number, and x
some expression,
%e^(r*log(x))
will be simplified into x^r
. It should be noted
that the radcan
command also does this transformation, and more
complicated transformations of this ilk as well. The logcontract
command "contracts" expressions containing log
.
Default value: true
When %emode
is true
, %e^(%pi %i x)
is simplified as
follows.
%e^(%pi %i x)
simplifies to cos (%pi x) + %i sin (%pi x)
if
x
is a floating point number, an integer, or a multiple of 1/2, 1/3, 1/4,
or 1/6, and then further simplified.
For other numerical x
, %e^(%pi %i x)
simplifies to
%e^(%pi %i y)
where y
is x - 2 k
for some integer k
such that abs(y) < 1
.
When %emode
is false
, no special simplification of
%e^(%pi %i x)
is carried out.
(%i1) %emode; (%o1) true
(%i2) %e^(%pi*%i*1); (%o2) - 1
(%i3) %e^(%pi*%i*216/144); (%o3) - %i
(%i4) %e^(%pi*%i*192/144); sqrt(3) %i 1 (%o4) (- ----------) - - 2 2
(%i5) %e^(%pi*%i*180/144); %i 1 (%o5) (- -------) - ------- sqrt(2) sqrt(2)
(%i6) %e^(%pi*%i*120/144); %i sqrt(3) (%o6) -- - ------- 2 2
(%i7) %e^(%pi*%i*121/144); 121 %i %pi ---------- 144 (%o7) %e
Default value: false
When %enumer
is true
, %e
is replaced by its numeric value
2.718… whenever numer
is true
.
When %enumer
is false
, this substitution is carried out
only if the exponent in %e^x
evaluates to a number.
(%i1) %enumer; (%o1) false
(%i2) numer; (%o2) false
(%i3) 2*%e; (%o3) 2 %e
(%i4) %enumer: not %enumer; (%o4) true
(%i5) 2*%e; (%o5) 2 %e
(%i6) numer: not numer; (%o6) true
(%i7) 2*%e; (%o7) 5.43656365691809
(%i8) 2*%e^1; (%o8) 5.43656365691809
(%i9) 2*%e^x; x (%o9) 2 2.718281828459045
Represents the exponential function. Instances of exp (x)
in input
are simplified to %e^x
; exp
does not appear in simplified
expressions.
demoivre
if true
causes %e^(a + b %i)
to simplify to
%e^(a (cos(b) + %i sin(b)))
if b
is free of %i
.
See demoivre
.
%emode
, when true
, causes %e^(%pi %i x)
to be simplified.
See %emode
.
%enumer
, when true
causes %e
to be replaced by
2.718… whenever numer
is true
. See %enumer
.
(%i1) demoivre; (%o1) false
(%i2) %e^(a + b*%i); %i b + a (%o2) %e
(%i3) demoivre: not demoivre; (%o3) true
(%i4) %e^(a + b*%i); a (%o4) %e (%i sin(b) + cos(b))
Represents the polylogarithm function of order s and argument z, defined by the infinite series
inf ==== k \ z Li (z) = > -- s / s ==== k k = 1
li [1]
is - log (1 - z)
. li [2]
and li [3]
are the
dilogarithm and trilogarithm functions, respectively.
When the order is 1, the polylogarithm simplifies to - log (1 - z)
, which
in turn simplifies to a numerical value if z is a real or complex floating
point number or the numer
evaluation flag is present.
When the order is 2 or 3,
the polylogarithm simplifies to a numerical value
if z is a real floating point number
or the numer
evaluation flag is present.
Examples:
(%i1) assume (x > 0); (%o1) [x > 0]
(%i2) integrate ((log (1 - t)) / t, t, 0, x); (%o2) - li (x) 2
(%i3) li [2] (7); (%o3) li (7) 2
(%i4) li [2] (7), numer; (%o4) 1.248273182099423 - 6.113257028817991 %i
(%i5) li [3] (7); (%o5) li (7) 3
(%i6) li [3] (7), numer; (%o6) 5.319257992145674 - 5.94792444808033 %i
(%i7) L : makelist (i / 4.0, i, 0, 8); (%o7) [0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0]
(%i8) map (lambda ([x], li [2] (x)), L); (%o8) [0.0, 0.2676526390827326, 0.5822405264650125, 0.978469392930306, 1.644934066848226, 2.190177011441645 - 0.7010261415046585 %i, 2.37439527027248 - 1.2738062049196 %i, 2.448686765338205 - 1.758084848210787 %i, 2.467401100272339 - 2.177586090303601 %i]
(%i9) map (lambda ([x], li [3] (x)), L); (%o9) [0.0, 0.2584613953442624, 0.537213192678042, 0.8444258046482203, 1.2020569, 1.642866878950322 - 0.07821473130035025 %i, 2.060877505514697 - 0.2582419849982037 %i, 2.433418896388322 - 0.4919260182322965 %i, 2.762071904015935 - 0.7546938285978846 %i]
Represents the natural (base \(e\)) logarithm of x.
Maxima does not have a built-in function for the base 10 logarithm or other
bases. log10(x) := log(x) / log(10)
is a useful definition.
Simplification and evaluation of logarithms is governed by several global flags:
logexpand
causes log(a^b)
to become b*log(a)
. If it is
set to all
, log(a*b)
will also simplify to log(a)+log(b)
.
If it is set to super
, then log(a/b)
will also simplify to
log(a)-log(b)
for rational numbers a/b
, a#1
.
(log(1/b)
, for b
integer, always simplifies.) If it is set to
false
, all of these simplifications will be turned off.
logsimp
if false
then no simplification of %e
to a power containing
log
’s is done.
lognegint
if true
implements the rule log(-n) -> log(n)+%i*%pi
for
n
a positive integer.
%e_to_numlog
when true
, r
some rational number, and x
some expression,
the expression %e^(r*log(x))
will be simplified into x^r
. It
should be noted that the radcan
command also does this transformation,
and more complicated transformations of this as well. The logcontract
command "contracts" expressions containing log
.
Default value: false
When doing indefinite integration where logs are generated, e.g.
integrate(1/x,x)
, the answer is given in terms of log(abs(...))
if logabs
is true
, but in terms of log(...)
if
logabs
is false
. For definite integration, the logabs:true
setting is used, because here "evaluation" of the indefinite integral at the
endpoints is often needed.
The function logarc(expr)
carries out the replacement of
inverse circular and hyperbolic functions with equivalent logarithmic
functions for an expression expr without setting the global
variable logarc
.
When the global variable logarc
is true
,
inverse circular and hyperbolic functions are replaced by
equivalent logarithmic functions.
The default value of logarc
is false
.
Default value: false
Controls which coefficients are
contracted when using logcontract
. It may be set to the name of a
predicate function of one argument. E.g. if you like to generate
SQRTs, you can do logconcoeffp:'logconfun$
logconfun(m):=featurep(m,integer) or ratnump(m)$
. Then
logcontract(1/2*log(x));
will give log(sqrt(x))
.
Recursively scans the expression expr, transforming
subexpressions of the form a1*log(b1) + a2*log(b2) + c
into
log(ratsimp(b1^a1 * b2^a2)) + c
(%i1) 2*(a*log(x) + 2*a*log(y))$
(%i2) logcontract(%); 2 4 (%o2) a log(x y )
The declaration declare(n,integer)
causes
logcontract(2*a*n*log(x))
to simplify to a*log(x^(2*n))
. The
coefficients that "contract" in this manner are those such as the 2 and the
n
here which satisfy featurep(coeff,integer)
. The user can
control which coefficients are contracted by setting the option
logconcoeffp
to the name of a predicate function of one argument.
E.g. if you like to generate SQRTs, you can do logconcoeffp:'logconfun$
logconfun(m):=featurep(m,integer) or ratnump(m)$
. Then
logcontract(1/2*log(x));
will give log(sqrt(x))
.
Default value: true
If true
, that is the default value, causes log(a^b)
to become
b*log(a)
. If it is set to all
, log(a*b)
will also simplify
to log(a)+log(b)
. If it is set to super
, then log(a/b)
will also simplify to log(a)-log(b)
for rational numbers a/b
,
a#1
. (log(1/b)
, for integer b
, always simplifies.) If it
is set to false
, all of these simplifications will be turned off.
When logexpand
is set to all
or super
,
the logarithm of a product expression simplifies to a summation of logarithms.
Examples:
When logexpand
is true
,
log(a^b)
simplifies to b*log(a)
.
(%i1) log(n^2), logexpand=true; (%o1) 2 log(n)
When logexpand
is all
,
log(a*b)
simplifies to log(a)+log(b)
.
(%i1) log(10*x), logexpand=all; (%o1) log(x) + log(10)
When logexpand
is super
,
log(a/b)
simplifies to log(a)-log(b)
for rational numbers a/b
with a#1
.
(%i1) log(a/(n + 1)), logexpand=super; (%o1) log(a) - log(n + 1)
When logexpand
is set to all
or super
,
the logarithm of a product expression simplifies to a summation of logarithms.
(%i1) my_product : product (X(i), i, 1, n); n /===\ ! ! (%o1) ! ! X(i) ! ! i = 1 (%i2) log(my_product), logexpand=all; n ==== \ (%o2) > log(X(i)) / ==== i = 1 (%i3) log(my_product), logexpand=super; n ==== \ (%o3) > log(X(i)) / ==== i = 1
When logexpand
is false
,
these simplifications are disabled.
(%i1) logexpand : false $ (%i2) log(n^2); 2 (%o2) log(n ) (%i3) log(10*x); (%o3) log(10 x) (%i4) log(a/(n + 1)); a (%o4) log(-----) n + 1 (%i5) log ('product (X(i), i, 1, n)); n /===\ ! ! (%o5) log( ! ! X(i)) ! ! i = 1
Default value: false
If true
implements the rule
log(-n) -> log(n)+%i*%pi
for n
a positive integer.
Default value: true
If false
then no simplification of %e
to a
power containing log
’s is done.
Represents the principal branch of the complex-valued natural
logarithm with -%pi < carg(x) <= +%pi
.
The square root of x. It is represented internally by
x^(1/2)
. See also rootscontract
and radexpand
.
Maxima has many trigonometric functions defined. Not all trigonometric
identities are programmed, but it is possible for the user to add many
of them using the pattern matching capabilities of the system. The
trigonometric functions defined in Maxima are: acos
,
acosh
, acot
, acoth
, acsc
,
acsch
, asec
, asech
, asin
,
asinh
, atan
, atanh
, cos
,
cosh
, cot
, coth
, csc
, csch
,
sec
, sech
, sin
, sinh
, tan
,
and tanh
. There are a number of commands especially for
handling trigonometric functions, see trigexpand
,
trigreduce
, and the switch trigsign
. Two share
packages extend the simplification rules built into Maxima,
ntrig
and atrig1
. Do describe(command)
for details.
– Arc Cosine.
– Hyperbolic Arc Cosine.
– Arc Cotangent.
– Hyperbolic Arc Cotangent.
– Arc Cosecant.
– Hyperbolic Arc Cosecant.
– Arc Secant.
– Hyperbolic Arc Secant.
– Arc Sine.
– Hyperbolic Arc Sine.
– Arc Tangent.
See also atan2
.
– yields the value of \(\tan^{-1}(y/x)\) in the interval \(-\pi\) to \(\pi\) taking into consideration the quadrant of the point \((x,y).\)
See also atan
.
– Hyperbolic Arc Tangent.
– Cosine.
– Hyperbolic Cosine.
– Cotangent.
– Hyperbolic Cotangent.
– Cosecant.
– Hyperbolic Cosecant.
– Secant.
– Hyperbolic Secant.
– Sine.
– Hyperbolic Sine.
– Tangent.
– Hyperbolic Tangent.
Default value: true
When %piargs
is true
,
trigonometric functions are simplified to algebraic constants
when the argument is an integer multiple
of
\(\pi,\)
\(\pi/2,\)
\(\pi/4,\)
or
\(\pi/6.\)
Maxima knows some identities which can be applied when \(\pi\) , etc., are multiplied by an integer variable (that is, a symbol declared to be integer).
Examples:
(%i1) %piargs : false$
(%i2) [sin (%pi), sin (%pi/2), sin (%pi/3)]; %pi %pi (%o2) [sin(%pi), sin(---), sin(---)] 2 3
(%i3) [sin (%pi/4), sin (%pi/5), sin (%pi/6)]; %pi %pi %pi (%o3) [sin(---), sin(---), sin(---)] 4 5 6
(%i4) %piargs : true$
(%i5) [sin (%pi), sin (%pi/2), sin (%pi/3)]; sqrt(3) (%o5) [0, 1, -------] 2
(%i6) [sin (%pi/4), sin (%pi/5), sin (%pi/6)]; 1 %pi 1 (%o6) [-------, sin(---), -] sqrt(2) 5 2
(%i7) [cos (%pi/3), cos (10*%pi/3), tan (10*%pi/3), cos (sqrt(2)*%pi/3)]; 1 1 sqrt(2) %pi (%o7) [-, - -, sqrt(3), cos(-----------)] 2 2 3
Some identities are applied when \(\pi\) and \(\pi/2\) are multiplied by an integer variable.
(%i1) declare (n, integer, m, even)$
(%i2) [sin (%pi * n), cos (%pi * m), sin (%pi/2 * m), cos (%pi/2 * m)]; m/2 (%o2) [0, 1, 0, (- 1) ]
Default value: true
When %iargs
is true
,
trigonometric functions are simplified to hyperbolic functions
when the argument is apparently a multiple of the imaginary
unit
\(i.\)
Even when the argument is demonstrably real, the simplification is applied; Maxima considers only whether the argument is a literal multiple of \(i.\)
Examples:
(%i1) %iargs : false$
(%i2) [sin (%i * x), cos (%i * x), tan (%i * x)]; (%o2) [sin(%i x), cos(%i x), tan(%i x)]
(%i3) %iargs : true$
(%i4) [sin (%i * x), cos (%i * x), tan (%i * x)]; (%o4) [%i sinh(x), cosh(x), %i tanh(x)]
Even when the argument is demonstrably real, the simplification is applied.
(%i1) declare (x, imaginary)$
(%i2) [featurep (x, imaginary), featurep (x, real)]; (%o2) [true, false]
(%i3) sin (%i * x); (%o3) %i sinh(x)
Default value: false
When halfangles
is true
, trigonometric functions of arguments
expr/2
are simplified to functions of expr.
For a real argument \(x\) in the interval \(0 \le x < 2\pi,\) \(\sin{x\over 2}\) simplifies to a simple formula:
A complicated factor is needed to make this formula correct for all complex arguments \(z = x+iy\):
Maxima knows this factor and similar factors for the functions sin
,
cos
, sinh
, and cosh
. For special values of the argument
\(z\) these factors simplify accordingly.
Examples:
(%i1) halfangles : false$
(%i2) sin (x / 2); x (%o2) sin(-) 2
(%i3) halfangles : true$
(%i4) sin (x / 2); x floor(-----) 2 %pi (- 1) sqrt(1 - cos(x)) (%o4) ---------------------------------- sqrt(2)
(%i5) assume(x>0, x<2*%pi)$
(%i6) sin(x / 2); sqrt(1 - cos(x)) (%o6) ---------------- sqrt(2)
Default value: true
When trigsign
is true
, it permits simplification of negative
arguments to trigonometric functions. E.g.,
\(\sin(-x)\)
will
become
\(-\sin x\)
only if trigsign
is true
.
Expands trigonometric and hyperbolic functions of
sums of angles and of multiple angles occurring in expr. For best
results, expr should be expanded. To enhance user control of
simplification, this function expands only one level at a time,
expanding sums of angles or multiple angles. To obtain full expansion
into sines and cosines immediately, set the switch trigexpand: true
.
trigexpand
is governed by the following global flags:
trigexpand
If true
causes expansion of all
expressions containing sin’s and cos’s occurring subsequently.
halfangles
If true
causes half-angles to be simplified
away.
trigexpandplus
Controls the "sum" rule for trigexpand
,
expansion of sums (e.g. sin(x + y)
) will take place only if
trigexpandplus
is true
.
trigexpandtimes
Controls the "product" rule for trigexpand
,
expansion of products (e.g. sin(2 x)
) will take place only if
trigexpandtimes
is true
.
Examples:
(%i1) x+sin(3*x)/sin(x),trigexpand=true,expand; 2 2 (%o1) (- sin (x)) + 3 cos (x) + x
(%i2) trigexpand(sin(10*x+y)); (%o2) cos(10 x) sin(y) + sin(10 x) cos(y)
Default value: true
trigexpandplus
controls the "sum" rule for
trigexpand
. Thus, when the trigexpand
command is used or the
trigexpand
switch set to true
, expansion of sums
(e.g. sin(x+y))
will take place only if trigexpandplus
is
true
.
Default value: true
trigexpandtimes
controls the "product" rule for trigexpand
.
Thus, when the trigexpand
command is used or the trigexpand
switch set to true
, expansion of products (e.g. sin(2*x)
)
will take place only if trigexpandtimes
is true
.
Default value: true
triginverses
controls the simplification of the
composition of trigonometric and hyperbolic functions with their inverse
functions.
If all
, both e.g. atan(tan(x))
and tan(atan(x))
simplify to x.
If true
, the arcfun(fun(x))
simplification is turned off.
If false
, both the
arcfun(fun(x))
and
fun(arcfun(x))
simplifications are turned off.
trigreduce
(expr, x) trigreduce
(expr) ¶Combines products and powers of trigonometric and hyperbolic sin’s and cos’s of x into those of multiples of x. It also tries to eliminate these functions when they occur in denominators. If x is omitted then all variables in expr are used.
See also poissimp
.
(%i1) trigreduce(-sin(x)^2+3*cos(x)^2+x); cos(2 x) cos(2 x) 1 1 (%o1) -------- + 3 (-------- + -) + x - - 2 2 2 2
Employs the identities
\(\sin\left(x\right)^2 + \cos\left(x\right)^2 = 1\)
and
\(\cosh\left(x\right)^2 - \sinh\left(x\right)^2 = 1\)
to
simplify expressions containing tan
, sec
,
etc., to sin
, cos
, sinh
, cosh
.
trigreduce
, ratsimp
, and radcan
may be
able to further simplify the result.
demo ("trgsmp.dem")
displays some examples of trigsimp
.
Gives a canonical simplified quasilinear form of a trigonometrical expression;
expr is a rational fraction of several sin
, cos
or
tan
, the arguments of them are linear forms in some variables (or
kernels) and %pi/n
(n integer) with integer coefficients.
The result is a simplified fraction with numerator and denominator linear in
sin
and cos
. Thus trigrat
linearize always when it is
possible.
(%i1) trigrat(sin(3*a)/sin(a+%pi/3)); (%o1) sqrt(3) sin(2 a) + cos(2 a) - 1
The following example is taken from Davenport, Siret, and Tournier, Calcul Formel, Masson (or in English, Addison-Wesley), section 1.5.5, Morley theorem.
(%i1) c : %pi/3 - a - b$
(%i2) bc : sin(a)*sin(3*c)/sin(a+b); %pi sin(a) sin(3 ((- b) - a + ---)) 3 (%o2) ------------------------------- sin(b + a)
(%i3) ba : bc, c=a, a=c; %pi sin(3 a) sin(b + a - ---) 3 (%o3) ------------------------- %pi sin(a - ---) 3
(%i4) ac2 : ba^2 + bc^2 - 2*bc*ba*cos(b); 2 2 %pi sin (3 a) sin (b + a - ---) 3 (%o4) --------------------------- 2 %pi sin (a - ---) 3 %pi - (2 sin(a) sin(3 a) sin(3 ((- b) - a + ---)) cos(b) 3 %pi %pi sin(b + a - ---))/(sin(a - ---) sin(b + a)) 3 3 2 2 %pi sin (a) sin (3 ((- b) - a + ---)) 3 + --------------------------------- 2 sin (b + a)
(%i5) trigrat (ac2); (%o5) - (sqrt(3) sin(4 b + 4 a) - cos(4 b + 4 a) - 2 sqrt(3) sin(4 b + 2 a) + 2 cos(4 b + 2 a) - 2 sqrt(3) sin(2 b + 4 a) + 2 cos(2 b + 4 a) + 4 sqrt(3) sin(2 b + 2 a) - 8 cos(2 b + 2 a) - 4 cos(2 b - 2 a) + sqrt(3) sin(4 b) - cos(4 b) - 2 sqrt(3) sin(2 b) + 10 cos(2 b) + sqrt(3) sin(4 a) - cos(4 a) - 2 sqrt(3) sin(2 a) + 10 cos(2 a) - 9)/4
The atrig1
package contains several additional simplification rules
for inverse trigonometric functions. Together with rules
already known to Maxima, the following angles are fully implemented:
\(0\),
\(\pi/6,\)
\(\pi/4,\)
\(\pi/3,\)
and
\(\pi/2.\)
Corresponding angles in the other three quadrants are also available.
Do load("atrig1");
to use them.
The ntrig
package contains a set of simplification rules that are
used to simplify trigonometric function whose arguments are of the form
f(n %pi/10)
where f is any of the functions
sin
, cos
, tan
, csc
, sec
and cot
.
make_random_state
(n) make_random_state
(s) make_random_state
(true) make_random_state
(false) ¶A random state object represents the state of the random number generator. The state comprises 627 32-bit words.
make_random_state (n)
returns a new random state object
created from an integer seed value equal to n modulo 2^32.
n may be negative.
make_random_state (s)
returns a copy of the random state s.
make_random_state (true)
returns a new random state object,
using the current computer clock time as the seed.
make_random_state (false)
returns a copy of the current state
of the random number generator.
Copies s to the random number generator state.
set_random_state
always returns done
.
Returns a pseudorandom number. If x is an integer,
random (x)
returns an integer from 0 through x - 1
inclusive. If x is a floating point number, random (x)
returns a nonnegative floating point number less than x. random
complains with an error if x is neither an integer nor a float, or if
x is not positive.
The functions make_random_state
and set_random_state
maintain the state of the random number generator.
The Maxima random number generator is an implementation of the Mersenne twister MT 19937.
Examples:
(%i1) s1: make_random_state (654321)$
(%i2) set_random_state (s1); (%o2) done
(%i3) random (1000); (%o3) 768
(%i4) random (9573684); (%o4) 7657880
(%i5) random (2^75); (%o5) 11804491615036831636390
(%i6) s2: make_random_state (false)$
(%i7) random (1.0); (%o7) 0.2310127244107132
(%i8) random (10.0); (%o8) 4.394553645870825
(%i9) random (100.0); (%o9) 32.28666704056853
(%i10) set_random_state (s2); (%o10) done
(%i11) random (1.0); (%o11) 0.2310127244107132
(%i12) random (10.0); (%o12) 4.394553645870825
(%i13) random (100.0); (%o13) 32.28666704056853
alphabetic
is a property type recognized by declare
.
The expression declare(s, alphabetic)
tells Maxima to recognize
as alphabetic all of the characters in s, which must be a string.
See also Identifiers.
Example:
(%i1) xx\~yy\`\@ : 1729; (%o1) 1729 (%i2) declare ("~`@", alphabetic); (%o2) done (%i3) xx~yy`@ + @yy`xx + `xx@@yy~; (%o3) `xx@@yy~ + @yy`xx + 1729 (%i4) listofvars (%); (%o4) [@yy`xx, `xx@@yy~]
The command declare(x, bindtest)
tells Maxima to trigger an error
when the symbol x is evaluated unbound.
(%i1) aa + bb; (%o1) bb + aa (%i2) declare (aa, bindtest); (%o2) done (%i3) aa + bb; aa unbound variable -- an error. Quitting. To debug this try debugmode(true); (%i4) aa : 1234; (%o4) 1234 (%i5) aa + bb; (%o5) bb + 1234
declare(a, constant)
declares a to be a constant. The
declaration of a symbol to be constant does not prevent the assignment of a
nonconstant value to the symbol.
Example:
(%i1) declare(c, constant); (%o1) done (%i2) constantp(c); (%o2) true (%i3) c : x; (%o3) x (%i4) constantp(c); (%o4) false
Returns true
if expr is a constant expression, otherwise returns
false
.
An expression is considered a constant expression if its arguments are
numbers (including rational numbers, as displayed with /R/
),
symbolic constants such as %pi
, %e
, and %i
,
variables bound to a constant or declared constant by declare
,
or functions whose arguments are constant.
constantp
evaluates its arguments.
See the property constant
which declares a symbol to be constant.
Examples:
(%i1) constantp (7 * sin(2)); (%o1) true (%i2) constantp (rat (17/29)); (%o2) true (%i3) constantp (%pi * sin(%e)); (%o3) true (%i4) constantp (exp (x)); (%o4) false (%i5) declare (x, constant); (%o5) done (%i6) constantp (exp (x)); (%o6) true (%i7) constantp (foo (x) + bar (%e) + baz (2)); (%o7) false (%i8)
Assigns the atom or list of atoms a_i the property or list of properties p_i. When a_i and/or p_i are lists, each of the atoms gets all of the properties.
declare
quotes its arguments. declare
always returns done
.
As noted in the description for each declaration flag, for some flags
featurep(object, feature)
returns true
if object
has been declared to have feature.
For more information about the features system, see features
. To
remove a property from an atom, use remove
.
declare
recognizes the following properties:
additive
Tells Maxima to simplify a_i expressions by the substitution
a_i(x + y + z + ...)
-->
a_i(x) + a_i(y) + a_i(z) + ...
.
The substitution is carried out on the first argument only.
alphabetic
Tells Maxima to recognize all characters in a_i (which must be a string) as alphabetic characters.
antisymmetric, commutative, symmetric
Tells Maxima to recognize a_i as a symmetric or antisymmetric
function. commutative
is the same as symmetric
.
bindtest
Tells Maxima to trigger an error when a_i is evaluated unbound.
constant
Tells Maxima to consider a_i a symbolic constant.
even, odd
Tells Maxima to recognize a_i as an even or odd integer variable.
evenfun, oddfun
Tells Maxima to recognize a_i as an odd or even function.
evflag
Makes a_i known to the ev
function so that a_i is bound
to true
during the execution of ev
when a_i appears as
a flag argument of ev
. See evflag
.
evfun
Makes a_i known to ev
so that the function named by a_i
is applied when a_i appears as a flag argument of ev
.
See evfun
.
feature
Tells Maxima to recognize a_i as the name of a feature. Other atoms may then be declared to have the a_i property.
increasing, decreasing
Tells Maxima to recognize a_i as an increasing or decreasing function.
integer, noninteger
Tells Maxima to recognize a_i as an integer or noninteger variable.
integervalued
Tells Maxima to recognize a_i as an integer-valued function.
lassociative, rassociative
Tells Maxima to recognize a_i as a right-associative or left-associative function.
linear
Equivalent to declaring a_i both outative
and
additive
.
mainvar
Tells Maxima to consider a_i a "main variable". A main variable
succeeds all other constants and variables in the canonical ordering of
Maxima expressions, as determined by ordergreatp
.
multiplicative
Tells Maxima to simplify a_i expressions by the substitution
a_i(x * y * z * ...)
-->
a_i(x) * a_i(y) * a_i(z) * ...
.
The substitution is carried out on the first argument only.
nary
Tells Maxima to recognize a_i as an n-ary function.
The nary
declaration is not the same as calling the nary
function. The sole effect of declare(foo, nary)
is to instruct the
Maxima simplifier to flatten nested expressions, for example, to simplify
foo(x, foo(y, z))
to foo(x, y, z)
.
nonarray
Tells Maxima to consider a_i not an array. This declaration prevents multiple evaluation of a subscripted variable name.
nonscalar
Tells Maxima to consider a_i a nonscalar variable. The usual application is to declare a variable as a symbolic vector or matrix.
noun
Tells Maxima to parse a_i as a noun. The effect of this is to
replace instances of a_i with 'a_i
or
nounify(a_i)
, depending on the context.
outative
Tells Maxima to simplify a_i expressions by pulling constant factors out of the first argument.
When a_i has one argument, a factor is considered constant if it is a literal or declared constant.
When a_i has two or more arguments, a factor is considered constant if the second argument is a symbol and the factor is free of the second argument.
posfun
Tells Maxima to recognize a_i as a positive function.
rational, irrational
Tells Maxima to recognize a_i as a rational or irrational real variable.
real, imaginary, complex
Tells Maxima to recognize a_i as a real, pure imaginary, or complex variable.
scalar
Tells Maxima to consider a_i a scalar variable.
Examples of the usage of the properties are available in the documentation for each separate description of a property.
The commands declare(f, decreasing)
or
declare(f, increasing)
tell Maxima to recognize the function
f as an decreasing or increasing function.
See also declare
for more properties.
Example:
(%i1) assume(a > b); (%o1) [a > b] (%i2) is(f(a) > f(b)); (%o2) unknown (%i3) declare(f, increasing); (%o3) done (%i4) is(f(a) > f(b)); (%o4) true
declare(a, even)
or declare(a, odd)
tells Maxima to
recognize the symbol a as an even or odd integer variable. The
properties even
and odd
are not recognized by the functions
evenp
, oddp
, and integerp
.
See also declare
and askinteger
.
Example:
(%i1) declare(n, even); (%o1) done (%i2) askinteger(n, even); (%o2) yes (%i3) askinteger(n); (%o3) yes (%i4) evenp(n); (%o4) false
Maxima understands two distinct types of features, system features and features
which apply to mathematical expressions. See also status
for information
about system features. See also features
and featurep
for
information about mathematical features.
feature
itself is not the name of a function or variable.
Attempts to determine whether the object a has the feature f on the
basis of the facts in the current database. If so, it returns true
,
else false
.
Note that featurep
returns false
when neither f
nor the negation of f can be established.
featurep
evaluates its argument.
See also declare
and features
.
(%i1) declare (j, even)$ (%i2) featurep (j, integer); (%o2) true
Maxima recognizes certain mathematical properties of functions and variables. These are called "features".
declare (x, foo)
gives the property foo
to the function or variable x.
declare (foo, feature)
declares a new feature foo.
For example,
declare ([red, green, blue], feature)
declares three new features, red
, green
, and blue
.
The predicate featurep (x, foo)
returns true
if x has the foo property,
and false
otherwise.
The infolist features
is a list of known features. These are
integer noninteger even odd rational irrational real imaginary complex analytic increasing decreasing oddfun evenfun posfun constant commutative lassociative rassociative symmetric antisymmetric integervalued
plus any user-defined features.
features
is a list of mathematical features. There is also a list of
non-mathematical, system-dependent features. See status
.
Example:
(%i1) declare (FOO, feature); (%o1) done (%i2) declare (x, FOO); (%o2) done (%i3) featurep (x, FOO); (%o3) true
Retrieves the user property indicated by i associated with
atom a or returns false
if a doesn’t have property i.
get
evaluates its arguments.
(%i1) put (%e, 'transcendental, 'type); (%o1) transcendental (%i2) put (%pi, 'transcendental, 'type)$ (%i3) put (%i, 'algebraic, 'type)$ (%i4) typeof (expr) := block ([q], if numberp (expr) then return ('algebraic), if not atom (expr) then return (maplist ('typeof, expr)), q: get (expr, 'type), if q=false then errcatch (error(expr,"is not numeric.")) else q)$ (%i5) typeof (2*%e + x*%pi); x is not numeric. (%o5) [[transcendental, []], [algebraic, transcendental]] (%i6) typeof (2*%e + %pi); (%o6) [transcendental, [algebraic, transcendental]]
declare(a, integer)
or declare(a, noninteger)
tells
Maxima to recognize a as an integer or noninteger variable.
See also declare
.
Example:
(%i1) declare(n, integer, x, noninteger); (%o1) done (%i2) askinteger(n); (%o2) yes (%i3) askinteger(x); (%o3) no
declare(f, integervalued)
tells Maxima to recognize f as an
integer-valued function.
See also declare
.
Example:
(%i1) exp(%i)^f(x); %i f(x) (%o1) (%e ) (%i2) declare(f, integervalued); (%o2) done (%i3) exp(%i)^f(x); %i f(x) (%o3) %e
The command declare(a, nonarray)
tells Maxima to consider a not
an array. This declaration prevents multiple evaluation, if a is a
subscripted variable.
See also declare
.
Example:
(%i1) a:'b$ b:'c$ c:'d$ (%i4) a[x]; (%o4) d x (%i5) declare(a, nonarray); (%o5) done (%i6) a[x]; (%o6) a x
Makes atoms behave as does a list or matrix with respect to the dot operator.
See also declare
.
Returns true
if expr is a non-scalar, i.e., it contains
atoms declared as non-scalars, lists, or matrices.
declare (f, posfun)
declares f
to be a positive function.
is (f(x) > 0)
yields true
.
See also declare
.
printprops
(a, i) printprops
([a_1, …, a_n], i) printprops
(all, i) ¶Displays the property with the indicator i associated with the atom
a. a may also be a list of atoms or the atom all
in which
case all of the atoms with the given property will be used. For example,
printprops ([f, g], atvalue)
. printprops
is for properties that
cannot otherwise be displayed, i.e. for atvalue
,
atomgrad
, gradef
, and matchdeclare
.
Returns a list of the names of all the properties associated with the atom a.
Default value: []
props
are atoms which have any property other than those explicitly
mentioned in infolists
, such as specified by atvalue
,
matchdeclare
, etc., as well as properties specified in the
declare
function.
Returns a list of those atoms on the props
list which
have the property indicated by prop. Thus propvars (atvalue)
returns a list of atoms which have atvalues.
Assigns value to the property (specified by indicator) of atom. indicator may be the name of any property, not just a system-defined property.
rem
reverses the effect of put
.
put
evaluates its arguments.
put
returns value.
Examples:
(%i1) put (foo, (a+b)^5, expr); 5 (%o1) (b + a) (%i2) put (foo, "Hello", str); (%o2) Hello (%i3) properties (foo); (%o3) [[user properties, str, expr]] (%i4) get (foo, expr); 5 (%o4) (b + a) (%i5) get (foo, str); (%o5) Hello
Assigns value to the property (specified by indicator) of
atom. This is the same as put
, except that the arguments are
quoted.
See also get
.
Example:
(%i1) foo: aa$ (%i2) bar: bb$ (%i3) baz: cc$ (%i4) put (foo, bar, baz); (%o4) bb (%i5) properties (aa); (%o5) [[user properties, cc]] (%i6) get (aa, cc); (%o6) bb (%i7) qput (foo, bar, baz); (%o7) bar (%i8) properties (foo); (%o8) [value, [user properties, baz]] (%i9) get ('foo, 'baz); (%o9) bar
declare(a, rational)
or declare(a, irrational)
tells
Maxima to recognize a as a rational or irrational real variable.
See also declare
.
declare(a, real)
, declare(a, imaginary)
, or
declare(a, complex)
tells Maxima to recognize a as a real,
pure imaginary, or complex variable.
See also declare
.
Removes the property indicated by indicator from atom.
rem
reverses the effect of put
.
rem
returns done
if atom had an indicator property
when rem
was called, or false
if it had no such property.
remove
(a_1, p_1, …, a_n, p_n) remove
([a_1, …, a_m], [p_1, …, p_n], …) remove
("a", operator) remove
(a, transfun) remove
(all, p) ¶Removes properties associated with atoms.
remove (a_1, p_1, ..., a_n, p_n)
removes property p_k
from atom a_k
.
remove ([a_1, ..., a_m], [p_1, ..., p_n], ...)
removes properties p_1, ..., p_n
from atoms a_1, …, a_m.
There may be more than one pair of lists.
remove (all, p)
removes the property p from all atoms which
have it.
The removed properties may be system-defined properties such as
function
, macro
, or mode_declare
.
remove
does not remove properties defined by put
.
A property may be transfun
to remove
the translated Lisp version of a function.
After executing this, the Maxima version of the function is executed
rather than the translated version.
remove ("a", operator)
or, equivalently,
remove ("a", op)
removes from a the operator properties
declared by prefix
, infix
,
nary
, postfix
, matchfix
, or
nofix
. Note that the name of the operator must be written as a quoted
string.
remove
always returns done
whether or not an atom has a specified
property. This behavior is unlike the more specific remove functions
remvalue
, remarray
, remfunction
, and
remrule
.
remove
quotes its arguments.
declare(a, scalar)
tells Maxima to consider a a scalar
variable.
See also declare
.
Returns true
if expr is a number, constant, or variable declared
scalar
with declare
, or composed entirely of numbers,
constants, and such variables, but not containing matrices or lists.
See also the predicate function nonscalarp
.
Activates the contexts context_1, …, 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 facts ()
.
The variable activecontexts
is the list
of contexts which are active by way of the activate
function.
Default value: []
activecontexts
is a list of the contexts which are active
by way of the activate
function, as opposed to being active because
they are subcontexts of the current context.
askequal
(expr1, expr2) ¶askequal(expr1, expr2)
attempts to determine from the
assume
database whether expr1 is equal to expr2,
and prompts the user if it cannot tell.
If the user provides the answer,
the answer is stored in the assume
database
for the duration of the evaluation of the expression currently in progress.
When the evaluation is completed,
the user-provided answer is removed from the database.
askequal
returns yes
or no
,
whether the answer was determined from the assume
database
or provided by the user.
See also equal
.
askinteger
(expr, integer) askinteger
(expr) askinteger
(expr, even) askinteger
(expr, odd) ¶askinteger (expr, integer)
attempts to determine from the
assume
database whether expr is an integer.
askinteger
prompts the user if it cannot tell otherwise,
and attempt to install the information in the database if possible.
askinteger (expr)
is equivalent to
askinteger (expr, integer)
.
askinteger (expr, even)
and askinteger (expr, odd)
likewise attempt to determine if expr is an even integer or odd integer,
respectively.
First attempts to determine whether the specified
expression is positive, negative, or zero. If it cannot, it asks the
user the necessary questions to complete its deduction. The user’s
answer is recorded in the data base for the duration of the current
computation. The return value of asksign
is one of pos
,
neg
, or zero
.
Adds predicates pred_1, …, pred_n to the current context.
If a predicate is inconsistent or redundant with the predicates in the current
context, it is not added to the context. The context accumulates predicates
from each call to assume
.
assume
returns a list whose elements are the predicates added to the
context or the atoms redundant
or inconsistent
where applicable.
The predicates pred_1, …, pred_n can only be expressions
with the relational operators < <= equal notequal >=
and >
.
Predicates cannot be literal equality =
or literal inequality #
expressions, nor can they be predicate functions such as integerp
.
Compound predicates of the form pred_1 and ... and pred_n
are recognized, but not pred_1 or ... or pred_n
.
not pred_k
is recognized if pred_k is a relational predicate.
Expressions of the form not (pred_1 and pred_2)
and not (pred_1 or pred_2)
are not recognized.
Maxima’s deduction mechanism is not very strong;
there are many obvious consequences which cannot be determined by is
.
This is a known weakness.
assume
does not handle predicates with complex numbers. If a predicate
contains a complex number assume
returns inconsistent
or
redundant
.
assume
evaluates its arguments.
See also is
, facts
, forget
,
context
, and declare
.
Examples:
(%i1) assume (xx > 0, yy < -1, zz >= 0); (%o1) [xx > 0, yy < - 1, zz >= 0] (%i2) assume (aa < bb and bb < cc); (%o2) [bb > aa, cc > bb] (%i3) facts (); (%o3) [xx > 0, - 1 > yy, zz >= 0, bb > aa, cc > bb] (%i4) is (xx > yy); (%o4) true (%i5) is (yy < -yy); (%o5) true (%i6) is (sinh (bb - aa) > 0); (%o6) true (%i7) forget (bb > aa); (%o7) [bb > aa] (%i8) prederror : false; (%o8) false (%i9) is (sinh (bb - aa) > 0); (%o9) unknown (%i10) is (bb^2 < cc^2); (%o10) unknown
Default value: true
assumescalar
helps govern whether expressions expr
for which nonscalarp (expr)
is false
are assumed to behave like scalars for certain transformations.
Let expr
represent any expression other than a list or a matrix,
and let [1, 2, 3]
represent any list or matrix.
Then expr . [1, 2, 3]
yields [expr, 2 expr, 3 expr]
if assumescalar
is true
, or scalarp (expr)
is
true
, or constantp (expr)
is true
.
If assumescalar
is true
, such
expressions will behave like scalars only for commutative
operators, but not for noncommutative multiplication .
.
When assumescalar
is false
, such
expressions will behave like non-scalars.
When assumescalar
is all
, such expressions will behave like
scalars for all the operators listed above.
Default value: false
When assume_pos
is true
and the sign of a parameter x
cannot be determined from the current context
or other considerations,
sign
and asksign (x)
return true
.
This may forestall some automatically-generated asksign
queries,
such as may arise from integrate
or other computations.
By default, a parameter is x such that symbolp (x)
or subvarp (x)
.
The class of expressions considered parameters can be modified to some extent
via the variable assume_pos_pred
.
sign
and asksign
attempt to deduce the sign of expressions
from the sign of operands within the expression.
For example, if a
and b
are both positive,
then a + b
is also positive.
However, there is no way to bypass all asksign
queries.
In particular, when the asksign
argument is a
difference x - y
or a logarithm log(x)
,
asksign
always requests an input from the user,
even when assume_pos
is true
and assume_pos_pred
is
a function which returns true
for all arguments.
Default value: false
When assume_pos_pred
is assigned the name of a function
or a lambda expression of one argument x,
that function is called to determine
whether x is considered a parameter for the purpose of assume_pos
.
assume_pos_pred
is ignored when assume_pos
is false
.
The assume_pos_pred
function is called by sign
and asksign
with an argument x
which is either an atom, a subscripted variable, or a function call expression.
If the assume_pos_pred
function returns true
,
x is considered a parameter for the purpose of assume_pos
.
By default, a parameter is x such that symbolp (x)
or subvarp (x)
.
See also assume
and assume_pos
.
Examples:
(%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
Default value: initial
context
names the collection of facts maintained by assume
and
forget
. assume
adds facts to the collection named by
context
, while forget
removes facts.
Binding context
to a name foo changes the current context to
foo. If the specified context foo does not yet exist,
it is created automatically by a call to newcontext
.
The specified context is activated automatically.
See contexts
for a general description of the context mechanism.
Default value: [initial, global]
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 collection of facts, 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 forget
or destroyed as a whole by calling kill
to destroy the context to which they belong.
Contexts exist in a hierarchy, with the root always being
the context 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 a subcontext
of the active context.
When a fresh Maxima is started up, the user is in a
context called initial
, which has global
as a subcontext.
See also facts
, newcontext
, supcontext
,
killcontext
, activate
, deactivate
,
assume
, and forget
.
Deactivates the specified contexts context_1, …, context_n.
facts
(item) facts
() ¶If item is the name of a context, facts (item)
returns a
list of the facts in the specified context.
If item is not the name of a context, facts (item)
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.
facts ()
(i.e., without an argument) lists the current context.
forget
(pred_1, …, pred_n) forget
(L) ¶Removes predicates established by assume
.
The predicates may be expressions equivalent to (but not necessarily identical
to) those previously assumed.
forget (L)
, where L is a list of predicates,
forgets each item on the list.
Attempts to determine whether the predicate expr is provable from the
facts in the assume
database.
If the predicate is provably true
or false
, is
returns
true
or false
, respectively. Otherwise, the return value is
governed by the global flag prederror
. When prederror
is
true
, is
complains with an error message. Otherwise, is
returns unknown
.
ev(expr, pred)
(which can be written expr, pred
at
the interactive prompt) is equivalent to is(expr)
.
See also assume
, facts
, and maybe
.
Examples:
is
causes evaluation of predicates.
(%i1) %pi > %e; (%o1) %pi > %e (%i2) is (%pi > %e); (%o2) true
is
attempts to derive predicates from the assume
database.
(%i1) assume (a > b); (%o1) [a > b] (%i2) assume (b > c); (%o2) [b > c] (%i3) is (a < b); (%o3) false (%i4) is (a > c); (%o4) true (%i5) is (equal (a, c)); (%o5) false
If is
can neither prove nor disprove a predicate from the assume
database, the global flag prederror
governs the behavior of is
.
(%i1) assume (a > b); (%o1) [a > b] (%i2) prederror: true$ (%i3) is (a > 0); Maxima was unable to evaluate the predicate: a > 0 -- an error. Quitting. To debug this try debugmode(true); (%i4) prederror: false$ (%i5) is (a > 0); (%o5) unknown
Kills the contexts context_1, …, 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, empty initial
context is created.
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
.
killcontext
evaluates its arguments.
killcontext
returns done
.
Attempts to determine whether the predicate expr is provable from the
facts in the assume
database.
If the predicate is provably true
or false
, maybe
returns
true
or false
, respectively. Otherwise, maybe
returns
unknown
.
maybe
is functionally equivalent to is
with
prederror: false
, but the result is computed without actually assigning
a value to prederror
.
See also assume
, facts
, and is
.
Examples:
(%i1) maybe (x > 0); (%o1) unknown (%i2) assume (x > 1); (%o2) [x > 1] (%i3) maybe (x > 0); (%o3) true
newcontext
(name) newcontext
() ¶Creates a new, empty context, called name, which
has global
as its only subcontext. The newly-created context
becomes the currently active context.
If name is not specified, a new name is created (via gensym
) and returned.
newcontext
evaluates its argument.
newcontext
returns name (if specified) or the new context name.
Attempts to determine the sign of expr on the basis of the facts in the
current data base. It returns one of the following answers: pos
(positive), neg
(negative), zero
, pz
(positive or zero),
nz
(negative or zero), pn
(positive or negative), or pnz
(positive, negative, or zero, i.e. nothing known).
See also signum
.
supcontext
(name, context) supcontext
(name) supcontext
() ¶Creates a new context, called name, which has context as a subcontext. context must exist.
If context is not specified, the current context is assumed.
If name is not specified, a new name is created (via gensym
) and returned.
supcontext
evaluates its argument.
supcontext
returns name (if specified) or the new context name.
Return 0 when the predicate p evaluates to false
; return 1 when
the predicate evaluates to true
. When the predicate evaluates to
something other than true
or false
(unknown), return a noun form.
Examples:
(%i1) charfun (x < 1); (%o1) charfun(x < 1) (%i2) subst (x = -1, %); (%o2) 1 (%i3) e : charfun ('"and" (-1 < x, x < 1))$ (%i4) [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)]; (%o4) [0, 1, 0]
Return a comparison operator op (<
, <=
, >
, >=
,
=
, or #
) such that is (x op y)
evaluates
to true
; when either x or y depends on %i
and
x # y
, return notcomparable
; when there is no such
operator or Maxima isn’t able to determine the operator, return unknown
.
Examples:
(%i1) compare (1, 2); (%o1) < (%i2) compare (1, x); (%o2) unknown (%i3) compare (%i, %i); (%o3) = (%i4) compare (%i, %i + 1); (%o4) notcomparable (%i5) compare (1/x, 0); (%o5) # (%i6) compare (x, abs(x)); (%o6) <=
The function compare
doesn’t try to determine whether the real domains of
its arguments are nonempty; thus
(%i1) compare (acos (x^2 + 1), acos (x^2 + 1) + 1); (%o1) <
The real domain of acos (x^2 + 1)
is empty.
Represents equivalence, that is, equal value.
By itself, equal
does not evaluate or simplify.
The function is
attempts to evaluate equal
to a Boolean value.
is(equal(a, b))
returns true
(or false
) if
and only if a and b are equal (or not equal) for all possible
values of their variables, as determined by evaluating
ratsimp(a - b)
; if ratsimp
returns 0, the two
expressions are considered equivalent. Two expressions may be equivalent even
if they are not syntactically equal (i.e., identical).
When is
fails to reduce equal
to true
or false
, the
result is governed by the global flag prederror
. When prederror
is true
, is
complains with an error message. Otherwise, is
returns unknown
.
In addition to is
, some other operators evaluate equal
and
notequal
to true
or false
, namely if
,
and
, or
, and not
.
The negation of equal
is notequal
.
Examples:
By itself, equal
does not evaluate or simplify.
(%i1) equal (x^2 - 1, (x + 1) * (x - 1)); 2 (%o1) equal(x - 1, (x - 1) (x + 1)) (%i2) equal (x, x + 1); (%o2) equal(x, x + 1) (%i3) equal (x, y); (%o3) equal(x, y)
The function is
attempts to evaluate equal
to a Boolean value.
is(equal(a, b))
returns true
when
ratsimp(a - b)
returns 0. Two expressions may be equivalent
even if they are not syntactically equal (i.e., identical).
(%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1)); (%o1) 0 (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1))); (%o2) true (%i3) is (x^2 - 1 = (x + 1) * (x - 1)); (%o3) false (%i4) ratsimp (x - (x + 1)); (%o4) - 1 (%i5) is (equal (x, x + 1)); (%o5) false (%i6) is (x = x + 1); (%o6) false (%i7) ratsimp (x - y); (%o7) x - y (%i8) is (equal (x, y)); (%o8) unknown (%i9) is (x = y); (%o9) false
When is
fails to reduce equal
to true
or false
,
the result is governed by the global flag prederror
.
(%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1]; 2 2 (%o1) [x + 2 x + 1, x - 2 x - 1] (%i2) ratsimp (aa - bb); (%o2) 4 x + 2 (%i3) prederror : true; (%o3) true (%i4) is (equal (aa, bb)); Maxima was unable to evaluate the predicate: 2 2 equal(x + 2 x + 1, x - 2 x - 1) -- an error. Quitting. To debug this try debugmode(true); (%i5) prederror : false; (%o5) false (%i6) is (equal (aa, bb)); (%o6) unknown
Some operators evaluate equal
and notequal
to true
or
false
.
(%i1) if equal (y, y - 1) then FOO else BAR; (%o1) BAR (%i2) eq_1 : equal (x, x + 1); (%o2) equal(x, x + 1) (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2); 2 2 (%o3) equal(y + 2 y + 1, (y + 1) ) (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1]; (%o4) [false, true, true]
Because not expr
causes evaluation of expr,
not equal(a, b)
is equivalent to
is(notequal(a, b))
.
(%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)]; (%o1) [notequal(2 z, 2 z - 1), true] (%i2) is (notequal (2*z, 2*z - 1)); (%o2) true
Represents the negation of equal(a, b)
.
Examples:
(%i1) equal (a, b); (%o1) equal(a, b) (%i2) maybe (equal (a, b)); (%o2) unknown (%i3) notequal (a, b); (%o3) notequal(a, b) (%i4) not equal (a, b); (%o4) notequal(a, b) (%i5) maybe (notequal (a, b)); (%o5) unknown (%i6) assume (a > b); (%o6) [a > b] (%i7) equal (a, b); (%o7) equal(a, b) (%i8) maybe (equal (a, b)); (%o8) false (%i9) notequal (a, b); (%o9) notequal(a, b) (%i10) maybe (notequal (a, b)); (%o10) true
Returns true
if and only if expr contains an operator or function
not recognized by the Maxima simplifier.
Tests whether the expression expr in the variable v is equivalent
to zero, returning true
, false
, or dontknow
.
zeroequiv
has these restrictions:
For example zeroequiv (sin(2 * x) - 2 * sin(x) * cos(x), x)
returns
true
and zeroequiv (%e^x + x, x)
returns false
.
On the other hand zeroequiv (log(a * b) - log(a) - log(b), a)
returns
dontknow
because of the presence of an extra parameter b
.
To make the plots, Maxima can use an external plotting package or its
own graphical interface Xmaxima (see the section on Plotting Formats
). The plotting functions calculate a set of points and pass
them to the plotting package together with a set of commands specific to
that graphic program. In some cases those commands and data are saved in
a file and the graphic program is executed giving it the name of that
file to be parsed.
When a file is created, it will begiven the name
maxout_xxx.format
, where xxx
is a number that is unique to
every concurrently-running instance of Maxima and format
is the
name of the plotting format being used (gnuplot
, xmaxima
,
mgnuplot
or geomview
).
There are commands to save the plot in a graphic format file, rather
than showing it in the screen. The default name for that graphic file is
maxplot.extension
, where extension
is the extension
normally used for the kind of graphic file selected, but that name can
also be specified by the user.
The maxout_xxx.format
and maxplot.extension
files are created
in the directory specified by the system variable
maxima_tempdir
. That location can be changed by assigning to
that variable (or to the environment variable MAXIMA_TEMPDIR
) a string
that represents a valid directory where Maxima can create new files. The
output of the Maxima plotting command will be a list with the names of
the file(s) created, including their complete path, or empty if no files
are created. Those files should be deleted after the maxima session ends.
If the format used is either gnuplot
or xmaxima
, and the
maxout_xxx.gnuplot
or maxout_xxx.xmaxima
was saved,
gnuplot
or xmaxima
can be run, giving it the name of that
file as argument, in order to view again a plot previously created in
Maxima. Thus, when a Maxima plotting command fails, the format can be
set to gnuplot
or xmaxima
and the plain-text file
maxout_xxx.gnuplot
(or maxout_xxx.xmaxima
) can be
inspected to look for the source of the problem.
The additional package draw provides functions similar to the ones
described in this section with some extra features, but it only works
with gnuplot
. Note that some plotting options have the same name
in both plotting packages, but their syntax and behavior is
different. To view the documentation for a graphic option opt
,
type ?? opt
in order to choose the information for either of
those two packages.
Maxima can use either Gnuplot, Xmaxima or Geomview as graphics
program. Gnuplot and Geomview are external programs which must be
installed separately, while Xmaxima is distributed with Maxima. To see
which plotting format you are currently using, use the command
get_plot_option(plot_format);
and to change to another format,
you can use set_plot_option([plot_format, <format>])
, where
<format>
is the name of one of the formats described below. Those
two commands show and change the global plot format, while each
individual plotting command can use its own format, if it includes an
option [plot_format, <format>]
(see get_plot_option
and
set_plot_option
).
The plotting formats are the following:
Used to launch the external program gnuplot, which must be installed in
your system. All plotting commands and data are saved into the file
maxout_xxx.gnuplot
.
It is similar to the gnuplot
format except that the commands and
plot data are sent directly to gnuplot
without creating any
files. A single gnuplot process is kept open, with a single graphic
window, and subsequent plot commands will be sent to the same process,
replacing previous plots in that same window. Even if the graphic window
is closed, the gnuplot
process is still running until the end of
the session or until it is killed with gnuplot_close
.. The
function gnuplot_replot
can be used to modify a plot that has
already been displayed on the screen or to open again the graphic window
after it was closed.
This format does not work with some versions of Lisp under Windows and
it is only used to plot to the screen; whenever graphic files are to be
created, the format is silently switched to gnuplot
and the
commands needed to create the graphic file are saved with the data in
file maxout_xxx.gnuplot
.
Mgnuplot is a Tk-based wrapper around gnuplot. It is an old interface still included in the Maxima distribution, but it is currently disabled because it does not have most of the features introduced by the newer versions of the plotting commands. Mgnuplot requires an external gnuplot installation and, in Unix systems, the Tcl/Tk system.
Xmaxima is a Tcl/Tk graphical interface for Maxima that can also be used
to display plots created when Maxima is run from the console or from
other graphical interfaces. To use this format, the xmaxima program,
which is distributed together with Maxima, must be installed; in some
Linux distributions Xmaxima is distributed in a package separate from
other parts of Maxima. If Maxima is being run from the Xmaxima console,
the data and commands are passed to xmaxima through the same socket used
for the communication between Maxima and the Xmaxima console. When used
from a terminal or from graphical interfaces different from Xmaxima, the
commands and data are saved in the file maxout_xxx.xmaxima
and
xmaxima is run with the name of that file as argument.
Geomview, a Motif based interactive 3D viewing program for Unix. It can
only be used to display plots created with plot3d
. To use this
format, the geomview program must be installed.
This variable stores the name of the command used to run the geomview
program when the plot format is geomview
. Its default value is
"geomview". If the geomview program is not found unless you give
its complete path or if you want to try a different version of it,
you may change the value of this variable. For instance,
(%i1) geomview_command: "/usr/local/bin/my_geomview"$
Returns the current default value of the option named keyword, which is a list. The optional argument index must be a positive integer which can be used to extract only one element from the list (element 1 is the name of the option).
See also set_plot_option
, remove_plot_option
and the
section on Plotting Options
.
This variable stores the name of the command used to run the gnuplot
program when the plot format is gnuplot
or
gnuplot_pipes
. Its default value is "gnuplot". If the gnuplot
program is not found unless you give its complete path or if you want to
try a different version of it, you may change the value of this
variable. For instance,
(%i1) gnuplot_command: "/usr/local/bin/my_gnuplot"$
When a graphic file is going to be created using gnuplot
, this
variable is used to specify the format used to print the file name given
to gnuplot. Its default value is "~a" in SBCL and Openmcl, and "~s" in
other lisp versions, which means that the name of the file will be
passed without quotes if SBCL or Openmcl are used and within quotes if
other Lisp versions are used. The contents of this variable can be
changed in order to add options for the gnuplot program, adding those
options before the format directive "~s".
This variable is the format used to parse the argument that will be
passed to the gnuplot program when the plot format is
gnuplot
. Its default value is "-persist ~a" when SBCL or Openmcl
are used, and "-persist ~s" with other Lisp variants, where "~a" or "~s"
will be replaced with the name of the file where the gnuplot commands
have been written (usually "maxout_xxx.gnuplot"). The option
-persist
tells gnuplot to exit after the commands in the file
have been executed, without closing the window that displays the plot.
Those familiar with gnuplot, might want to change the value of this variable. For example, by changing it to:
(%i1) gnuplot_view_args: "~s -"$
gnuplot will not be closed after the commands in the file have been executed; thus, the window with the plot will remain, as well as the gnuplot interactive shell where other commands can be issued in order to modify the plot.
In Windows versions of Gnuplot older than 4.6.3 the behavior of "~s -"
and "-persist ~s" were the opposite; namely, "-persist ~s" made the plot
window and the gnuplot interactive shell remain, while "~s -" closed the
gnuplot shell keeping the plot window. Therefore, when older gnuplot
versions are used in Windows, it might be necessary to adjust the value
of gnuplot_view_args
.
Creates a graphic representation of the Julia set for the complex number
(x + i y). The two mandatory parameters x and y
must be real. This program is part of the additional package
dynamics
, but that package does not have to be loaded; the first
time julia is used, it will be loaded automatically.
Each pixel in the grid is given a color corresponding to the number of
iterations it takes the sequence that starts at that point to move out
of the convergence circle of radius 2 centered at the origin. The number
of pixels in the grid is controlled by the grid
plot option
(default 30 by 30). The maximum number of iterations is set with the
option iterations
. The program sets its own default palette:
magenta, violet, blue, cyan, green, yellow, orange, red, brown and black,
but it can be changed by adding an explicit palette
option in the
command.
The default domain used goes from -2 to 2 in both axes and can be
changed with the x
and y
options. By default, the two axes
are shown with the same scale, unless the option yx_ratio
is used
or the option same_xy
is disabled. Other general plot options are
also accepted.
The following example shows a region of the Julia set for the number
-0.55 + i0.6. The option color_bar_tics
is used to prevent
Gnuplot from adjusting the color box up to 40, in which case the points
corresponding the maximum 36 iterations would not be black.
(%i1) julia (-0.55, 0.6, [iterations, 36], [x, -0.3, 0.2], [y, 0.3, 0.9], [grid, 400, 400], [color_bar_tics, 0, 6, 36])$
Returns a function suitable to be used in the option transform_xy
of plot3d. The three variables var1, var2, var3 are
three dummy variable names, which represent the 3 variables given by the
plot3d command (first the two independent variables and then the
function that depends on those two variables). The three functions
fx, fy, fz must depend only on those 3 variables, and
will give the corresponding x, y and z coordinates that should be
plotted. There are two transformations defined by default:
polar_to_xy
and spherical_to_xyz
. See the documentation
for those two transformations.
Creates a graphic representation of the Mandelbrot set. This program is
part of the additional package dynamics
, but that package does
not have to be loaded; the first time mandelbrot is used, the package
will be loaded automatically.
This program can be called without any arguments, in which case it will
use a default value of 9 iterations per point, a grid with dimensions
set by the grid
plot option (default 30 by 30) and a region
that extends from -2 to 2 in both axes. The options are all the same
that plot2d accepts, plus an option iterations
to change the
number of iterations.
Each pixel in the grid is given a color corresponding to the number of
iterations it takes the sequence starting at zero to move out
of the convergence circle of radius 2, centered at the origin. The
maximum number of iterations is set by the option iterations
.
The program uses its own default palette: magenta,violet, blue, cyan,
green, yellow, orange, red, brown and black, but it can be changed by
adding an explicit palette
option in the command. By default, the
two axes are shown with the same scale, unless the option yx_ratio
is used or the option same_xy
is disabled.
Example:
[grid,400,400])$
(%i1) mandelbrot ([iterations, 30], [x, -2, 1], [y, -1.2, 1.2], [grid,400,400])$
It can be given as value for the transform_xy
option of
plot3d. Its effect will be to interpret the two independent variables in
plot3d as the distance from the z axis and the azimuthal angle (polar
coordinates), and transform them into x and y coordinates.
plot2d
(expr, range_x, options) plot2d
(expr_1=expr_2, range_x, range_y, options) plot2d
([parametric, expr_x, expr_y, range], options) plot2d
([discrete, points], options) plot2d
([contour, expr], range_x, range_y, options) plot2d
([type_1, …, type_n], options) ¶There are 5 types of plots that can be plotted by plot2d
:
plot2d
(expr, range_x,
options), where expr is an expression that depends on only
one variable, or the name of a function with one input parameter and
numerical results. range_x is a list with three elements, the
first one being the name of the variable that will be shown on the
horizontal axis of the plot, and the other two elements should be two
numbers, the first one smaller than the second, that define the minimum
and maximum values to be shown on the horizontal axis. The name of the
variable used in range_x must be the same variable on which
expr depends. The result will show in the vertical axis the
corresponding values of the expression or function for each value of the
variable in the horizontal axis.
plot2d
(expr_1=expr_2,
range_x, range_y, options), where expr_1 and
expr_2 are two expressions that can depend on one or two
variables. range_x and range_y must be two lists of three
elements that define the ranges for the variables in the two axes of the
plot; the first element of each list is the name of the corresponding
variable, and the other two elements are the minimum and maximum values
for that variable. The two variables on which expr_1 and
expr_2 can depend are those specified by range_x and
range_y. The result will be a curve or a set of curves where the
equation expr_1=expr_2 is true.
plot2d
([parametric,
expr_x, expr_y, range], options), where
expr_x and expr_y are two expressions that depend on a
single parameter. range must be a three-element list; the first
element must be the name of the parameter on which expr_x and
expr_y depend, and the other two elements must be the minimum and
maximum values for that parameter. The result will be a curve in which
the horizontal and vertical coordinates of each point are the values of
expr_x and expr_y for a value of the parameter within the
range given.
plot2d
([discrete, points],
options), displays a list of points, joined by segments by
default. The horizontal and vertical coordinates of each of those points
can be specified in three different ways: With two lists of the same
length, in which the elements of the first list are the horizontal
coordinates of the points and the second list are the vertical
coordinates, or with a list of two-element lists, each one corresponding
to the two coordinates of one of the points, or with a single list that
defines the vertical coordinates of the points; in this last case, the
horizontal coordinates of the n points will be assumed to be the first n
natural numbers.
plot2d
([contour, expr],
range_x, range_y, options), where expr is an
expression that depends on two variables. range_x and
range_y will be lists whose first elements are the names of those
two variables, followed by two numbers that set the minimum and maximum
values for them. The first variable will be represented along the
horizontal axis and the second along the vertical axis. The result will
be a set of curves along which the given expression has certain
values. If those values are not specified with the option levels
,
plotd2d will try to choose, at the most, 8 values of the form d*10^n, where d is
either 1, 2 or 5, all of them within the minimum and maximum values of
expr within the given ranges.
At the end of a plot2d command several of the options described in
Plotting Options
can be used. Many instances of the 5 types
described above can be combined into a single plot, by putting them
inside a list: plot2d
([type_1, …, type_n],
options). If one of the types included in the list require
range_x or range_y, those ranges should come immediately
after the list.
If there are several plots to be plotted, a legend will be
written to identity each of the expressions. The labels that should be
used in that legend can be given with the option legend
. If that
option is not used, Maxima will create labels from the expressions or
function names.
Examples:
(%i1) plot2d (sin(x), [x, -%pi, %pi])$
(%i1) plot2d (x^2-y^3+3*y=2, [x,-2.5,2.5], [y,-2.5,2.5])$
(%i1) r: (exp(cos(t))-2*cos(4*t)-sin(t/12)^5)$ (%i2) plot2d([parametric, r*sin(t), r*cos(t), [t,-8*%pi,8*%pi]])$
(%i1) plot2d ([discrete, makelist(i*%pi, i, 1, 5), [0.6, 0.9, 0.2, 1.3, 1]])$
(%i1) plot2d ([contour, u^3 + v^2], [u, -4, 4], [v, -4, 4])$
Examples using options.
If an explicit function grows too fast, the y
option can be used
to limit the values in the vertical axis:
(%i1) plot2d (sec(x), [x, -2, 2], [y, -20, 20])$
When the plot box is disabled, no labels are created for the axes. In
that case, instead of using xlabel
and ylabel
to set the
names of the axes, it is better to use option label