> with(LinearAlgebra); with(linalg):
Warning, the assigned name GramSchmidt now has a global binding


  [Add, Adjoint, BackwardSubstitute, BandMatrix, Basis, BezoutMatrix,

        BidiagonalForm, BilinearForm, CharacteristicMatrix,

        CharacteristicPolynomial, Column, ColumnDimension,

        ColumnOperation, ColumnSpace, CompanionMatrix,

        ConditionNumber, ConstantMatrix, ConstantVector,

        CreatePermutation, CrossProduct, DeleteColumn, DeleteRow,

        Determinant, DiagonalMatrix, Dimension, Dimensions,

        DotProduct, Eigenvalues, Eigenvectors, Equal,

        ForwardSubstitute, FrobeniusForm, GenerateEquations,

        GenerateMatrix, GetResultDataType, GetResultShape,

        GivensRotationMatrix, GramSchmidt, HankelMatrix, HermiteForm,

        HermitianTranspose, HessenbergForm, HilbertMatrix,

        HouseholderMatrix, IdentityMatrix, IntersectionBasis,

        IsDefinite, IsOrthogonal, IsSimilar, IsUnitary,

        JordanBlockMatrix, JordanForm, LA_Main, LUDecomposition,

        LeastSquares, LinearSolve, Map, Map2, MatrixAdd,

        MatrixInverse, MatrixMatrixMultiply, MatrixNorm,

        MatrixScalarMultiply, MatrixVectorMultiply, MinimalPolynomial,

        Minor, Multiply, NoUserValue, Norm, Normalize, NullSpace,

        OuterProductMatrix, Permanent, Pivot, QRDecomposition,

        RandomMatrix, RandomVector, Rank, Row, RowDimension,

        RowOperation, RowSpace, ScalarMatrix, ScalarMultiply,

        ScalarVector, SchurForm, SingularValues, SmithForm, SubMatrix,

        SubVector, SumBasis, SylvesterMatrix, ToeplitzMatrix, Trace,

        Transpose, TridiagonalForm, UnitVector, VandermondeMatrix,

        VectorAdd, VectorAngle, VectorMatrixMultiply, VectorNorm,

        VectorScalarMultiply, ZeroMatrix, ZeroVector, Zip]

Warning, the previous binding of the name GramSchmidt has been removed
and it now has an assigned value

> A := Matrix(2,3,[[1,2,3],[4,5,6]]);

                               [1    2    3]
                          A := [           ]
                               [4    5    6]

> Transpose(
> A);
> 

                               [1    4]
                               [      ]
                               [2    5]
                               [      ]
                               [3    6]

> B := Matrix(3,1,[[a],[b],[c]]);

                                    [a]
                                    [ ]
                               B := [b]
                                    [ ]
                                    [c]

> transpose(evalm(A &* B));

                  [a + 2 b + 3 c    4 a + 5 b + 6 c]

> evalm(Transpose(B) &* Transpose(A));

                  [a + 2 b + 3 c    4 a + 5 b + 6 c]

> I3 := IdentityMatrix(3);

                               [1    0    0]
                               [           ]
                         I3 := [0    1    0]
                               [           ]
                               [0    0    1]

> evalm( A &* I3);

                            [1    2    3]
                            [           ]
                            [4    5    6]

> evalm( I3 &* B);

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

> Diag := DiagonalMatrix([alpha,beta,gamma]);

                           [alpha     0        0  ]
                           [                      ]
                   Diag := [  0      beta      0  ]
                           [                      ]
                           [  0       0      gamma]

> evalm(A &* Diag);

                    [ alpha     2 beta    3 gamma]
                    [                            ]
                    [4 alpha    5 beta    6 gamma]

> evalm(Diag &* B);

                              [alpha a]
                              [       ]
                              [beta b ]
                              [       ]
                              [gamma c]

> rnd:=rand(1..10);

  rnd := proc()
local t;
global _seed;
    _seed := irem(427419669081*_seed, 999999999989);
    t := _seed;
    irem(t, 10) + 1
end proc

> C := Matrix(4,4);

                            [0    0    0    0]
                            [                ]
                            [0    0    0    0]
                       C := [                ]
                            [0    0    0    0]
                            [                ]
                            [0    0    0    0]

> for i from 1 to 4 do for j from 1 to 4 do C[i,j]:=rnd(); od;od;
> print(C);

                         [7     9    6     9]
                         [                  ]
                         [2    10    6     4]
                         [                  ]
                         [8     1    5     6]
                         [                  ]
                         [7     2    8    10]

> Cinv := MatrixInverse(C);

                        [         -1      26      -17]
                        [2/101    ---     ---     ---]
                        [         101     101     101]
                        [                            ]
                        [          47     -5      -55]
                        [9/101    ----    ---     ---]
                        [         1212    606     606]
                Cinv := [                            ]
                        [ -29     275     61      65 ]
                        [ ---     ----    ---     ---]
                        [ 101     1212    606     606]
                        [                            ]
                        [ 20      -221    -157    91 ]
                        [ ---     ----    ----    ---]
                        [ 101     1212    606     606]

> evalm(C &* Cinv);

                          [1    0    0    0]
                          [                ]
                          [0    1    0    0]
                          [                ]
                          [0    0    1    0]
                          [                ]
                          [0    0    0    1]

> evalm(Cinv &* C);

                          [1    0    0    0]
                          [                ]
                          [0    1    0    0]
                          [                ]
                          [0    0    1    0]
                          [                ]
                          [0    0    0    1]

> Fibo:= <<0,1>|<1,1>>;

                                   [0    1]
                           Fibo := [      ]
                                   [1    1]

> MatrixInverse(Fibo);

                              [-1    1]
                              [       ]
                              [ 1    0]

> Matts := <<1,1>|<1,1>>;

                                   [1    1]
                          Matts := [      ]
                                   [1    1]

> MatrixInverse(Matts);
Error, (in MatrixInverse) singular matrix

>