halfp - A floating-point half precision support package

This package comprises a new MATLAB classdef called 'halfp' that is intended to support storing and operating on half precision variables.

This package comprises a new MATLAB classdef called 'halfp' that is intended to support storing and operating on half precision variables. The new classdef allows the user the flexibility to choose the length of the Exponent (E), Mantissa (M) and rounding method, as long as E+M+1=16bit.

The classdef file is halfp.m that defines a new matlab half-precision number class with the following properties:

• E - length of the exponent (in bits)
• M - length of the mantissa (in bits)
• roundMethod - the rounding method to use when performing various arithmetic operations:

0=roundTiesToEven

1=roundTowardPositive

2=roundTowardNegative

3=roundTowardZero

4=roundTiesToOdd

• val - a uint16 value comprises the 16-bit representation of the half-precision number.

A new halfp object can now be easily created by calling, for example:

>> a=halfp;a.val=10000

a =

halfp with properties:

E: 5

M: 10

roundMethod: 0

val: 10000

The new class also comprises methods that allow to act on the 'halfp' object:

• a.castfrom(x) - imports a's value from a 'double' or 'single' variable x.
• a.double - returns the 'double' precision value of the halp object a.
• a.single - returns the 'double' precision value of the halp object a.
• a.hex - returns the hex value of the uint16 representation of object a.
• a.bin - returns the binary value of the uint16 representation of object a.
• a.plus - supports signed addition of 2 halfp objects.
• a.minus - supports signed subtraction of 2 halfp objects.
• a.mtimes - supports signed multiplication of 2 halfp objects.

Importing from 'double' is performed in the following way:

>> a=halfp

a =

halfp with properties:

E: 5

M: 10

roundMethod: 0

val: []

>> x=1.25

x =

1.250000000000000e+00

>> a=a.castfrom(x)

a =

halfp with properties:

E: 5

M: 10

roundMethod: 0

val: 15616

The class of x (single or double) will be automatically recognized.

There is also an option to define a as a vector or matrix of halfp object:

>> a.val(1:5)=[1 2 3 4 5]

a =

halfp with properties:

E: 5

M: 10

roundMethod: 0

val: [1 2 3 4 5]

>> a.val

ans =

1×5 uint16 row vector

1 2 3 4 5

Another way to work with halfp vectors/matrices is using the following code for example:

>> a(1:5)=halfp

a =

1×5 halfp array with properties:

E

M

roundMethod

val

>> a(1).val=10000;a(2).val=10000;a(3).val=10000;a(4).val=10000;a(5).val=10000;

>> a.val

ans =

uint16

10000

ans =

uint16

10000

ans =

uint16

10000

ans =

uint16

10000

ans =

uint16

10000

However, please note that the below operation functions cannot apply to vectors/matrices comprising multiple halfp object. To mitigate that, these functions should be called for one halfp object at a time (using a for loop for example).

Addition, subtraction or multiplication of 2 halfp objects is simply done using the normal +,- and * operators:

• c = a + b
• c = a - b
• c = a * b

The input arguments must be valid 'halfp' objects having the same E and M, and the output argument will also be an 'halfp' object with the same E and M. The rounding method to be carried-out will be determined by the roundMethod property of the first input argument. Operators priority is natively supported (e.g. multiplication over addition/subtraction and the use of parentheses).

These operations will also support vector/matrix 'halfp' input arguments and will perform the calculation on each scalar member. Needless to say, the input arguments MUST have the same length if both arguments are of size > 1. Performing the operations when one of the arguments is of size>1 and the other is of size=1, is also supported. Furthermore, inroducing direct 'double' or 'single' precision input arguments to the above operation functions is now also supported (scalar or vector). The code will simply convert them to an 'halfp' object before perfoming the actual arithmetics. For example:

>> a=halfp;a.val=10000;a.double

ans =

0.0276

>> b = a + 1

b =

halfp with properties:

E: 5

M: 10

roundMethod: 0

val: 15388

>> b.double

ans =

1.0273

(halfp_extract_sem.m, halfp_primitive_signed_addition.m and halfp_primitive_signed_multiply.m are internal functions and need not be used by the user).

Note: the code was not optimized for runtime in any way. This will be the focus of future versions.