Declaring Local Complex Variables Implicitly :: Using the Embedded MATLAB Function Block (Using Simulink)

Using Simulink

Declaring Local Complex Variables Implicitly

Using complex variables in Embedded MATLAB functions differs, in part, from the way in which complex variables are used in MATLAB. In MATLAB, the identity of a variable as complex is an attribute of the variable. In Embedded MATLAB functions, the identity of a variable as complex is part of its assigned type. Use the following rules to specify and use complex variables in Embedded MATLAB functions:

You can declare a complex number in an Embedded MATLAB function through assignment to a complex constant, as shown in the following examples:

x = 5 + 6i; %x is a complex number by assignment.
y = 7 + 8j; %y is a complex number by assignment.

Note You can use the symbol i or j in specifying an imaginary constant.

You can also declare a complex number with the function complex, as shown in the following example:
- ```
x = complex(5,6); %x is the complex number 5 + 6i.
```

Cases in which a function can return a complex number for a real argument are handled individually for each function.

Generally, this can result in a complex result or a warning that the function takes only arguments producing real results. For example, for negative arguments, the function sqrt warns that only positive arguments are allowed.

Complex numbers obey the general Embedded MATLAB rule that once a variable is typed and sized, it cannot be cast to another type or size.

In the following example, the variable x is declared complex and stays complex:

x = 1 + 2i; %x is declared a complex variable
y = int16(x); %real and imaginary parts of y are int16
x = 3; %x now has the value 3 + 0i

Conflicts can occur from operations with real operands that can have complex results. For example, the following code is flagged as an error:

z = 3; %sets type of z to double (real)
z = 3 + 2i; %ERROR - cannot recast z to complex.

The following is a possible workaround that you can use if you know that a variable can be assigned a complex number:

m = complex(3); %sets m to complex variable of value 3 + 0i
m = 5 + 6.7i; %assigns a complex result to a complex number

In general, if an expression has a complex number or variable in it, its result is a complex number, even if the result is 0.

For example, the following code produces the complex result z:
- ```
x = 2 + 3i;
y = 2 - 3i;
z = x + y; %z is 4 + 0i
```
In MATLAB, this code generates the real result z = 0. However, in Embedded MATLAB, when code for z = x + y is generated, the types for x and y are known, but their values are not. Because either or both operands in this expression are complex, z is declared a complex variable requiring storage for both a real and an imaginary part. This means that z has the complex result 4 + 0i in Embedded MATLAB, not 4 as in MATLAB.

An exception to the preceding rule is a function call that takes complex arguments but produces real results, as shown in the following examples:
- ```
y = real(x); %y is the real part of the complex number x.
y = imag(x); %y is the real-valued imaginary part of x.
y = isreal(x); %y is false (0) for a complex number x.
```
Another exception is a function call that takes real arguments but produces complex results, as shown in the following example:
- ```
z = complex(x,y); %z is a complex number for a real x and y.
```

Declaring Local Variables Implicitly Functions in Embedded MATLAB Functions