Maxima Manual

Version 5.45.0
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.
 i

Short Contents
1 Introduction to Maxima . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
2 Bug Detection and Reporting . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3 Help . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4 Command Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5 Data Types and Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6 Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
7 Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
8 Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
9 Simplification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
10 Mathematical Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
11 Maxima’s Database . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
12 Plotting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
13 File Input and Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
14 Polynomials . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
15 Special Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
16 Elliptic Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
17 Limits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
18 Differentiation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
19 Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
20 Equations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
21 Differential Equations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
22 Numerical . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
23 Matrices and Linear Algebra . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
24 Affine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
25 itensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
26 ctensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463
27 atensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
28 Sums, Products, and Series . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
29 Number Theory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515
30 Symmetries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537
31 Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555
32 Runtime Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
33 Miscellaneous Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565
ii

34 Rules and Patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 569

35 Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
36 Function Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
37 Program Flow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641
38 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
39 alt-display . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 665
40 asympa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 671
41 augmented lagrangian . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 673
42 Bernstein . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675
43 bitwise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677
44 bode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 681
45 celine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685
46 clebsch gordan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687
47 cobyla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 689
48 combinatorics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693
49 contrib ode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699
50 descriptive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705
51 diag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 739
52 distrib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 745
53 draw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 779
54 drawdf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 897
55 dynamics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 901
56 engineering-format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 915
57 ezunits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 917
58 f90 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 935
59 finance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 937
60 fractals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 943
61 ggf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 947
62 graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 949
63 grobner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 979
64 hompack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 987
65 impdiff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 991
66 interpol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 993
67 lapack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1001
68 lbfgs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1009
69 lindstedt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1015
 iii

70 linearalgebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1017
71 lsquares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1031
72 minpack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1041
73 makeOrders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1043
74 mnewton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1045
75 numericalio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1047
76 odepack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1053
77 operatingsystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057
78 opsubst . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1059
79 orthopoly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1061
80 pytranslate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1073
81 ratpow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1079
82 romberg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1081
83 simplex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1085
84 simplification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1089
85 solve rec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1099
86 stats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1105
87 stirling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1123
88 stringproc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1125
89 to poly solve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1149
90 unit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1169
91 wrstcse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1179
92 zeilberger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1183
93 Error and warning messages . . . . . . . . . . . . . . . . . . . . . . . . . . 1187
94 Command-line options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1191
A Function and Variable Index . . . . . . . . . . . . . . . . . . . . . . . . . . 1193
 v

Table of Contents

1 Introduction to Maxima . . . . . . . . . . . . . . . . . . . . . . . . 1

2 Bug Detection and Reporting . . . . . . . . . . . . . . . . . . 7

2.1 Functions and Variables for Bug Detection and Reporting . . . . . . . 7

3 Help . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1 Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2 Functions and Variables for Help. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4 Command Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.1 Introduction to Command Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.2 Functions and Variables for Command Line . . . . . . . . . . . . . . . . . . . . 15
4.3 Functions and Variables for Display . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

5 Data Types and Structures. . . . . . . . . . . . . . . . . . . . 41

5.1 Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.1.1 Introduction to Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.1.2 Functions and Variables for Numbers . . . . . . . . . . . . . . . . . . . . . 41
5.2 Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.2.1 Introduction to Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.2.2 Functions and Variables for Strings . . . . . . . . . . . . . . . . . . . . . . . 47
5.3 Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
5.3.1 Functions and Variables for Constants . . . . . . . . . . . . . . . . . . . . 50
5.4 Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
5.4.1 Introduction to Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
5.4.2 Functions and Variables for Lists. . . . . . . . . . . . . . . . . . . . . . . . . . 53
5.4.3 Performance considerations for Lists . . . . . . . . . . . . . . . . . . . . . . 70
5.5 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.5.1 Functions and Variables for Arrays . . . . . . . . . . . . . . . . . . . . . . . . 72
5.6 Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
5.6.1 Introduction to Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
5.6.2 Functions and Variables for Structures . . . . . . . . . . . . . . . . . . . . 82

6 Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.1 Introduction to Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.2 Nouns and Verbs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.3 Identifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
6.4 Inequality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
6.5 Functions and Variables for Expressions. . . . . . . . . . . . . . . . . . . . . . . . 87
vi

7 Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
7.1 Introduction to operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
7.2 Arithmetic operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
7.3 Relational operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
7.4 Logical operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
7.5 Operators for Equations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
7.6 Assignment operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
7.7 User defined operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

8 Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
8.1 Functions and Variables for Evaluation . . . . . . . . . . . . . . . . . . . . . . . 131

9 Simplification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
9.1 Introduction to Simplification. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
9.2 Functions and Variables for Simplification . . . . . . . . . . . . . . . . . . . . 145

10 Mathematical Functions . . . . . . . . . . . . . . . . . . . . 161

10.1 Functions for Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
10.2 Functions for Complex Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
10.3 Combinatorial Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
10.4 Root, Exponential and Logarithmic Functions . . . . . . . . . . . . . . . 173
10.5 Trigonometric Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
10.5.1 Introduction to Trigonometric . . . . . . . . . . . . . . . . . . . . . . . . . . 180
10.5.2 Functions and Variables for Trigonometric . . . . . . . . . . . . . . 180
10.6 Random Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

11 Maxima’s Database. . . . . . . . . . . . . . . . . . . . . . . . . . 189

11.1 Introduction to Maxima’s Database. . . . . . . . . . . . . . . . . . . . . . . . . . 189
11.2 Functions and Variables for Properties . . . . . . . . . . . . . . . . . . . . . . . 189
11.3 Functions and Variables for Facts . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
11.4 Functions and Variables for Predicates . . . . . . . . . . . . . . . . . . . . . . . 205

12 Plotting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
12.1 Introduction to Plotting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
12.2 Plotting Formats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
12.3 Functions and Variables for Plotting . . . . . . . . . . . . . . . . . . . . . . . . . 210
12.4 Plotting Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
12.5 Gnuplot Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
12.6 Gnuplot pipes Format Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239

13 File Input and Output . . . . . . . . . . . . . . . . . . . . . . 241

13.1 Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
13.2 Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
13.3 Functions and Variables for File Input and Output. . . . . . . . . . . 242
13.4 Functions and Variables for TeX Output . . . . . . . . . . . . . . . . . . . . . 249
13.5 Functions and Variables for Fortran Output . . . . . . . . . . . . . . . . . 254
 vii

14 Polynomials . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
14.1 Introduction to Polynomials . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
14.2 Functions and Variables for Polynomials . . . . . . . . . . . . . . . . . . . . . 257

15 Special Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287

15.1 Introduction to Special Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
15.2 Bessel Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
15.3 Airy Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
15.4 Gamma and factorial Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
15.5 Exponential Integrals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
15.6 Error Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
15.7 Struve Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
15.8 Hypergeometric Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
15.9 Parabolic Cylinder Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
15.10 Functions and Variables for Special Functions . . . . . . . . . . . . . . 307

16 Elliptic Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313

16.1 Introduction to Elliptic Functions and Integrals . . . . . . . . . . . . . . 313
16.2 Functions and Variables for Elliptic Functions . . . . . . . . . . . . . . . 314
16.3 Functions and Variables for Elliptic Integrals . . . . . . . . . . . . . . . . 316

17 Limits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
17.1 Functions and Variables for Limits. . . . . . . . . . . . . . . . . . . . . . . . . . . 319

18 Differentiation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
18.1 Functions and Variables for Differentiation . . . . . . . . . . . . . . . . . . . 321

19 Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
19.1 Introduction to Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
19.2 Functions and Variables for Integration . . . . . . . . . . . . . . . . . . . . . . 335
19.3 Introduction to QUADPACK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
19.3.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
19.4 Functions and Variables for QUADPACK . . . . . . . . . . . . . . . . . . . . 347

20 Equations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
20.1 Functions and Variables for Equations . . . . . . . . . . . . . . . . . . . . . . . 357

21 Differential Equations . . . . . . . . . . . . . . . . . . . . . . . 377

21.1 Introduction to Differential Equations . . . . . . . . . . . . . . . . . . . . . . . 377
21.2 Functions and Variables for Differential Equations . . . . . . . . . . . 377
viii

22 Numerical . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
22.1 Introduction to fast Fourier transform . . . . . . . . . . . . . . . . . . . . . . . 381
22.2 Functions and Variables for fft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
22.3 Functions and Variables for FFTPACK5 . . . . . . . . . . . . . . . . . . . . . 385
22.4 Functions for numerical solution of equations . . . . . . . . . . . . . . . . 387
22.5 Introduction to numerical solution of differential equations . . . 389
22.6 Functions for numerical solution of differential equations . . . . . 390

23 Matrices and Linear Algebra . . . . . . . . . . . . . . . 399

23.1 Introduction to Matrices and Linear Algebra . . . . . . . . . . . . . . . . . 399
23.1.1 Dot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
23.1.2 Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
23.1.3 Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
23.1.4 eigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
23.2 Functions and Variables for Matrices and Linear Algebra. . . . . 400

24 Affine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
24.1 Introduction to Affine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
24.2 Functions and Variables for Affine . . . . . . . . . . . . . . . . . . . . . . . . . . . 425

25 itensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
25.1 Introduction to itensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
25.1.1 New tensor notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
25.1.2 Indicial tensor manipulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
25.2 Functions and Variables for itensor . . . . . . . . . . . . . . . . . . . . . . . . . . 433
25.2.1 Managing indexed objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
25.2.2 Tensor symmetries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
25.2.3 Indicial tensor calculus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
25.2.4 Tensors in curved spaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
25.2.5 Moving frames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451
25.2.6 Torsion and nonmetricity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
25.2.7 Exterior algebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
25.2.8 Exporting TeX expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460
25.2.9 Interfacing with ctensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
25.2.10 Reserved words . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462

26 ctensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463
26.1 Introduction to ctensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463
26.2 Functions and Variables for ctensor . . . . . . . . . . . . . . . . . . . . . . . . . . 465
26.2.1 Initialization and setup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
26.2.2 The tensors of curved space. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468
26.2.3 Taylor series expansion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
26.2.4 Frame fields . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473
26.2.5 Algebraic classification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473
26.2.6 Torsion and nonmetricity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476
26.2.7 Miscellaneous features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
 ix

26.2.8 Utility functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480

26.2.9 Variables used by ctensor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485
26.2.10 Reserved names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488
26.2.11 Changes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488

27 atensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
27.1 Introduction to atensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
27.2 Functions and Variables for atensor . . . . . . . . . . . . . . . . . . . . . . . . . . 492

28 Sums, Products, and Series . . . . . . . . . . . . . . . . . 495

28.1 Functions and Variables for Sums and Products. . . . . . . . . . . . . . 495
28.2 Introduction to Series . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
28.3 Functions and Variables for Series . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
28.4 Introduction to Fourier series . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511
28.5 Functions and Variables for Fourier series . . . . . . . . . . . . . . . . . . . . 511
28.6 Functions and Variables for Poisson series . . . . . . . . . . . . . . . . . . . 512

29 Number Theory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515

29.1 Functions and Variables for Number Theory . . . . . . . . . . . . . . . . . 515

30 Symmetries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537
30.1 Introduction to Symmetries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537
30.2 Functions and Variables for Symmetries . . . . . . . . . . . . . . . . . . . . . 537
30.2.1 Changing bases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537
30.2.2 Changing representations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541
30.2.3 Groups and orbits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
30.2.4 Partitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
30.2.5 Polynomials and their roots . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546
30.2.6 Resolvents. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547
30.2.7 Miscellaneous . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553

31 Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555
31.1 Functions and Variables for Groups . . . . . . . . . . . . . . . . . . . . . . . . . . 555

32 Runtime Environment . . . . . . . . . . . . . . . . . . . . . . 557

32.1 Introduction for Runtime Environment . . . . . . . . . . . . . . . . . . . . . . 557
32.2 Interrupts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
32.3 Functions and Variables for Runtime Environment . . . . . . . . . . . 557

33 Miscellaneous Options . . . . . . . . . . . . . . . . . . . . . . 565

33.1 Introduction to Miscellaneous Options . . . . . . . . . . . . . . . . . . . . . . . 565
33.2 Share . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565
33.3 Functions and Variables for Miscellaneous Options . . . . . . . . . . . 565
x

34 Rules and Patterns . . . . . . . . . . . . . . . . . . . . . . . . . . 569

34.1 Introduction to Rules and Patterns . . . . . . . . . . . . . . . . . . . . . . . . . . 569
34.2 Functions and Variables for Rules and Patterns . . . . . . . . . . . . . . 569

35 Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
35.1 Introduction to Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
35.1.1 Usage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
35.1.2 Set Member Iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587
35.1.3 Authors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
35.2 Functions and Variables for Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588

36 Function Definition . . . . . . . . . . . . . . . . . . . . . . . . . . 609

36.1 Introduction to Function Definition . . . . . . . . . . . . . . . . . . . . . . . . . . 609
36.2 Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
36.2.1 Ordinary functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
36.2.2 Memoizing Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
36.3 Macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611
36.4 Functions and Variables for Function Definition . . . . . . . . . . . . . . 615

37 Program Flow. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641

37.1 Lisp and Maxima . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641
37.2 Garbage Collection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642
37.3 Introduction to Program Flow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642
37.4 Functions and Variables for Program Flow . . . . . . . . . . . . . . . . . . . 643

38 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
38.1 Source Level Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
38.2 Keyword Commands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658
38.3 Functions and Variables for Debugging . . . . . . . . . . . . . . . . . . . . . . 659

39 alt-display . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 665
39.1 Introduction to alt-display . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 665
39.2 Functions and Variables for alt-display. . . . . . . . . . . . . . . . . . . . . . . 666

40 asympa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 671
40.1 Introduction to asympa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 671
40.2 Functions and variables for asympa . . . . . . . . . . . . . . . . . . . . . . . . . . 671

41 augmented lagrangian . . . . . . . . . . . . . . . . . . . . . . . 673

41.1 Functions and Variables for augmented lagrangian . . . . . . . . . . . 673

42 Bernstein . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675
42.1 Functions and Variables for Bernstein . . . . . . . . . . . . . . . . . . . . . . . 675
 xi

43 bitwise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677
43.1 Functions and Variables for bitwise . . . . . . . . . . . . . . . . . . . . . . . . . . 677

44 bode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 681
44.1 Functions and Variables for bode . . . . . . . . . . . . . . . . . . . . . . . . . . . . 681

45 celine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685
45.1 Introduction to celine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685

46 clebsch gordan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687

46.1 Functions and Variables for clebsch gordan . . . . . . . . . . . . . . . . . . 687

47 cobyla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 689
47.1 Introduction to cobyla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 689
47.2 Functions and Variables for cobyla. . . . . . . . . . . . . . . . . . . . . . . . . . . 689
47.3 Examples for cobyla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 691

48 combinatorics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693
48.1 Package combinatorics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693
48.2 Functions and Variables for Combinatorics . . . . . . . . . . . . . . . . . . . 693

49 contrib ode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699

49.1 Introduction to contrib ode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699
49.2 Functions and Variables for contrib ode . . . . . . . . . . . . . . . . . . . . . 701
49.3 Possible improvements to contrib ode. . . . . . . . . . . . . . . . . . . . . . . . 703
49.4 Test cases for contrib ode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704
49.5 References for contrib ode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704

50 descriptive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705
50.1 Introduction to descriptive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705
50.2 Functions and Variables for data manipulation . . . . . . . . . . . . . . . 707
50.3 Functions and Variables for descriptive statistics . . . . . . . . . . . . . 713
50.4 Functions and Variables for statistical graphs . . . . . . . . . . . . . . . . 728

51 diag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 739
51.1 Functions and Variables for diag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 739

52 distrib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 745
52.1 Introduction to distrib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 745
52.2 Functions and Variables for continuous distributions . . . . . . . . . 747
52.3 Functions and Variables for discrete distributions . . . . . . . . . . . . 767
xii

53 draw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 779
53.1 Introduction to draw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 779
53.2 Functions and Variables for draw . . . . . . . . . . . . . . . . . . . . . . . . . . . . 780
53.2.1 Scenes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 780
53.2.2 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 781
53.2.3 Plot options for draw programs . . . . . . . . . . . . . . . . . . . . . . . . . 785
53.2.4 Graphics objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 854
53.3 Functions and Variables for pictures . . . . . . . . . . . . . . . . . . . . . . . . . 884
53.4 Functions and Variables for worldmap . . . . . . . . . . . . . . . . . . . . . . . 886
53.4.1 Variables and Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 886
53.4.2 Graphic objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 891

54 drawdf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 897
54.1 Introduction to drawdf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 897
54.2 Functions and Variables for drawdf . . . . . . . . . . . . . . . . . . . . . . . . . . 897
54.2.1 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 897

55 dynamics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 901
55.1 The dynamics package. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 901
55.2 Graphical analysis of discrete dynamical systems . . . . . . . . . . . . . 901
55.3 Visualization with VTK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 906
55.3.1 Scene options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 908
55.3.2 Scene objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 909
55.3.3 Scene object’s options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 910

56 engineering-format . . . . . . . . . . . . . . . . . . . . . . . . . . 915
56.1 Functions and Variables for engineering-format . . . . . . . . . . . . . . 915
56.2 Known Bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 915

57 ezunits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 917
57.1 Introduction to ezunits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 917
57.2 Introduction to physical constants . . . . . . . . . . . . . . . . . . . . . . . . . . . 918
57.3 Functions and Variables for ezunits . . . . . . . . . . . . . . . . . . . . . . . . . . 920

58 f90 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 935
58.1 Package f90 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 935

59 finance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 937
59.1 Introduction to finance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 937
59.2 Functions and Variables for finance . . . . . . . . . . . . . . . . . . . . . . . . . . 937
 xiii

60 fractals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 943
60.1 Introduction to fractals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 943
60.2 Definitions for IFS fractals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 943
60.3 Definitions for complex fractals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 944
60.4 Definitions for Koch snowflakes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 945
60.5 Definitions for Peano maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 945

61 ggf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 947
61.1 Functions and Variables for ggf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 947

62 graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 949
62.1 Introduction to graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 949
62.2 Functions and Variables for graphs . . . . . . . . . . . . . . . . . . . . . . . . . . 949
62.2.1 Building graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 949
62.2.2 Graph properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 955
62.2.3 Modifying graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 970
62.2.4 Reading and writing to files . . . . . . . . . . . . . . . . . . . . . . . . . . . . 972
62.2.5 Visualization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 973

63 grobner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 979
63.1 Introduction to grobner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 979
63.1.1 Notes on the grobner package . . . . . . . . . . . . . . . . . . . . . . . . . . . 979
63.1.2 Implementations of admissible monomial orders in grobner . . 979
63.2 Functions and Variables for grobner . . . . . . . . . . . . . . . . . . . . . . . . . 980
63.2.1 Global switches for grobner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 980
63.2.2 Simple operators in grobner . . . . . . . . . . . . . . . . . . . . . . . . . . . . 981
63.2.3 Other functions in grobner. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 981
63.2.4 Standard postprocessing of Groebner Bases . . . . . . . . . . . . . 983

64 hompack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 987
64.1 Introduction to hompack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 987
64.2 Functions and Variables for hompack . . . . . . . . . . . . . . . . . . . . . . . . 987

65 impdiff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 991
65.1 Functions and Variables for impdiff . . . . . . . . . . . . . . . . . . . . . . . . . . 991

66 interpol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 993
66.1 Introduction to interpol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 993
66.2 Functions and Variables for interpol . . . . . . . . . . . . . . . . . . . . . . . . . 993

67 lapack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1001
67.1 Introduction to lapack. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1001
67.2 Functions and Variables for lapack . . . . . . . . . . . . . . . . . . . . . . . . . 1001
xiv

68 lbfgs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1009
68.1 Introduction to lbfgs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1009
68.2 Functions and Variables for lbfgs . . . . . . . . . . . . . . . . . . . . . . . . . . . 1009

69 lindstedt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1015
69.1 Functions and Variables for lindstedt . . . . . . . . . . . . . . . . . . . . . . . 1015

70 linearalgebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1017
70.1 Introduction to linearalgebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1017
70.2 Functions and Variables for linearalgebra . . . . . . . . . . . . . . . . . . . 1019

71 lsquares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1031
71.1 Introduction to lsquares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1031
71.2 Functions and Variables for lsquares . . . . . . . . . . . . . . . . . . . . . . . . 1031

72 minpack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1041
72.1 Introduction to minpack. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1041
72.2 Functions and Variables for minpack . . . . . . . . . . . . . . . . . . . . . . . 1041

73 makeOrders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1043
73.1 Functions and Variables for makeOrders . . . . . . . . . . . . . . . . . . . . 1043

74 mnewton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1045
74.1 Introduction to mnewton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1045
74.2 Functions and Variables for mnewton . . . . . . . . . . . . . . . . . . . . . . . 1045

75 numericalio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1047
75.1 Introduction to numericalio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1047
75.1.1 Plain-text input and output . . . . . . . . . . . . . . . . . . . . . . . . . . . 1047
75.1.2 Separator flag values for input . . . . . . . . . . . . . . . . . . . . . . . . . 1047
75.1.3 Separator flag values for output . . . . . . . . . . . . . . . . . . . . . . . 1047
75.1.4 Binary floating-point input and output . . . . . . . . . . . . . . . . 1048
75.2 Functions and Variables for plain-text input and output . . . . 1048
75.3 Functions and Variables for binary input and output . . . . . . . . 1050

76 odepack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1053
76.1 Introduction to ODEPACK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1053
76.1.1 Getting Started with ODEPACK . . . . . . . . . . . . . . . . . . . . . . 1053
76.2 Functions and Variables for odepack . . . . . . . . . . . . . . . . . . . . . . . . 1054

77 operatingsystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057
77.1 Introduction to operatingsystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057
77.2 Directory operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057
77.3 File operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057
77.4 Environment operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057
 xv

78 opsubst . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1059
78.1 Functions and Variables for opsubst . . . . . . . . . . . . . . . . . . . . . . . . 1059

79 orthopoly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1061
79.1 Introduction to orthogonal polynomials . . . . . . . . . . . . . . . . . . . . . 1061
79.1.1 Getting Started with orthopoly . . . . . . . . . . . . . . . . . . . . . . . . 1061
79.1.2 Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1063
79.1.3 Floating point Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1065
79.1.4 Graphics and orthopoly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1066
79.1.5 Miscellaneous Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1067
79.1.6 Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1068
79.2 Functions and Variables for orthogonal polynomials . . . . . . . . . 1068

80 pytranslate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1073
80.1 Introduction to pytranslate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1073
80.1.1 Tests for pytranslate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1074
80.2 Functions in pytranslate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1074
80.3 Extending pytranslate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1075

81 ratpow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1079
81.1 Functions and Variables for ratpow . . . . . . . . . . . . . . . . . . . . . . . . . 1079

82 romberg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1081
82.1 Functions and Variables for romberg. . . . . . . . . . . . . . . . . . . . . . . . 1081

83 simplex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1085
83.1 Introduction to simplex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1085
83.1.1 Tests for simplex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1085
83.1.1.1 klee minty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1085
83.1.1.2 NETLIB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1085
83.2 Functions and Variables for simplex . . . . . . . . . . . . . . . . . . . . . . . . 1086

84 simplification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1089
84.1 Introduction to simplification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1089
84.2 Package absimp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1089
84.3 Package facexp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1089
84.4 Package functs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1091
84.5 Package ineq . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1094
84.6 Package rducon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1096
84.7 Package scifac . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1096

85 solve rec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1099

85.1 Introduction to solve rec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1099
85.2 Functions and Variables for solve rec . . . . . . . . . . . . . . . . . . . . . . . 1099
xvi

86 stats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1105
86.1 Introduction to stats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1105
86.2 Functions and Variables for inference result . . . . . . . . . . . . . . . . 1105
86.3 Functions and Variables for stats . . . . . . . . . . . . . . . . . . . . . . . . . . . 1107
86.4 Functions and Variables for special distributions . . . . . . . . . . . . 1122

87 stirling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1123
87.1 Functions and Variables for stirling . . . . . . . . . . . . . . . . . . . . . . . . . 1123

88 stringproc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1125
88.1 Introduction to String Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . 1125
88.2 Input and Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1126
88.3 Characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1132
88.4 String Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1137
88.5 Octets and Utilities for Cryptography . . . . . . . . . . . . . . . . . . . . . . 1143

89 to poly solve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1149

89.1 Functions and Variables for to poly solve . . . . . . . . . . . . . . . . . . . 1149

90 unit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1169
90.1 Introduction to Units . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1169
90.2 Functions and Variables for Units . . . . . . . . . . . . . . . . . . . . . . . . . . 1170

91 wrstcse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1179
91.1 Introduction to wrstcse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1179
91.2 Functions and Variables for wrstcse. . . . . . . . . . . . . . . . . . . . . . . . . 1179

92 zeilberger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1183
92.1 Introduction to zeilberger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1183
92.1.1 The indefinite summation problem . . . . . . . . . . . . . . . . . . . . . 1183
92.1.2 The definite summation problem . . . . . . . . . . . . . . . . . . . . . . 1183
92.1.3 Verbosity levels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1183
92.2 Functions and Variables for zeilberger . . . . . . . . . . . . . . . . . . . . . . 1184
92.3 General global variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1185
92.4 Variables related to the modular test . . . . . . . . . . . . . . . . . . . . . . . 1186

93 Error and warning messages. . . . . . . . . . . . . . . 1187

93.1 Error messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1187
93.1.1 apply: no such "list" element . . . . . . . . . . . . . . . . . . . . . . . . . . 1187
93.1.2 argument must be a non-atomic expression . . . . . . . . . . . . 1187
93.1.3 assignment: cannot assign to <function name> . . . . . . . . 1187
93.1.4 expt: undefined: 0 to a negative exponent. . . . . . . . . . . . . . 1187
93.1.5 incorrect syntax: , is not a prefix operator . . . . . . . . . . . . . 1187
93.1.6 incorrect syntax: Illegal use of delimiter ) . . . . . . . . . . . . . . 1187
93.1.7 loadfile: failed to load <filename> . . . . . . . . . . . . . . . . . . . . . 1188
 xvii

93.1.8 makelist: second argument must evaluate to a number . . 1188

93.1.9 Only symbols can be bound . . . . . . . . . . . . . . . . . . . . . . . . . . . 1188
93.1.10 operators of arguments must all be the same . . . . . . . . . . 1188
93.1.11 Out of memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1188
93.1.12 part: fell off the end . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1189
93.1.13 undefined variable (draw or plot) . . . . . . . . . . . . . . . . . . . . . 1189
93.1.14 VTK is not installed, which is required for Scene . . . . . 1189
93.2 Warning messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1189
93.2.1 Encountered undefined variable <x> in translation . . . . . 1190
93.2.2 Rat: replaced <x> by <y> = <z> . . . . . . . . . . . . . . . . . . . . . . . 1190

94 Command-line options . . . . . . . . . . . . . . . . . . . . . 1191

94.1 Command line options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1191

Appendix A Function and Variable Index . . . 1193

 1

1 Introduction to Maxima
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:
[wfs@chromium]$ maxima
Maxima 5.9.1 http://maxima.sourceforge.net
Using Lisp CMU Common Lisp 19a
Distributed under the GNU Public License. See the file COPYING.
Dedicated to the memory of William Schelter.
This is a development version of Maxima. 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();
[wfs@chromium]$
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'.
2 Maxima 5.45.0 Manual

‘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
Chapter 1: Introduction to Maxima 3

(%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:
4 Maxima 5.45.0 Manual

(%i1) plot2d (sin(x)/x, [x, -20, 20])$

0.8

0.6
sin(x)/x

0.4

0.2

-0.2

-20 -15 -10 -5 0 5 10 15 20

x

(%i2) plot2d ([atan(x), erf(x), tanh(x)], [x, -5, 5], [y, -1.5, 2])$

2
atan(x)
erf(x)
1.5 tanh(x)

0.5

-0.5

-1

-1.5
-4 -2 0 2 4
x
Chapter 1: Introduction to Maxima 5

(%i3) plot3d (sin(sqrt(x^2 + y^2))/sqrt(x^2 + y^2),

[x, -12, 12], [y, -12, 12])$

sin(sqrt(y^2+x^2))/sqrt(y^2+x^2)

1
0.8
0.6
0.4
z
0.2
0
-0.2 10
5
-0.4
-10 0
-5 y
0 -5
x 5 -10
10
 7

2 Bug Detection and Reporting

2.1 Functions and Variables for Bug Detection and

Reporting
run_testsuite ([options]) [Function]
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 [Option variable]
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]]
8 Maxima 5.45.0 Manual

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 [Option variable]

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..

bug_report () [Function]
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 "".

build_info () [Function]
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"
Chapter 2: Bug Detection and Reporting 9

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 3660647
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.
 11

3 Help

3.1 Documentation
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.

3.2 Functions and Variables for Help

apropos (name) [Function]
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 com-
mand 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:
12 Maxima 5.45.0 Manual

(%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

demo (filename) [Function]

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 [Function]
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.
Chapter 3: Help 13

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.
See also Section 3.1 [Documentation], page 11.
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.
14 Maxima 5.45.0 Manual

example [Function]
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

manual_demo [Option variable]

Default value: "manual.demo"
manual_demo specifies the name of the file containing the examples for the function
example. See example.
 15

4 Command Line

4.1 Introduction to Command Line

4.2 Functions and Variables for Command Line

__ [System variable]
__ is the input expression currently being evaluated. That is, while an input expres-
sion expr is being evaluated, __ is expr.
__ is assigned the input expression before the input is simplified or evaluated. How-
ever, 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.
See also _ and %.
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

_ [System variable]
_ 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.
16 Maxima 5.45.0 Manual

See also __ and %.

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

% [System variable]
% 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.
See also _, %%, and %th.

%% [System variable]
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:
Chapter 4: Command Line 17

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 state-

ment 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
_

%th (i) [Function]

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.
See also % and %%.
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
18 Maxima 5.45.0 Manual

? [Special symbol]
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
Section 37.1 [Lisp and Maxima], page 641, 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.
?? [Special symbol]
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.
$ [Input terminator]
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
; [Input terminator]
The semicolon ; terminates an input expression, and the resulting output is displayed.
See also $.
Example:
(%i1) 1 + 2 + 3;
(%o1) 6
inchar [Option variable]
Default value: %i
inchar is the prefix of the labels of expressions entered by the user. Maxima auto-
matically 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
Chapter 4: Command Line 19

(input2) expand((a+b)^3);
3 2 2 3
(%o2) b + 3 a b + 3 a b + a

infolists [System variable]

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
All user-defined functions, created by := or define.

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 an 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.)
20 Maxima 5.45.0 Manual

kill [Function]
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 com-
bined, 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 vari-
ables 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.

labels (symbol) [Function]

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.
Chapter 4: Command Line 21

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 vari-
able programmode controls whether solve and some other functions generate interme-
diate 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.
labels [System variable]
The variable labels is the list of input, output, and intermediate expression labels,
including all previous labels if inchar, outchar, or linechar were redefined.
linechar [Option variable]
Default value: %t
linechar is the prefix of the labels of intermediate expressions generated by Max-
ima. 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.
linenum [System variable]
The line number of the current pair of input and output expressions.
myoptions [System variable]
Default value: []
myoptions is the list of all options ever reset by the user, whether or not they get
reset to their default value.
nolabels [Option variable]
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.
22 Maxima 5.45.0 Manual

optionset [Option variable]

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

outchar [Option variable]

Default value: %o
outchar is the prefix of the labels of expressions computed by Maxima. Maxima auto-
matically 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 [Function]
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.
Chapter 4: Command Line 23

playback () (with no arguments) displays all input, output, and intermediate expres-
sions 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 inter-
mediate expression counts as one.
playback ([m, n]) displays input, output, and intermediate expressions with num-
bers 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 func-
tion. Output expressions are not affected by the grind option. See grind.
Arguments may be combined, e.g., playback ([5, 10], grind, time, slow).

prompt [Option variable]

Default value: _
prompt is the prompt symbol of the demo function, playback (slow) mode, and the
Maxima break loop (as invoked by break).

quit () [Function]
Terminates the Maxima session. Note that the function must be invoked as quit();
or quit()$, not quit by itself.
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 Chapter 38 [Debugging], page 657.

read (expr_1, . . . , expr_n) [Function]

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)
24 Maxima 5.45.0 Manual

readonly (expr_1, . . . , expr_n) [Function]

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
reset () [Function]
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.
showtime [Option variable]
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.
to_lisp () [Function]
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)
Chapter 4: Command Line 25

((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)
values [System variable]
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) []

4.3 Functions and Variables for Display

%edispflag [Option variable]
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
26 Maxima 5.45.0 Manual

absboxchar [Option variable]

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!

declare_index_properties (a, [p_1, p_2, p_3, ...]) [Function]

declare_index_properties ([a, b, c, ...], [p_1, p_2, p_3, ...]) [Function]
postsubscript [Symbol]
postsuperscript [Symbol]
presuperscript [Symbol]
presubscript [Symbol]
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 prop-
erties (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
Chapter 4: Command Line 27

(%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]"
get_index_properties (a) [Function]
Returns the properties for a established by declare_index_properties.
See also remove_index_properties.
remove_index_properties (a, b, c, ...) [Function]
Removes the properties established by declare_index_properties. All index prop-
erties are removed from each symbol a, b, c, ....
remove_index_properties quotes (does not evaluate) its arguments.
display_index_separator [Symbol property]
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).
28 Maxima 5.45.0 Manual

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)
Chapter 4: Command Line 29

(%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
(%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
30 Maxima 5.45.0 Manual

disp (expr_1, expr_2, . . . ) [Function]

is like display but only the value of the arguments are displayed rather than equa-
tions. 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.
See also ldisp and print.
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
display (expr_1, expr_2, . . . ) [Function]
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
display2d [Option variable]
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, num-
bers, and some punctuation characters. This display is sometimes called the "pretty
printer" display.
When display2d is false, the console display is a 1-dimensional or linear form which
is the same as the output produced by grind.
Chapter 4: Command Line 31

When display2d is false, the value of stringdisp is ignored, and strings are always
displayed with quote marks.
See also leftjust to switch between a left justified and a centered display of equa-
tions.
Example:
(%i1) x/(x^2+1);
x
(%o1) ------
2
x + 1
(%i2) display2d:false$
(%i3) x/(x^2+1);
(%o3) x/(x^2+1)
display_format_internal [Option variable]
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
dispterms (expr) [Function]
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);

+
32 Maxima 5.45.0 Manual

2 a sin(x)

x
%e

(%o1) done
expt (a, b) [Special symbol]
ncexpt (a, b) [Special symbol]
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.
exptdispflag [Option variable]
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
grind (expr) [Function]
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
Chapter 4: Command Line 33

(%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
34 Maxima 5.45.0 Manual

(%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)

grind [Option variable]

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. Other-
wise, no attempt is made to specially format input expressions.

ibase [Option variable]

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.
Chapter 4: Command Line 35

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

ldisp (expr_1, . . . , expr_n) [Function]

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
36 Maxima 5.45.0 Manual

(%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

ldisplay (expr_1, . . . , expr_n) [Function]

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

leftjust [Option variable]

Default value: false
Chapter 4: Command Line 37

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
linel [Option variable]
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.

lispdisp [Option variable]

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
negsumdispflag [Option variable]
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.
obase [Option variable]
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
38 Maxima 5.45.0 Manual

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
pfeformat [Option variable]
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)
powerdisp [Option variable]
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.
Chapter 4: Command Line 39

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

print (expr_1, . . . , expr_n) [Function]

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)

sqrtdispflag [Option variable]

Default value: true
When sqrtdispflag is false, causes sqrt to display with exponent 1/2.
40 Maxima 5.45.0 Manual

stardisp [Option variable]

Default value: false
When stardisp is true, multiplication is displayed with an asterisk * between
operands.

ttyoff [Option variable]

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.
 41

5 Data Types and Structures

5.1 Numbers
5.1.1 Introduction to Numbers
Complex numbers
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.

5.1.2 Functions and Variables for Numbers

bfloat (expr) [Function]
bfloat replaces integers, rationals, floating point numbers, and some symbolic con-
stants 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 trigono-
metric 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 con-
stants 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));
42 Maxima 5.45.0 Manual

(%o2) 2.314069263277927b1
(%i3) bfloat(abs(-%gamma));
(%o3) 5.772156649015329b-1
(%i4) bfloat(log(%phi));
(%o4) 4.812118250596035b-1

bfloatp (expr) [Function]

Returns true if expr is a bigfloat number, otherwise false.

bftorat [Option variable]

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.e-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

bftrunc [Option variable]

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.

evenp (expr) [Function]

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.

float (expr) [Function]

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.
Chapter 5: Data Types and Structures 43

float2bf [Option variable]

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.
floatnump (expr) [Function]
Returns true if expr is a floating point number, otherwise false.
fpprec [Option variable]
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.
fpprintprec [Option variable]
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 (inclu-
sive), 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.
integerp (expr) [Function]
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
44 Maxima 5.45.0 Manual

(%i8) declare (n, integer);

(%o8) done
(%i9) integerp (n);
(%o9) false

m1pbranch [Option variable]

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

nonnegintegerp (n) [Function]

Return true if and only if n >= 0 and n is an integer.

numberp (expr) [Function]

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]
Chapter 5: Data Types and Structures 45

numer [Option variable]

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]

numer_pbranch [Option variable]

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

numerval (x_1, expr_1, . . . , var_n, expr_n) [Function]

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.

oddp (expr) [Function]

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.
46 Maxima 5.45.0 Manual

ratepsilon [Option variable]

Default value: 2.0e-15
ratepsilon is the tolerance used in the conversion of floating point numbers to ra-
tional numbers, when the option variable bftorat has the value false. See bftorat
for an example.

rationalize (expr) [Function]

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

ratnump (expr) [Function]

Returns true if expr is a literal integer or ratio of literal integers, otherwise false.
Chapter 5: Data Types and Structures 47

5.2 Strings
5.2.1 Introduction to Strings
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 re-
turn 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 termina-
tion (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 termi-
nation, 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
(%o3) Embedded line termination
in this string.
(%i4) in this string.";
(%o4) Ignore the line termination characters in this string.
(%i5) s_4 : "Ignore the \
(%o5) false
(%i6) line termination \
(%o6) This is a string.
(%i7) characters in \
(%o7) true
(%i8) this string.";
(%o8) "This is a string."
(%i9) stringdisp : false;

5.2.2 Functions and Variables for Strings

concat (arg_1, arg_2, . . . ) [Function]
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$
48 Maxima 5.45.0 Manual

(%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

sconcat (arg_1, arg_2, . . . ) [Function]

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

string (expr) [Function]

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.

stringdisp [Option variable]

Default value: false
When stringdisp is true, strings are displayed enclosed in double quote marks.
Otherwise, quote marks are not displayed.
Chapter 5: Data Types and Structures 49

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."
50 Maxima 5.45.0 Manual

5.3 Constants
5.3.1 Functions and Variables for Constants
%e [Constant]
%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.

%i [Constant]
%i represents the imaginary unit, sqrt(−1).

false [Constant]
false represents the Boolean constant of the same name. Maxima implements false
by the value NIL in Lisp.

%gamma [Constant]
The Euler-Mascheroni constant, 0.5772156649015329 ....

ind [Constant]
ind represents a bounded, indefinite result.
See also limit.
Example:
(%i1) limit (sin(1/x), x, 0);
(%o1) ind

inf [Constant]
inf represents real positive infinity.

infinity [Constant]
infinity represents complex infinity.

minf [Constant]
minf represents real minus (i.e., negative) infinity.

%phi [Constant]
%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 evaluat-
ing 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
Chapter 5: Data Types and Structures 51

(%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 evaluat-
ing 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 [Constant]
%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 [Constant]
true represents the Boolean constant of the same name. Maxima implements true
by the value T in Lisp.
und [Constant]
und represents an undefined result.
See also limit.
Example:
(%i1) limit (x*sin(x), x, inf);
(%o1) und
zeroa [Constant]
zeroa represents an infinitesimal above zero. zeroa can be used in expressions. limit
simplifies expressions which contain infinitesimals.
52 Maxima 5.45.0 Manual

See also zerob and limit.

Example:
limit simplifies expressions which contain infinitesimals:
(%i1) limit(zeroa);
(%o1) 0
(%i2) limit(x+zeroa);
(%o2) x

zerob [Constant]
zerob represents an infinitesimal below zero. zerob can be used in expressions. limit
simplifies expressions which contain infinitesimals.
See also zeroa and limit.
Chapter 5: Data Types and Structures 53

5.4 Lists
5.4.1 Introduction to Lists
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))

5.4.2 Functions and Variables for Lists

[ [Operator]
] [Operator]
[ 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 nth element of a list may need
an amount of time that is roughly proportional to n, See Section 5.4.3 [Performance
considerations for Lists], page 70.
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 Section 5.5 [Arrays], page 72) 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
54 Maxima 5.45.0 Manual

(%i8) g[k] := 1/(k^2+1);

1
(%o8) g := ------
k 2
k + 1
(%i9) g[10];
1
(%o9) ---
101

append (list_1, . . . , list_n) [Function]

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 [Function]
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 match-
ing 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.
See also sublist and member.
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
Chapter 5: Data Types and Structures 55

cons [Function]
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 expres-
sion 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, oth-
erwise 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

copylist (list) [Function]

Returns a copy of the list list.

create_list (form, x_1, list_1, . . . , x_n, list_n) [Function]

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.
56 Maxima 5.45.0 Manual

delete [Function]
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 oper-
ator 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 ]
Chapter 5: Data Types and Structures 57

eighth (expr) [Function]

Returns the 8th item of expression or list expr. See first for more details.

endcons [Function]
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 argu-
ment 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

fifth (expr) [Function]

Returns the 5th item of expression or list expr. See first for more details.

first (expr) [Function]

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
58 Maxima 5.45.0 Manual

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.
See also firstn and part.

firstn (expr, count) [Function]

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.
See also lastn and rest.
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)]
Chapter 5: Data Types and Structures 59

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
fourth (expr) [Function]
Returns the 4th item of expression or list expr. See first for more details.
join (l, m) [Function]
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]
60 Maxima 5.45.0 Manual

(%i3) join (L1, [aa, bb, cc, dd, ee, ff]);

(%o3) [a, aa, sin(b), bb, c!, cc, d - 1, dd]

last (expr) [Function]

Returns the last part (term, row, element, etc.) of the expr.
See also lastn.

lastn (expr, count) [Function]

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.
See also firstn and rest.
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
Chapter 5: Data Types and Structures 61

(%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
length (expr) [Function]
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.
listarith [Option variable]
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.
listp (expr) [Function]
Returns true if expr is a list else false.
lreduce [Function]
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.
62 Maxima 5.45.0 Manual

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 [Function]
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 jth 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]
Chapter 5: Data Types and Structures 63

(%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]
member (expr_1, expr_2) [Function]
Returns true if is(expr_1 = a) for some element a in args(expr_2), otherwise re-
turns 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
ninth (expr) [Function]
Returns the 9th item of expression or list expr. See first for more details.
pop (list) [Function]
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 (item, list) [Function]
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
64 Maxima 5.45.0 Manual

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 [Function]
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 argu-
ments, 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 ^.
See also firstn and lastn.
(%i1) rest(a+b+c);
(%o1) b+a
(%i2) rest(a+b+c,2);
(%o2) a
(%i3) rest(a+b+c,-2);
(%o3) c
Chapter 5: Data Types and Structures 65

reverse (list) [Function]

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 [Function]
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
second (expr) [Function]
Returns the 2nd item of expression or list expr. See first for more details.
seventh (expr) [Function]
Returns the 7th item of expression or list expr. See first for more details.
sixth (expr) [Function]
Returns the 6th item of expression or list expr. See first for more details.
sort [Function]
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
66 Maxima 5.45.0 Manual

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 magni-
tude. 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]]
Chapter 5: Data Types and Structures 67

(%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 magni-
tude. 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]
68 Maxima 5.45.0 Manual

(%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]
sublist (list, p) [Function]
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]
sublist_indices (L, P) [Function]
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]
tenth (expr) [Function]
Returns the 10th item of expression or list expr. See first for more details.
third (expr) [Function]
Returns the 3rd item of expression or list expr. See first for more details.
tree_reduce [Function]
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
Chapter 5: Data Types and Structures 69

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)
unique (L) [Function]
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 [Function]
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
70 Maxima 5.45.0 Manual

(%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]

5.4.3 Performance considerations for Lists

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 han-
dling 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

(%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

3
Chapter 5: Data Types and Structures 71

(%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
72 Maxima 5.45.0 Manual

5.5 Arrays
Maxima supports 3 array-like constructs:
• If one tries to write to an indexed variable without creating a list first an undeclared
array (also named hashed array) is created that grows dynamically and allows numbers,
symbols and strings as indices:
(%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.
• Lists (see makelist allow for fast addition and removal of elements, can be created
without knowing their final size.
• Declared arrays that allow fast access to random elements at the cost that their size
needs to be known at construction time. (See Section 5.4.3 [Performance considerations
for Lists], page 70.)

5.5.1 Functions and Variables for Arrays

array [Function]
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 speci-
fied 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.

arrayapply (A, [i_1, . . . , i_n]) [Function]

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 func-
tion.
Chapter 5: Data Types and Structures 73

arrayinfo (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.
74 Maxima 5.45.0 Manual

(%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 )]

arraymake (A, [i_1, . . . , i_n]) [Function]

Returns the expression A[i_1, ..., i_n]. The result is an unevaluated array refer-
ence.
Chapter 5: Data Types and Structures 75

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

arrays [System variable]

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.
76 Maxima 5.45.0 Manual

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]
arraysetapply (A, [i_1, . . . , i_n], x) [Function]
Assigns x to A[i_1, ..., i_n], where A is an array and i 1, . . . , i n are integers.
arraysetapply evaluates its arguments.
fillarray (A, B) [Function]
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)}
Chapter 5: Data Types and Structures 77

(%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))}

listarray (A) [Function]

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 re-
turned 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)
78 Maxima 5.45.0 Manual

(%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]]

make_array (type, dim_1, . . . , dim_n) [Function]

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 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:
Chapter 5: Data Types and Structures 79

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

rearray (A, dim_1, . . . , dim_n) [Function]

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.
80 Maxima 5.45.0 Manual

remarray [Function]
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.

subvar (x, i) [Function]

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

subvarp (expr) [Function]

Returns true if expr is a subscripted variable, for example a[i].

use_fast_arrays [Option variable]

Default value: false
When use_fast_arrays is true, arrays declared by array are values instead of prop-
erties, and undeclared arrays (hashed arrays) are implemented as Lisp hashed arrays.
When use_fast_arrays is false, arrays declared by array are properties, and un-
declared 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.
Chapter 5: Data Types and Structures 81

translate_fast_arrays [Option variable]

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.
82 Maxima 5.45.0 Manual

5.6 Structures
5.6.1 Introduction to Structures
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 in-
stances 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.

5.6.2 Functions and Variables for Structures

structures [Global variable]
structures is the list of user-defined structures defined by defstruct.

defstruct [Function]
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));
Chapter 5: Data Types and Structures 83

(%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 [Function]
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)
@ [Operator]
@ 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)
84 Maxima 5.45.0 Manual

(%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
 85

6 Expressions

6.1 Introduction to Expressions

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 expres-
sion 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

6.2 Nouns and Verbs

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
86 Maxima 5.45.0 Manual

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)

6.3 Identifiers
Maxima identifiers may comprise alphabetic characters, plus the numerals 0 through 9, plus
any special 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.
Characters may be declared alphabetic by the declare function. If so declared, they
need not be preceded by a backslash in an identifier. The alphabetic characters are initially
A through Z, a through z, %, and _.
Chapter 6: Expressions 87

Maxima is case-sensitive. The identifiers foo, FOO, and Foo are distinct. See Section 37.1
[Lisp and Maxima], page 641, 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 Section 37.1 [Lisp
and Maxima], page 641, 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

6.4 Inequality
Maxima has the inequality operators <, <=, >=, >, #, and notequal. See if for a description
of conditional expressions.

6.5 Functions and Variables for Expressions

alias (new_name_1, old_name_1, . . . , new_name_n, old_name_n) [Function]
provides an alternate name for a (user or system) function, variable, array, etc. Any
even number of arguments may be used.

aliases [System variable]

Default value: []
88 Maxima 5.45.0 Manual

aliases is the list of atoms which have an user defined alias (set up by the alias,
ordergreat, orderless functions or by declaring the atom a noun with declare.)

allbut [Keyword]
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, . . .

args (expr) [Function]

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]
Chapter 6: Expressions 89

atom (expr) [Function]

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 [Function]
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) -
90 Maxima 5.45.0 Manual

(%i8) box (sin(x) + cos(y));

-----------------
(%o8) -cos(y) + sin(x)-
-----------------

boxchar [Option variable]

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.

collapse (expr) [Function]

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)).

copy (e) [Function]

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.

disolate (expr, x_1, . . . , x_n) [Function]

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")$.
Chapter 6: Expressions 91

dispform [Function]
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 re-
spect 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 repre-
sentation 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
92 Maxima 5.45.0 Manual

dpart (expr, n_1, . . . , n_k) [Function]

Selects the same subexpression as part, but instead of just returning that subex-
pression 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"
"""
exptisolate [Option variable]
Default value: false
exptisolate, when true, causes isolate (expr, var) to examine exponents of
atoms (such as %e) which contain var.
exptsubst [Option variable]
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, . . . , x_n, expr) [Function]
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 evalu-
ates 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.
Chapter 6: Expressions 93

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 ex-
pressions. 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 equiv-
alent 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
94 Maxima 5.45.0 Manual

(%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

inflag [Option variable]

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.

inpart (expr, n_1, . . . , n_k) [Function]

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)
Chapter 6: Expressions 95

isolate (expr, x) [Function]

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.
isolate_wrt_times [Option variable]
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
listconstvars [Option variable]
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.
listdummyvars [Option variable]
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
96 Maxima 5.45.0 Manual

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]
listofvars (expr) [Function]
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
lfreeof (list, expr) [Function]
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
lpart (label, expr, n_1, . . . , n_k) [Function]
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.
mainvar [Property]
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., com-
pare 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, resimplifica-
tion 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 [Property]
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.
Chapter 6: Expressions 97

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
noundisp [Option variable]
Default value: false
When noundisp is true, nouns display with a single quote. This switch is always
true when displaying function definitions.
nounify (f) [Function]
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.
nterms (expr) [Function]
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).
op (expr) [Function]
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 ex-
pression, 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) "+"
98 Maxima 5.45.0 Manual

(%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 [Function]
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.

opsubst [Option variable]

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
Chapter 6: Expressions 99

(%i5) subst (x^2, r, r+r[0]);

2
(%o5) x + r
0

optimize (expr) [Function]

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.

optimprefix [Option variable]

Default value: %
optimprefix is the prefix used for generated symbols by the optimize command.

ordergreat (v_1, . . . , v_n) [Function]

orderless (v_1, . . . , v_n) [Function]
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 pre-
cedes v 2 precedes . . . precedes v n, and v n precedes any other variable not men-
tioned 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 (expr_1, expr_2) [Function]

orderlessp (expr_1, expr_2) [Function]
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 Max-
ima 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 follow-
ing.
(integers and floats) precede (bigfloats) precede (declared constants) precede (strings)
precede (declared scalars) precede (first argument to orderless) precedes . . . pre-
cedes (last argument to orderless) precedes (other symbols) precede (last argument
to ordergreat) precedes . . . precedes (first argument to ordergreat) precedes (de-
clared 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.
100 Maxima 5.45.0 Manual

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
Chapter 6: Expressions 101

part (expr, n_1, . . . , n_k) [Function]

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.
partition (expr, x) [Function]
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)]]
partswitch [Option variable]
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.
pickapart (expr, n) [Function]
Assigns intermediate expression labels to subexpressions of expr at depth n, an in-
teger. 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.
102 Maxima 5.45.0 Manual

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
Chapter 6: Expressions 103

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

piece [System variable]

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 [Function]
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)
104 Maxima 5.45.0 Manual

(%i2) subst ([a^2=b, b=a], sin(a^2) + sin(b));

(%o2) 2 sin(a)

rembox [Function]
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 "
"""""""""""
Chapter 6: Expressions 105

(%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
reveal (expr, depth) [Function]
Replaces parts of expr at the specified integer depth with descriptive summaries.
• Sums and differences are replaced by Sum(n) where n is the number of operands
of the sum.
• Products are replaced by Product(n) where n is the number of operands of the
product.
• Exponentials are replaced by Expt.
• Quotients are replaced by Quotient.
• Unary negation is replaced by Negterm.
• Lists are replaced by 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) ------------------------------------
106 Maxima 5.45.0 Manual

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
sqrtdenest (expr) [Function]
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).
sublis (list, expr) [Function]
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)
sublis_apply_lambda [Option variable]
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.
Chapter 6: Expressions 107

subnumsimp [Option variable]

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
subst (a, b, c) [Function]
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
108 Maxima 5.45.0 Manual

(%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).

substinpart (x, expr, n_1, . . . , n_k) [Function]

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.
Chapter 6: Expressions 109

(%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.
substpart (x, expr, n_1, . . . , n_k) [Function]
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.
symbolp (expr) [Function]
Returns true if expr is a symbol, else false.
110 Maxima 5.45.0 Manual

See also Section 6.3 [Identifiers], page 86.

unorder () [Function]
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]

verbify (f) [Function]

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
 111

7 Operators

7.1 Introduction to operators

It is possible to define new operators with specified precedence, to undefine existing opera-
tors, 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.
unary prefix
negation - a
unary postfix
factorial a!
binary infix
exponentiation a^b
n-ary infix addition a + b
matchfix 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
112 Maxima 5.45.0 Manual

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
Chapter 7: Operators 113

(%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)

7.2 Arithmetic operators

+ [Operator]
- [Operator]
* [Operator]
/ [Operator]
^ [Operator]
The symbols + * / and ^ represent addition, multiplication, division, and exponen-
tiation, 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). Expres-
sions 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 expo-
nentiation are binary, noncommutative operators.
Maxima sorts the operands of commutative operators to construct a canonical rep-
resentation. For internal storage, the ordering is determined by orderlessp. For
display, the ordering for addition is determined by ordergreatp, and for multiplica-
tion, it is the same as the internal ordering.
Arithmetic computations are carried out on literal numbers (integers, rationals, or-
dinary floats, and bigfloats). Except for exponentiation, all arithmetic operations on
114 Maxima 5.45.0 Manual

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 multipli-
cation, respectively.
Chapter 7: Operators 115

(%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]
116 Maxima 5.45.0 Manual

(%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 ]

** [Operator]
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

^^ [Operator]
Noncommutative exponentiation operator. ^^ is the exponentiation operator corre-
sponding 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

. [Operator]
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.
Chapter 7: Operators 117

See also Section 23.1.1 Dot, dot0nscsimp, dot0simp, dot1simp, dotassoc,

dotconstrules, dotdistrib, dotexptsimp, dotident, and dotscrules.

7.3 Relational operators

< [Operator]
<= [Operator]
>= [Operator]
> [Operator]
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 pro-
gramming 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]
118 Maxima 5.45.0 Manual

(%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]

7.4 Logical operators

and [Operator]
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.

not [Operator]
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.

or [Operator]
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 can-
not 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.
Chapter 7: Operators 119

7.5 Operators for Equations

# [Operator]
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

= [Operator]
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.
See also equal and notequal.
Examples:
120 Maxima 5.45.0 Manual

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);
Chapter 7: Operators 121

(%o2) true

7.6 Assignment operators

: [Operator]
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 nonex-
istent 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);
122 Maxima 5.45.0 Manual

(%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

:: [Operator]
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
Chapter 7: Operators 123

::= [Operator]
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, respec-
tively.
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$
124 Maxima 5.45.0 Manual

(%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

:= [Operator]
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 an-
other 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.
See also define and ::=.
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
Chapter 7: Operators 125

(%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
126 Maxima 5.45.0 Manual

(%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

7.7 User defined operators

infix [Function]
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.
Chapter 7: Operators 127

"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 eval-
uated 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 Section 7.1 [Introduction to operators], page 111.
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.
128 Maxima 5.45.0 Manual

(%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 [Function]
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:
Chapter 7: Operators 129

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
130 Maxima 5.45.0 Manual

nary [Function]
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 Section 7.1 [Introduction to operators], page 111.

nofix [Function]
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 Section 7.1 [Introduction to operators], page 111.

postfix [Function]
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 Section 7.1 [Introduction to operators], page 111.

prefix [Function]
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 Section 7.1 [Introduction to operators], page 111.
 131

8 Evaluation

8.1 Functions and Variables for Evaluation

’ [Operator]
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, al-
though 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 [quote-quote], page 133 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);
132 Maxima 5.45.0 Manual

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)
Chapter 8: Evaluation 133

(%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)

’’ [Operator]
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 [quote], page 131 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];
134 Maxima 5.45.0 Manual

(%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);
Chapter 8: Evaluation 135

(%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
136 Maxima 5.45.0 Manual

ev (expr, arg_1, . . . , arg_n) [Function]

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.
1. First the environment is set up by scanning the arguments which may be any or
all of the following.
• 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 determi-
nant 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.
Chapter 8: Evaluation 137

• F where F, a function name, has been declared to be an evaluation function

evfun causes F to be applied to expr.
• Any other function names, e.g. sum, cause evaluation of occurrences of those
names in expr as though they were verbs.
• In addition a function occurring in expr (say F(x)) may be defined locally
for the purpose of this evaluation of expr by giving F(x) := expression as
an argument to ev.
• If an atom not mentioned above or a subscripted variable or subscripted
expression was given as an argument, it is evaluated and if the result is an
equation or assignment then the indicated binding or substitution is per-
formed. If the result is a list then the members of the list are treated as if
they were additional arguments given to 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 substi-
tution 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.
2. During step (1), a list is made of the non-subscripted variables appearing on the
left side of equations in the arguments or in the value of some arguments if the
value is an equation. The variables (subscripted variables which do not have
associated 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.
3. If any substitutions are indicated by the arguments, they are carried out now.
4. The resulting expression is then re-evaluated (unless one of the arguments was
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)).
5. For each instance of eval in the arguments, steps (3) and (4) are repeated.
See also [quote-quote], page 133, at and subst.
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
138 Maxima 5.45.0 Manual

(%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
eval [Special symbol]
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
Chapter 8: Evaluation 139

(%i5) a,eval,eval;
(%o5) e

evflag [Property]
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
140 Maxima 5.45.0 Manual

(%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

evfun [Property]
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
Chapter 8: Evaluation 141

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))
infeval [Option variable]
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 [Special symbol]
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 [Special symbol]
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.
pred [Special symbol]
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
142 Maxima 5.45.0 Manual

(%i2) 1<2,pred;
(%o2) true
 143

9 Simplification

9.1 Introduction to Simplification

Maxima performs a cycle of actions in response to each new user-typed command. This
consists of four steps: reading or "parsing" the input, evaluation, simplification and output.
Parsing converts a syntactically valid sequence of typed characters into a data structure to
be used for the rest of the operations. Evaluation includes replacing names with their
assigned values. Simplification means rewriting an expression to be easier for the user
or other programs to understand. Output includes displaying computational results in a
variety of different formats and notations.
Evaluation and simplification sometimes appear to have similar functionality as they
both have the goal of removing "complexity" and system designers have sometimes divided
a task so that it is performed partly in each. For example, integrate(x,x) evaluates the
answer as x*x/2, which is then simplified to x^2/2.
Evaluation is always present: it is the consequence of having a programming system with
functions, subroutines, variables, values, loops, assignments and so on. In the evaluation
step, built-in or user-defined function names are replaced by their definitions, variables are
replaced by their values. This is largely the same as activities of a conventional programming
language, but extended to work with symbolic mathematical data. Because of the generality
of the mathematics at hand, there are different possible models of evaluation and so the
systems has optional "flags" that can steer the process of evaluation. See Section 8.1
[Functions and Variables for Evaluation], page 131.
By contrast, the intent of simplification is to maintain the value of an expression while
re-formulating its representation to be smaller, simpler to understand, or to conform to
particular specifications (like factored, expanded). For example, sin(0) to 0 or x+x to
2*x. There are several powerful tools to alter the results of simplification, since it is largely
in this part of the system that an user can incorporate knowledge of newly introduced
functions or symbolic notation into Maxima.
Simplification is generally done at four different levels:
• The internal, built-in automated simplifier,
• Built-in simplification routines that can be explicitly called by the user at selected
places in a program or command sequence,
• User-written simplification routines, linked to the simplifier by using "tellsimp" or
"tellsimpafter" and called automatically,
• User-written routines that can be explicitly called by the user at selected places in a
program or command sequence.
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.
144 Maxima 5.45.0 Manual

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. The structure turns out to be, in modern jargon, data- directed, or
object-oriented. The program dispatches to the appropriate routine depending on the root
of some sub-tree of the expression, recursively. This general notion means you can make
modifications to the simplification process by very local changes to the program. In many
cases it is conceptually straightforward to add an operator and add its simplification routine
without disturbing existing code.
We note that in addition to this general simplifier operating on algebraic expression
trees, there are several other representations of expressions in Maxima which have separate
methods and simplifiers. 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.
You can set a number of option variables which direct Maxima’s processing to favor
particular kinds of patterns as being goals. You can even use the most extreme option
which is to turn the simplifier off by simp:false. We do not recommend this since many
internal routines expect their arguments to be simplified. (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.
Chapter 9: Simplification 145

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 proper-
ties from the actual context may have an impact on the simplifier’s behavior, too. See
Section 11.1 [Introduction to Maxima’s Database], page 189.
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 lan-
guage 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 Chapter 34 [Rules and Patterns], page 569.
Over the years (Maxima/Macsyma’s origins date back to about 1966!) users have con-
tributed 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 Chapter 84 [simplification-pkg], page 1089.
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.

9.2 Functions and Variables for Simplification

additive [Property]
If declare(f,additive) has been executed, then:
146 Maxima 5.45.0 Manual

(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)

antisymmetric [Property]
If declare(h,antisymmetric) is done, this tells the simplifier that h is antisymmet-
ric. 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)

combine (expr) [Function]

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
Chapter 9: Simplification 147

(%i2) combine (%);

75 b f + 4 (3 a b c + 10 a c)
(%o2) -----------------------------
60

commutative [Property]
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)

demoivre (expr) [Function]

demoivre [Option variable]
The function demoivre (expr) converts one expression without setting the global
variable demoivre.
When the variable demoivre is true, complex exponentials are converted into equiv-
alent 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.

distrib (expr) [Function]

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)
148 Maxima 5.45.0 Manual

(%i4) expand (1/((a+b) * (c+d)), 1, 0);

1
(%o4) ---------------------
b d + a d + b c + a c

distribute_over [Option variable]

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 argu-
ments:
(%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]
Chapter 9: Simplification 149

(%i3) distribute_over : not distribute_over;

(%o3) false
(%i4) sin([x,1,1.0]);
(%o4) sin([x, 1, 1.0])

domain [Option variable]

Default value: real
When domain is set to complex, sqrt (x^2) will remain sqrt (x^2) instead of re-
turning abs(x).

evenfun [Property]
oddfun [Property]
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 [Function]
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 algo-
rithm.
maxnegex and maxposex control the maximum negative and positive exponents, re-
spectively, 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
150 Maxima 5.45.0 Manual

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 vari-
ables (nextlayerfactor and facsum_combine) that provide the user with the ability
to structure expressions by controlled expansion. Brief function descriptions are avail-
able 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)
Chapter 9: Simplification 151

(%i2) exponentialize:true;
(%o2) true
(%i3) expand(expr,0,0);
2 %i x - %i x
%i (x + 1) (%e - %e )
(%o3) - -------------------------------
2

expandwrt (expr, x_1, . . . , x_n) [Function]

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.

expandwrt_denom [Option variable]

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.

expandwrt_factored (expr, x_1, . . . , x_n) [Function]

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.

expon [Option variable]

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.

exponentialize (expr) [Function]

exponentialize [Option variable]
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.

expop [Option variable]

Default value: 0
152 Maxima 5.45.0 Manual

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.
lassociative [Property]
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).
linear [Property]
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
maxnegex [Option variable]
Default value: 1000
Chapter 9: Simplification 153

maxnegex is the largest negative exponent which will be expanded by the expand
command, see also maxposex.

maxposex [Option variable]

Default value: 1000
maxposex is the largest exponent which will be expanded with the expand command,
see also maxnegex.

multiplicative [Property]
declare(f, multiplicative) tells the Maxima simplifier that f is multiplicative.
1. If 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(...)).
2. If f is a function of 2 or more arguments, multiplicativity is defined as multiplica-
tivity 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
154 Maxima 5.45.0 Manual

multthru [Function]
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
nary [Property]
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 [function_nary], page 130
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.
Chapter 9: Simplification 155

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)
negdistrib [Option variable]
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 [System variable]
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]
define_opproperty (property_name, simplifier_fn) [Function]
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 de-
clared 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.
156 Maxima 5.45.0 Manual

define_opproperty returns done.

Example:
Declare a new property, identity, which is simplified by simplify_identity. De-
clare 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

outative [Property]
declare(f, outative) tells the Maxima simplifier that constant factors in the argu-
ment of f can be pulled out.
1. If 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.
2. If 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)

radcan (expr) [Function]

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 an 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.
Chapter 9: Simplification 157

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
radexpand [Option variable]
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).
• If radexpand is all or assume (x > 0) has been executed, sqrt(x^2) simplifies
to x.
• If radexpand is true and domain is real (its default), sqrt(x^2) simplifies to
abs(x).
• If 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.
rassociative [Property]
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))).
scsimp (expr, rule_1, . . . , rule_n) [Function]
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.
simp [Option variable]
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.
158 Maxima 5.45.0 Manual

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 simplifi-
cation 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)

symmetric [Property]
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.

xthru (expr) [Function]

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 ratsimping 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 ratsimped.
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)
Chapter 9: Simplification 159

(%i2) xthru (%);

20
(x + 2) - y
(%o2) -------------
20
(y + x)
 161

10 Mathematical Functions

10.1 Functions for Numbers

abs (z) [Function]
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 in-
tegrals involving the abs function. See (%i12) in the examples below.
When applied to a list or matrix, abs automatically distributes over the terms. Sim-
ilarly, 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)
162 Maxima 5.45.0 Manual

Integrating and differentiating with the abs function. Note that more integrals in-
volving 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

ceiling (x) [Function]

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:
Chapter 10: Mathematical Functions 163

(%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
164 Maxima 5.45.0 Manual

(%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

entier (x) [Function]

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.

floor (x) [Function]

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
Chapter 10: Mathematical Functions 165

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

fix (x) [Function]

A synonym for entier (x).

hstep (x) [Function]

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.

lmax (L) [Function]

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.

lmin (L) [Function]

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.

max (x_1, . . . , x_n) [Function]

Return a simplified value for the maximum of the expressions x 1 through x n. When
get (trylevel, maxmin), is 2 or greater, max uses the simplification max (e, -e) -->
|e|. When get (trylevel, maxmin) is 3 or greater, max tries to eliminate expres-
sions that are between two other arguments; for example, max (x, 2*x, 3*x) -->
max (x, 3*x). To set the value of trylevel to 2, use put (trylevel, 2, maxmin).
See also min and lmax.

min (x_1, . . . , x_n) [Function]

Return a simplified value for the minimum of the expressions x_1 through x_n. When
get (trylevel, maxmin), is 2 or greater, min uses the simplification min (e, -e) -->
-|e|. When get (trylevel, maxmin) is 3 or greater, min tries to eliminate expres-
sions that are between two other arguments; for example, min (x, 2*x, 3*x) -->
min (x, 3*x). To set the value of trylevel to 2, use put (trylevel, 2, maxmin).
See also max and lmin.

round (x) [Function]

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.
166 Maxima 5.45.0 Manual

The round function distributes over lists, matrices and equations. See distribute_
over.

signum (x) [Function]

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 simplifica-
tions 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.

truncate (x) [Function]

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.

10.2 Functions for Complex Numbers

cabs (expr) [Function]
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
Chapter 10: Mathematical Functions 167

(%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 character-
istic.
cabs is a verb function and is not suitable for symbolic calculations. For such calcula-
tions (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:
Examples with sqrt and sin.
(%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))
168 Maxima 5.45.0 Manual

carg (z) [Function]

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

conjugate (x) [Function]

Returns the complex conjugate of x.
(%i1) declare ([aa, bb], real, cc, complex, ii, imaginary);
(%o1) done
Chapter 10: Mathematical Functions 169

(%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

imagpart (expr) [Function]

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)

polarform (expr) [Function]

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

realpart (expr) [Function]

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
170 Maxima 5.45.0 Manual

(%i2) realpart (1+sqrt(2)*%i);

(%o2) 1
(%i3) realpart (sqrt(2)*%i);
(%o3) 0
(%i4) realpart (1);
(%o4) 1
rectform (expr) [Function]
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

10.3 Combinatorial Functions

!! [Operator]
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).
binomial (x, y) [Function]
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
Chapter 10: Mathematical Functions 171

(%i5) binomial (11, y);

(%o5) binomial(11, y)

factcomb (expr) [Function]

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)!

factorial [Function]
! [Operator]
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 facto-
rials 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.
172 Maxima 5.45.0 Manual

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 ex-
pressions with the factorial function.
(%i1) (n+1)!/n!,factorial_expand:true;
(%o1) n + 1
factlim [Option variable]
Default value: 100000
factlim specifies the highest factorial which is automatically expanded. If it is -1
then all integers are expanded.
factorial_expand [Option variable]
Default value: false
The option variable factorial_expand controls the simplification of expressions like
(n+1)!, where n is an integer. See factorial for an example.
Chapter 10: Mathematical Functions 173

genfact (x, y, z) [Function]

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!!.

minfactorial (expr) [Function]

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)

sumsplitfact [Option variable]

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)

10.4 Root, Exponential and Logarithmic Functions

%e_to_numlog [Option variable]
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
174 Maxima 5.45.0 Manual

this transformation, and more complicated transformations of this ilk as well. The
logcontract command "contracts" expressions containing log.
%emode [Option variable]
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
%enumer [Option variable]
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.
See also ev and numer.
(%i1) %enumer;
(%o1) false
(%i2) numer;
(%o2) false
Chapter 10: Mathematical Functions 175

(%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
exp (x) [Function]
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))
li [s] (z) [Function]
Represents the polylogarithm function of order s and argument z, defined by the
infinite series
∞
X zk
Lis (z) =
k=1
ks

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.
176 Maxima 5.45.0 Manual

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]

log (x) [Function]

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 an 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.
Chapter 10: Mathematical Functions 177

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 expres-
sion %e^(r*log(x)) will be simplified into x^r. It should be noted that
the radcan command also does this transformation, and more compli-
cated transformations of this as well. The logcontract command "con-
tracts" expressions containing log.
logabs [Option variable]
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.
logarc (expr) [Function]
The function logarc(expr) carries out the replacement of inverse circular and hyper-
bolic functions with equivalent logarithmic functions for an expression expr without
setting the global variable logarc.
logarc [Option variable]
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.
logconcoeffp [Option variable]
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)).
logcontract (expr) [Function]
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 sim-
plify 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,
178 Maxima 5.45.0 Manual

you can do logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) or

ratnump(m)$ . Then logcontract(1/2*log(x)); will give log(sqrt(x)).
logexpand [Option variable]
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 simplifi-
cations will be turned off.
When logexpand is set to all or super, the logarithm of a product expression sim-
plifies 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 num-
bers 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 sim-
plifies 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))
Chapter 10: Mathematical Functions 179

/
====
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

lognegint [Option variable]

Default value: false
If true implements the rule log(-n) -> log(n)+%i*%pi for n a positive integer.

logsimp [Option variable]

Default value: true
If false then no simplification of %e to a power containing log’s is done.

plog (x) [Function]

Represents the principal branch of the complex-valued natural logarithm with -%pi
< carg(x) <= +%pi .

sqrt (x) [Function]

The square root of x. It is represented internally by x^(1/2). See also rootscontract
and radexpand.
180 Maxima 5.45.0 Manual

10.5 Trigonometric Functions

10.5.1 Introduction to Trigonometric
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.

10.5.2 Functions and Variables for Trigonometric

%piargs [Option variable]
Default value: true
When %piargs is true, trigonometric functions are simplified to algebraic constants
when the argument is an integer multiple of π, π/2, π/3, π/4, or π/6.
Maxima knows some identities which can be applied when π, 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 π and π/2 are multiplied by an integer variable.
(%i1) declare (n, integer, m, even)$
Chapter 10: Mathematical Functions 181

(%i2) [sin (%pi * n), cos (%pi * m), sin (%pi/2 * m),
cos (%pi/2 * m)];
m/2
(%o2) [0, 1, 0, (- 1) ]

%iargs [Option variable]

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)

acos (x) [Function]

– Arc Cosine.

acosh (x) [Function]

– Hyperbolic Arc Cosine.

acot (x) [Function]

– Arc Cotangent.

acoth (x) [Function]

– Hyperbolic Arc Cotangent.

acsc (x) [Function]

– Arc Cosecant.

acsch (x) [Function]

– Hyperbolic Arc Cosecant.

asec (x) [Function]

– Arc Secant.

asech (x) [Function]

– Hyperbolic Arc Secant.
182 Maxima 5.45.0 Manual

asin (x) [Function]

– Arc Sine.
asinh (x) [Function]
– Hyperbolic Arc Sine.
atan (x) [Function]
– Arc Tangent.
See also atan2.
atan2 (y, x) [Function]
– yields the value of atan(y/x) in the interval -%pi to %pi.
See also atan.
atanh (x) [Function]
– Hyperbolic Arc Tangent.
atrig1 [Package]
The atrig1 package contains several additional simplification rules for inverse trigono-
metric 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.
cos (x) [Function]
– Cosine.
cosh (x) [Function]
– Hyperbolic Cosine.
cot (x) [Function]
– Cotangent.
coth (x) [Function]
– Hyperbolic Cotangent.
csc (x) [Function]
– Cosecant.
csch (x) [Function]
– Hyperbolic Cosecant.
halfangles [Option variable]
Default value: false
When halfangles is true, trigonometric functions of arguments expr/2 are simpli-
fied to functions of expr.
For a real argument x in the interval 0 < x < 2*%pi the sine of the half-angle simplifies
to a simple formula:
sqrt(1 - cos(x))
----------------
sqrt(2)
Chapter 10: Mathematical Functions 183

A complicated factor is needed to make this formula correct for all complex arguments
z:
realpart(z)
floor(-----------)
2 %pi
(- 1) (1 - unit_step(- imagpart(z))

realpart(z) realpart(z)
floor(-----------) - ceiling(-----------)
2 %pi 2 %pi
((- 1) + 1))
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)

ntrig [Package]
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.

sec (x) [Function]

– Secant.

sech (x) [Function]

– Hyperbolic Secant.

sin (x) [Function]

– Sine.
184 Maxima 5.45.0 Manual

sinh (x) [Function]

– Hyperbolic Sine.

tan (x) [Function]

– Tangent.

tanh (x) [Function]

– Hyperbolic Tangent.

trigexpand (expr) [Function]

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 oc-
curring 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)

trigexpandplus [Option variable]

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.

trigexpandtimes [Option variable]

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.
Chapter 10: Mathematical Functions 185

triginverses [Option variable]

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 [Function]
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

trigsign [Option variable]

Default value: true
When trigsign is true, it permits simplification of negative arguments to trigono-
metric functions. E.g., sin(-x) will become -sin(x) only if trigsign is true.

trigsimp (expr) [Function]

2 2 2 2
Employs the identities sin (x) +cos (x) = 1 and cosh (x) −sinh (x) = 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.

trigrat (expr) [Function]

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$
186 Maxima 5.45.0 Manual

(%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
Chapter 10: Mathematical Functions 187

10.6 Random Numbers

make_random_state [Function]
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 num-
ber generator.

set_random_state (s) [Function]

Copies s to the random number generator state.
set_random_state always returns done.

random (x) [Function]

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
188 Maxima 5.45.0 Manual

(%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
 189

11 Maxima’s Database

11.1 Introduction to Maxima’s Database

11.2 Functions and Variables for Properties

alphabetic [Property]
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 Section 6.3 [Identifiers], page 86.
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~]
bindtest [Property]
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
constant [Property]
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.
See constantp and declare.
Example:
(%i1) declare(c, constant);
(%o1) done
(%i2) constantp(c);
(%o2) true
190 Maxima 5.45.0 Manual

(%i3) c : x;
(%o3) x
(%i4) constantp(c);
(%o4) false
constantp (expr) [Function]
Returns true if expr is a constant expression, otherwise returns false.
An expression is considered a constant expression if its arguments are numbers (in-
cluding 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)
declare (a_1, p_1, a_2, p_2, . . . ) [Function]
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.
Chapter 11: Maxima’s Database 191

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.
192 Maxima 5.45.0 Manual

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 vari-
able.
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.

decreasing [Property]
increasing [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

even [Property]
odd [Property]
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.
Chapter 11: Maxima’s Database 193

Example:
(%i1) declare(n, even);
(%o1) done
(%i2) askinteger(n, even);
(%o2) yes
(%i3) askinteger(n);
(%o3) yes
(%i4) evenp(n);
(%o4) false

feature [Property]
Maxima understands two distinct types of features, system features and features
which apply to mathematical expressions. See also status for information about sys-
tem features. See also features and featurep for information about mathematical
features.
feature itself is not the name of a function or variable.

featurep (a, f) [Function]

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

features [Declaration]
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
194 Maxima 5.45.0 Manual

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
get (a, i) [Function]
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.
See also put and qput.
(%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]]
integer [Property]
noninteger [Property]
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
Chapter 11: Maxima’s Database 195

integervalued [Property]
declare(f, integervalued) tells Maxima to recognize f as an integer-valued func-
tion.
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

nonarray [Property]
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

nonscalar [Property]
Makes atoms behave as does a list or matrix with respect to the dot operator.
See also declare.

nonscalarp (expr) [Function]

Returns true if expr is a non-scalar, i.e., it contains atoms declared as non-scalars,
lists, or matrices.
See also the predicate function scalarp and declare.

posfun [Property]
declare (f, posfun) declares f to be a positive function. is (f(x) > 0) yields true.
See also declare.
196 Maxima 5.45.0 Manual

printprops [Function]
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.

properties (a) [Function]

Returns a list of the names of all the properties associated with the atom a.

props [System variable]

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.

propvars (prop) [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.

put (atom, value, indicator) [Function]

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.
See also qput and get.
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

qput (atom, value, indicator) [Function]

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.
Chapter 11: Maxima’s Database 197

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
rational [Property]
irrational [Property]
declare(a, rational) or declare(a, irrational) tells Maxima to recognize a as
a rational or irrational real variable.
See also declare.
real [Property]
imaginary [Property]
complex [Property]
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.
rem (atom, indicator) [Function]
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 [Function]
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.
198 Maxima 5.45.0 Manual

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 op-
erator properties declared by prefix, infix, [function_nary], page 130, 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.

scalar [Property]
declare(a, scalar) tells Maxima to consider a a scalar variable.
See also declare.

scalarp (expr) [Function]

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.

11.3 Functions and Variables for Facts

activate (context_1, . . . , context_n) [Function]
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.

activecontexts [System variable]

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.

askinteger [Function]
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,
Chapter 11: Maxima’s Database 199

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 deter-
mine if expr is an even integer or odd integer, respectively.

asksign (expr) [Function]

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 deduc-
tion. 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.

assume (pred_1, . . . , pred_n) [Function]

Adds predicates pred 1, . . . , pred n to the current context. If a predicate is incon-
sistent 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 opera-
tors < <= 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 conse-
quences 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]
200 Maxima 5.45.0 Manual

(%i8) prederror : false;

(%o8) false
(%i9) is (sinh (bb - aa) > 0);
(%o9) unknown
(%i10) is (bb^2 < cc^2);
(%o10) unknown

assumescalar [Option variable]

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 commuta-
tive 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 op-
erators listed above.

assume_pos [Option variable]

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 re-
quests an input from the user, even when assume_pos is true and assume_pos_pred
is a function which returns true for all arguments.

assume_pos_pred [Option variable]

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
Chapter 11: Maxima’s Database 201

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
202 Maxima 5.45.0 Manual

Is b - a positive, negative, or zero?

p;
(%o11) neg
context [Option variable]
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.
contexts [Option variable]
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 an 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.
deactivate (context_1, . . . , context_n) [Function]
Deactivates the specified contexts context 1, . . . , context n.
facts [Function]
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.
Chapter 11: Maxima’s Database 203

facts () (i.e., without an argument) lists the current context.

forget [Function]
forget (pred_1, . . . , pred_n)
forget (L)
Removes predicates established by assume. The predicates may be expressions equiv-
alent to (but not necessarily identical to) those previously assumed.
forget (L), where L is a list of predicates, forgets each item on the list.

is (expr) [Function]
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);
204 Maxima 5.45.0 Manual

(%i4) prederror: false$

(%i5) is (a > 0);
(%o5) unknown

killcontext (context_1, . . . , context_n) [Function]

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.

maybe (expr) [Function]

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 com-
puted 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 [Function]
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.

sign (expr) [Function]

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.
Chapter 11: Maxima’s Database 205

supcontext [Function]
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.

11.4 Functions and Variables for Predicates

charfun (p) [Function]
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]

compare (x, y) [Function]

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) <=
206 Maxima 5.45.0 Manual

The function compare doesn’t try to determine whether the real domains of its argu-
ments 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.
equal (a, b) [Function]
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);
Chapter 11: Maxima’s Database 207

(%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

notequal (a, b) [Function]

Represents the negation of equal(a, b).
Examples:
(%i1) equal (a, b);
(%o1) equal(a, b)
208 Maxima 5.45.0 Manual

(%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

unknown (expr) [Function]

Returns true if and only if expr contains an operator or function not recognized by
the Maxima simplifier.

zeroequiv (expr, v) [Function]

Tests whether the expression expr in the variable v is equivalent to zero, returning
true, false, or dontknow.
zeroequiv has these restrictions:
1. Do not use functions that Maxima does not know how to differentiate and eval-
uate.
2. If the expression has poles on the real line, there may be errors in the result (but
this is unlikely to occur).
3. If the expression contains functions which are not solutions to first order differ-
ential equations (e.g. Bessel functions) there may be incorrect results.
4. The algorithm uses evaluation at randomly chosen points for carefully selected
subexpressions. This is always a somewhat hazardous business, although the
algorithm tries to minimize the potential for error.
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 pa-
rameter b.
 209

12 Plotting

12.1 Introduction to Plotting

To make the plots, Maxima can use an external plotting package or its own graphical
interface Xmaxima (see the section on Section 12.2 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 spec-
ified 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], page 781, 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 be-
havior 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.

12.2 Plotting Formats

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).
210 Maxima 5.45.0 Manual

The plotting formats are the following:

• gnuplot (default on Windows)
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.
• gnuplot pipes (default on non-Windows platforms)
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
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
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
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.

12.3 Functions and Variables for Plotting

geomview_command [System variable]
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,
Chapter 12: Plotting 211

(%i1) geomview_command: "/usr/local/bin/my_geomview"$

get_plot_option (keyword, index) [Function]
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 Section 12.4
Plotting Options.
gnuplot_command [System variable]
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"$
gnuplot_file_args [System variable]
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".
gnuplot_view_args [System variable]
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.
julia (x, y, ...options...) [Function]
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
212 Maxima 5.45.0 Manual

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])$

0.9 36

0.8 30

0.7
24

0.6
y

18

0.5
12

0.4
6

0.3
-0.3 -0.2 -0.1 0 0.1 0.2
x

make_transform ([var1, var2, var3], fx, fy, fz) [Function]

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.
Chapter 12: Plotting 213

mandelbrot (options) [Function]

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])$

30
1
25

0.5
20

0 15
y

10
-0.5

5
-1
0
-2 -1.5 -1 -0.5 0 0.5 1
x

polar_to_xy [System function]

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.
214 Maxima 5.45.0 Manual

plot2d [Function]
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:
1. Explicit functions. 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.
2. Implicit functions. 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.
3. Parametric functions. 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.
4. Set of points. 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.
5. Contour lines. 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
Chapter 12: Plotting 215

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 Section 12.4
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:

1. Explicit function.

(%i1) plot2d (sin(x), [x, -%pi, %pi])$

0.5
sin(x)

-0.5

-1

-3 -2 -1 0 1 2 3
x

2. Implicit function.
216 Maxima 5.45.0 Manual

(%i1) plot2d (x^2-y^3+3*y=2, [x,-2.5,2.5], [y,-2.5,2.5])$

0
y

-1

-2

-2 -1 0 1 2
x

3. Parametric function.

(%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]])$

4
cos(t)*((-2*cos(4*t))+%e^cos(t)-sin(t/12)^5)

-1

-2

-4 -3 -2 -1 0 1 2 3 4
sin(t)*((-2*cos(4*t))+%e^cos(t)-sin(t/12)^5)

4. Set of points.

(%i1) plot2d ([discrete, makelist(i*%pi, i, 1, 5),

Chapter 12: Plotting 217

[0.6, 0.9, 0.2, 1.3, 1]])$

1.2

0.8
y

0.6

0.4

0.2

2 4 6 8 10 12 14 16
x

5. Contour lines.

(%i1) plot2d ([contour, u^3 + v^2], [u, -4, 4], [v, -4, 4])$

4
-40.0
-20.0
3 0.0
20.0
40.0
2 60.0

0
v

-1

-2

-3

-4
-4 -3 -2 -1 0 1 2 3 4
u

Examples using options.

If an explicit function grows too fast, the y option can be used to limit the values in
the vertical axis:
218 Maxima 5.45.0 Manual

(%i1) plot2d (sec(x), [x, -2, 2], [y, -20, 20])$

20

15

10

5
sec(x)

-5

-10

-15

-20
-2 -1.5 -1 -0.5 0 0.5 1 1.5 2
x

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, which allows more flexibility. Option yx_ratio is used to change the default
rectangular shape of the plot; in this example the plot will fill a square.

(%i1) plot2d ( x^2 - 1, [x, -3, 3], nobox, grid2d,

[yx_ratio, 1], [axes, solid], [xtics, -2, 4, 2],
[ytics, 2, 2, 6], [label, ["x", 2.9, -0.3],
["x^2-1", 0.1, 8]], [title, "A parabola"])$

A parabola

x^2-1

x
-2 2

A plot with a logarithmic scale in the vertical axis:

Chapter 12: Plotting 219

(%i1) plot2d (exp(3*s), [s, -2, 2], logy)$

1000

100

10
%e^(3*s)

0.1

0.01

0.001
-2 -1.5 -1 -0.5 0 0.5 1 1.5 2
s

Plotting functions by name:

(%i1) F(x) := x^2 $

(%i2) :lisp (defun |$g| (x) (m* x x x))
$g
(%i2) H(x) := if x < 0 then x^4 - 1 else 1 - x^5 $
(%i3) plot2d ([F, G, H], [u, -1, 1], [y, -1.5, 1.5])$

1.5
F
G
H
1

0.5

-0.5

-1

-1.5
-1 -0.5 0 0.5 1
u

Plot of a circle, using its parametric representation, together with the function -|x|.
The circle will only look like a circle if the scale in the two axes is the same, which is
done with the option same_xy.
220 Maxima 5.45.0 Manual

(%i1) plot2d([[parametric, cos(t), sin(t), [t,0,2*%pi]], -abs(x)],

[x, -sqrt(2), sqrt(2)], same_xy)$

1 cos(t), sin(t)
-abs(x)

0.5

-0.5

-1

-1.5
-1 -0.5 0 0.5 1
x

A plot of 200 random numbers between 0 and 9:

(%i1) plot2d ([discrete, makelist ( random(10), 200)])$

5
y

0 20 40 60 80 100 120 140 160 180 200

x

In the next example a table with three columns is saved in a file “data.txt” which is
then read and the second and third column are plotted on the two axes:

(%i1) display2d:false$
(%i2) with_stdout ("data.txt", for x:0 thru 10 do
print (x, x^2, x^3))$
(%i3) data: read_matrix ("data.txt")$
(%i4) plot2d ([discrete, transpose(data)[2], transpose(data)[3]],
Chapter 12: Plotting 221

[style,points], [point_type,diamond], [color,red])$

1000

800

600
y

400

200

0 20 40 60 80 100
x

A plot of discrete data points together with a continuous function:

(%i1) xy: [[10, .6], [20, .9], [30, 1.1], [40, 1.3], [50, 1.4]]$
(%i2) plot2d([[discrete, xy], 2*%pi*sqrt(l/980)], [l,0,50],
[style, points, lines], [color, red, blue],
[point_type, asterisk],
[legend, "experiment", "theory"],
[xlabel, "pendulum's length (cm)"],
[ylabel, "period (s)"])$

1.4 experiment
theory

1.2

1
period (s)

0.8

0.6

0.4

0.2

0 10 20 30 40 50
pendulum's length (cm)

See also the section about Plotting Options.

plot3d [Function]
plot3d (expr, x_range, y_range, . . . , options, . . . )
plot3d ([expr_1, . . . , expr_n], x_range, y_range, . . . , options, . . . )
Displays a plot of one or more surfaces defined as functions of two variables or in
parametric form.
The functions to be plotted may be specified as expressions or function names. The
mouse can be used to rotate the plot looking at the surface from different sides.
222 Maxima 5.45.0 Manual

Examples.
Plot of a function of two variables:
(%i1) plot3d (u^2 - v^2, [u, -2, 2], [v, -3, 3], [grid, 100, 100],
nomesh_lines)$

u^2-v^2

4
2
0
-2
z
-4
-6
3
-8 2
-10 -2 1
-1.5 -1 0
-0.5 -1 v
0 0.5 1 -2
u 1.5 2 -3

Use of the z option to limit a function that goes to infinity (in this case the function
is minus infinity on the x and y axes); this also shows how to plot with only lines and
no shading:
(%i1) plot3d ( log ( x^2*y^2 ), [x, -2, 2], [y, -2, 2], [z, -8, 4],
nopalette, [color, magenta])$

log(x^2*y^2)

z -2

-4

-6 2
1.5
1
-8 -2 0.5
-1.5 -1 0
-0.5 -0.5 y
0 0.5 -1
x 1 -1.5
1.5 2 -2

The infinite values of z can also be avoided by choosing a grid that does not fall on
any points where the function is undefined, as in the next example, which also shows
how to change the palette and how to include a color bar that relates colors to values
of the z variable:
Chapter 12: Plotting 223

(%i1) plot3d (log (x^2*y^2), [x, -2, 2], [y, -2, 2],[grid, 29, 29],
[palette, [gradient, red, orange, yellow, green]],
color_bar, [xtics, 1], [ytics, 1], [ztics, 4],
[color_bar_tics, 4])$

log(x^2*y^2)

4 0

-4
0
-8
z -4
-12

-8
2
1
-12 -2
0
-1 y
0 -1
x 1
2 -2

Two surfaces in the same plot. Ranges specific to one of the surfaces can be given
by placing each expression and its ranges in a separate list; global ranges for the
complete plot are also given after the function definitions.
(%i1) plot3d ([[-3*x - y, [x, -2, 2], [y, -2, 2]],
4*sin(3*(x^2 + y^2))/(x^2 + y^2), [x, -3, 3], [y, -3, 3]],
[x, -4, 4], [y, -4, 4])$

(4*sin(3*(y^2+x^2)))/(y^2+x^2)
(-y)-3*x

15

10

5
z
0

-5 4
3
2
-10 -4 1
-3 0
-2 -1 -1 y
0 1 -2
x 2 -3
3 4 -4

Plot of a Klein bottle, defined parametrically:

(%i1) expr_1: 5*cos(x)*(cos(x/2)*cos(y)+sin(x/2)*sin(2*y)+3)-10$
(%i2) expr_2: -5*sin(x)*(cos(x/2)*cos(y)+sin(x/2)*sin(2*y)+3)$
(%i3) expr_3: 5*(-sin(x/2)*cos(y)+cos(x/2)*sin(2*y))$
(%i4) plot3d ([expr_1, expr_2, expr_3], [x, -%pi, %pi],
224 Maxima 5.45.0 Manual

[y, -%pi, %pi], [grid, 50, 50])$

Parametric function

8
6
4
2
z 0
-2
-4
25
-6 20
15
10
-8-35 5
-30 -25 0
-20 -15 -5 y
-10 -5 -10
-15
x 0 5 -20
10 -25

Plot of a “spherical harmonic” function, using the predefined transformation,

spherical_to_xyz to transform from spherical coordinates to rectangular
coordinates. See the documentation for spherical_to_xyz.

(%i1) plot3d (sin(2*theta)*cos(phi), [theta,0,%pi], [phi,0,2*%pi],

[transform_xy, spherical_to_xyz], [grid, 30, 60], nolegend)$

0.8
0.6
0.4
0.2
z 0
-0.2
-0.4
0.4
-0.6 0.3
0.2
-0.8-0.8 0.1
-0.6 -0.4 0
-0.2 -0.1 y
0 0.2 0.4 -0.2
x -0.3
0.6 0.8 -0.4

Use of the pre-defined function polar_to_xy to transform from cylindrical to rectan-

gular coordinates. See the documentation for polar_to_xy.
Chapter 12: Plotting 225

(%i1) plot3d (r^.33*cos(th/3), [r,0,1], [th,0,6*%pi], nobox,

nolegend, [grid, 12, 80], [transform_xy, polar_to_xy])$

Plot of a sphere using the transformation from spherical to rectangular coordinates.

Option same_xyz is used to get the three axes scaled in the same proportion. When
transformations are used, it is not convenient to eliminate the mesh lines, because
Gnuplot will not show the surface correctly.
(%i1) plot3d ( 5, [theta,0,%pi], [phi,0,2*%pi], same_xyz, nolegend,
[transform_xy, spherical_to_xyz], [mesh_lines_color,blue],
[palette,[gradient,"#1b1b4e", "#8c8cf8"]])$

z 0

-2

-4
5
4
-6 -6 3
2
-4 1
-2 0
0 -1 y
2 -2
-3
x 4 -4
6-5

Definition of a function of two-variables using a matrix. Notice the single quote in

the definition of the function, to prevent plot3d from failing when it realizes that the
matrix will require integer indices.
(%i1) M: matrix([1,2,3,4], [1,2,3,2], [1,2,3,4], [1,2,3,3])$
(%i2) f(x, y) := float('M [round(x), round(y)])$
226 Maxima 5.45.0 Manual

(%i3) plot3d (f(x,y), [x,1,4], [y,1,4], [grid,3,3], nolegend)$

3.5

z 2.5

1.5 4
3.5
11 3
1.5 2.5
2 2 y
2.5
3 1.5
x 3.5
4 1

By setting the elevation equal to zero, a surface can be seen as a map in which each
color represents a different level.
(%i1) plot3d (cos (-x^2 + y^3/4), [x,-4,4], [y,-4,4], [zlabel,""],
[mesh_lines_color,false], [elevation,0], [azimuth,0],
color_bar, [grid,80,80], noztics, [color_bar_tics,1])$

cos(y^3/4-x^2)

4 1
3
2
0
1
0 y
-1 -1
-2
-3
-4
-4 -3 -2 -1 0 1 2 3 4

See also Section 12.4 Plotting Options.

plot_options [System variable]

This option is being kept for compatibility with older versions, but its use is depre-
cated. To set global plotting options, see their current values or remove options, use
set_plot_option, get_plot_option and remove_plot_option.

remove_plot_option (name) [Function]

Removes the default value of an option. The name of the option must be given.
See also set_plot_option, get_plot_option and Section 12.4 Plotting
Options.
Chapter 12: Plotting 227

set_plot_option (option) [Function]

Accepts any of the options listed in the section Plotting Options, and saves them for
use in plotting commands. The values of the options set in each plotting command
will have precedence, but if those options are not given, the default values set with
this function will be used.
set_plot_option evaluates its argument and returns the complete list of options
(after modifying the option given). If called without any arguments, it will simply
show the list of current default options.
See also remove_plot_option, get_plot_option and the section on Plotting Op-
tions.
Example:
Modification of the grid values.
(%i1) set_plot_option ([grid, 30, 40]);
(%o1) [[plot_format, gnuplot_pipes], [grid, 30, 40],
[run_viewer, true], [axes, true], [nticks, 29], [adapt_depth, 5],
[color, blue, red, green, magenta, black, cyan],
[point_type, bullet, box, triangle, plus, times, asterisk],
[palette, [gradient, green, cyan, blue, violet],
[gradient, magenta, violet, blue, cyan, green, yellow, orange,
red, brown, black]], [gnuplot_preamble, ], [gnuplot_term, default]]
spherical_to_xyz [System function]
It can be given as value for the transform_xy option of plot3d. Its effect will be to
interpret the two independent variables and the function in plot3d as the spherical
coordinates of a point (first, the angle with the z axis, then the angle of the xy
projection with the x axis and finally the distance from the origin) and transform
them into x, y and z coordinates.

12.4 Plotting Options

All options consist of a list starting with one of the keywords in this section, followed by
one or more values. If the option appears inside one of the plotting commands, its value
will be local for that command. It the option is given as argument to set_plot_option,
its value will be global and used in all plots, unless it is overridden by a local value.
Some of the options may have different effects in different plotting commands as it will
be pointed out in the following list. The options that accept among their possible values
true or false, can also be set to true by simply writing their names, and false by writing their
names with the prefix no. For instance, typing logx as an option is equivalent to writing
[logx, true] and nobox is equivalent to [box, false]. When just the name of the option
is used for an option which cannot have a value true, it means that any value previously
assigned to that option will be removed, leaving it to the graphic program to decide what
to do.
adapt_depth [adapt depth, integer] [Plot option]
Default value: 5
The maximum number of splittings used by the adaptive plotting routine of plot2d;
integer must be a non-negative integer. A value of zero means that adaptive plotting
228 Maxima 5.45.0 Manual

will not be used and the resulting plot will have 1+4*nticks points (see option nticks).
To have more control on the number of points and their positions, a list of points can
be created and then plotted using the discrete method of plot2d.

axes [axes, symbol], axes, noaxes [Plot option]

Default value: true
Where symbol can be either true, false, x, y or solid. If false, no axes are shown;
if equal to x or y only the x or y axis will be shown; if it is equal to true, both axes
will be shown and solid will show the two axes with a solid line, rather than the
default broken line. This option does not have any effect in the 3 dimensional plots.
The single keywords axes and noaxes can be used as synonyms for [axes, true]
and [axes, false].

azimuth [azimuth, number] [Plot option]

Default value: 30
A plot3d plot can be thought of as starting with the x and y axis in the horizontal
and vertical axis, as in plot2d, and the z axis coming out of the screen. The z axis
is then rotated around the x axis through an angle equal to elevation and then the
new xy plane is rotated around the new z axis through an angle azimuth. This option
sets the value for the azimuth, in degrees.
See also elevation.

box [box, symbol], box, nobox [Plot option]

Default value: true
If set to true, a bounding box will be drawn for the plot; if set to false, no box will
be drawn. The single keywords box and nobox can be used as synonyms for [box,
true] and [box, false].

color [color, color_1, . . . , color_n] [Plot option]

In 2d plots it defines the color (or colors) for the various curves. In plot3d, it defines
the colors used for the mesh lines of the surfaces, when no palette is being used.
If there are more curves or surfaces than colors, the colors will be repeated in sequence.
The valid colors are red, green, blue, magenta, cyan, yellow, orange, violet,
brown, gray, black, white, or a string starting with the character # and followed by
six hexadecimal digits: two for the red component, two for green component and two
for the blue component. If the name of a given color is unknown color, black will be
used instead.

color_bar [color bar, symbol], color bar, nocolor bar [Plot option]
Default value: false in plot3d, true in mandelbrot and julia
Where symbol can be either true or false. If true, whenever plot3d, mandelbrot
or julia use a palette to represent different values, a box will be shown on the right,
showing the corresponding between colors and values. The single keywords color_bar
and nocolor_bar can be used as synonyms for [color_bar, true] and [color_bar,
false].
Chapter 12: Plotting 229

color_bar_tics [color bar tics, x1, x2, x3], color bar tics, [Plot option]
nocolor bar tics
Defines the values at which a mark and a number will be placed in the color bar. The
first number is the initial value, the second the increments and the third is the last
value where a mark is placed. The second and third numbers can be omitted. When
only one number is given, it will be used as the increment from an initial value that
will be chosen automatically. The single keyword color_bar_tics removes a value
given previously, making the graphic program use its default for the values of the tics
and nocolor_bar_tics will not show any tics on the color bar.
elevation [elevation, number] [Plot option]
Default value: 60
A plot3d plot can be thought of as starting with the x and y axis in the horizontal
and vertical axis, as in plot2d, and the z axis coming out of the screen. The z axis
is then rotated around the x axis through an angle equal to elevation and then the
new xy plane is rotated around the new z axis through an angle azimuth. This option
sets the value for the elevation, in degrees.
See also azimuth.
grid [grid, integer, integer] [Plot option]
Default value: 30, 30
Sets the number of grid points to use in the x- and y-directions for three-dimensional
plotting or for the julia and mandelbrot programs.
For a way to actually draw a grid See grid2d.
grid2d [grid2d, value], grid2d, nogrid2d [Plot option]
Default value: false
Shows a grid of lines on the xy plane. The points where the grid lines are placed are
the same points where tics are marked in the x and y axes, which can be controlled
with the xtics and ytics options. The single keywords grid2d and nogrid2d can
be used as synonyms for [grid2d, true] and [grid2d, false].
See also grid.
iterations [iterations, value] [Plot option]
Default value: 9
Number of iterations made by the programs mandelbrot and julia.
label [label, [string, x, y], . . . ] [Plot option]
Writes one or several labels in the points with x, y coordinates indicated after each
label.
legend [legend, string_1, . . . , string_n], legend, nolegend [Plot option]
It specifies the labels for the plots when various plots are shown. If there are more
plots than the number of labels given, they will be repeated. If given the value false,
no legends will be shown. By default, the names of the expressions or functions will
be used, or the words discrete1, discrete2, . . . , for discrete sets of points. The single
keyword legend removes any previously defined legends, leaving it to the plotting
program to set up a legend. The keyword nolegend is a synonym for [legend,
false].
230 Maxima 5.45.0 Manual

levels [levels, number, . . . ] [Plot option]

This option is used by plot2d to do contour plots. If only one number is given after
the keyword levels, it must be a natural number; plot2d will try to plot that number
of contours with values between the minimum and maximum value of the expression
given, with the form d*10^n, where d is either 1, 2 or 5. Since not always it will be
possible to find that number of levels in that interval, the number of contour lines
show will be smaller than the number specified by this option.
If more than one number are given after the keyword levels, plot2d. will show the
contour lines corresponding to those values of the expression plotted, if they exist
within the domain used.

logx [logx, value], logx, nologx [Plot option]

Default value: false
Makes the horizontal axes to be scaled logarithmically. It can be either true or false.
The single keywords logx and nologx can be used as synonyms for [logx, true]
and [logx, false].

logy [logy, value], logy, nology [Plot option]

Default value: false
Makes the vertical axes to be scaled logarithmically. It can be either true or false.
The single keywords logy and nology can be used as synonyms for [logy, true]
and [logy, false].

mesh_lines_color [mesh lines color, color], mesh lines color, [Plot option]
no mesh lines
Default value: black
It sets the color used by plot3d to draw the mesh lines, when a palette is being used.
It accepts the same colors as for the option color (see the list of allowed colors in
color). It can also be given a value false to eliminate completely the mesh lines.
The single keyword mesh_lines_color removes any previously defined colors, leaving
it to the graphic program to decide what color to use. The keyword no_mesh_lines
is a synonym for [mesh_lines_color, false]

nticks [nticks, integer] [Plot option]

Default value: 29
When plotting functions with plot2d, it is gives the initial number of points used
by the adaptive plotting routine for plotting functions. When plotting parametric
functions with plot3d, it sets the number of points that will be shown for the plot.

palette [palette, [palette_1], . . . , [palette_n]], palette, [Plot option]

nopalette
It can consist of one palette or a list of several palettes. Each palette is a list with a
keyword followed by values. If the keyword is gradient, it should be followed by a list
of valid colors.
If the keyword is hue, saturation or value, it must be followed by 4 numbers. The first
three numbers, which must be between 0 and 1, define the hue, saturation and value
of a basic color to be assigned to the minimum value of z. The keyword specifies which
Chapter 12: Plotting 231

of the three attributes (hue, saturation or value) will be increased according to the
values of z. The last number indicates the increase corresponding to the maximum
value of z. That last number can be bigger than 1 or negative; the corresponding
values of the modified attribute will be rounded modulo 1.
Gnuplot only uses the first palette in the list; xmaxima will use the palettes in the
list sequentially, when several surfaces are plotted together; if the number of palettes
is exhausted, they will be repeated sequentially.
The color of the mesh lines will be given by the option mesh_lines_color. If palette
is given the value false, the surfaces will not be shaded but represented with a mesh
of curves only. In that case, the colors of the lines will be determined by the option
color.
The single keyword palette removes any palette previously defined, leaving it to
the graphic program to decide the palette to use and nopalette is a synonym for
[palette, false].

plotepsilon [plotepsilon, value] [Plot option]

Default value: 1e-6
This value is used by plot2d when plotting implicit functions or contour lines. When
plotting an explicit function expr_1=expr_2, it is converted into expr_1-expr_2 and
the points where that equals zero are searched. When a contour line for expr equal to
some value is going to be plotted, the points where expr minus that value are equal
to zero are searched. The search is done by computing those expressions at a grid
of points (see sample). If at one of the points in that grid the absolute value of the
expression is less than the value of plotepsilon, it will be assumed to be zero, and
therefore, as being part of the curve to be plotted.

plot_format [plot format, format] [Plot option]

Default value: gnuplot, in Windows systems, or gnuplot_pipes in other systems.
Where format is one of the following: gnuplot, xmaxima, mgnuplot, gnuplot pipes or
geomview.
It sets the format to be used for plotting as explained in Section 12.2 Plotting
Formats.

plot_realpart [plot realpart, symbol], plot realpart, [Plot option]

noplot realpart
Default value: false
If set to true, the functions to be plotted will be considered as complex
functions whose real value should be plotted; this is equivalent to plotting
realpart(function). If set to false, nothing will be plotted when the function
does not give a real value. For instance, when x is negative, log(x) gives a complex
value, with real value equal to log(abs(x)); if plot_realpart were true, log(-5)
would be plotted as log(5), while nothing would be plotted if plot_realpart
were false. The single keyword plot_realpart can be used as a synonym for
[plot_realpart, true] and noplot_realpart is a synonym for [plot_realpart,
false].
232 Maxima 5.45.0 Manual

point_type [point type, type_1, . . . , type_n] [Plot option]

In gnuplot, each set of points to be plotted with the style “points” or “linespoints”
will be represented with objects taken from this list, in sequential order. If there are
more sets of points than objects in this list, they will be repeated sequentially. The
possible objects that can be used are: bullet, circle, plus, times, asterisk, box,
square, triangle, delta, wedge, nabla, diamond, lozenge.

pdf_file [pdf file, file_name] [Plot option]

Saves the plot into a PDF file with name equal to file name, rather than showing it in
the screen. By default, the file will be created in the directory defined by the variable
maxima_tempdir, unless file name contains the character “/”, in which case it will
be assumed to contain the complete path where the file should be created. The value
of maxima_tempdir can be changed to save the file in a different directory. When the
option gnuplot_pdf_term_command is also given, it will be used to set up Gnuplot’s
PDF terminal; otherwise, Gnuplot’s pdfcairo terminal will be used with solid colored
lines of width 3, plot size of 17.2 cm by 12.9 cm and font of 18 points.

png_file [png file, file_name] [Plot option]

Saves the plot into a PNG graphics file with name equal to file name, rather than
showing it in the screen. By default, the file will be created in the directory defined by
the variable maxima_tempdir, unless file name contains the character “/”, in which
case it will be assumed to contain the complete path where the file should be created.
The value of maxima_tempdir can be changed to save the file in a different directory.
When the option gnuplot_png_term_command is also given, it will be used to set up
Gnuplot’s PNG terminal; otherwise, Gnuplot’s pngcairo terminal will be used, with
a font of size 12.

ps_file [ps file, file_name] [Plot option]

Saves the plot into a Postscript file with name equal to file name, rather than showing
it in the screen. By default, the file will be created in the directory defined by the
variable maxima_tempdir, unless file name contains the character “/”, in which case
it will be assumed to contain the complete path where the file should be created.
The value of maxima_tempdir can be changed to save the file in a different directory.
When the option gnuplot_ps_term_command is also given, it will be used to set up
Gnuplot’s Postscript terminal; otherwise, Gnuplot’s postscript terminal will be used
with the EPS option, solid colored lines of width 2, plot size of 16.4 cm by 12.3 cm
and font of 24 points.

run_viewer [run viewer, symbol], run viewer, norun viewer [Plot option]
Default value: true
This option is only used when the plot format is gnuplot and the terminal is default
or when the Gnuplot terminal is set to dumb (see gnuplot_term) and can have a true
or false value.
If the terminal is default, a file maxout_xxx.gnuplot (or other name specified with
gnuplot_out_file) is created with the gnuplot commands necessary to generate the
plot. Option run_viewer controls whether or not Gnuplot will be launched to execute
those commands and show the plot.
Chapter 12: Plotting 233

If the terminal is default, gnuplot is run to execute the commands in maxout_

xxx.gnuplot, producing another file maxplot.txt (or other name specified with
gnuplot_out_file). Option run_viewer controls whether or not that file, with an
ASCII representation of the plot, will be shown in the Maxima or Xmaxima console.
Its default value, true, makes the plots appear in either the console or a separate
graphics window. run_viewer and norun_viewer are synonyms for [run_viewer,
true] and [run_viewer, false].

same_xy [same xy , value], same xy, nosame xy [Plot option]

It can be either true or false. If true, the scales used in the x and y axes will be
the same, in either 2d or 3d plots. See also yx_ratio. same_xy and nosame_xy are
synonyms for [same_xy, true] and [same_xy, false].

same_xyz [same xyz , value], same xyz, nosame xyz [Plot option]
It can be either true or false. If true, the scales used in the 3 axes of a 3d plot will
be the same. same_xyz and nosame_xyz are synonyms for [same_xyz, true] and
[same_xyz, false].

sample [sample, nx, ny] [Plot option]

Default value: [sample, 50, 50]
nx and ny must be two natural numbers that will be used by plot2d to look for
the points that make part of the plot of an implicit function or a contour line. The
domain is divided into nx intervals in the horizontal axis and ny intervals in the
vertical axis and the numerical value of the expression is computed at the borders
of those intervals. Higher values of nx and ny will give smoother curves, but will
increase the time needed to trace the plot. When there are critical points in the plot
where the curve changes direction, to get better results it is more important to try to
make those points to be at the border of the intervals, rather than increasing nx and
ny.

style [style, type_1, . . . , type_n], [style, [style_1], . . . , [Plot option]

[style_n]]
The styles that will be used for the various functions or sets of data in a 2d plot. The
word style must be followed by one or more styles. If there are more functions and
data sets than the styles given, the styles will be repeated. Each style can be either
lines for line segments, points for isolated points, linespoints for segments and points,
or dots for small isolated dots. Gnuplot accepts also an impulses style.
Each of the styles can be enclosed inside a list with some additional parameters. lines
accepts one or two numbers: the width of the line and an integer that identifies a
color. The default color codes are: 1: blue, 2: red, 3: magenta, 4: orange, 5: brown,
6: lime and 7: aqua. If you use Gnuplot with a terminal different than X11, those
colors might be different; for example, if you use the option [gnuplot term, ps], color
index 4 will correspond to black, instead of orange.
points accepts one two or three parameters; the first parameter is the radius of the
points, the second parameter is an integer that selects the color, using the same
code used for lines and the third parameter is currently used only by Gnuplot and
it corresponds to several objects instead of points. The default types of objects are:
234 Maxima 5.45.0 Manual

1: filled circles, 2: open circles, 3: plus signs, 4: x, 5: *, 6: filled squares, 7: open

squares, 8: filled triangles, 9: open triangles, 10: filled inverted triangles, 11: open
inverted triangles, 12: filled lozenges and 13: open lozenges.
linespoints accepts up to four parameters: line width, points radius, color and type
of object to replace the points.
See also color and point_type.

svg_file [svg file, file_name] [Plot option]

Saves the plot into an SVG file with name equal to file name, rather than showing
it in the screen. By default, the file will be created in the directory defined by the
variable maxima_tempdir, unless file name contains the character “/”, in which case
it will be assumed to contain the complete path where the file should be created.
The value of maxima_tempdir can be changed to save the file in a different directory.
When the option gnuplot_svg_term_command is also given, it will be used to set up
Gnuplot’s SVG terminal; otherwise, Gnuplot’s svg terminal will be used with font of
14 points.

t [t, min, max] [Plot option]

Default range for parametric plots.

title [title, text] [Plot option]

Defines a title that will be written at the top of the plot.

transform_xy [transform xy, symbol], notransform xy [Plot option]

Where symbol is either false or the result obtained by using the function transform_
xy. If different from false, it will be used to transform the 3 coordinates in plot3d.
notransform_xy removes any transformation function previously defined.
See make_transform, polar_to_xy and spherical_to_xyz.

x [x, min, max] [Plot option]

When used as the first option in a plot2d command (or any of the first two in plot3d),
it indicates that the first independent variable is x and it sets its range. It can also
be used again after the first option (or after the second option in plot3d) to define
the effective horizontal domain that will be shown in the plot.

xlabel [xlabel, string] [Plot option]

Specifies the string that will label the first axis; if this option is not used, that label
will be the name of the independent variable, when plotting functions with plot2d the
name of the first variable, when plotting surfaces with plot3d, or the first expression
in the case of a parametric plot.

xtics [xtics, x1, x2, x3], [xtics, false], xtics, noxtics [Plot option]
Defines the values at which a mark and a number will be placed in the x axis. The
first number is the initial value, the second the increments and the third is the last
value where a mark is placed. The second and third numbers can be omitted, in
which case the first number is the increment from an initial value that will be chosen
by the graphic program. If [xtics, false] is used, no marks or numbers will be
shown along the x axis.
Chapter 12: Plotting 235

The single keyword xtics removes any values previously defined, leaving it to the
graphic program to decide the values to use and noxtics is a synonym for [xtics,
false]

xy_scale [xy scale, sx, sy] [Plot option]

In a 2d plot, it defines the ratio of the total size of the Window to the size that will
be used for the plot. The two numbers given as arguments are the scale factors for
the x and y axes.
This option does not change the size of the graphic window or the placement of the
graph in the window. If you want to change the aspect ratio of the plot, it is better
to use option yx_ratio. For instance, [yx_ratio, 10] instead of [xy_scale, 0.1,
1].

y [y, min, max] [Plot option]

When used as one of the first two options in plot3d, it indicates that one of the
independent variables is y and it sets its range. Otherwise, it defines the effective
domain of the second variable that will be shown in the plot.

ylabel [ylabel, string] [Plot option]

Specifies the string that will label the second axis; if this option is not used, that
label will be “y”, when plotting explicit functions with plot2d, or the name of the
second variable, when plotting surfaces with plot3d, or the second expression in the
case of a parametric plot.

ytics [ytics, y1, y2, y3], [ytics, false], ytics, noytics [Plot option]
Defines the values at which a mark and a number will be placed in the y axis. The
first number is the initial value, the second the increments and the third is the last
value where a mark is placed. The second and third numbers can be omitted, in
which case the first number is the increment from an initial value that will be chosen
by the graphic program. If [ytics, false] is used, no marks or numbers will be
shown along the y axis.
The single keyword ytics removes any values previously defined, leaving it to the
graphic program to decide the values to use and noytics is a synonym for [ytics,
false]

yx_ratio [yx ratio, r] [Plot option]

In a 2d plot, the ratio between the vertical and the horizontal sides of the rectangle
used to make the plot. See also same_xy.

z [z, min, max] [Plot option]

Used in plot3d to set the effective range of values of z that will be shown in the plot.

zlabel [zlabel, string] [Plot option]

Specifies the string that will label the third axis, when using plot3d. If this option
is not used, that label will be “z”, when plotting surfaces, or the third expression in
the case of a parametric plot. It can not be used with set_plot_option and it will
be ignored by plot2d.
236 Maxima 5.45.0 Manual

zmin [zmin, z], zmin [Plot option]

In 3d plots, the value of z that will be at the bottom of the plot box.
The single keyword zmin removes any value previously defined, leaving it to the
graphic program to decide the value to use.

ztics [ztics, z1, z2, z3], [ztics, false], ztics, noztics [Plot option]
Defines the values at which a mark and a number will be placed in the z axis. The
first number is the initial value, the second the increments and the third is the last
value where a mark is placed. The second and third numbers can be omitted, in
which case the first number is the increment from an initial value that will be chosen
by the graphic program. If [ztics, false] is used, no marks or numbers will be
shown along the z axis.
The single keyword ztics removes any values previously defined, leaving it to the
graphic program to decide the values to use and noztics is a synonym for [ztics,
false]

12.5 Gnuplot Options

There are several plot options specific to gnuplot. All of them consist of a keyword (the
name of the option), followed by a string that should be a valid gnuplot command, to be
passed directly to gnuplot. In most cases, there exist a corresponding plotting option that
will produce a similar result and whose use is more recommended than the gnuplot specific
option.

gnuplot_term [gnuplot term, terminal_name] [Plot option]

Sets the output terminal type for gnuplot. The argument terminal name can be a
string or one of the following 3 special symbols
• default (default value)
Gnuplot output is displayed in a separate graphical window and the gnuplot
terminal used will be specified by the value of the option gnuplot_default_
term_command.
• dumb
Gnuplot output is saved to a file maxout_xxx.gnuplot using "ASCII art" approx-
imation to graphics. If the option gnuplot_out_file is set to filename, the plot
will be saved there, instead of the default maxout_xxx.gnuplot. The settings
for the “dumb” terminal of Gnuplot are given by the value of option gnuplot_
dumb_term_command. If option run_viewer is set to true and the plot format is
gnuplot that ASCII representation will also be shown in the Maxima or Xmax-
ima console.
• ps
Gnuplot generates commands in the PostScript page description language. If
the option gnuplot_out_file is set to filename, gnuplot writes the PostScript
commands to filename. Otherwise, it is saved as maxplot.ps file. The settings for
this terminal are given by the value of the option gnuplot_dumb_term_command.
Chapter 12: Plotting 237

• A string representing any valid gnuplot term specification

Gnuplot can generate output in many other graphical formats such as png, jpeg,
svg etc. To use those formats, option gnuplot_term can be set to any sup-
ported gnuplot term name (which must be a symbol) or even a full gnuplot
term specification with any valid options (which must be a string). For example
[gnuplot_term, png] creates output in PNG (Portable Network Graphics) for-
mat while [gnuplot_term, "png size 1000,1000"] creates PNG of 1000 x 1000
pixels size. If the option gnuplot_out_file is set to filename, gnuplot writes
the output to filename. Otherwise, it is saved as maxplot.term file, where term
is gnuplot terminal name.

gnuplot_out_file [gnuplot out file, file_name] [Plot option]

It can be used to replace the default name for the file that contains the commands
that will interpreted by gnuplot, when the terminal is set to default, or to replace the
default name of the graphic file that gnuplot creates, when the terminal is different
from default. If it contains one or more slashes, “/”, the name of the file will be left
as it is; otherwise, it will be appended to the path of the temporary directory. The
complete name of the files created by the plotting commands is always sent as output
of those commands so they can be seen if the command is ended by semi-colon.
When used in conjunction with the gnuplot_term option, it can be used to save the
plot in a file, in one of the graphic formats supported by Gnuplot. To create PNG,
PDF, Postscript or SVG, it is easier to use options png_file, pdf_file, ps_file, or
svg_file.

gnuplot_script_file [gnuplot script file, [Plot option]

file_name_or_function]
Set the name of the script file created by plot2d or plot3d when the plot_format
is gnuplot. The value file name or function can be a string or a Maxima function of
one variable that returns a string.
In this example, the script file name is set to “sin.gnuplot”.
(%i1) plot2d( sin(x), [x,0,2*%pi], [gnuplot_script_file, "sin.gnuplot"]);

(%o1) ["/tmp/sin.gnuplot"]
In this example, gnuplot_maxout_prt(file) is a function that takes the default file
name, file. It constructs a full file name for the data file by interpolating a random 8-
digit integer with a pad of zeros into the default file name. The directory is determined
by maxima_tempdir (it is “/tmp” in this example).
(%i1) gnuplot_maxout_prt(file) := block([beg,end],
[beg,end] : split(file,"."),
printf(false,"~a_~8,'0d.~a",beg,random(10^8-1),end)) $

(%i2) plot2d( sin(x), [x,0,2*%pi], [gnuplot_script_file, gnuplot_maxout_prt]);

(%o2) ["/tmp/maxout68715_09606909.gnuplot"]
By default, the script would have been saved in a file named maxoutXXXXX.gnuplot
(XXXXX=68715 in this example).
238 Maxima 5.45.0 Manual

gnuplot_pm3d [gnuplot pm3d, value] [Plot option]

With a value of false, it can be used to disable the use of PM3D mode, which is
enabled by default.

gnuplot_preamble [gnuplot preamble, string] [Plot option]

This option inserts gnuplot commands before any other commands sent to Gnuplot.
Any valid gnuplot commands may be used. Multiple commands should be separated
with a semi-colon. See also gnuplot_postamble.

gnuplot_postamble [gnuplot postamble, string] [Plot option]

This option inserts gnuplot commands after other commands sent to Gnuplot
and right before the plot command is sent. Any valid gnuplot commands may
be used. Multiple commands should be separated with a semi-colon. See also
gnuplot_preamble.

gnuplot_default_term_command [Plot option]

[gnuplot default term command, command]
The gnuplot command to set the terminal type for the default terminal. It this option
is not set, the command used will be: "set term wxt size 640,480 font \",12\";
set term pop".

gnuplot_dumb_term_command [Plot option]

[gnuplot dumb term command, command]
The gnuplot command to set the terminal type for the dumb terminal. It this option
is not set, the command used will be: "set term dumb 79 22", which makes the text
output 79 characters by 22 characters.

gnuplot_pdf_term_command [gnuplot pdf term command, [Plot option]

command]
The gnuplot command to set the terminal type for the PDF terminal. If this option
is not set, the command used will be: "set term pdfcairo color solid lw 3 size
17.2 cm, 12.9 cm font \",18\"". See the gnuplot documentation for more informa-
tion.

gnuplot_png_term_command [gnuplot png term command, [Plot option]

command]
The gnuplot command to set the terminal type for the PNG terminal. If this option
is not set, the command used will be: "set term pngcairo font \",12\"". See the
gnuplot documentation for more information.

gnuplot_ps_term_command [gnuplot ps term command, command] [Plot option]

The gnuplot command to set the terminal type for the PostScript terminal. If this
option is not set, the command used will be: "set term postscript eps color solid
lw 2 size 16.4 cm, 12.3 cm font \",24\"". See the gnuplot documentation for set
term postscript for more information.

gnuplot_strings [gnuplot strings, value] [Plot option]

With a value of true, all strings used in labels and titles will be interpreted by gnuplot
as “enhanced” text, if the terminal being used supports it. In enhanced mode, some
Chapter 12: Plotting 239

characters such as ^ and are not printed, but interpreted as formatting characters.
For a list of the formatting characters and their meaning, see the documentation for
enhanced in Gnuplot. The default value for this option is false, which will not treat
any characters as formatting characters.

gnuplot_svg_term_command [gnuplot svg term command, [Plot option]

command]
The gnuplot command to set the terminal type for the SVG terminal. If this option is
not set, the command used will be: "set term svg font \",14\"". See the gnuplot
documentation for more information.

gnuplot_curve_titles [Plot option]

This is an obsolete option that has been replaced by legend described above.

gnuplot_curve_styles [Plot option]

This is an obsolete option that has been replaced by style.

12.6 Gnuplot pipes Format Functions

gnuplot_start () [Function]
Opens the pipe to gnuplot used for plotting with the gnuplot_pipes format. Is not
necessary to manually open the pipe before plotting.

gnuplot_close () [Function]
Closes the pipe to gnuplot which is used with the gnuplot_pipes format.

gnuplot_restart () [Function]
Closes the pipe to gnuplot which is used with the gnuplot_pipes format and opens
a new pipe.

gnuplot_replot [Function]
gnuplot_replot ()
gnuplot_replot (s)
Updates the gnuplot window. If gnuplot_replot is called with a gnuplot command
in a string s, then s is sent to gnuplot before reploting the window.

gnuplot_reset () [Function]
Resets the state of gnuplot used with the gnuplot_pipes format. To update the
gnuplot window call gnuplot_replot after gnuplot_reset.
 241

13 File Input and Output

13.1 Comments
A comment in Maxima input is any text between /* and */.
The Maxima parser treats a comment as whitespace for the purpose of finding tokens
in the input stream; a token always ends at a comment. An input such as a/* foo */b
contains two tokens, a and b, and not a single token ab. Comments are otherwise ignored
by Maxima; neither the content nor the location of comments is stored in parsed input
expressions.
Comments can be nested to arbitrary depth. The /* and */ delimiters form matching
pairs. There must be the same number of /* as there are */.
Examples:
(%i1) /* aa is a variable of interest */ aa : 1234;
(%o1) 1234
(%i2) /* Value of bb depends on aa */ bb : aa^2;
(%o2) 1522756
(%i3) /* User-defined infix operator */ infix ("b");
(%o3) b
(%i4) /* Parses same as a b c, not abc */ a/* foo */b/* bar */c;
(%o4) a b c
(%i5) /* Comments /* can be nested /* to any depth */ */ */ 1 + xyz;
(%o5) xyz + 1

13.2 Files
A file is simply an area on a particular storage device which contains data or text. Files
on the disks are figuratively grouped into "directories". A directory is just a list of files.
Commands which deal with files are:
appendfile batch batchload
closefile file_output_append filename_merge
file_search file_search_maxima file_search_lisp
file_search_demo file_search_usage file_search_tests
file_type file_type_lisp file_type_maxima
load load_pathname loadfile
loadprint pathname_directory pathname_name
pathname_type printfile save
stringout with_stdout writefile
When a file name is passed to functions like plot2d, save, or writefile and the file
name does not include a path, Maxima stores the file in the current working directory.
The current working directory depends on the system like Windows or Linux and on the
installation.
242 Maxima 5.45.0 Manual

13.3 Functions and Variables for File Input and Output

appendfile (filename) [Function]
Appends a console transcript to filename. appendfile is the same as writefile,
except that the transcript file, if it exists, is always appended.
closefile closes the transcript file opened by appendfile or writefile.
batch [Function]
batch (filename)
batch (filename, option)
batch(filename) reads Maxima expressions from filename and evaluates them.
batch searches for filename in the list file_search_maxima. See also file_search.
batch(filename, demo) is like demo(filename). In this case batch searches for
filename in the list file_search_demo. See demo.
batch(filename, test) is like run_testsuite with the option display_all=true.
For this case batch searches filename in the list file_search_maxima and not in
the list file_search_tests like run_testsuite. Furthermore, run_testsuite runs
tests which are in the list testsuite_files. With batch it is possible to run any file
in a test mode, which can be found in the list file_search_maxima. This is useful,
when writing a test file.
filename comprises a sequence of Maxima expressions, each terminated with ; or $.
The special variable % and the function %th refer to previous results within the file.
The file may include :lisp constructs. Spaces, tabs, and newlines in the file are
ignored. A suitable input file may be created by a text editor or by the stringout
function.
batch reads each input expression from filename, displays the input to the console,
computes the corresponding output expression, and displays the output expression.
Input labels are assigned to the input expressions and output labels are assigned to
the output expressions. batch evaluates every input expression in the file unless there
is an error. If user input is requested (by asksign or askinteger, for example) batch
pauses to collect the requisite input and then continue.
It may be possible to halt batch by typing control-C at the console. The effect of
control-C depends on the underlying Lisp implementation.
batch has several uses, such as to provide a reservoir for working command lines, to
give error-free demonstrations, or to help organize one’s thinking in solving complex
problems.
batch evaluates its argument. batch returns the path of filename as a string, when
called with no second argument or with the option demo. When called with the option
test, the return value is a an empty list [] or a list with filename and the numbers
of the tests which have failed.
See also load, batchload, and demo.
batchload (filename) [Function]
Reads Maxima expressions from filename and evaluates them, without displaying
the input or output expressions and without assigning labels to output expressions.
Printed output (such as produced by print or describe)) is displayed, however.
Chapter 13: File Input and Output 243

The special variable % and the function %th refer to previous results from the interac-
tive interpreter, not results within the file. The file cannot include :lisp constructs.
batchload returns the path of filename, as a string. batchload evaluates its argu-
ment.
See also batch, and load.

closefile () [Function]
Closes the transcript file opened by writefile or appendfile.

file_output_append [Option variable]

Default value: false
file_output_append governs whether file output functions append or truncate their
output file. When file_output_append is true, such functions append to their
output file. Otherwise, the output file is truncated.
save, stringout, and with_stdout respect file_output_append. Other functions
which write output files do not respect file_output_append. In particular, plotting
and translation functions always truncate their output file, and tex and appendfile
always append.

filename_merge (path, filename) [Function]

Constructs a modified path from path and filename. If the final component of path is
of the form ###.something, the component is replaced with filename.something.
Otherwise, the final component is simply replaced by filename.
The result is a Lisp pathname object.

file_search [Function]
file_search (filename)
file_search (filename, pathlist)
file_search searches for the file filename and returns the path to the file (as a string)
if it can be found; otherwise file_search returns false. file_search (filename)
searches in the default search directories, which are specified by the file_search_
maxima, file_search_lisp, and file_search_demo variables.
file_search first checks if the actual name passed exists, before attempting to match
it to “wildcard” file search patterns. See file_search_maxima concerning file search
patterns.
The argument filename can be a path and file name, or just a file name, or, if a file
search directory includes a file search pattern, just the base of the file name (without
an extension). For example,
file_search ("/home/wfs/special/zeta.mac");
file_search ("zeta.mac");
file_search ("zeta");
all find the same file, assuming the file exists and /home/wfs/special/###.mac is in
file_search_maxima.
file_search (filename, pathlist) searches only in the directories specified by
pathlist, which is a list of strings. The argument pathlist supersedes the default
search directories, so if the path list is given, file_search searches only the ones
244 Maxima 5.45.0 Manual

specified, and not any of the default search directories. Even if there is only one
directory in pathlist, it must still be given as an one-element list.
The user may modify the default search directories. See file_search_maxima.
file_search is invoked by load with file_search_maxima and file_search_lisp
as the search directories.
file_search_maxima [Option variable]
file_search_lisp [Option variable]
file_search_demo [Option variable]
file_search_usage [Option variable]
file_search_tests [Option variable]
These variables specify lists of directories to be searched by load, demo, and some
other Maxima functions. The default values of these variables name various directories
in the Maxima installation.
The user can modify these variables, either to replace the default values or to append
additional directories. For example,
file_search_maxima: ["/usr/local/foo/###.mac",
"/usr/local/bar/###.mac"]$
replaces the default value of file_search_maxima, while
file_search_maxima: append (file_search_maxima,
["/usr/local/foo/###.mac", "/usr/local/bar/###.mac"])$
appends two additional directories. It may be convenient to put such an expression
in the file maxima-init.mac so that the file search path is assigned automatically
when Maxima starts. See also Section 32.1 [Introduction for Runtime Environment],
page 557.
Multiple filename extensions and multiple paths can be specified by special “wildcard”
constructions. The string ### expands into the sought-after name, while a comma-
separated list enclosed in curly braces {foo,bar,baz} expands into multiple strings.
For example, supposing the sought-after name is neumann,
"/home/{wfs,gcj}/###.{lisp,mac}"
expands into /home/wfs/neumann.lisp, /home/gcj/neumann.lisp,
/home/wfs/neumann.mac, and /home/gcj/neumann.mac.
file_type (filename) [Function]
Returns a guess about the content of filename, based on the filename extension.
filename need not refer to an actual file; no attempt is made to open the file and
inspect the content.
The return value is a symbol, either object, lisp, or maxima. If the extension is
matches one of the values in file_type_maxima, file_type returns maxima. If the
extension matches one of the values in file_type_lisp, file_type returns lisp. If
none of the above, file_type returns object.
See also pathname_type.
See file_type_maxima and file_type_lisp for the default values.
Examples:
(%i2) map('file_type,
Chapter 13: File Input and Output 245

["test.lisp", "test.mac", "test.dem", "test.txt"]);

(%o2) [lisp, maxima, maxima, object]

file_type_lisp [Option variable]

Default value: [l, lsp, lisp]
file_type_lisp is a list of file extensions that maxima recognizes as denoting a Lisp
source file.
See also file_type.

file_type_maxima [Option variable]

Default value: [mac, mc, demo, dem, dm1, dm2, dm3, dmt, wxm]
file_type_maxima is a list of file extensions that maxima recognizes as denoting a
Maxima source file.
See also file_type.

load (filename) [Function]

Evaluates expressions in filename, thus bringing variables, functions, and other objects
into Maxima. The binding of any existing object is clobbered by the binding recovered
from filename. To find the file, load calls file_search with file_search_maxima
and file_search_lisp as the search directories. If load succeeds, it returns the
name of the file. Otherwise load prints an error message.
load works equally well for Lisp code and Maxima code. Files created by save,
translate_file, and compile_file, which create Lisp code, and stringout, which
creates Maxima code, can all be processed by load. load calls loadfile to load Lisp
files and batchload to load Maxima files.
load does not recognize :lisp constructs in Maxima files, and while processing
filename, the global variables _, __, %, and %th have whatever bindings they had
when load was called.
Note also that structures will only be read back as structures if they have been defined
by defstruct before the load command is called.
See also loadfile, for Lisp files; and batch, batchload, and demo. for Maxima files.
See file_search for more detail about the file search mechanism. The numericalio
chapter describes many functions for loading csv and other data files.
During Maxima file loading, the variable load_pathname is bound to the pathname
of the file being loaded.
load evaluates its argument.

load_pathname [System variable]

Default value: false
When a file is loaded with the functions load, loadfile or batchload the system
variable load_pathname is bound to the pathname of the file which is processed.
The variable load_pathname can be accessed from the file during the loading.
Example:
246 Maxima 5.45.0 Manual

Suppose we have a batchfile test.mac in the directory

"/home/dieter/workspace/mymaxima/temp/" with the following commands
print("The value of load_pathname is: ", load_pathname)$
print("End of batchfile")$
then we get the following output
(%i1) load("/home/dieter/workspace/mymaxima/temp/test.mac")$
The value of load_pathname is:
/home/dieter/workspace/mymaxima/temp/test.mac
End of batchfile
loadfile (filename) [Function]
Evaluates Lisp expressions in filename. loadfile does not invoke file_search, so
filename must include the file extension and as much of the path as needed to find
the file.
loadfile can process files created by save, translate_file, and compile_file.
The user may find it more convenient to use load instead of loadfile.
loadprint [Option variable]
Default value: true
loadprint tells whether to print a message when a file is loaded.
• When loadprint is true, always print a message.
• When loadprint is 'loadfile, print a message only if a file is loaded by the
function loadfile.
• When loadprint is 'autoload, print a message only if a file is automatically
loaded. See setup_autoload.
• When loadprint is false, never print a message.
directory (path) [Function]
Returns a list of the files and directories found in path in the file system.
path may contain wildcard characters (i.e., characters which represent unspecified
parts of the path), which include at least the asterisk on most systems, and possibly
other characters, depending on the system.
directory relies on the Lisp function DIRECTORY, which may have
implementation-specific behavior.
pathname_directory (pathname) [Function]
pathname_name (pathname) [Function]
pathname_type (pathname) [Function]
These functions return the components of pathname.
Examples:
(%i1) pathname_directory("/home/dieter/maxima/changelog.txt");
(%o1) /home/dieter/maxima/
(%i2) pathname_name("/home/dieter/maxima/changelog.txt");
(%o2) changelog
(%i3) pathname_type("/home/dieter/maxima/changelog.txt");
(%o3) txt
Chapter 13: File Input and Output 247

printfile (path) [Function]

Prints the file named by path to the console. path may be a string or a symbol; if it
is a symbol, it is converted to a string.
If path names a file which is accessible from the current working directory, that file is
printed to the console. Otherwise, printfile attempts to locate the file by appending
path to each of the elements of file_search_usage via filename_merge.
printfile returns path if it names an existing file, or otherwise the result of a
successful filename merge.
save [Function]
save (filename, name_1, name_2, name_3, . . . )
save (filename, values, functions, labels, . . . )
save (filename, [m, n])
save (filename, name_1=expr_1, . . . )
save (filename, all)
save (filename, name_1=expr_1, name_2=expr_2, . . . )
Stores the current values of name 1, name 2, name 3, . . . , in filename. The argu-
ments are the names of variables, functions, or other objects. If a name has no value
or function associated with it, it is ignored. save returns filename.
save stores data in the form of Lisp expressions. If filename ends in .lisp the data
stored by save may be recovered by load (filename). See load.
The global flag file_output_append governs whether save appends or truncates the
output file. When file_output_append is true, save appends to the output file.
Otherwise, save truncates the output file. In either case, save creates the file if it
does not yet exist.
The special form save (filename, values, functions, labels, ...) stores the
items named by values, functions, labels, etc. The names may be any specified
by the variable infolists. values comprises all user-defined variables.
The special form save (filename, [m, n]) stores the values of input and output la-
bels m through n. Note that m and n must be literal integers. Input and output labels
may also be stored one by one, e.g., save ("foo.1", %i42, %o42). save (filename,
labels) stores all input and output labels. When the stored labels are recovered,
they clobber existing labels.
The special form save (filename, name_1=expr_1, name_2=expr_2, ...) stores
the values of expr 1, expr 2, . . . , with names name 1, name 2, . . . It is useful
to apply this form to input and output labels, e.g., save ("foo.1", aa=%o88).
The right-hand side of the equality in this form may be any expression, which is
evaluated. This form does not introduce the new names into the current Maxima
environment, but only stores them in filename.
These special forms and the general form of save may be mixed at will. For example,
save (filename, aa, bb, cc=42, functions, [11, 17]).
The special form save (filename, all) stores the current state of Maxima. This
includes all user-defined variables, functions, arrays, etc., as well as some auto-
matically defined items. The saved items include system variables, such as file_
search_maxima or showtime, if they have been assigned new values by the user; see
myoptions.
248 Maxima 5.45.0 Manual

save evaluates filename and quotes all other arguments.

stringout [Function]
stringout (filename, expr_1, expr_2, expr_3, . . . )
stringout (filename, [m, n])
stringout (filename, input)
stringout (filename, functions)
stringout (filename, values)
stringout writes expressions to a file in the same form the expressions would be
typed for input. The file can then be used as input for the batch or demo commands,
and it may be edited for any purpose. stringout can be executed while writefile
is in progress.
The global flag file_output_append governs whether stringout appends or trun-
cates the output file. When file_output_append is true, stringout appends to
the output file. Otherwise, stringout truncates the output file. In either case,
stringout creates the file if it does not yet exist.
The general form of stringout writes the values of one or more expressions to the
output file. Note that if an expression is a variable, only the value of the variable is
written and not the name of the variable. As an useful special case, the expressions
may be input labels (%i1, %i2, %i3, . . . ) or output labels (%o1, %o2, %o3, . . . ).
If grind is true, stringout formats the output using the grind format. Otherwise
the string format is used. See grind and string.
The special form stringout (filename, [m, n]) writes the values of input labels m
through n, inclusive.
The special form stringout (filename, input) writes all input labels to the file.
The special form stringout (filename, functions) writes all user-defined func-
tions (named by the global list functions)) to the file.
The special form stringout (filename, values) writes all user-assigned variables
(named by the global list values)) to the file. Each variable is printed as an assign-
ment statement, with the name of the variable, a colon, and its value. Note that the
general form of stringout does not print variables as assignment statements.

with_stdout [Function]
with_stdout (f, expr_1, expr_2, expr_3, . . . )
with_stdout (s, expr_1, expr_2, expr_3, . . . )
Evaluates expr 1, expr 2, expr 3, . . . and writes any output thus generated to a file f
or output stream s. The evaluated expressions are not written to the output. Output
may be generated by print, display, grind, among other functions.
The global flag file_output_append governs whether with_stdout appends or trun-
cates the output file f. When file_output_append is true, with_stdout appends
to the output file. Otherwise, with_stdout truncates the output file. In either case,
with_stdout creates the file if it does not yet exist.
with_stdout returns the value of its final argument.
See also writefile and display2d.
(%i1) with_stdout ("tmp.out", for i:5 thru 10 do
Chapter 13: File Input and Output 249

print (i, "! yields", i!))$

(%i2) printfile ("tmp.out")$
5 ! yields 120
6 ! yields 720
7 ! yields 5040
8 ! yields 40320
9 ! yields 362880
10 ! yields 3628800
writefile (filename) [Function]
Begins writing a transcript of the Maxima session to filename. All interaction between
the user and Maxima is then recorded in this file, just as it appears on the console.
As the transcript is printed in the console output format, it cannot be reloaded into
Maxima. To make a file containing expressions which can be reloaded, see save and
stringout. save stores expressions in Lisp form, while stringout stores expressions
in Maxima form.
The effect of executing writefile when filename already exists depends on the un-
derlying Lisp implementation; the transcript file may be clobbered, or the file may be
appended. appendfile always appends to the transcript file.