### 27.3 Products of Polynomials

— Function File: conv (a, b)
— Function File: conv (a, b, shape)

> Convolve two vectors.

> `c = conv (`a`,` b`)` returns a vector of length equal to `length (`a`) + length (`b`) - 1`. If a and b are the coefficient vectors of two polynomials, the returned value is the coefficient vector of the product polynomial.

> The optional shape argument may be

> shape = "full"
>   Return the full convolution. (default)
> shape = "same"
>   Return the central part of the convolution with the same size as a.

> See also: deconv, fftconv, conv2, poly.

— Loadable Function: C = convn (A, B, shape)

> Return the n-D convolution of A and B where the size of C is given by

> shape = "full"
>   Return the full convolution.
> shape = "same"
>   Return central part of the convolution with the same size as A.
> shape = "valid"
>   Return only the parts which do not include zero-padded edges.

> By default shape is ‘`"full"`’.

> See also: conv2, conv.

— Function File: deconv (y, a)

> Deconvolve two vectors.

> `[b, r] = deconv (y, a)` solves for b and r such that `y = conv (a, b) + r`.

> If y and a are polynomial coefficient vectors, b will contain the coefficients of the polynomial quotient and r will be a remainder polynomial of lowest order.

> See also: conv, poly, roots, residue, polyval, polyderiv, polyint.

— Loadable Function: conv2 (A, B)
— Loadable Function: conv2 (v1, v2, m)
— Loadable Function: conv2 (..., shape)

> Return the 2-D convolution of A and B. The size of the result is determined by the optional shape argument which takes the following values

> shape = "full"
>   Return the full convolution. (default)
> shape = "same"
>   Return the central part of the convolution with the same size as A.
> shape = "valid"
>   Return only the parts which do not include zero-padded edges.

> When the third argument is a matrix, return the convolution of the matrix m by the vector v1 in the column direction and by the vector v2 in the row direction

> See also: conv, convn.

— Function File: q = polygcd (b, a)
— Function File: q = polygcd (b, a, tol)

> Find the greatest common divisor of two polynomials. This is equivalent to the polynomial found by multiplying together all the common roots. Together with deconv, you can reduce a ratio of two polynomials. Tolerance defaults to `sqrt(eps)`.

> Note that this is a numerically unstable algorithm, and should not be used on large polynomials.

> Example:

>               polygcd (poly(1:8), poly(3:12)) - poly(3:8)
>               ⇒ [ 0, 0, 0, 0, 0, 0, 0 ]
>               deconv (poly(1:8), polygcd (poly(1:8), poly(3:12))) ...
>                 - poly(1:2)
>               ⇒ [ 0, 0, 0 ]

> See also: poly, polyint, polyderiv, polyreduce, roots, conv, deconv, residue, filter, polyval, polyvalm.

— Function File: [r, p, k, e] = residue (b, a)
— Function File: [b, a] = residue (r, p, k)
— Function File: [b, a] = residue (r, p, k, e)

> The first calling form computes the partial fraction expansion for the quotient of the polynomials, b and a.

>                B(s)    M       r(m)         N
>                ---- = SUM -------------  + SUM k(i)*s^(N-i)
>                A(s)   m=1 (s-p(m))^e(m)    i=1

> where M is the number of poles (the length of the r, p, and e), the k vector is a polynomial of order N-1 representing the direct contribution, and the e vector specifies the multiplicity of the m-th residue's pole.

> For example,

>               b = [1, 1, 1];
>               a = [1, -5, 8, -4];
>               [r, p, k, e] = residue (b, a);
>                    ⇒ r = [-2; 7; 3]
>                    ⇒ p = [2; 2; 1]
>                    ⇒ k = [](0x0)
>                    ⇒ e = [1; 2; 1]

> which represents the following partial fraction expansion

>                       s^2 + s + 1       -2        7        3
>                  ------------------- = ----- + ------- + -----
>                  s^3 - 5s^2 + 8s - 4   (s-2)   (s-2)^2   (s-1)

> The second calling form performs the inverse operation and computes the reconstituted quotient of polynomials, b(s)/a(s), from the partial fraction expansion; represented by the residues, poles, and a direct polynomial specified by r, p and k, and the pole multiplicity e.

> If the multiplicity, e, is not explicitly specified the multiplicity is determined by the function `mpoles`.

> For example:

>               r = [-2; 7; 3];
>               p = [2; 2; 1];
>               k = [1, 0];
>               [b, a] = residue (r, p, k);
>                    ⇒ b = [1, -5, 9, -3, 1]
>                    ⇒ a = [1, -5, 8, -4]

>               where mpoles is used to determine e = [1; 2; 1]

> Alternatively the multiplicity may be defined explicitly, for example,

>               r = [7; 3; -2];
>               p = [2; 1; 2];
>               k = [1, 0];
>               e = [2; 1; 1];
>               [b, a] = residue (r, p, k, e);
>                    ⇒ b = [1, -5, 9, -3, 1]
>                    ⇒ a = [1, -5, 8, -4]

> which represents the following partial fraction expansion

>                   -2        7        3         s^4 - 5s^3 + 9s^2 - 3s + 1
>                  ----- + ------- + ----- + s = --------------------------
>                  (s-2)   (s-2)^2   (s-1)          s^3 - 5s^2 + 8s - 4

> See also: poly, roots, conv, deconv, mpoles, polyval, polyderiv, polyint.