Scalar product of vectors
This functionality does not run in MATLAB.
linalg::scalarProduct(u
, v
, <Real
>)
linalg::scalarProduct(u, v)
computes the
scalar product of the vectors
and
with
respect to the standard basis, i.e., the sum
.
The scalar product is also called "inner product" or "dot product".
If the component ring of the vectors u
and v
does
not define the entry "conjugate"
or if the option Real
is
specified, then linalg::scalarProduct
uses the
definition u_{1} v_{1} +
… + u_{n} v_{n} of
the scalar product.
The vectors u
and v
must
be defined over the same component ring.
linalg::scalarProduct
can be redefined to
a different scalar product. This also affects the behaviour of functions
such as linalg::angle
, linalg::factorQR
, linalg::isUnitary
, norm
(for vectors and
matrices), linalg::orthog
and linalg::pseudoInverse
depend
on the definition of linalg::scalarProduct
. See Example 3.
Properties of identifiers are taken into account.
We compute the scalar product of the vectors (i, 1) and (1,  i):
MatC := Dom::Matrix(Dom::Complex): u := MatC([I, 1]): v := MatC([1, I]): linalg::scalarProduct(u, v)
We compute the scalar product of the vectors and with the symbolic entries u_{1}, u_{2}, v_{1}, v_{2} over the standard component ring for matrices:
delete u1, u2, v1, v2: u := matrix([u1, u2]): v := matrix([v1, v2]): linalg::scalarProduct(u, v)
You can use assume
to
tell the system that the symbolic components are to represent real
numbers:
assume([u1, u2, v1, v2], Type::Real):
Then the scalar product of and simplifies to:
linalg::scalarProduct(u, v)
Alternatively, the option Real
can be specified:
unassume(u1, u2, v1, v2): linalg::scalarProduct(u, v, Real)
One particular scalar product in the real vector space of continuous functions on the interval [0, 1] is defined by
.
To compute an orthogonal basis corresponding to the polynomial basis 1, t, t^{2}, t^{3}, … with respect to this scalar product, we replace the standard scalar product by the following procedure:
standardScalarProduct := linalg::scalarProduct: unprotect(linalg): linalg::scalarProduct := proc(u, v) local F, f, t; begin // (0) f := expr(u[1] * v[1]); // (1) t := indets(f); if t = {} then t := genident("t") else t := op(t, 1) end_if; // (2) F := int(f, t = 0..1); // (3) u::dom::coeffRing::coerce(F) end:
We start with step (0)
to convert f(t) g(t) to
an expression of a basic domain type, such that the system function int
in step (2)
can
handle its input (this is not necessary if the elements of the component
ring of the vectors are already represented by elements of basic domains).
Step (1)
extracts the indeterminate of the
polynomials, step (2)
computes the scalar product
as defined above and step (3)
converts the result
back to an element of the component ring of vectors u
and v
.
Note that we need to unprotect the write protected identifier linalg
,
otherwise the assignment would lead to an error message.
We next create the matrix which consists of the first five of the above polynomials:
P := matrix([[1, t, t^2, t^3, t^4]])
If we now perform the GramSchmidt orthogonalization procedure
on the columns of P
with the function linalg::orthog
,
we get:
S := linalg::orthog(linalg::col(P, 1..4))
Each vector in S
is orthogonal to the other
vectors in S
with respect to the modified scalar
product. We check this for the first vector:
linalg::scalarProduct(S[1], S[j]) $ j = 2..nops(S)
Finally, we undo the redefinition of the scalar product, so as not to run into trouble with subsequent computations:
linalg::scalarProduct := standardScalarProduct: protect(linalg, Error):

Vectors of the same dimension (a vector is an n×1 or 1
×n matrix of
a domain of category 

Use u_{1} v_{1} +
… + u_{n} v_{n} as
the definition of the scalar product, i.e., suppress the use of 
Element of the component ring of u
and v
.