immutable data structure
sequence
1. Definition: A set of expressions separated by commas
2. For example: the parameter item of the function is a sequence:
[< l := 2*x + 3 = 1, x;#Generate sequence [< solve(l);#solve -1
3. Extract sequence elements: use index(sequencename[index])
4. Encoding to generate a sequence: use the seq function
[< seq(2*i + 1, i = 1 .. 5, 2);#Generate sequence 2i+1,i=1,3,5 3, 7, 11
list
1. Definition: a sequence enclosed in square brackets: [ ]
2. Features: orderly, keep repeating elements
Related function operation
1. Determine the expression type: whattype(a)
2. Return a sequence of expressions in a list: op(a)
3. Test whether an expression is a member of a list: member( expression, list name) or has( list name, expression)
4. The number of elements in the list: numelems (list name)
a := seq(2*i + 1, i = 1 .. 5);#generate a sequence a := 3, 5, 7, 9, 11 b:=[1,2,3,1] whattype(a);whattype(b) #Determine the type of an expression exprseq list member(1,b);hasr(b,4) true false numelems(b); 4
gather
Definition: {sequence}
Features: No repeating elements, disordered.
Related operations
1. Extract the elements in the collection: op( )
2. Conversion of sets and lists: convert( collection name, 'list') or [op( collection name)]
3. Filter out the elements in the collection that meet certain conditions: select(x->conditional expression, collection name)
4. Remove elements that do not meet the conditions: remove(x->conditional expression, set name)
5. Filter + remove both: selectremove(issqr, d)
6. Apply a function to all elements in a list or set: map
a := {1, 2, 3}; b := {1, a}; a := {1, 2, 3} b := {1, {1, 2, 3}} op(a);#Extract elements from a collection 1, 2, 3 [op(b)];#Collection --> List [1, {1, 2, 3}] convert(a, 'list');List ->gather [1, 2, 3] select(x -> x^2 = 4, a);#Select the element x in the set a, which satisfies x^2=4 {2} remove(x -> x^2 = 4, a);#Elements in the outgoing set a that satisfy x^2=4 {1, 3} selectremove(x -> x^2 = 4, a); {2}, {1, 3} map(sin, a);#a as the domain of the sin function {sin(1), sin(2), sin(3)}
mutable data structure
arrayArray
1. Create: a:=Array([a,b,c])
2. Get the number of elements in the array: numelems(a)
3. Get the upper and lower bounds of the index: lowerbound(a), upperbound(a);
4. Calculate the cumulative sum: s(k)=sum(xi,i=1,…k)
Here k=10;x(i)=i
matrix/vector
1. Create:
1.Matrix() , Vector()
2. Use index: M := Matrix(x, y, (i, j) -> f)
Where x,y are the number of rows and columns of the matrix, and f is the expression of the element Mij
3. Use <<>>:M := <<<1,2>|<3,4>>>
2. Type conversion:
Order | illustrate |
---|---|
convert( listname, Vector) | list --> vector |
convert(L[L1,[L2]], Matrix) | List -> Matrix (L1, L2 are lists with the same number of elements) |
surface
1. Create: A:=table(a1=b1,a2=b2;a3=b3,...)
Where a1,a2,... are the indices of the list; b1,b2,... are the corresponding values
Call: A[a1]
2. Add element: A[index]:= value
3. View the contents of the list: eval()
4. If the variable has no value, Maple will create an empty list
5. View the index sequence: indices( ) (the default output form is a list)
6. View the value: entries( ) (the default output form is a list)
7. Both get indices (array name, pairs); (the default output format is a list)
8. Parameter nolist: unpacking list indices(table, nolist), entries(table, nolist)
t := table([age = 18, name = lily]); t[age]; t[name]; t[sex] := boy; eval(t); t := table([age = 18, name = lily]) 18 lily t[sex] := boy table([age = 18, sex = boy, name = lily]) eval(T); T T[3] := 5; T[3] := 5 eval(T); table([3 = 5]) indices(t);entries(t); indices(t, pairs); indices(t, nolist);entries(t, nolist); [age], [sex], [name] [18], [boy], [lily] age = 18, sex = boy, name = lily age, sex, name 18, boy, lily