# cast

Cast variable to different data type

## Syntax

``b = cast(a,'like',p)``

## Description

example

````b = cast(a,'like',p)` converts `a` to the same `numerictype`, complexity (real or complex), and `fimath` as `p`. If `a` and `p` are both real, then `b` is also real. Otherwise, `b` is complex.```

## Examples

collapse all

Define a scalar 8–bit integer.

`a = int8(5);`

Create a signed `fi` object with word length of `24` and fraction length of `12`.

`p = fi([],1,24,12);`

Convert `a` to fixed point with `numerictype`, complexity (real or complex), and `fimath` of the specified `fi` object, `p`.

`b = cast(a, 'like', p)`
```b = 5 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 24 FractionLength: 12 ```

Define a 2-by-3 matrix of ones.

`A = ones(2,3);`

Create a signed `fi` object with word length of `16` and fraction length of `8`.

`p = fi([],1,16,8);`

Convert `A` to the same data type and complexity (real or complex) as `p`.

`B = cast(A,'like',p)`
```B = 1 1 1 1 1 1 DataTypeMode: Fixed-point: binary point scaling Signedness: Signed WordLength: 16 FractionLength: 8 ```

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```

## Input Arguments

collapse all

Variable, specified as a `fi` object or numeric variable.

Complex Number Support: Yes

Prototype, specified as a `fi` object or numeric variable. To use the prototype to specify a complex object, you must specify a value for the prototype. Otherwise, you do not need to specify a value.

Complex Number Support: Yes

## Tips

Using the `b = cast(a,'like',p)` syntax to specify data types separately from algorithm code allows you to:

• Reuse your algorithm code with different data types.

• Keep your algorithm uncluttered with data type specifications and switch statements for different data types.