Evaluate Matlab symbolic function

Evaluating Symbolic Functions in MATLAB

Learn how to effectively evaluate symbolic expressions and functions in MATLAB, covering common methods like subs, eval, and matlabFunction for numerical and symbolic substitutions.

MATLAB's Symbolic Math Toolbox is a powerful tool for performing symbolic computations, including differentiation, integration, and solving equations. A common task when working with symbolic expressions is evaluating them at specific numerical values or substituting other symbolic variables. This article will guide you through the various methods available in MATLAB for evaluating symbolic functions, highlighting their use cases and best practices.

Understanding Symbolic Variables and Expressions

Before evaluating, it's crucial to define your variables as symbolic. This tells MATLAB to treat them as mathematical symbols rather than numerical values. The syms command is used for this purpose. Once defined, you can create symbolic expressions and functions.

syms x y z;
f = x^2 + 2*y*z + 5;
g = sin(x) + cos(y);

disp(f);
disp(g);

Defining symbolic variables and expressions

Method 1: Using subs for Substitution

The subs function is the primary method for substituting values into symbolic expressions. It allows you to replace symbolic variables with either numerical values or other symbolic expressions. This is highly flexible and works well for single or multiple substitutions.

syms x y z;
f = x^2 + 2*y*z + 5;

% Substitute a single numerical value
result1 = subs(f, x, 3);
disp(['Result after subs(f, x, 3): ', char(result1)]);

% Substitute multiple numerical values
result2 = subs(f, [x, y, z], [1, 2, 4]);
disp(['Result after subs(f, [x, y, z], [1, 2, 4]): ', char(result2)]);

% Substitute with another symbolic expression
syms a;
result3 = subs(f, x, a+1);
disp(['Result after subs(f, x, a+1): ', char(result3)]);

Examples of using subs for various substitutions

Method 2: Converting to a MATLAB Function with matlabFunction

For repeated numerical evaluations, especially within loops or when performance is critical, converting your symbolic expression into an anonymous MATLAB function using matlabFunction is often the most efficient approach. This compiles the symbolic expression into a fast, callable function.

syms x y;
f_sym = x^2 + sin(y);

% Convert symbolic expression to a MATLAB function handle
f_handle = matlabFunction(f_sym);

% Evaluate the function handle
result_handle1 = f_handle(2, pi/2);
disp(['Result from matlabFunction(2, pi/2): ', num2str(result_handle1)]);

% Evaluate with arrays
x_vals = [1, 2, 3];
y_vals = [0, pi/4, pi/2];
result_handle2 = f_handle(x_vals, y_vals);
disp('Result from matlabFunction with arrays:');
disp(result_handle2);

Using matlabFunction for efficient numerical evaluation

flowchart TD
    A[Symbolic Expression] --> B{matlabFunction}
    B --> C[MATLAB Function Handle]
    C --> D[Numerical Evaluation (Fast)]
    A --> E{subs}
    E --> F[Symbolic or Numerical Result (Flexible)]

Comparison of subs and matlabFunction workflows

Method 3: Using eval (Use with Caution)

The eval function can execute a string as a MATLAB command. While it can be used to evaluate symbolic expressions, it is generally discouraged for this purpose due to potential security risks and performance overhead. It's better to use subs or matlabFunction for symbolic evaluation. However, in specific legacy contexts or for very simple, one-off evaluations where the expression is guaranteed safe, it might be encountered.

syms x;
f_sym = x^2 + 1;

% Convert symbolic expression to a string
f_str = char(f_sym);

% Define x numerically
x = 5;

% Evaluate the string
result_eval = eval(f_str);
disp(['Result from eval(char(f_sym)) with x=5: ', num2str(result_eval)]);

Example of using eval (not recommended for general use)

Choosing the right method depends on your specific needs. For single or infrequent substitutions, subs is versatile. For performance-critical numerical evaluations, matlabFunction is superior. Always prioritize these two methods over eval for safety and efficiency.