typecast

Convert an integer to an unsigned integer of the same storage size.

X = int16(-1)

X = int16

-1

Y = typecast(X,"uint16")

Y = uint16

65535

Show the bit patterns in hexadecimal representation. Converting the data type by using typecast does not change the underlying data.

format hex
X

X = int16
   ffff

Y = typecast(X,"uint16")

Y = uint16
   ffff

Create a 1-by-4 vector of 8-bit integers.

X = int8([77 60 43 26])

X = 1x4 int8 row vector

   77   60   43   26

Convert the four 8-bit integers, which use 4 bytes (32 bits) of storage, to a single-precision number that also uses 4 bytes of storage.

Y = typecast(X,"single")

Y = single

3.5411e-23

Show the bit patterns in hexadecimal representation. In hexadecimal notation, 1 byte (8 bits) is represented by two digits. The typecast function rearranges the bit patterns without modifying the data.

format hex
X

X = 1x4 int8 row vector

   4d   3c   2b   1a

Y = typecast(X,"single")

Y = single
   1a2b3c4d

Create a 1-by-3 vector of 32-bit unsigned integers.

X = uint32([1 255 256])

X = 1x3 uint32 row vector

     1   255   256

Cast X into 8-bit unsigned integers using typecast. Each 32-bit value is divided into four 8-bit segments. Running this code on a little-endian system produces the following results.

Y = typecast(X,"uint8")

Y = 1x12 uint8 row vector

     1     0     0     0   255     0     0     0     0     1     0     0

The third element of X, 256, exceeds the maximum value that 8 bits can hold. The converted value in Y(9) thus overflows to Y(10).

Y(9:12)

ans = 1x4 uint8 row vector

   0   1   0   0

You can convert Y back to 32-bit unsigned integers without changing the underlying data.

X2 = typecast(Y,"uint32")

X2 = 1x3 uint32 row vector

     1   255   256

Compare the output of typecast and the output of cast to see the difference between the two functions.

Z = cast(X,"uint8")

Z = 1x3 uint8 row vector

     1   255   255

X2 = cast(Z,"uint32")

X2 = 1x3 uint32 row vector

     1   255   255

Casts integers from a smaller data type (uint8) into a larger one (uint16). Use hexadecimal representation to show the rearrangement of the bit patterns. The typecast function returns the output in little-endian style, combining the four 8-bit segments of the input data to produce two 16-bit segments.

format hex
X = uint8([44 55 66 77])

X = 1x4 uint8 row vector

   2c   37   42   4d

Y = typecast(X,"uint16")

Y = 1x2 uint16 row vector

   372c   4d42

You can convert the little-endian output to big-endian (and vice versa) using the swapbytes function.

Y = swapbytes(typecast(X,"uint16"))

Y = 1x2 uint16 row vector

   2c37   424d

Since R2024b

Create a 1-by-4 vector of real numbers in double precision.

X = [1.2 2 3.4 4]

X = 1×4

    1.2000    2.0000    3.4000    4.0000

Create a complex number in double precision.

p = 1i

p = 
0.0000 + 1.0000i

Convert X to the same data type and complexity as the variable p. The result is a vector of two complex numbers in double precision.

Y = typecast(X,"like",p)

Y = 1×2 complex

   1.2000 + 2.0000i   3.4000 + 4.0000i

Convert Y back to the same data type and complexity as X. The result is a vector of the four original numbers in X.

X2 = typecast(Y,"like",X)

X2 = 1×4

    1.2000    2.0000    3.4000    4.0000