jptr/ece210
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

uploaded all materials

Browse Source
This commit is contained in:
james ryan
2025-03-24 00:43:09 -04:00
commit f2fb36f646
78 changed files with 15606 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

810
lessons/lesson08/octave-log.txt Normal file
View File

@ -0,0 +1,810 @@
octave:5> pkg load symbolic
octave:6> syms x z
Symbolic pkg v3.0.1: Python communication link active, SymPy v1.11.1.
octave:7> syms
Symbolic variables in current scope:
x
z
octave:8> x
x = (sym) x
octave:9> syms x_0
octave:10> xu-0
error: 'xu' undefined near line 1, column 1
octave:11> x_0
x_0 = (sym) x₀
octave:12> v = x + 2
v = (sym) x + 2
octave:13> w = x * z
w = (sym) x⋅z
octave:14> help subs
error: help: 'subs' not found
octave:15> help @sym/subs
'@sym/subs' is a function from the file /usr/share/octave/packages/symbolic-3.0.1/@sym
/subs.m
-- Method on @sym: subs (F, X, Y)
-- Method on @sym: subs (F, Y)
-- Method on @sym: subs (F)
Replace symbols in an expression with other expressions.
Example substituting a value for a variable:
syms x y
f = x*y;
subs(f, x, 2)
⇒ ans = (sym) 2⋅y
If X is omitted, ‘symvar’ is called on F to determine an
appropriate variable.
X and Y can also be vectors or lists of syms to replace:
subs(f, {x y}, {sin(x) 16})
⇒ ans = (sym) 16⋅sin(x)
F = [x x*y; 2*x*y y];
subs(F, {x y}, [2 sym(pi)])
⇒ ans = (sym 2×2 matrix)
⎡ 2 2⋅π⎤
⎢ ⎥
⎣4⋅π π ⎦
With only one argument, ‘subs(F)’ will attempt to find values for
each symbol in F by searching the workspace:
f = x*y
⇒ f = (sym) x⋅y
x = 42;
f
⇒ f = (sym) x⋅y
Here assigning a numerical value to the variable ‘x’ did not change
the expression (because symbols are not the same as variables!)
However, we can automatically update ‘f’ by calling:
subs(f)
⇒ ans = (sym) 42⋅y
*Warning*: ‘subs’ cannot be easily used to substitute a ‘double’
matrix; it will cast Y to a ‘sym’. Instead, create a “function
handle” from the symbolic expression, which can be efficiently
evaluated numerically. For example:
syms x
f = exp(sin(x))
⇒ f = (sym)
sin(x)
ℯ
fh = function_handle(f)
⇒ fh =
@(x) exp (sin (x))
fh(linspace(0, 2*pi, 700)')
⇒ ans =
1.0000
1.0090
1.0181
1.0273
1.0366
...
*Note*: Mixing scalars and matrices may lead to trouble. We
support the case of substituting one or more symbolic matrices in
for symbolic scalars, within a scalar expression:
f = sin(x);
g = subs(f, x, [1 sym('a'); pi sym('b')])
⇒ g = (sym 2×2 matrix)
⎡sin(1) sin(a)⎤
⎢ ⎥
⎣ 0 sin(b)⎦
When using multiple variables and matrix substitions, it may be
helpful to use cell arrays:
subs(y*sin(x), {x, y}, {3, [2 sym('a')]})
⇒ ans = (sym) [2⋅sin(3) a⋅sin(3)] (1×2 matrix)
subs(y*sin(x), {x, y}, {[2 3], [2 sym('a')]})
⇒ ans = (sym) [2⋅sin(2) a⋅sin(3)] (1×2 matrix)
*Caution*, multiple interdependent substitutions can be ambiguous
and results may depend on the order in which you specify them. A
cautionary example:
syms y(x) A B
u = y + diff(y, x)
⇒ u(x) = (symfun)
d
y(x) + ──(y(x))
dx
subs(u, {y, diff(y, x)}, {A, B})
⇒ ans = (sym) A
subs(u, {diff(y, x), y}, {B, A})
⇒ ans = (sym) A + B
Here it would be clearer to explicitly avoid the ambiguity by
calling ‘subs’ twice:
subs(subs(u, diff(y, x), B), y, A)
⇒ ans = (sym) A + B
See also: @sym/symfun.
Additional help for built-in functions and operators is
available in the online version of the manual. Use the command
'doc <topic>' to search the manual index.
Help and information about Octave is also available on the WWW
at https://www.octave.org and via the help@octave.org
mailing list.
octave:16> syms r
octave:17> w
w = (sym) x⋅z
octave:18> subs(w, z, r)
ans = (sym) r⋅x
octave:19> solve(x + 3 == 5, x)
ans = (sym) 2
octave:20>
octave:20> syms a b c
octave:21> solve(a*x^2 + b*x + c, x)
ans = (sym 2×1 matrix)
⎡ _____________⎤
⎢ ╱ 2 ⎥
⎢ b ╲╱ -4⋅a⋅c + b ⎥
⎢- ─── - ────────────────⎥
⎢ 2⋅a 2⋅a ⎥
⎢ ⎥
⎢ _____________⎥
⎢ ╱ 2 ⎥
⎢ b ╲╱ -4⋅a⋅c + b ⎥
⎢- ─── + ────────────────⎥
⎣ 2⋅a 2⋅a ⎦
octave:22> help @sym/solve
'@sym/solve' is a function from the file /usr/share/octave/packages/symbolic-3.0.1/@sy
m/solve.m
-- Method on @sym: SOL = solve (EQN)
-- Method on @sym: SOL = solve (EQN, VAR)
-- Method on @sym: SOL = solve (EQN1, ..., EQNN)
-- Method on @sym: SOL = solve (EQN1, ..., EQNN, VAR1, ..., VARM)
-- Method on @sym: SOL = solve (EQNS, VARS)
-- Method on @sym: [S1, ..., SN] = solve (EQNS, VARS)
Symbolic solutions of equations, inequalities and systems.
Examples
syms x
solve(x == 2*x + 6, x)
⇒ ans = (sym) -6
solve(x^2 + 6 == 5*x, x);
sort(ans)
⇒ ans = (sym 2×1 matrix)
⎡2⎤
⎢ ⎥
⎣3⎦
Sometimes its helpful to assume an unknown is real:
syms x real
solve(abs(x) == 1, x);
sort(ans)
⇒ ans = (sym 2×1 matrix)
⎡-1⎤
⎢ ⎥
⎣1 ⎦
In general, the output will be a list of dictionaries. Each entry
of the list is one a solution, and the variables that make up that
solutions are keys of the dictionary (fieldnames of the struct).
syms x y
d = solve(x^2 == 4, x + y == 1);
% the first solution
d{1}.x
⇒ (sym) -2
d{1}.y
⇒ (sym) 3
% the second solution
d{2}.x
⇒ (sym) 2
d{2}.y
⇒ (sym) -1
But there are various special cases for the output (single versus
multiple variables, single versus multiple solutions, etc). FIXME:
provide a ’raw_output’ argument or something to always give the
general output.
Alternatively:
[X, Y] = solve(x^2 == 4, x + y == 1, x, y)
⇒ X = (sym 2×1 matrix)
⎡-2⎤
⎢ ⎥
⎣2 ⎦
⇒ Y = (sym 2×1 matrix)
⎡3 ⎤
⎢ ⎥
⎣-1⎦
You can solve inequalities and systems involving mixed inequalities
and equations. For example:
solve(x^2 == 4, x > 0)
⇒ ans = (sym) x = 2
syms x
solve(x^2 - 1 > 0, x < 10)
⇒ ans = (sym) (-∞ < x ∧ x < -1) ∨ (1 < x ∧ x < 10)
See also: @sym/eq, @sym/dsolve.
Additional help for built-in functions and operators is
available in the online version of the manual. Use the command
'doc <topic>' to search the manual index.
Help and information about Octave is also available on the WWW
at https://www.octave.org and via the help@octave.org
mailing list.
octave:23> eqs = [x + z == 14; x - z == 6]
<stdin>:7: SymPyDeprecationWarning:
non-Expr objects in a Matrix is deprecated. Matrix represents
a mathematical matrix. To represent a container of non-numeric
entities, Use a list of lists, TableForm, NumPy array, or some
other data structure instead.
See https://docs.sympy.org/latest/explanation/active-deprecations.html#deprecated-non-
expr-in-matrix
for details.
This has been deprecated since SymPy version 1.9. It
will be removed in a future version of SymPy.
eqs = (sym 2×1 matrix)
⎡x + z = 14⎤
⎢ ⎥
⎣x - z = 6 ⎦
octave:24> soln = solve(eqs, [x z])
soln =
scalar structure containing the fields:
x =
<class sym>
z =
<class sym>
octave:25> soln.x
ans = (sym) 10
octave:26> soln.z
ans = (sym) 4
octave:27> help subs
error: help: 'subs' not found
octave:28> help @sym/subs
'@sym/subs' is a function from the file /usr/share/octave/packages/symbolic-3.0.1/@sym
/subs.m
-- Method on @sym: subs (F, X, Y)
-- Method on @sym: subs (F, Y)
-- Method on @sym: subs (F)
Replace symbols in an expression with other expressions.
Example substituting a value for a variable:
syms x y
f = x*y;
subs(f, x, 2)
⇒ ans = (sym) 2⋅y
If X is omitted, ‘symvar’ is called on F to determine an
appropriate variable.
X and Y can also be vectors or lists of syms to replace:
subs(f, {x y}, {sin(x) 16})
⇒ ans = (sym) 16⋅sin(x)
F = [x x*y; 2*x*y y];
subs(F, {x y}, [2 sym(pi)])
⇒ ans = (sym 2×2 matrix)
⎡ 2 2⋅π⎤
⎢ ⎥
⎣4⋅π π ⎦
With only one argument, ‘subs(F)’ will attempt to find values for
each symbol in F by searching the workspace:
f = x*y
⇒ f = (sym) x⋅y
x = 42;
f
⇒ f = (sym) x⋅y
Here assigning a numerical value to the variable ‘x’ did not change
the expression (because symbols are not the same as variables!)
However, we can automatically update ‘f’ by calling:
subs(f)
⇒ ans = (sym) 42⋅y
*Warning*: ‘subs’ cannot be easily used to substitute a ‘double’
matrix; it will cast Y to a ‘sym’. Instead, create a “function
handle” from the symbolic expression, which can be efficiently
evaluated numerically. For example:
syms x
f = exp(sin(x))
⇒ f = (sym)
sin(x)
ℯ
fh = function_handle(f)
⇒ fh =
@(x) exp (sin (x))
fh(linspace(0, 2*pi, 700)')
⇒ ans =
1.0000
1.0090
1.0181
1.0273
1.0366
...
*Note*: Mixing scalars and matrices may lead to trouble. We
support the case of substituting one or more symbolic matrices in
for symbolic scalars, within a scalar expression:
f = sin(x);
g = subs(f, x, [1 sym('a'); pi sym('b')])
⇒ g = (sym 2×2 matrix)
⎡sin(1) sin(a)⎤
⎢ ⎥
⎣ 0 sin(b)⎦
When using multiple variables and matrix substitions, it may be
helpful to use cell arrays:
subs(y*sin(x), {x, y}, {3, [2 sym('a')]})
⇒ ans = (sym) [2⋅sin(3) a⋅sin(3)] (1×2 matrix)
subs(y*sin(x), {x, y}, {[2 3], [2 sym('a')]})
⇒ ans = (sym) [2⋅sin(2) a⋅sin(3)] (1×2 matrix)
*Caution*, multiple interdependent substitutions can be ambiguous
and results may depend on the order in which you specify them. A
cautionary example:
syms y(x) A B
u = y + diff(y, x)
⇒ u(x) = (symfun)
d
y(x) + ──(y(x))
dx
subs(u, {y, diff(y, x)}, {A, B})
⇒ ans = (sym) A
subs(u, {diff(y, x), y}, {B, A})
⇒ ans = (sym) A + B
Here it would be clearer to explicitly avoid the ambiguity by
calling ‘subs’ twice:
subs(subs(u, diff(y, x), B), y, A)
⇒ ans = (sym) A + B
See also: @sym/symfun.
Additional help for built-in functions and operators is
available in the online version of the manual. Use the command
'doc <topic>' to search the manual index.
Help and information about Octave is also available on the WWW
at https://www.octave.org and via the help@octave.org
mailing list.
octave:29> eqn(1)
error: 'eqn' undefined near line 1, column 1
octave:30> eqs(1)
ans = (sym) x + z = 14
octave:31> subs(eqs(1), {x, z}, {soln.x, soln.z})
ans = (sym) True
octave:32> syms n
octave:33> solve(n^2 == 4, n)
ans = (sym 2×1 matrix)
⎡-2⎤
⎢ ⎥
⎣2 ⎦
octave:34> assume n positive
octave:35> assumptions
ans =
{
[1,1] = n: positive
}
octave:36> solve(n^2 == 4, n)
ans = (sym) 2
octave:37> assume n
error: assume: general algebraic assumptions are not supported
error: called from
assert at line 109 column 11
assume at line 65 column 3
octave:38> syms n
octave:39> assumptions
ans = {}(0x0)
octave:40> help @sym/assume
'@sym/assume' is a function from the file /usr/share/octave/packages/symbolic-3.0.1/@s
ym/assume.m
-- Method on @sym: X = assume (X, COND, COND2, ...)
-- Method on @sym: X = assume (X, 'clear')
-- Method on @sym: [X, Y] = assume ([X Y], ...)
-- Method on @sym: assume (X, COND, COND2, ...)
-- Method on @sym: assume (X, 'clear')
-- Method on @sym: assume ([X Y], ...)
New assumptions on a symbolic variable (replace old if any).
This function has two different behaviours depending on whether it
has an output argument or not. The first form is simpler; it
returns a new sym with assumptions given by COND, for example:
syms x
x1 = x;
x = assume(x, 'positive');
assumptions(x)
⇒ ans =
{
[1,1] = x: positive
}
assumptions(x1) % empty, x1 still has the original x
⇒ ans = {}(0x0)
Another example to help clarify:
x1 = sym('x', 'positive')
⇒ x1 = (sym) x
x2 = assume(x1, 'negative')
⇒ x2 = (sym) x
assumptions(x1)
⇒ ans =
{
[1,1] = x: positive
}
assumptions(x2)
⇒ ans =
{
[1,1] = x: negative
}
The second form—with no output argument—is different; it attempts
to find *all* instances of symbols with the same name as X and
replace them with the new version (with COND assumptions). For
example:
syms x
x1 = x;
f = sin(x);
assume(x, 'positive');
assumptions(x)
⇒ ans =
{
[1,1] = x: positive
}
assumptions(x1)
⇒ ans =
{
[1,1] = x: positive
}
assumptions(f)
⇒ ans =
{
[1,1] = x: positive
}
To clear assumptions on a variable use ‘assume(x, 'clear')’, for
example:
syms x positive
f = sin (x);
assume (x, 'clear')
isempty (assumptions (f))
⇒ ans = 1
*Warning*: the second form operates on the caller’s workspace via
evalin/assignin. So if you call this from other functions, it will
operate in your function’s workspace (and not the ‘base’
workspace). This behaviour is for compatibility with other
symbolic toolboxes.
FIXME: idea of rewriting all sym vars is a bit of a hack, not well
tested (for example, with global vars.)
See also: @sym/assumeAlso, assume, assumptions, sym, syms.
Additional help for built-in functions and operators is
available in the online version of the manual. Use the command
'doc <topic>' to search the manual index.
Help and information about Octave is also available on the WWW
at https://www.octave.org and via the help@octave.org
mailing list.
octave:41> assume n positive
octave:42> assumptions
ans =
{
[1,1] = n: positive
}
octave:43> assume n clear
octave:44> assumptions
ans = {}(0x0)
octave:45> exp(log(x))
ans = (sym) x
octave:46> e^(log(x))
ans = (sym) x
octave:47> x + 3
ans = (sym) x + 3
octave:48> (x + 3)*(1/x + 3)
ans = (sym)
⎛ 1⎞
⎜3 + ─⎟⋅(x + 3)
⎝ x⎠
octave:49> (x + 3)*(1/(x + 3))
ans = (sym) 1
octave:50> help @sym/simplify
'@sym/simplify' is a function from the file /usr/share/octave/packages/symbolic-3.0.1/
@sym/simplify.m
-- Method on @sym: simplify (X)
Simplify an expression.
Example:
syms x
p = x^2 + x + 1
⇒ p = (sym)
2
x + x + 1
q = horner (p)
⇒ q = (sym) x⋅(x + 1) + 1
d = p - q
⇒ d = (sym)
2
x - x⋅(x + 1) + x
isAlways(p == q)
⇒ 1
simplify(p - q)
⇒ (sym) 0
Please note that ‘simplify’ is not a well-defined mathematical
operation: its precise behaviour can change between software
versions (and certainly between different software packages!)
See also: @sym/isAlways, @sym/factor, @sym/expand, @sym/rewrite.
Additional help for built-in functions and operators is
available in the online version of the manual. Use the command
'doc <topic>' to search the manual index.
Help and information about Octave is also available on the WWW
at https://www.octave.org and via the help@octave.org
mailing list.
octave:51> (x + 3)^2 + (x + 3) + (x + 3)^2
ans = (sym)
2
x + 2⋅(x + 3) + 3
octave:52> simplify((x + 3)^2 + (x + 3) + (x + 3)^2)
ans = (sym)
2
x + 2⋅(x + 3) + 3
octave:53> expand((x + 3)^2 + (x + 3) + (x + 3)^2)
ans = (sym)
2
2⋅x + 13⋅x + 21
octave:54> collect((x + 3)^2 + (x + 3) + (x + 3)^2)
error: 'collect' undefined near line 1, column 1
octave:55> combine
error: 'combine' undefined near line 1, column 1
octave:56> factor
error: Invalid call to factor. Correct usage is:
-- PF = factor (Q)
-- [PF, N] = factor (Q)
Additional help for built-in functions and operators is
available in the online version of the manual. Use the command
'doc <topic>' to search the manual index.
Help and information about Octave is also available on the WWW
at https://www.octave.org and via the help@octave.org
mailing list.
octave:57> expand((x + 3)^2 + (x + 3) + (x + 3)^2)
ans = (sym)
2
2⋅x + 13⋅x + 21
octave:58> factor(ans)
ans = (sym) (x + 3)⋅(2⋅x + 7)
octave:59> partfrac
error: 'partfrac' undefined near line 1, column 1
octave:60> help @sym/partfrac
'@sym/partfrac' is a function from the file /usr/share/octave/packages/symbolic-3.0.1/
@sym/partfrac.m
-- Method on @sym: partfrac (F)
-- Method on @sym: partfrac (F, X)
Compute partial fraction decomposition of a rational function.
Examples:
syms x
f = 2/(x + 4)/(x + 1)
⇒ f = (sym)
2
───────────────
(x + 1)⋅(x + 4)
partfrac(f)
⇒ ans = (sym)
2 2
- ───────── + ─────────
3⋅(x + 4) 3⋅(x + 1)
Other examples:
syms x y
partfrac(y/(x + y)/(x + 1), x)
⇒ ans = (sym)
y y
- ─────────────── + ───────────────
(x + y)⋅(y - 1) (x + 1)⋅(y - 1)
partfrac(y/(x + y)/(x + 1), y)
⇒ ans = (sym)
x 1
- ─────────────── + ─────
(x + 1)⋅(x + y) x + 1
See also: @sym/factor.
Additional help for built-in functions and operators is
available in the online version of the manual. Use the command
'doc <topic>' to search the manual index.
Help and information about Octave is also available on the WWW
at https://www.octave.org and via the help@octave.org
mailing list.
octave:61>
octave:61>
octave:61>
octave:61>
octave:61>
octave:61> partfrac((x^7+x^2)/(x^3 - 3*x + 2))
ans = (sym)
4 2 124 25 2
x + 3⋅x - 2⋅x + 9 - ───────── + ───────── + ──────────
9⋅(x + 2) 9⋅(x - 1) 2
3⋅(x - 1)
octave:62> (x^7+x^2)/(x^3 - 3*x + 2)
ans = (sym)
7 2
x + x
────────────
3
x - 3⋅x + 2
octave:63> p = [1 2 3 4]
p =
1 2 3 4
octave:64> poly2sim(p, x)
error: 'poly2sim' undefined near line 1, column 1
octave:65> syms f(y)
octave:66> syms
Symbolic variables in current scope:
a
ans
b
c
eqs
f (symfun)
n
r
v
w
x
x_0
y
z
octave:67> f
f(y) = (symfun) f(y)
octave:68> f(y) = y^2
f(y) = (symfun)
2
y
octave:69> f
f(y) = (symfun)
2
y
octave:70> finverse
error: 'finverse' undefined near line 1, column 1
The 'finverse' function belongs to the symbolic package from Octave
Forge but has not yet been implemented.
Please read <https://www.octave.org/missing.html> to learn how you can
contribute missing functionality.
octave:71> syms t
octave:72> int(1/t, 1, x)
ans = (sym) log(x)
octave:73> int(1/t, .5, x)
warning: passing floating-point values to sym is dangerous, see "help sym"
warning: called from
double_to_sym_heuristic at line 50 column 7
sym at line 379 column 13
int at line 138 column 7
ans = (sym) log(x) + log(2)
octave:74> x^2
ans = (sym)
2
x
octave:75> x^2 + 5
ans = (sym)
2
x + 5
octave:76> diff(x^2 + 5)
ans = (sym) 2⋅x
octave:77> diff(x^2 + z^3 + 5)
ans = (sym) 2⋅x
octave:78> diff(x^2 + z^3 + 5, z)
ans = (sym)
2
3⋅z
octave:79> syms y(t) a
octave:80> diff(y) == a*y
ans = (sym)
d
──(y(t)) = a⋅y(t)
dt
octave:81> dsolve(diff(y) == a*y, t)
error: Python exception: AttributeError: 'Symbol' object has no attribute 'lhs'
occurred at line 7 of the Python code block:
ics = {ics.lhs: ics.rhs}
error: called from
pycall_sympy__ at line 179 column 7
dsolve at line 198 column 8
octave:82> dirac(x)
ans = (sym) δ(x)
octave:83> laplace(dirac(x))
ans = (sym) 1
octave:84> laplace(dirac(x - 1))
ans = (sym)
-s
ℯ
octave:85> (1:5)(2)
ans = 2
octave:86>

BIN
lessons/lesson08/octave-workspace Normal file
View File

Binary file not shown.

183
lessons/lesson08/symbolic_toolbox.m Normal file
View File

@ -0,0 +1,183 @@
%% Symbolic Toolbox
% MATLAB is typically associated with computing *numerical* solutions
% (i.e., estimating solutions using floating point calculations), we
% may often want to compute *analytic* solutions (exact solutions,
% often represented by formulas).
%
% Wolfram Mathematica is a premier example of technical software with
% support for symbolic computation, but we can achieve many useful
% symbolic calculations in MATLAB using the *symbolic toolbox*.
%
% The symbolic toolbox is useful if you want to represent an abstract
% expression. You can think of a symbolic calculation as storing the
% structure of expressions to operate on rather than the values
% themselves.
clear; clc; close all;
%% Create symbolic variables
syms x z;
%% Creating expressions
v = x + 2;
w = x * z;
%% Substituting expressions into a symbolic expression
subs(v, x, 3);
% You can also substitute symbolic expressions, not only values.
syms r;
subs(w, z, r);
%% Solve a symbolic equation for a variable
% You may want to look at the documentation page for the `solve` function.
% If the expression cannot be solved analytically, MATLAB will default
% to using a numerical solver.
solve(x + 3 == 5, x);
syms a b c;
solve(a*x^2 + b*x + c, x);
% Solving multiple variables simultaneously
eqs = [x + z == 14, x - z == 6];
soln = solve(eqs, [x z]);
soln.x;
soln.z;
%% Set "assumptions" (constraints) on a variable
% This is the shorthand syntax for setting assumptions on symbolic objects.
% See also the `assume` function.
syms n positive;
solve(n^2 == 4, n);
%% Simplify an expression
% This attempts to simplify an expression using known
% mathematical identities.
simplify(exp(log(x)));
% See also `simplifyFraction` for more efficient simplification
% of fractions only.
%% Collect
% This collects coefficients of like terms together.
collect((x + 2) * (x + 3), x);
%% Combine
% Tries to rewrite products of powers in the expression as a single power
combine(x^4 * x^3);
% Has other options such as 'log' and 'sincos'
assume(x > 0);
combine(log(x) + log(2*x), 'log');
combine(sin(x)*cos(x), 'sincos');
%% Expand
% Similar to `collect`, but expands all variables. More or less the
% inverse of `combine`.
expand((x + 5)^3);
%% Partial fraction decomposition
partfrac((x^7+x^2)/(x^3 - 3*x + 2));
%% poly2sym and sym2poly
p = [1 2 3 4];
psym = poly2sym(p, x);
q = sym2poly(psym);
%% Symbolic functions
% Symbolic functions are like symbolic expressions but with a formal
% parameter rather than all free parameters. This may be useful for
% substituting for a symbolic variable or for differential equations.
syms f(y);
f(y) = y^2;
f(4);
%% Compose symbolic functions
syms g(y)
g(y) = sin(y);
h = compose(f, g);
%% Symbolic function inverse
f(y) = exp(y);
finverse(f)
%% Symbolic differentiation
% Note that this `diff` is different from the `diff` from before.
% This one is actually `sym.diff`.
syms x y z;
v = x^2 + 16*x + 5;
dvdx = diff(v);
dvdx_3 = subs(dvdx, x,3);
%% Partial differentiation
% This function assumes derivatives commute (i.e., second partials exist
% and are continuous).
w = -x^3 + x^2 + 3*y + 25*sin(x*y);
dwdx = diff(w, x);
dwdy = diff(w, y);
% third order derivative w.r.t. x
dw3dx3 = diff(w, x, 3);
% Vector operations exist as well such as: curl, divergence, gradient,
% laplacian, jacobian, hessian...
%% Differential equations
syms y(t) a;
dsolve(diff(y) == a*y, t);
dsolve(diff(y) == a*y, y(0) == 5); % with initial conditions
%% Symbolic integration
v = x^2 + 16*x + 5;
V = int(v);
%% Definite integral
syms a b;
Vab = int(v, a, b);
V01 = int(v, 0, 1);
%% z transform
syms a n z;
f = a^n;
ztrans(f);
%% Symbolic matrices
syms m;
n = 4;
A = m.^((0:n)'*(0:n));
D = diff(A);
%% Laplace Transform
syms t a s;
f = exp(-a*t);
laplace(f);
%% Inverse Laplace Transform
ilaplace(-4*s+8/(s^2+6*s+8));
%% Fourier Transform
f = dirac(x) + sin(x);
fourier(f);
%% Inverse Fourier Transform
syms w;
% fourier transform of cosine(t)
expr = dirac(w+1) + dirac(w-1);
ift = ifourier(expr);
simplify(ift);
%% Note: performance
syms x v;
v = x^3 + 5*x^2 - 3*x + 9;
t = 1:1e4;
tic;
X = t.^3 + 5*t.^2 - 3*t + 9;
toc;
tic;
Y = subs(v,x,t);
toc;
% Symbolic computation and data structures are relatively expensive
% when compared to numerical operations! Use sparingly!