> with(linalg):
Warning, new definition for norm
Warning, new definition for trace
> A := matrix(2,3,[a,b,c,d,e,f]);

                               [a    b    c]
                          A := [           ]
                               [d    e    f]

> B := matrix(3,2,[1,2,3,4,5,6]);

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

> equal(A,B);

                                false

> ?equal
> A = B;

                                A = B

> evalm(A = B);

                                       [1    2]
                       [a    b    c]   [      ]
                       [           ] = [3    4]
                       [d    e    f]   [      ]
                                       [5    6]

> A + B;

                                A + B

> a := 2;

                                a := 2

> b := 3;

                                b := 3

> a+b;

                                  5

> evalm(A + B);
Error, (in linalg[matadd]) matrix dimensions incompatible
> Matlab[dimensions](A);

                                [2, 3]

> ?dimensions
> C := matrix(2,3,[u,v,w,x,y,z]);

                               [u    v    w]
                          C := [           ]
                               [x    y    z]

> evalm(A+C);

                      [a + u    b + v    c + w]
                      [                       ]
                      [d + x    e + y    f + z]

> 2*C;

                                 2 C

> C2:=evalm(2*C);

                            [2 u    2 v    2 w]
                      C2 := [                 ]
                            [2 x    2 y    2 z]

> C3:=evalm(C+C);

                            [2 u    2 v    2 w]
                      C3 := [                 ]
                            [2 x    2 y    2 z]

> equal(C2,C3);

                                 true

> evalm(A);

                            [a    b    c]
                            [           ]
                            [d    e    f]

> evalm(C);

                            [u    v    w]
                            [           ]
                            [x    y    z]

> LS := evalm(alpha * (A + C));

             [alpha (a + u)    alpha (b + v)    alpha (c + w)]
       LS := [                                               ]
             [alpha (d + x)    alpha (e + y)    alpha (f + z)]

> RS := evalm(alpha*A + alpha*C);

  RS :=

        [alpha a + alpha u , alpha b + alpha v , alpha c + alpha w]

        [alpha d + alpha x , alpha e + alpha y , alpha f + alpha z]

> equal(LS,RS);

                                false

> equal(map(expand,LS), map(expand,RS));

                                 true

> evalm(A);

                            [a    b    c]
                            [           ]
                            [d    e    f]

> evalm(B);

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

> a := 'a'; b:='b';

                                a := a


                                b := b

> evalm(A * B);
Error, (in evalm/evaluate) use the &* operator for matrix/vector
multiplication
> evalm(A &* B);

                  [a + 3 b + 5 c    2 a + 4 b + 6 c]
                  [                                ]
                  [d + 3 e + 5 f    2 d + 4 e + 6 f]

>