a9787677-0a6f-49e7-8f66-9a41c919cd37 230 4 5 false false 0 decimal

&[DATE] &[TIME] - &[FILENAME]

M 12345678933 mat :

Most functions for linalg package have been briefly explored here. there are a few that still need work to make them operate correctly.

T M transpose :

T 14725836933 mat

A couple of issues: don't know how to get a maple function call to remember a previous one. Not sure how to get maple function to read sets that use {} brackets.

j1 13531 mat :

j2 46831 mat :

expR 2 :

M T augment maple 12314745625878936936 mat

M adj maple 3 - 63 - 612 - 63 - 63 - 33 mat

ty [2,4,6] :

Maple thinks a string that holds a list is a list. Success...

ty parse list type maple true

This simple diag function with lambdas does not function according to Maple site... linalg[diag](λ.1,λ.2) parse maple λ.1 λ.2 linalg[diag]

diag(B1, B2, .., Bn) returns a matrix on whose diagonal are the matrix blocks B1, B2, .., Bn. linalg[diag](matrix(2,2,[1,2,3,4]),matrix(2,2,[1,2,3,4])) parse maple sparse 1..4 1..4 43 [3 = 224 = 331 = 342 = 111 = 444 = 122 = 21 3] = array

M eigenvalues maple 03533 sqrt + (* 2 / 3533 sqrt - (* 2 / 31 mat

M M equal maple true

M T equal maple false

M ffgausselim maple 12303 - 6 - 00033 mat

fibonacci(n) calling sequence returns the nth fibonacci matrix, F(n), defined as follows:F(0)=matrix(1,1,[1])F(1)=matrix(1,1,[1])F(2)=matrix(2,2,[1,1,1,0]) linalg[fibonacci](3) parse maple 11110111033 mat

linalg[fibonacci](2) parse maple 111022 mat

more about fibonacci at one of the forum discusssions by others.

linalg[fibonacci](1) parse maple 111 mat

linalg[fibonacci](0) parse maple 111 mat

M frobenius maple 0001018011533 mat

M gausselim maple (12303 - 6 - 00033 mat

M gaussjord maple 101 - 01200033 mat

M hadamard maple 209132 sqrt

M htranspose maple 14725836933 mat

P =

Two Matrices, A and B, are said to be similar if there exists an invertible Matrix C such that C⋅A=B⋅C. 33 [5 00012000 13] matrix 33 [5 340124 - 00 13] matrix issimilar maple true

11 - 1073 / - 4001 - 33 mat 5000120001333 mat * 512 - 13028 - 520013 - 33 mat

5340124 - 001333 mat 11 - 1073 / - 4001 - 33 mat * 512 - 13028 - 520013 - 33 mat

M iszero maple false

R 00000000033 mat :

R iszero maple true

M jordan maple 00003533 sqrt - (* 2 / 0003533 sqrt + (* 2 / 33 mat

kernel and nullspace are identical M kernel maple 1..3 11 mat

M LUdecomp maple 12303 - 6 - 00033 mat

M T matadd maple 26106101410141833 mat

M norm maple 24

orthog returns true if it can show that the matrix A is orthogonal, false if it can show that the matrix is not orthogonal, and FAIL otherwise.    A matrix is orthogonal if the inner product of any column of A with itself is 1, and the inner product of any column of A with any other column is 0. orthog(array([[-1/2,sqrt(3)/2],[sqrt(3)/2,1/2]])) parse maple true

M QRdecomp maple 66 sqrt 1366 sqrt * 11 / 1566 sqrt * 11 / 0311 sqrt / 611 sqrt / 00033 mat

M permanent maple 450

33 randmatrix maple 85 - 55 - 37 - 35 - 975079564933 mat

3 randvector maple 85 - 55 - 37 - 31 mat

M ratform maple 0001018011533 mat

M 1 row maple 12331 mat

M rowdim maple 3

M rowspace maple 1..3 1..3 21 mat

M rowspan maple 1..3 1..3 21 mat

M rref maple 101 - 01200033 mat

M 45 scalarmul maple 459013518022527031536040533 mat

M x smith maple 10001000033 mat

M trace maple 15

M eval maple 12345678933 mat

P [1,2,3,4,5] :

P parse maple Stack empty.

P parse list convert maple Stack empty.

P parse list convert 8 band maple #

band matrix can be assigned to a variable, but not printed in Smath Studio ban P parse list convert 8 band maple :

From Maple Tools log:

[3 4 5 0 0 0 0 0]
[2 3 4 5 0 0 0 0]
[1 2 3 4 5 0 0 0]
[0 1 2 3 4 5 0 0]
[0 0 1 2 3 4 5 0]
[0 0 0 1 2 3 4 5]
[0 0 0 0 1 2 3 4]
[0 0 0 0 0 1 2 3]

[INFO ] [<-] array(sparse,1..8,1..8,[(2,1)=2,(1,3)=5,(4,4)=3,(4,5)=4,(8,6)=1,(5,6)=4,(8,7)=2,(3,3)=3,(7,5)=1,(6,5)=2,(5,3)=1,(3,4)=4,(2,2)=3,(6,6)=3,(7,6)=2,(4,2)=1,(5,7)=5,(3,1)=1,(6,7)=4,(7,7)=3,(8,8)=3,(3,5)=5,(4,6)=5,(6,4)=1,(3,2)=2,(1,2)=4,(7,8)=4,(1,1)=3,(5,4)=2,(4,3)=2,(2,4)=5,(5,5)=3,(2,3)=4,(6,8)=5])

nothing happens when the user invokes Svd(X) (same for other calling sequences); the user must use evalf(Svd(X)) to actually compute the singular values and singular vectors. M Svd maple 12345678933 mat Svd

M Svd evalf maple 33696206720000000 / 213673903200000000 / 16 - .4909360835e + 31 mat

M nullspace maple 1..3 11 mat

([exp(x),cosh(x),sinh(x)],x) parse wronskian maple x exp x cosh x sinh x exp x sinh x cosh x exp x cosh x sinh 33 mat

[x\002C\y\002C\z] (vectdim maple 3

[1\002C\2\002C\3\002C\4] (vectdim maple 4

vector\0028\2\0029\ (vectdim maple 2

s linalg[stack][new](greg,tony,bruno,michael) parse maple :

Have not worked out how to save a previous call to maple result for next maple call... linalg[stack][depth](s) parse maple s linalg[stack][depth]

linalg[stack][top](s) parse maple s linalg[stack][top]

array(1..3,1..3,identity parse maple array00281002E002E3002C1002E002E3002Cidentity

array(1..3,1..3,diagonal parse maple array00281002E002E3002C1002E002E3002Cdiagonal

Returns a list of the singular values of the given matrix linalg[singularvals](array([[1,0,1],[1,0,1],[0,1,0]])) parse maple Stack empty.

[0,2,1]

computes the rank of a matrix, by performing Gaussian elimination on the rows of the given matrix. The rank of the matrix A is the number of non-zero rows in the resulting matrix. linalg[rank](matrix(3,3,[x,1,0,0,0,1,xy,y,1])) parse maple 3

normalize function normalizes the specified vector with the 2-norm. linalg[normalize](array([1,−I])) parse maple 12 sqrt / i 2 sqrt / - 21 mat

linalg[normalize](array([1,−2,2])) parse maple 13 / 23 / - 23 / 31 mat

ismith computes the Smith normal form S of an n by m rectangular matrix of integers. linalg[ismith](array([[9,−36,30],[−36,192,−180],[30,−180,180]])) parse maple 3000120006033 mat

ismith computes the Smith normal form S of an n by m rectangular matrix of integers. linalg[ismith](array([[13,5,7],[17,31,39]]),U,V) parse maple 10002023 mat

have not worked out how to transfer previous maple result to new maple call... U eval maple Stack empty.

V eval maple V

inverse computes the matrix inverse of A. An error occurs if the matrix is singular. linalg[inverse](array([[1,x],[2,3]])) parse maple 33 - 2 x * + / - x 3 - 2 x * + / 23 - 2 x * + / 13 - 2 x * + / - 22 mat

linalg[indexfunc](array(1..2,1..2,[[1,0],[0,1]])) parse maple Stack empty.

This works linalg[indexfunc](array(1..2,1..2,[[1,0],[0,1]],'symmetric')) parse maple symmetric

ihermite computes the Hermite Normal Form (reduced row echelon form) of a rectangular matrix of integers. linalg[ihermite](array( [[9,-36,30], [-36,192,-180], [30,-180,180]] )) parse maple 30300120006033 mat

To obtain column form of Hermite Normal Form linalg[transpose](linalg[ihermite](linalg[transpose](array( [[9,-36,30], [-36,192,-180], [30,-180,180]] )))) parse maple 30001203006033 mat

linalg[hilbert](3) parse maple symmetric 1..3 1..3 33 [15 / = 2314 / = 2213 / = 1313 / = 111 = 121 2] / = array

linalg[vandermonde]([1,2,3,4]) parse maple 111112481392714166444 mat

adjoint computes the matrix such that the matrix product of A and adjoint(A) is the product of det(A) and the matrix identity. This is done through the computation of minors of A. linalg[adjoint](matrix(3,3,[1,2,3,4,5,6,7,8,9])) parse maple 3 - 63 - 612 - 63 - 63 - 33 mat

linalg[adjoint](array(1..2,1..2,[[1,4],[0,2]])) parse maple 24 - 0122 mat

addcol(A, c1, c2, m) returns a copy of the matrix A in which column c2 is replaced by mcol(A,c1)+col(A,c2) addcol(array(1..3,1..3,[[1,2,3],[2,3,4],[3,4,5]]),1,2,−x) parse maple 12 x - 3232 x * - 4343 x * - 533 mat

addrow(A, r1, r2, m) returns a copy of the matrix A in which row r2 is replaced by mrow(A,r1)+row(A,r2). addrow(array( 1..3,1..3, [ [1,2,3], [2,3,4], [3,4,5] ] ),1,2,10) parse maple 12312233434533 mat

angle(vector([1,0]), vector([0,1])) parse maple π 2 /

angle(vector([1,0]), vector([1,0])) parse maple 0

angle(array([1,1]), array([0,1])) parse maple π 4 /

angle(vector([1,0,0]), vector([1,0,1])) parse maple π 4 /

exponential(array([[t,0,0],[0,t,0],[0,0,t]])) parse maple t exp 000 t exp 000 t exp 33 mat

exponential(array([[−13,−10],[21,16]]),t) parse maple 15 t exp * 142 t * exp * - 102 t * exp - t exp + (* 212 t * exp t exp - (* 14 t exp * - 152 t * exp * + 22 mat

eigenvalues(A, C) solves the ``generalized eigenvalue problem'', that is, finds the roots of the polynomial det(lambdaC−A). linalg[eigenvalues](matrix(3,3,[1.0,2.0,3.0,1.0,2.0,3.0,2.0,5.0,6.0])) parse maple 46609126950000000 / 15 - .7700622123e + 6436507612000000000 / - 31 mat

linalg[eigenvals](matrix(3,3,[1,2,3,1,2,3,2,5,6])) parse maple 0 9.3218 0.3218 - 31 mat

If a second parameter 'implicit' is given, the eigenvalues are expressed using Maple's RootOf notation for algebraic extensions. If the parameter 'radical' is given (the default), Maple tries to express the eigenvalues in terms of exact radicals. Note that if the characteristic polynomial has a factor of degree greater than four, then it may not be possible to express all the eigenvalues in terms of radicals. linalg[eigenvalues](matrix(3,3,[1,2,3,1,2,3,2,5,6]),'implicit') parse maple 0313_Z * + (* -_Z 2^+ RootOf 21 mat

extend(A, m, n, x) returns a new matrix which is a copy of the matrix A with m additional rows and n additional columns. The new entries are initialized to x. linalg[extend](matrix(2,2, [1,2,3,4]), 1, 1, 0) parse maple 12034000033 mat

extend(A, m, n, x) returns a new matrix which is a copy of the matrix A with m additional rows and n additional columns. The new entries are initialized to x. linalg[extend](matrix(2,2, [1,2,3,4]), 1, 1, x) parse maple 12 x 34 x x x x 33 mat

does not work yet. Need to do things with LU matrix function at same time.

linalg[forwardsub](1,vector([1,2,3])) parse maple ans

genmatrix generates the coefficient matrix from the linear system of equations eqns in the unknowns vars. If the optional third argument ``flag'' is present, the ``right-hand side'' vector will be included as the last column of the matrix. Otherwise an optional third argument will be assigned the ``right-hand side'' vector. linalg[genmatrix]\0028\x\002B\2\002A\y\003D\0\002C\3\002A\x\2212\5\002A\y\003D\0\007D\\002C\[x\002C\y]\0029\ (maple # :

geneqns(array([1,2],[3,-5]),[x,y]) parse maple ans

have not got genmatrix/eqns to work yet

multiply(A, B,...) calculates the matrix product A B ... .  The dimensions of each matrix must be consistent with the rules of matrix multiplication. linalg[multiply](array([[1,2],[3,4]]),array([[0,1],[1,0]]),array([[1,2],[4,5]])) parse maple 69162322 mat

multiply(A, v), for a matrix A and vector v, calculates the matrix-vector product A v. The number of entries in v must be equal to the number of columns of A. Thus if A is an n x m matrix, vectdim(v) must be m. The result is a vector with n entries. linalg[multiply](array([[1,2],[3,4]]),vector([3,4])) parse maple 112521 mat

multiply(v, v^T), for a vector and transposed vector v, calculates the vector-transpose vector product v v^T. linalg[multiply](vector([3,4]),linalg[transpose](vector([3,4]))) parse maple 912121622 mat

linalg[crossproduct](linalg[vector]([1,2,3]),linalg[vector]([2,3,4])) parse maple 12331 mat linalg[crossproduct]

[INFO ] [<-] linalg[crossproduct](mat(1,2,3,3,1))

linalg[crossproduct]\0028\[1\002C\2\002C\3]\002C\[2\002C\3\002C\4]\0029\ (maple [1 2 3] [2 3 4] linalg[crossproduct]

does not work yet. Think there is an Smath version anyway...

[INFO ] [<-] linalg[crossproduct]([1,2,3],[2,3,4])

Asked maple for help on crossproduct, assuming result would be of linalg package, got reply in terms of LinearAlgebra package!

[INFO ] [->] example(crossproduct)

Examples:
> with(LinearAlgebra):
> V1 := <1,2,3>;

[1]
[ ]
V1 := [2]
[ ]
[3]

> V2 := <2,3,4>;

[2]
[ ]
V2 := [3]
[ ]
[4]

> CrossProduct(V1, V2);

[-1]
[ ]
[ 2]
[ ]
[-1]

with(LinearAlgebra):V1 := <1,2,3>;V2 := <2,3,4>;CrossProduct(V1, V2) parse maple Stack empty.

matrix(3,4,[1,2,3,4,1,2,3,4,1,5,6,9]) parse maple 12341234156934 mat

linalg[coldim](matrix(3,4,[1,2,3,4,1,2,3,4,1,5,6,9])) parse maple 4

linalg[rowdim](matrix(3,4,[1,2,3,4,1,2,3,4,1,5,6,9])) parse maple 3

matrix(3,3,[1,2,3,1,2,3,1,5,6]) parse maple 12312315633 mat

22 matrix maple Stack empty.

[?[1, 1] ?[1, 2]]
[ ]
[?[2, 1] ?[2, 2]]

This behaves correctly

[INFO ] [<-] mat(,,,,2,2)

charmat constructs the characteristic matrix M=Iλ−A, where I is the identity matrix. If lambda is a name, then det(M) is the characteristic polynomial. linalg[charmat]\0028\matrix\0028\3\002C\3\002C\[1\002C\2\002C\3\002C\1\002C\2\002C\3\002C\1\002C\5\002C\6]\0029\\002C\λ\0029\ parse maple 1 - λ + 2 - 3 - 1 - 2 - λ + 3 - 1 - 5 - 6 - λ + 33 mat

linalg[mulrow](matrix(3,3,[1,2,3,1,2,3,1,5,6]),2,2) parse maple 12324615633 mat

linalg[mulcol](matrix(3,3,[1,2,3,1,2,3,1,5,6]),2,3) parse maple 163163115633 mat

(array( [[1,2,x],[3,4,y]] )) parse maple 12 x 34 y 23 mat

linalg[swaprow](array( [[1,2,x],[3,4,y]] ),1,2) parse maple 34 y 12 x 23 mat

linalg[swapcol](array( [[1,2,x],[3,4,y]] ),2,3) parse maple 1 x 23 y 423 mat

matrix\0028\3\002C\3\002C\\0020\[1\002C\2\002C\3\002C\2\002C\3\002C\4\002C\3\002C\4\002C\5]\0029\ maple 12323434533 mat

matadd(A, B) computes the matrix (vector) sum of A and B. {matadd(A, B, c1, c2)}.     If the optional scalar parameters c1 and c2 are given, then matadd computes the matrix (vector) sum c1A+c2B. linalg[matadd](matrix(3,3, [1,2,3,2,3,4,3,4,5]),array(1..3,1..3, identity),1,10) parse maple 11232134341533 mat

linalg[matadd](matrix(3,3, [1,2,3,2,3,4,3,4,5]),array(1..3,1..3, identity),10,1) parse maple 11203020314030405133 mat

hadamard computes a bound on the maxnorm of det(A) where A is an n by n matrix whose coefficients lie in the domain Z, Q, R, Z[x], Q[x], or R[x]. hadamard(matrix(3,3, [1,-1,0,0,2,-1,-2,0,1])) parse maple 50 sqrt

linalg[delrows](matrix(3,3, [1,2,3,4,5,6,7,8,9]),2..3) parse maple 12313 mat

linalg[delrows](matrix(3,3, [1,2,3,4,5,6,7,8,9]),1..1) parse maple 45678923 mat

linalg[delcols](matrix(3,3, [1,2,3,4,5,6,7,8,9]),2..3) parse maple 14731 mat

linalg[row](matrix(3,3, [1,2,3,4,5,6,7,8,9]),2) parse maple 45631 mat

linalg[col](matrix(3,3, [1,2,3,4,5,6,7,8,9]),3) parse maple 36931 mat

cond computes the ``standard'' matrix condition number, defined as norm(A) * norm(inverse(A)). The matrix norm is the default employed by the linalg[norm] function, namely the infinity norm (maximum row sum). linalg[cond](array(1..2,1..2, identity)) parse maple 1

linalg[cond](matrix(3,3, [1,0,3,-4,2,0,0,3,-2]),1) parse maple 3

linalg[cond](matrix(3,3, [1,0,3,-4,2,0,0,3,-2]),2) parse maple 34339703 i * 273252312 /^* + 3 nthroot 86 - 39703 i * 273252312 /^* + 3 nthroot + (* + i 32 nthroot * 343 - 39703 i * 27325232 nthroot * + 3 nthroot 2^+ (* + 639703 i * 273252312 /^* + 3 nthroot * / - abs 34339703 i * 27325232 nthroot * + 3 nthroot 2^+ 4339703 i * 273252312 /^* + 3 nthroot * + 339703 i * 273252312 /^* + 3 nthroot * / abs max sqrt 11401705851600 i * 27325232 nthroot * + 3 nthroot 2^+ 251705851600 i * 273252312 /^* + 3 nthroot * + 2400705851600 i * 273252312 /^* + 3 nthroot * / abs 48001152000011401705851600 i * 27325232 nthroot * + 3 nthroot 2^+ (* - 5783040000705851600 i * 273252312 /^* + 3 nthroot * + (* 55296000000 i * 32 nthroot * 11401 - 705851600 i * 27325232 nthroot * + 3 nthroot 2^+ (* - 265420800000000705851600 i * 273252312 /^* + 3 nthroot * / abs max sqrt *

linalg[cond](matrix(3,3, [1,0,3,-4,2,0,0,3,-2]),'frobenius') parse maple 43 sqrt 502 sqrt * 40 /

linalg[cond](matrix(3,3, [1,0,3,-4,2,0,0,3,-2]),'infinity') parse maple 3310 /

toeplitz(L) returns the symmetric toeplitz matrix corresponding to the list L. linalg[toeplitz]\0028\[a\002C\b\002C\c]\0029\ maple symmetric 1..3 1..3 12 [b = 11 a = 33 a = 22 a = 23 b = 13 c] = array

[a b c]
[ ]
[b a b]
[ ]
[c b a]

linalg[det](matrix(3,3,[1,2,3,1,2,4,1,5,6])) parse maple 3 -

linalg[det](matrix(2,2,[1,2,3,4])) parse maple 2 -

matrix(4,4,[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6]) parse maple 123456789012345644 mat

pivot pivots the matrix A about A[i, j] which must be non-zero.The function pivot(A, i, j) will add multiples of the ith row to every other row in the matrix, with the result that the (k, j)th entry of the matrix A is set to zero for all k not equal to i. That is, the jth column of the matrix will be all zeros, except for the (i, j)th element. linalg[pivot](matrix(4,4,[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6]),2,1) parse maple 045 / 85 / 125 / 56780545 / - 585 / - 625 / - 025 / 45 / 65 / 44 mat

linalg[stackmatrix](matrix(2,2,[1,2,3,4]),matrix(2,2,[5,6,7,8])) parse maple 1234567842 mat

linalg[stackmatrix](vector(2,[1,2]),matrix(2,2,[5,6,7,8]),vector(2,[1,2])) parse maple 1256781242 mat

This needs interactive input which we cannot do... linalg[entermatrix](array(1..3,1..3,symmetric)) parse maple empty

definite returns true if the matrix has the property specified by the parameter kind. The properties are positive definite, positive semidefinite, negative definite, or negative semidefinite. linalg[definite](matrix(2,2,[2,1,1,3]),'positive_def') parse maple true

definite returns true if the matrix has the property specified by the parameter kind. The properties are positive definite, positive semidefinite, negative definite, or negative semidefinite. linalg[definite](matrix(2,2,[2,1,1,3]),'negative_def') parse maple false

linalg[dotproduct](vector([1,x,y]),vector([1,0,0])) parse maple 1 x y 31 mat linalg[dotproduct]

linalg[dotproduct]([1, x, y], [1, 0, 0])

linalg[dotproduct]\0028\[1\002C\I]\002C\[I\002C\1]\0029\ (maple [1 i] [i 1] linalg[dotproduct]

does not work yet. Think Smath has this anyway.

minor returns the (r,c)th minor of the matrix A.  This is the matrix obtained by removing the rth row and the cth column of A. linalg[minor](matrix(3,3,[1,5,2,6,3,7,4,8,5]),2,2) parse maple 124522 mat

laplacian(f, v) computes the Laplacian of f with respect to v.•      The Laplacian is defined to be the sum of the second derivatives ∂2∂x2f for x in v.•      In the case of three dimensions, where f is a scalar expression of three variables and v is a list or a vector of three variables: linalg[laplacian](x^2*y*z,[x,y,z]) parse maple 2 y * z *

(linalg[laplacian](r*sin(theta)*z^2,[r, theta, z],coords=cylindrical)) parse maple 2 r * sinθ *

(linalg[laplacian](r^2*sin(theta)*cos(phi),[r, theta, phi],coords=spherical)) parse maple cosφ 5 sinθ 2^* cosθ 2^+ 1 - (* sinθ /

(linalg[laplacian](r^2*sin(theta)*cos(phi),[r, theta, phi],coords=toroidal)) parse maple cosθ - r cosh + (sinθ * cosφ * 2 r r sinh 2^- r cosh cosθ - r cosh + (* + (* r sinh cosθ - r cosh + (* + (* - r sinh r 2^* r cosh * + (r sinh * r 2^cosθ - r cosh + (* + (* r sinh 2^/ -

JordanBlock returns a matrix J of a special form: the Jordan block.  The matrix J will be such that Ji,i=t, Ji,i+1=1 for i=1..n−1 and Ji,j=0 otherwise. linalg[JordanBlock](3,5) parse maple 310000310000310000310000355 mat

linalg[JordanBlock](x,7) parse maple x 1000000 x 1000000 x 1000000 x 1000000 x 1000000 x 1000000 x 77 mat

hessian(expr, vars) computes the Hessian matrix of expr with respect to vars.•      The matrix result is n x n, where n is the length of vars. The (i, j)th entry of the matrix result is diff(expr, vars[i], vars[j]). linalg[hessian](x*y*z, [x,y,z]) parse maple 0 z y z 0 x y x 033 mat

linalg[hessian](x^2*y + 3*x*y^2, [x,y]) parse maple 2 y * 2 x 3 y * + (* 2 x 3 y * + (* 6 x * 22 mat

v1 := vector([1,0,1,0]);

v1 := [1, 0, 1, 0]

> v2 := vector([0,1,0,1]);

v2 := [0, 1, 0, 1]

> v3 := vector([1,2,1,1]);

v3 := [1, 2, 1, 1]

> v4 := vector([-1,-2,1,0]);

v4 := [-1, -2, 1, 0]

> intbasis({v1,v2},{v3,v4});

{}

> intbasis([v1,v2,v3],[v3,v4],[v2,v3]);

{[1, 2, 1, 1]}

> u := evalm(v1-v2);

u := [1, -1, 1, -1]

> v := evalm(v1+v2);

v := [1, 1, 1, 1]

> w := evalm(v1-v3);

w := [0, -2, 0, -1]

> intbasis({u,v,w},{v1,v2,v3});

{[-2, 0, -2, 0], [0, 2, 0, 1], [-1, 1, -1, 1]}

v1 := vector([1,0,1,0]);

v1 := [1, 0, 1, 0]

> v2 := vector([0,1,0,1]);

v2 := [0, 1, 0, 1]

> v3 := vector([1,2,1,1]);

v3 := [1, 2, 1, 1]

> v4 := vector([-1,-2,1,0]);

v4 := [-1, -2, 1, 0]

> sumbasis({v1,v2},{v3,v4});

{v1, v2, v3, v4}

> sumbasis({v1,v2,v3},{v3,v4},{v2,v3});

{v1, v2, v3, v4}

have not got inbasis

Does not work yet, assume when it works sumbasis can be made to work as well...

linalg[intbasis]({vector([1,0,1,0]),vector([0,1,0,1])},{vector([1,2,1,1]),vector([-1,-2,1,0])}) parse maple Stack empty.

[INFO ] [<-] mat(,0,1)

Does not work yet

sylvester(p, q, x) returns the Sylvester matrix of the polynomials p and q with respect to x.  Note that the determinant of this matrix is equal to resultant(p,q,x). linalg[sylvester]([a+b*x],[c+d*x+f*x*x],x) parse maple ans

linalg[sylvester]\0028\[a\002B\b\002A\x]\002C\[c\002B\d\002A\x\002B\f\002A\x\002A\x]\002C\x\0029\ (maple Stack empty.

p q x sylvester

2
linalg[sylvester]([a + b x], [c + d x + f x ], x)

At moment, dont know how to do this.

A := matrix(3,3,(i,j) -> abs(i-j));

[0 1 2]
[ ]
A := [1 0 1]
[ ]
[2 1 0]

> B := matrix(3,3,(i,j) -> abs(i-j)^2);

[0 1 4]
[ ]
B := [1 0 1]
[ ]
[4 1 0]

> Z := matrix(3,3,0);

[0 0 0]
[ ]
Z := [0 0 0]
[ ]
[0 0 0]

> blockmatrix(2,4,[A,B,Z,A,B,Z,A,B]);

[0 1 2 0 1 4 0 0 0 0 1 2]
[ ]
[1 0 1 1 0 1 0 0 0 1 0 1]
[ ]
[2 1 0 4 1 0 0 0 0 2 1 0]
[ ]
[0 1 4 0 0 0 0 1 2 0 1 4]
[ ]
[1 0 1 0 0 0 1 0 1 1 0 1]
[ ]
[4 1 0 0 0 0 2 1 0 4 1 0]

At moment, dont know how to do this.

linalg[hermite]\0028\matrix\0028\3\002C\3\002C\[[1\002C\x\002C\x\002A\x]\002C\[x\002A\x\002A\x\002B\2 x\2212\1\002C\0\002C\1]\002C\[1\002C\x\2212\1\002C\x\002A\x\002B\1]]\0029\\0029\ * (x maple linalg[hermite]\0028\matrix\0028\3\002C\3\002C\[[1\002C\x\002C\x\002A\x]\002C\[x\002A\x\002A\x\002B\2 x\2212\1\002C\0\002C\1]\002C\[1\002C\x\2212\1\002C\x\002A\x\002B\1]]\0029\\0029\ * x maple

linalg[swaprow](array( [[1,2,x],[3,4,y]] ),1,2) parse maple 34 y 12 x 23 mat

linalg[swapcol](array( [[1,2,x],[3,4,y]] ),2,3) parse maple 1 x 23 y 423 mat

charpoly computes the characteristic polynomial of the matrix A=det(Iλ−A), where I is the identity matrix and n is the dimension of A. linalg[charpoly](matrix(3,3,[1,2,3,1,2,3,1,5,6]),x) parse maple x 2^9 - x + (*

potential determines whether a given vector function is derivable from a scalar potential, and determines that potential if it exists.The function returns true if the function f has a scalar potential, and false if it does not. linalg[potential]([2*x*y + y^3, x^2 + 3*x*y^2],[x,y], 'F') parse maple true

routine cholesky computes the cholesky decomposition of the matrix A.•      The result is a lower triangular matrix R such that Rtranspose(R)=A.•      This decomposition assumes the matrix A is positive-definite. I.e. R exists with real elements on the diagonal.  cholesky will fail with an error when called on a demonstrably non-positive-definite matrix. linalg[cholesky](matrix(3,3,[1,2,3,2,5,7,3,7,26])) parse maple 10021031433 mat

submatrix(A, Rrange, Crange) returns the submatrix of A selected by the row range Rrange and the column range Crange. linalg[submatrix](array([[1,2,3],[4,x,6]]),1..2,2..3) parse maple 23 x 622 mat

submatrix(A, Rlist, Clist) returns the matrix whose (i,j)th element is A[Rlist[i], Clist[j]]. linalg[submatrix](array([[1,2,3],[4,x,6]]),[2,1],[2,1]) parse maple x 42122 mat

linalg[submatrix](array([[1,2,3],[4,x,6]]),[2,1],1..2) parse maple 4 x 1222 mat

jacobian(f, v) computes the Jacobian matrix of f with respect to v. The (i,j)th entry of the matrix result is ∂∂vjfi. linalg[jacobian]([x*x,x*y,x*z],[x,y,z]) parse maple 2 x * 00 y x 0 z 0 x 33 mat

minpoly(A, x) computes the minimum polynomial of the matrix A in x. The minimum polynomial is the polynomial of lowest degree which annihilates A. linalg[minpoly](array([[2,1,0,0],[0,2,0,0],[0,0,1,1],[0,0,−2,4]]),x) parse maple 43 - 4 x * + (* x 2^7 - x + (* +

innerprod calculates the inner product of a sequence of vectors and matrices. The dimension of each matrix and vector must be compatible for multiplication in the order given. (linalg[innerprod](vector(2, [1,2]),matrix(2,3, [1,1,1,2,2,2]),vector(3, [1,2,3]))) parse maple 30

(linalg[innerprod](vector(3, [1,2,3]),vector(3, [3,2,1]))) parse maple 10

vecpotent determines whether a given vector function has a vector potential, and determines that vector potential if it exists.The function returns true if the function f has a vector potential, and false if it does not.  The vector potential exists if and only if the divergence of f is zero.If a vector potential for f exists, it will be assigned to the name given in the third argument V.  If vecpotent returns true, then V will be assigned a vector function such that curl V = f. linalg[vecpotent]([x^2*y, -1/2*x*y^2, -x*y*z],[x,y,z], 'V') parse maple true

linalg[vecpotent]([x^2, y^2, z^2],[x,y,z], 'G') parse maple false

curl(f, v) computes the curl of f with respect to v, where f is a three-dimensional function of the three variables v.  When the third argument is not given, the curl of f is computed in the Cartesian coordinate system. linalg[curl]([x^2, x*z, y^2*z],[x, y, z]) parse maple x - 2 y * z * + 0 z 31 mat

If the optional third argument co is of the form coords = coords_name or coords = coords_name([const]), curl will operate on commonly used orthogonally curvilinear coordinate systems. linalg[curl]([r, sin(theta), z],[r, theta, z],coords=cylindrical) parse (maple 00 sinθ r / 31 mat

linalg[curl]([r, sin(theta), z],[r, theta, z],[1, r, 1]) parse (maple 00 sinθ r / 31 mat

linalg[curl]([r, sin(theta)*r, cos(phi)*r],[r, theta, z],coords=spherical) parse (maple cosθ cosφ * sinθ / 2 cosφ * - 2 sinθ * 31 mat

linalg[curl]([r, sin(theta)*r, cos(phi)*r],[r, theta, z],coords=toroidal) parse (maple cosφ r * sinθ * - cosφ r r cosh cosθ - r cosh + (* - r sinh 2^+ (* r sinh cosθ - r cosh + (* - (* r sinh / sinθ cosθ r r sinh * + r cosh - r - (* - 31 mat

linalg[concat](vector(2,[1,2]),matrix(2,3,[3,4,5,6,7,8]),vector(2,[1,2])) parse maple 134512678225 mat

linalg[augment](matrix([[1,2],[2,3]]),matrix(2,3,[3,4,5,6,7,8])) parse maple 123452367825 mat

Basis does not work yet.

linalg[basis]([vector([0,0,1]),vector([0,1,0]),vector([1,0,0])]) parse maple 0131] [mat

linalg[basis]({vector([0,1,1]),vector([1,0,1]),vector([1,1,1]),vector([1,−1,1]),vector([2,2,2]),vector([2,−2,2])}) parse maple ans

linalg[basis](array([[1,0,0],[0,1,0],[0,0,1],[1,1,1]]),'rowspace') parse maple 0031] [mat

linalg[diverge]([x, y^2, z],[x, y, z]) parse maple 21 y + (*

If the optional third argument co is of the form coords = coords_name or coords = coords_name([const]), curl will operate on commonly used orthogonally curvilinear coordinate systems. linalg[diverge]([r, sin(theta), z],[r, theta, z],coords=cylindrical) parse (maple cosθ 3 r * + r /

linalg[diverge]([r, sin(theta)*r, cos(phi)*r],[r, theta, phi],coords=spherical) parse (maple sinφ sinθ 32 cosθ * + (* - sinθ / -

There is no toroidal coords available with diverge function. linalg[diverge]([r, sin(theta)*r, cos(phi)*r],[r, theta, phi],coords=torodial) parse (maple ans

linalg[diverge]([r, sin(theta)*r, cos(phi)*r],[r, theta, phi],[1, r, r*sin(theta)]) parse (maple sinφ - sinθ 32 cosθ * + (* + sinθ /

does not work yet

linalg[GSchmidt]({vector([1,0,0]),vector([1,1,0]),vector([1,1,1])}) parse maple 10031 mat linalg[GSchmidt]

linalg[GSchmidt](vector([2,2,2]),vector([0,2,2]),vector([0,0,2])) parse maple 22231 mat linalg[GSchmidt]

linalg[GSchmidt](vector([2,2,2]),vector([0,2,2]),vector([0,0,2]),normalized) parse maple 22231 mat normalized linalg[GSchmidt]

grad computes the gradient of expr with respect to v.It computes the following vector of partial derivatives:vector( [diff(expr, v[1]), diff(expr, v[2]), ...] ).In the case of three dimensions, where expr is a scalar expression of three variables and v is a list or a vector of three variables: linalg[grad](3*x^2+2*y*z,[x, y, z]) parse maple 6 x * 2 z * 2 y * 31 mat

If the optional third argument co is of the form coords = coords_name or coords = coords_name({[const]}), grad will operate on commonly used orthogonally curvilinear coordinate systems. linalg[grad](r*sin(theta)*z^2,[r, theta, z],coords=cylindrical) parse (maple sinθ z 2^* cosθ z 2^* 2 r * sinθ * z * 31 mat

linalg[grad](r^2*sin(theta)*cos(phi),[r, theta, phi],coords=spherical) parse (maple 2 r * sinθ * cosφ * r cosθ * cosφ * r sinφ * - 31 mat

There is no toroidal coords available with grad function. linalg[grad](r^2*sin(theta)*cos(phi),[r, theta, phi],[1, r, r*sin(theta)]) parse (maple 2 r * sinθ * cosφ * r cosθ * cosφ * r sinφ * - 31 mat

linalg[grad](cosh(xi)*cos(eta)*cos(phi),[xi, eta, phi],coords=prolatespheroidal(1)) parse (maple sinhξ cosη * cosφ * sinhξ 2^sinη 2^+ sqrt / coshξ sinη * cosφ * sinhξ 2^sinη 2^+ sqrt / - coshξ cosη * sinφ * sinhξ sinη * / - 31 mat

Changed prolatespheroidal(1) to prolatespheroidal(2) to see what would happens. -> Denominator has halved. linalg[grad](cosh(xi)*cos(eta)*cos(phi),[xi, eta, phi],coords=prolatespheroidal(2)) parse (maple sinhξ cosη * cosφ * 2 sinhξ 2^sinη 2^+ sqrt * / coshξ sinη * cosφ * 2 sinhξ 2^sinη 2^+ sqrt * / - coshξ cosη * sinφ * 2 sinhξ * sinη * / - 31 mat

linalg[grad](cosh(xi)*cos(eta)*cos(phi),[xi, eta, phi],coords=oblatespheroidal(1)) parse (maple sinhξ cosη * cosφ * coshξ sinη - (coshξ sinη + (* sqrt / coshξ sinη * cosφ * coshξ sinη - (coshξ sinη + (* sqrt / - cosη sinφ * sinη / - 31 mat

Changed oblatespheroidal(1) to oblatespheroidal(2) to see what happens. ->Denominator has halved. linalg[grad](cosh(xi)*cos(eta)*cos(phi),[xi, eta, phi],coords=oblatespheroidal(2)) parse (maple sinhξ cosη * cosφ * 2 coshξ sinη - (coshξ sinη + (* sqrt * / coshξ sinη * cosφ * 2 coshξ sinη - (coshξ sinη + (* sqrt * / - cosη sinφ * 2 sinη * / - 31 mat

assume not all of these will work with Linalg

linsolve(A, b) finds the vector x which satisfies the matrix equation A\x\=\b. If A has n rows and m columns, then vectdim(b) must be n and vectdim(x) will be m, if a solution exists. linalg[linsolve](matrix( [[1,2],[1,3]] ),vector( [1,-2])) parse maple 73 - 21 mat

linsolve(A, B) finds the matrix X which solves the matrix equation AX=B where each column of X satisfies Acol(X,i)=col(B,i) . If AX=B has does not have a unique solution, then NULL is returned. linalg[linsolve](matrix( [[1,2],[1,3]] ),matrix( [[1,1],[-2,1]] )) parse maple 713 - 022 mat

optional third argument is a name which will be assigned the rank of A. But don't know how to access it. linalg[linsolve](matrix( [[5,7],[0,0]] ),vector( [3,0]),'r') parse maple 37_t 1 el * - 5 /_t 1 el 21 mat

fourth argument allows you to specify the seed for the global names used as parameters in a parametric solution.  If there is no fourth argument, the default, then the global names _t[1], _t[2], _t[3], ... will be used in the vector case, _t[1][1], _t[1][2], _t[2][1], ... in the matrix case (where _t[1][i] is used for the first column, _t[2][i] for the second, etc).  This is particularly useful when programming with linsolve.  If you declare v as a local variable and then call linsolve with fourth argument v, the resulting parameters (v[1], v[2], ...) will be local to the procedure. linalg[linsolve](matrix( [[5,7],[0,0]] ),vector( [3,0]),'r',v) parse maple 37 v 1 el * - 5 / v 1 el 21 mat

linalg[linsolve](matrix( [[5,7],[10,14]] ),matrix( [[3,0],[6,0]] )) parse maple 37_t 1 el 1 el * - 5 / 7_t 2 el 1 el * 5 / -_t 1 el 1 el_t 2 el 1 el 22 mat

linalg[gaussjord](array( [[4,-6,1,0],[-6,12,0,1],[-2,6,1,1]] ),'r') parse maple 10112 / 0112 / 13 / 000034 mat

To ask for help, type your query into placeholder where GSchmidt is. Look at log file to see if Maple decides to help you or not.

GSchmidt example maple Stack empty.