This is machine translation

Translated by Microsoft
Mouseover text to see original. Click the button below to return to the English verison of the page.

Note: This page has been translated by MathWorks. Please click here
To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.


Scalar product of vectors

MuPAD® notebooks are not recommended. Use MATLAB® live scripts instead.

MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.


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 u1v1 + … + unvn 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.

Environment Interactions

Properties of identifiers are taken into account.


Example 1

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)

Example 2

We compute the scalar product of the vectors and with the symbolic entries u1, u2, v1, v2 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)

Example 3

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, t2, t3, … with respect to this scalar product, we replace the standard scalar product by the following procedure:

standardScalarProduct := linalg::scalarProduct:
linalg::scalarProduct := proc(u, v) 
    local F, f, t;
    // (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)

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 Gram-Schmidt 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):


u, v

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



Use u1v1 + … + unvn as the definition of the scalar product, i.e., suppress the use of conjugate.

Return Values

Element of the component ring of u and v.

Was this topic helpful?