Check If Expression Contains Particular Subexpression

Use the has function to check if an expression contains a particular variable or subexpression.

Check if these expressions contain variable z.

syms x y z
has(x + y + z, z)

ans =
  logical
   1

has(x + y, z)

ans =
  logical
   0

Check if x + y + z contains the following subexpressions. Note that has finds the subexpression x + z even though the terms x and z do not appear next to each other in the expression.

has(x + y + z, x + y)
has(x + y + z, y + z)
has(x + y + z, x + z)

ans =
  logical
   1
ans =
  logical
   1
ans =
  logical
   1

Check if the expression (x + 1)^2 contains x^2. Although (x + 1)^2 is mathematically equivalent to the expression x^2 + 2*x + 1, the result is a logical 0 because has typically does not transform expressions to different forms when testing for subexpressions.

has((x + 1)^2, x^2)

ans =
  logical
   0

Expand the expression and then call has to check if the result contains x^2. Because expand((x + 1)^2) transforms the original expression to x^2 + 2*x + 1, the has function finds the subexpression x^2 and returns logical 1.

has(expand((x + 1)^2), x^2)

ans =
  logical
   1

Check If Expression Contains Any of Specified Subexpressions

Check if a symbolic expression contains any of subexpressions specified as elements of a vector.

If an expression contains one or more of the specified subexpressions, has returns logical 1.

syms x
has(sin(x) + cos(x) + x^2, [tan(x), cot(x), sin(x), exp(x)])

ans =
  logical
   1

If an expression does not contain any of the specified subexpressions, has returns logical 0.

syms x
has(sin(x) + cos(x) + x^2, [tan(x), cot(x), exp(x)])

ans =
  logical
   0

Find Matrix Elements Containing Particular Subexpression

Using has, find those elements of a symbolic matrix that contain a particular subexpression.

First, create a matrix.

syms x y
M = [sin(x)*sin(y), cos(x*y) + 1; cos(x)*tan(x), 2*sin(x)^2]

M =
[ sin(x)*sin(y), cos(x*y) + 1]
[ cos(x)*tan(x),   2*sin(x)^2]

Use has to check which elements of M contain sin(x). The result is a matrix of the same size as M, with 1s and 0s as its elements. For the elements of M containing the specified expression, has returns logical 1s. For the elements that do not contain that subexpression, has returns logical 0s.

T = has(M, sin(x))

T =
  2×2 logical array
     1     0
     0     1

Return only the elements that contain sin(x) and replace all other elements with 0 by multiplying M by T elementwise.

M.*T

ans =
[ sin(x)*sin(y),          0]
[             0, 2*sin(x)^2]

To check if any of matrix elements contain a particular subexpression, use any.

any(has(M(:), sin(x)))

ans =
  logical
   1

any(has(M(:), cos(y)))

ans =
  logical
   0

Find Vector Elements Containing Any of Specified Subexpressions

Using has, find those elements of a symbolic vector that contain any of the specified subexpressions.

syms x y z
T = has([x + 1, cos(y) + 1, y + z, 2*x*cos(y)], [x, cos(y)])

T =
  1×4 logical array
     1     1     0     1

Return only the elements of the original vector that contain x or cos(y) or both, and replace all other elements with 0 by multiplying the original vector by T elementwise.

[x + 1, cos(y) + 1, y + z, 2*x*cos(y)].*T

ans =
[ x + 1, cos(y) + 1, 0, 2*x*cos(y)]

Use has for Symbolic Functions

If expr or subexpr is a symbolic function, has uses formula(expr) or formula(subexpr). This approach lets the has function check if an expression defining the symbolic function expr contains an expression defining the symbolic function subexpr.

Create a symbolic function.

syms x
f(x) = sin(x) + cos(x);

Here, sin(x) + cos(x) is an expression defining the symbolic function f.

formula(f)

ans =
cos(x) + sin(x)

Check if f and f(x) contain sin(x). In both cases has checks if the expression sin(x) + cos(x) contains sin(x).

has(f, sin(x))
has(f(x), sin(x))

ans =
  logical
   1
ans =
  logical
   1

Check if f(x^2) contains f. For these arguments, has returns logical 0 (false) because it does not check if the expression f(x^2) contains the letter f. This call is equivalent to has(f(x^2), formula(f)), which, in turn, resolves to has(cos(x^2) + sin(x^2), cos(x) + sin(x)).

has(f(x^2), f)

ans =
  logical
   0

Check for Calls to Particular Function

Check for calls to a particular function by specifying the function name as the second argument. Check for calls to any one of multiple functions by specifying the multiple functions as a cell array of character vectors.

Integrate tan(x^7). Determine if the integration is successful by checking the result for calls to int. Because has finds the int function and returns logical 1 (true), the integration is not successful.

syms x
f = int(tan(x^7), x);
has(f, 'int')

ans =
  logical
   1

Check if the solution to a differential equation contains calls to either sin or cos by specifying the second argument as {'sin','cos'}. The has function returns logical 0 (false), which means the solution does not contain calls to either sin or cos.

syms y(x) a
sol = dsolve(diff(y,x) == a*y);
has(sol, {'sin' 'cos'})

ans =
  logical
   0