Write a MATLAB^{®} algorithm that you can
run with different data types without changing the algorithm itself.
To reuse the algorithm, define the data types separately from the
algorithm.

This approach allows you to define a baseline by running the
algorithm with floating-point data types. You can then test the algorithm
with different fixed-point data types and compare the fixed-point
behavior to the baseline without making any modifications to the original MATLAB code.

Write a MATLAB function, `my_filter`,
that takes an input parameter, `T`, which is a structure
that defines the data types of the coefficients and the input and
output data.

function [y,z] = my_filter(b,a,x,z,T)
% Cast the coefficients to the coefficient type
b = cast(b,'like',T.coeffs);
a = cast(a,'like',T.coeffs);
% Create the output using zeros with the data type
y = zeros(size(x),'like',T.data);
for i = 1:length(x)
y(i) = b(1)*x(i) + z(1);
z(1) = b(2)*x(i) + z(2) - a(2) * y(i);
z(2) = b(3)*x(i) - a(3) * y(i);
end
end

Write a MATLAB function, `zeros_ones_cast_example`,
that calls `my_filter` with a floating-point step
input and a fixed-point step input, and then compares the results.

function zeros_ones_cast_example
% Define coefficients for a filter with specification
% [b,a] = butter(2,0.25)
b = [0.097631072937818 0.195262145875635 0.097631072937818];
a = [1.000000000000000 -0.942809041582063 0.333333333333333];
% Define floating-point types
T_float.coeffs = double([]);
T_float.data = double([]);
% Create a step input using ones with the
% floating-point data type
t = 0:20;
x_float = ones(size(t),'like',T_float.data);
% Initialize the states using zeros with the
% floating-point data type
z_float = zeros(1,2,'like',T_float.data);
% Run the floating-point algorithm
y_float = my_filter(b,a,x_float,z_float,T_float);
% Define fixed-point types
T_fixed.coeffs = fi([],true,8,6);
T_fixed.data = fi([],true,8,6);
% Create a step input using ones with the
% fixed-point data type
x_fixed = ones(size(t),'like',T_fixed.data);
% Initialize the states using zeros with the
% fixed-point data type
z_fixed = zeros(1,2,'like',T_fixed.data);
% Run the fixed-point algorithm
y_fixed = my_filter(b,a,x_fixed,z_fixed,T_fixed);
% Compare the results
coder.extrinsic('clf','subplot','plot','legend')
clf
subplot(211)
plot(t,y_float,'co-',t,y_fixed,'kx-')
legend('Floating-point output','Fixed-point output')
title('Step response')
subplot(212)
plot(t,y_float - double(y_fixed),'rs-')
legend('Error')
figure(gcf)
end