1008 lines
31 KiB
VHDL
1008 lines
31 KiB
VHDL
---------------------------------------------------------------------
|
|
--
|
|
-- Package fix_std
|
|
-- Fixed point arithmetic based on numeric_std
|
|
--
|
|
---------------------------------------------------------------------
|
|
--
|
|
-- This document describes a VHDL package of definitions and subprograms
|
|
-- intended to support the use of fixed-point arithmetic in test benches
|
|
-- and synthesisable designs. This document and the package it describes
|
|
-- are made freely available to the HDL design community without warranty
|
|
-- of any kind. You are welcome to make use of this information for your
|
|
-- own private study and in your own designs. If you make use of the
|
|
-- package, you accept sole responsibility for its fitness for purpose
|
|
-- and its suitability in your application. You are free to modify the
|
|
-- package in any way, and to record your contribution to it, but this
|
|
-- notice must appear in a prominent place in any modified or derived
|
|
-- version of the package or its supporting documentation.
|
|
--
|
|
-- The author wishes to thank his employer Doulos Ltd for making
|
|
-- available the facilities used to develop, test and distribute this
|
|
-- package. However, Doulos Ltd accepts no responsibility for the
|
|
-- package's contents and cannot support it in any way.
|
|
--
|
|
---------------------------------------------------------------------
|
|
-- Revision information:
|
|
--
|
|
-- Version 0.1 06-May-2003
|
|
-- Alpha version, for review
|
|
-- No division operators are provided, pending detailed
|
|
-- consultation on their functionality.
|
|
-- Some subprogram implementations are unnecessarily inefficient.
|
|
-- Version 0.2 11-Jun-2003
|
|
-- Fixes aiming to make the package portable across all synthesis tools:
|
|
-- * Removed deferred constants, made them package constants
|
|
-- * Removed all variable initialisations in procedures, made them
|
|
-- procedural initialisations in the code
|
|
---------------------------------------------------------------------
|
|
|
|
library ieee;
|
|
use ieee.std_logic_1164.all;
|
|
use ieee.numeric_std.all;
|
|
|
|
package fix_std is
|
|
|
|
--------------------------------------------------------------------
|
|
|
|
-- Integer subtype specifying legal values for a bit index.
|
|
-- At present it's restricted to 'natural' to conform with
|
|
-- the behaviour of mainstream synthesis tools. For simulation,
|
|
-- or in the future when synthesis tools are able to cope, it
|
|
-- would be possible to change this subtype to be the full
|
|
-- integer range, thus allowing negative subscripts for
|
|
-- fraction bits.
|
|
--
|
|
subtype Fix_Subscr is natural;
|
|
|
|
-- Fixed-point offset, the bit number (subscript) used for
|
|
-- the bit in a UFix or SFix vector having binary weight 2^0
|
|
-- (the units bit).
|
|
--
|
|
constant FixP: Fix_Subscr := 100;
|
|
|
|
-- Type declarations for the basic unsigned and signed fixed point
|
|
-- data types:
|
|
--
|
|
type UFix is array (Fix_Subscr range <>) of std_logic;
|
|
type SFix is array (Fix_Subscr range <>) of std_logic;
|
|
|
|
-- Type declarations for control of rounding and overflow modes:
|
|
--
|
|
type Fix_Rounding_Mode is (
|
|
clip_LS, -- Throw away unwanted least significant bits
|
|
towards_zero, -- Round towards zero - same as clip_LS for UFix
|
|
to_nearest -- Round to nearest. Exact halves round up.
|
|
);
|
|
type Fix_Overflow_Mode is (
|
|
clip_MS, -- Throw away unwanted most significant bits
|
|
saturate -- Saturate overflow to nearest representable value
|
|
);
|
|
|
|
-- Defaults for these modes:
|
|
--
|
|
constant Fix_Default_Rounding : Fix_Rounding_Mode := clip_LS;
|
|
constant Fix_Default_Overflow : Fix_Overflow_Mode := clip_MS;
|
|
|
|
--------------------------------------------------------------------
|
|
|
|
---------------------------
|
|
-- E. Extraction functions
|
|
---------------------------
|
|
|
|
-- E.1. Return the integral part of a UFix value
|
|
function Int(U: UFix) return UFix;
|
|
|
|
-- E.2. Return the fractional part of a UFix value
|
|
function Frac(U: UFix) return UFix;
|
|
|
|
-- E.3. Return the integral part of a SFix value
|
|
function Int(S: SFix) return SFix;
|
|
|
|
-- E.4. Return the fractional part of a SFix value
|
|
function Frac(S: SFix) return UFix;
|
|
|
|
-- E.5. Widen a SFix value if necessary so that
|
|
-- its range adjoins or spans the binary point
|
|
function Span(S: SFix) return SFix;
|
|
|
|
-- E.6. Widen a UFix value if necessary so that
|
|
-- its range adjoins or spans the binary point
|
|
function Span(U: UFix) return UFix;
|
|
|
|
---------------------------
|
|
-- T. Conversion functions
|
|
---------------------------
|
|
|
|
-- T.1 to T.8: Unsigned conversions
|
|
--
|
|
-- T.1. Resizing an existing UFix. Provide number of
|
|
-- integer bits and number of fraction bits.
|
|
--
|
|
function to_UFix(
|
|
N : UFix;
|
|
MSB_index : Fix_Subscr;
|
|
LSB_index : Fix_Subscr := FixP;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
) return UFix;
|
|
|
|
-- T.2. Resizing an existing SFix. Provide number of
|
|
-- integer bits and number of fraction bits.
|
|
--
|
|
function to_UFix(
|
|
N : SFix;
|
|
MSB_index : Fix_Subscr;
|
|
LSB_index : Fix_Subscr := FixP;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
) return UFix;
|
|
|
|
-- T.3. Conversion from integer to UFix. Provide number of
|
|
-- integer bits and number of fraction bits. Note that
|
|
-- negative input is tolerated!
|
|
--
|
|
function to_UFix(
|
|
N : integer;
|
|
MSB_index : Fix_Subscr;
|
|
LSB_index : Fix_Subscr := FixP;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
) return UFix;
|
|
|
|
-- T.4. Conversion from unsigned to UFix. Provide subscripts of
|
|
-- MS and (optionally) LS bit of the resulting UFix.
|
|
--
|
|
function to_UFix(
|
|
N : unsigned;
|
|
MSB_index : Fix_Subscr;
|
|
LSB_index : Fix_Subscr := FixP;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
) return UFix;
|
|
|
|
-- T.5. Conversion from unsigned to UFix. Automatically set the
|
|
-- range of the resulting UFix to match the unsigned value,
|
|
-- as an integral UFix value with no fraction bits.
|
|
--
|
|
function to_UFix( N : unsigned ) return UFix;
|
|
|
|
-- T.6. Conversion from UFix to unsigned. All integer bits are
|
|
-- preserved (including adding LS scale bits if necessary).
|
|
--
|
|
function to_unsigned(
|
|
N : UFix;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
) return unsigned;
|
|
|
|
-- T.7. Conversion from UFix to unsigned. Caller specifies
|
|
-- required number of bits in unsigned result.
|
|
--
|
|
function to_unsigned(
|
|
N : UFix;
|
|
bits : positive;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
) return unsigned;
|
|
|
|
-- T.8. Conversion from UFix to integer. Up to 31 integer bits are
|
|
-- preserved (including adding LS scale bits if necessary).
|
|
--
|
|
function to_integer(
|
|
N : UFix;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
) return integer;
|
|
|
|
|
|
-- T.9 to T.16: Signed conversions
|
|
--
|
|
-- T.9. Resizing an existing UFix. Provide number of
|
|
-- integer bits and number of fraction bits.
|
|
--
|
|
function to_SFix(
|
|
N : UFix;
|
|
MSB_index : Fix_Subscr;
|
|
LSB_index : Fix_Subscr := FixP;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
) return SFix;
|
|
|
|
-- T.10. Resizing an existing SFix. Provide number of
|
|
-- integer bits and number of fraction bits.
|
|
--
|
|
function to_SFix(
|
|
N : SFix;
|
|
MSB_index : Fix_Subscr;
|
|
LSB_index : Fix_Subscr := FixP;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
) return SFix;
|
|
|
|
-- T.11. Conversion from integer to SFix. Provide number of
|
|
-- integer bits and number of fraction bits.
|
|
--
|
|
function to_SFix(
|
|
N : integer;
|
|
MSB_index : Fix_Subscr;
|
|
LSB_index : Fix_Subscr := FixP;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
) return SFix;
|
|
|
|
-- T.12. Conversion from signed to SFix. Provide subscripts of
|
|
-- MS and (optionally) LS bit of the resulting SFix.
|
|
--
|
|
function to_SFix(
|
|
N : signed;
|
|
MSB_index : Fix_Subscr;
|
|
LSB_index : Fix_Subscr := FixP;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
) return SFix;
|
|
|
|
-- T.13. Conversion from signed to SFix. Automatically set the
|
|
-- range of the resulting SFix to match the signed value,
|
|
-- as an integral SFix value with no fraction bits.
|
|
--
|
|
function to_SFix( N : signed ) return SFix;
|
|
|
|
-- T.14. Conversion from SFix to signed. All integer bits are
|
|
-- preserved (including adding LS scale bits if necessary).
|
|
--
|
|
function to_signed(
|
|
N : SFix;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
) return signed;
|
|
|
|
-- T.15. Conversion from SFix to signed. Caller specifies
|
|
-- required number of bits in signed result.
|
|
--
|
|
function to_signed(
|
|
N : SFix;
|
|
bits : positive;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
) return signed;
|
|
|
|
-- T.16. Conversion from SFix to integer. Up to 32 integer bits are
|
|
-- preserved (including adding LS scale bits if necessary).
|
|
--
|
|
function to_integer(
|
|
N : SFix;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
) return integer;
|
|
|
|
-- T.17. Conversion from UFix to SFix. This simply adds
|
|
-- an extra more significant bit, set to zero.
|
|
--
|
|
function to_SFix(U: UFix) return SFix;
|
|
|
|
----------------------------------
|
|
-- V. Copy-to-variable procedures
|
|
----------------------------------
|
|
|
|
-- Range-aware copying of an expression into a variable. The
|
|
-- ranges of destination variable and source expression are
|
|
-- used to determine correct rounding, overflow and scaling
|
|
-- behaviour.
|
|
|
|
-- V.1 to V.5: Copy an expression into a UFix variable
|
|
--
|
|
|
|
-- V.1. Copy UFix to UFix
|
|
--
|
|
procedure Copy_V(
|
|
target : out UFix;
|
|
source : UFix;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
--
|
|
-- V.2. Copy SFix to UFix
|
|
--
|
|
procedure Copy_V(
|
|
target : out UFix;
|
|
source : SFix;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- V.3. Copy UNSIGNED to UFix
|
|
--
|
|
procedure Copy_V(
|
|
target : out UFix;
|
|
source : unsigned;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- V.4. Copy SIGNED to UFix
|
|
--
|
|
procedure Copy_V(
|
|
target : out UFix;
|
|
source : signed;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- V.5. Copy integer to UFix
|
|
--
|
|
procedure Copy_V(
|
|
target : out UFix;
|
|
source : integer;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- V.6 to V.10: Copy an expression into a SFix variable
|
|
--
|
|
|
|
-- V.6. Copy UFix to SFix
|
|
--
|
|
procedure Copy_V(
|
|
target : out SFix;
|
|
source : UFix;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- V.7. Copy SFix to SFix
|
|
--
|
|
procedure Copy_V(
|
|
target : out SFix;
|
|
source : SFix;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- V.8. Copy UNSIGNED to SFix
|
|
--
|
|
procedure Copy_V(
|
|
target : out SFix;
|
|
source : unsigned;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- V.9. Copy SIGNED to SFix
|
|
--
|
|
procedure Copy_V(
|
|
target : out SFix;
|
|
source : signed;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- V.10. Copy integer to SFix
|
|
--
|
|
procedure Copy_V(
|
|
target : out SFix;
|
|
source : integer;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
|
|
--------------------------------
|
|
-- S. Copy-to-signal procedures
|
|
--------------------------------
|
|
--
|
|
-- Range-aware copying of an expression into a signal. The
|
|
-- ranges of destination signal and source expression are
|
|
-- used to determine correct rounding, overflow and scaling
|
|
-- behaviour.
|
|
|
|
-- S.1 to S.5: Copy an expression into a UFix signal
|
|
--
|
|
|
|
-- S.1. Copy UFix to UFix
|
|
--
|
|
procedure Copy_S(
|
|
signal target : out UFix;
|
|
source : UFix;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- S.1. Copy SFix to UFix
|
|
--
|
|
procedure Copy_S(
|
|
signal target : out UFix;
|
|
source : SFix;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- S.3. Copy UNSIGNED to UFix
|
|
--
|
|
procedure Copy_S(
|
|
signal target : out UFix;
|
|
source : unsigned;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- S.4. Copy SIGNED to UFix
|
|
--
|
|
procedure Copy_S(
|
|
signal target : out UFix;
|
|
source : signed;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- S.5. Copy integer to UFix
|
|
--
|
|
procedure Copy_S(
|
|
signal target : out UFix;
|
|
source : integer;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- S.6 to S.10: Copy an expression into a SFix signal
|
|
--
|
|
|
|
-- S.6. Copy UFix to SFix
|
|
--
|
|
procedure Copy_S(
|
|
signal target : out SFix;
|
|
source : UFix;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- S.7. Copy SFix to SFix
|
|
--
|
|
procedure Copy_S(
|
|
signal target : out SFix;
|
|
source : SFix;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- S.8. Copy UNSIGNED to SFix
|
|
--
|
|
procedure Copy_S(
|
|
signal target : out SFix;
|
|
source : unsigned;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- S.9. Copy SIGNED to SFix
|
|
--
|
|
procedure Copy_S(
|
|
signal target : out SFix;
|
|
source : signed;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
-- S.10. Copy integer to SFix
|
|
--
|
|
procedure Copy_S(
|
|
signal target : out SFix;
|
|
source : integer;
|
|
overflow : Fix_Overflow_Mode := Fix_Default_Overflow;
|
|
rounding : Fix_Rounding_Mode := Fix_Default_Rounding
|
|
);
|
|
|
|
|
|
------------------------------------------------------------------
|
|
-- A. Arithmetic operations involving UFix, SFix and other
|
|
-- numeric types.
|
|
-- The operators are overloaded for most of the sensible
|
|
-- combinations of SFix, UFix, UNSIGNED, SIGNED and INTEGER.
|
|
--
|
|
-- IMPORTANT NOTE:
|
|
-- Arithmetic operators return a result that is wide enough
|
|
-- and precise enough so that no information is lost. THIS IS
|
|
-- SIGNIFICANTLY DIFFERENT FROM THE BEHAVIOUR OF numeric_std.
|
|
-- In the detailed description that follow, "scaling" means
|
|
-- the numerical value (weight) of the least significant bit
|
|
-- in a fixed-point value.
|
|
--
|
|
-- ADDITION returns a result whose least significant bit
|
|
-- is the same as the least significant bit in either operand,
|
|
-- and whose most significant bit is one position higher than
|
|
-- the most significant bit in either operand. Addition of
|
|
-- two operands having the same bounds therefore results in
|
|
-- a growth of one bit at the most significant end.
|
|
--
|
|
-- SUBTRACTION where one or both operands are signed behaves
|
|
-- in the same way as addition. Subtraction where both operands
|
|
-- are unsigned returns a result whose most significant bit
|
|
-- position is the same as the most significant bit in either
|
|
-- operand, and whose least significant bit is the same as the
|
|
-- least significant bit in either operand.
|
|
--
|
|
-- MULTIPLICATION returns a result whose width is the sum of
|
|
-- the widths of its two operands, and whose scaling is the
|
|
-- product of its two operands' scalings.
|
|
--
|
|
-- UNARY NEGATION always gives a result having one more
|
|
-- significant bit than the operand.
|
|
--
|
|
-- ABSOLUTE VALUE always gives a result having exactly the
|
|
-- same subtype as its operand.
|
|
--
|
|
-- In binary operations where one operand is a fixed-point type
|
|
-- and the other is an integer numeric type, the integer operand
|
|
-- is first converted to a fixed-point type of the same subtype
|
|
-- as the other operand using Copy_V with default rounding and
|
|
-- overflow modes. The operation is then performed between two
|
|
-- fixed-point operands in the normal way.
|
|
--
|
|
------------------------------------------------------------------
|
|
|
|
|
|
------------------------------------
|
|
-- A.1. Unary "-" negation operator
|
|
------------------------------------
|
|
|
|
-- A.1.1. SFix := - UFix
|
|
function "-" (R: UFix) return SFix;
|
|
|
|
-- A.1.2. SFix := - SFix
|
|
function "-" (R: SFix) return SFix;
|
|
|
|
|
|
--------------------------------------------
|
|
-- A.2. Unary "abs" absolute-value operator
|
|
--------------------------------------------
|
|
|
|
-- A.2.1. SFix := abs SFix
|
|
function "abs" (R: SFix) return SFix;
|
|
|
|
|
|
-------------------------------------
|
|
-- A.3. Binary "+" addition operator
|
|
-------------------------------------
|
|
|
|
-- A.3.1. UFix := UFix + UFix
|
|
function "+" (L: UFix; R: UFix) return UFix;
|
|
|
|
-- A.3.2. UFix := UFix + unsigned
|
|
function "+" (L: UFix; R: unsigned) return UFix;
|
|
|
|
-- A.3.3. UFix := unsigned + UFix
|
|
function "+" (L: unsigned; R: UFix) return UFix;
|
|
|
|
-- A.3.4. UFix := UFix + natural
|
|
function "+" (L: UFix; R: natural) return UFix;
|
|
|
|
-- A.3.5. UFix := natural + UFix
|
|
function "+" (L: natural; R: UFix) return UFix;
|
|
|
|
-- A.3.6. SFix := SFix + SFix
|
|
function "+" (L: SFix; R: SFix) return SFix;
|
|
|
|
-- A.3.7. SFix := SFix + UFix
|
|
function "+" (L: SFix; R: UFix) return SFix;
|
|
|
|
-- A.3.8. SFix := UFix + SFix
|
|
function "+" (L: UFix; R: SFix) return SFix;
|
|
|
|
-- A.3.9. SFix := SFix + signed
|
|
function "+" (L: SFix; R: signed) return SFix;
|
|
|
|
-- A.3.10. SFix := signed + SFix
|
|
function "+" (L: signed; R: SFix) return SFix;
|
|
|
|
-- A.3.11. SFix := SFix + integer
|
|
function "+" (L: SFix; R: integer) return SFix;
|
|
|
|
-- A.3.12. SFix := integer + SFix
|
|
function "+" (L: integer; R: SFix) return SFix;
|
|
|
|
|
|
----------------------------------------
|
|
-- A.4. Binary "-" subtraction operator
|
|
----------------------------------------
|
|
--
|
|
-- NOTE: There is a special problem with subtraction
|
|
-- operators that return a UFix result if that result
|
|
-- goes negative. Our arbitrary decision is that we
|
|
-- truncate most-significant bits in this case. If you
|
|
-- wish to avoid the risk of this arbitrarily-defined
|
|
-- truncation behaviour, change one or more of your
|
|
-- operands to SFix and get a SFix result using this
|
|
-- idiom:
|
|
-- SFix := UFix + (-UFix)
|
|
-- or copy one of the UFix operands into a SFix that's
|
|
-- one bit wider, before performing the operation.
|
|
--
|
|
-- Subtractions returning a UFix result take unsigned
|
|
-- operands and do not exhibit bit growth.
|
|
-- Subtractions returning a SFix result take signed or
|
|
-- unsigned operands and exhibit one-bit growth like addition.
|
|
|
|
-- A.4.1. UFix := UFix - UFix
|
|
function "-" (L: UFix; R: UFix) return UFix;
|
|
|
|
-- A.4.2. UFix := UFix - unsigned
|
|
function "-" (L: UFix; R: unsigned) return UFix;
|
|
|
|
-- A.4.3. UFix := unsigned - UFix
|
|
function "-" (L: unsigned; R: UFix) return UFix;
|
|
|
|
-- A.4.4. UFix := UFix - natural
|
|
function "-" (L: UFix; R: natural) return UFix;
|
|
|
|
-- A.4.5. UFix := natural - UFix
|
|
function "-" (L: natural; R: UFix) return UFix;
|
|
|
|
-- A.4.6. SFix := SFix - SFix
|
|
function "-" (L: SFix; R: SFix) return SFix;
|
|
|
|
-- A.4.7. SFix := SFix - UFix
|
|
function "-" (L: SFix; R: UFix) return SFix;
|
|
|
|
-- A.4.8. SFix := UFix - SFix
|
|
function "-" (L: UFix; R: SFix) return SFix;
|
|
|
|
-- A.4.9. SFix := SFix - signed
|
|
function "-" (L: SFix; R: signed) return SFix;
|
|
|
|
-- A.4.10. SFix := signed - SFix
|
|
function "-" (L: signed; R: SFix) return SFix;
|
|
|
|
-- A.4.11. SFix := SFix - integer
|
|
function "-" (L: SFix; R: integer) return SFix;
|
|
|
|
-- A.4.12. SFix := integer - SFix
|
|
function "-" (L: integer; R: SFix) return SFix;
|
|
|
|
|
|
-------------------------------------------
|
|
-- A.5. Binary "*" multiplication operator
|
|
-------------------------------------------
|
|
|
|
-- A.5.1. UFix := UFix * UFix
|
|
function "*" (L: UFix; R: UFix) return UFix;
|
|
|
|
-- A.5.2. UFix := UFix * unsigned
|
|
function "*" (L: UFix; R: unsigned) return UFix;
|
|
|
|
-- A.5.3. UFix := unsigned * UFix
|
|
function "*" (L: unsigned; R: UFix) return UFix;
|
|
|
|
-- A.5.4. UFix := UFix * natural
|
|
function "*" (L: UFix; R: natural) return UFix;
|
|
|
|
-- A.5.5. UFix := natural * UFix
|
|
function "*" (L: natural; R: UFix) return UFix;
|
|
|
|
-- A.5.6. SFix := SFix * SFix
|
|
function "*" (L: SFix; R: SFix) return SFix;
|
|
|
|
-- A.5.7. SFix := SFix * UFix
|
|
function "*" (L: SFix; R: UFix) return SFix;
|
|
|
|
-- A.5.8. SFix := UFix * SFix
|
|
function "*" (L: UFix; R: SFix) return SFix;
|
|
|
|
-- A.5.9. SFix := SFix * signed
|
|
function "*" (L: SFix; R: signed) return SFix;
|
|
|
|
-- A.5.10. SFix := signed * SFix
|
|
function "*" (L: signed; R: SFix) return SFix;
|
|
|
|
-- A.5.11. SFix := SFix * integer
|
|
function "*" (L: SFix; R: integer) return SFix;
|
|
|
|
-- A.5.12. SFix := integer * SFix
|
|
function "*" (L: integer; R: SFix) return SFix;
|
|
|
|
|
|
------------------------------------------------------------------
|
|
-- R. Relational operators - arithmetic comparisons involving
|
|
-- UFix, SFix and other numeric types.
|
|
-- The operators are overloaded for most of the sensible
|
|
-- combinations of SFix, UFix, UNSIGNED, SIGNED and INTEGER.
|
|
-- Note that in all cases comparisons are exact; if one
|
|
-- operand has more fraction bits than the other, the less
|
|
-- precise operand will have its LSBs zero-extended, and
|
|
-- these zero bits will take part in comparison with whatever
|
|
-- LSBs exist in the more precise operand.
|
|
------------------------------------------------------------------
|
|
|
|
-------------------------------------
|
|
-- R.1. Binary "=" equality operator
|
|
-------------------------------------
|
|
|
|
-- R.1.1. UFix = UFix
|
|
function "=" (L: UFix; R: UFix) return boolean;
|
|
|
|
-- R.1.2. UFix = unsigned
|
|
function "=" (L: UFix; R: unsigned) return boolean;
|
|
|
|
-- R.1.3. unsigned = UFix
|
|
function "=" (L: unsigned; R: UFix) return boolean;
|
|
|
|
-- R.1.4. UFix = integer
|
|
function "=" (L: UFix; R: integer) return boolean;
|
|
|
|
-- R.1.5. integer = UFix
|
|
function "=" (L: integer; R: UFix) return boolean;
|
|
|
|
-- R.1.6. SFix = SFix
|
|
function "=" (L: SFix; R: SFix) return boolean;
|
|
|
|
-- R.1.7. SFix = UFix
|
|
function "=" (L: SFix; R: UFix) return boolean;
|
|
|
|
-- R.1.8. UFix = SFix
|
|
function "=" (L: UFix; R: SFix) return boolean;
|
|
|
|
-- R.1.9. SFix = signed
|
|
function "=" (L: SFix; R: signed) return boolean;
|
|
|
|
-- R.1.10. signed = SFix
|
|
function "=" (L: signed; R: SFix) return boolean;
|
|
|
|
-- R.1.11. SFix = integer
|
|
function "=" (L: SFix; R: integer) return boolean;
|
|
|
|
-- R.1.12. integer = SFix
|
|
function "=" (L: integer; R: SFix) return boolean;
|
|
|
|
|
|
--------------------------------------
|
|
-- R.2. Binary "<" less-than operator
|
|
--------------------------------------
|
|
|
|
-- R.2.1. UFix < UFix
|
|
function "<" (L: UFix; R: UFix) return boolean;
|
|
|
|
-- R.2.2. UFix < unsigned
|
|
function "<" (L: UFix; R: unsigned) return boolean;
|
|
|
|
-- R.2.3. unsigned < UFix
|
|
function "<" (L: unsigned; R: UFix) return boolean;
|
|
|
|
-- R.2.4. UFix < integer
|
|
function "<" (L: UFix; R: integer) return boolean;
|
|
|
|
-- R.2.5. integer < UFix
|
|
function "<" (L: integer; R: UFix) return boolean;
|
|
|
|
-- R.2.6. SFix < SFix
|
|
function "<" (L: SFix; R: SFix) return boolean;
|
|
|
|
-- R.2.7. SFix < UFix
|
|
function "<" (L: SFix; R: UFix) return boolean;
|
|
|
|
-- R.2.8. UFix < SFix
|
|
function "<" (L: UFix; R: SFix) return boolean;
|
|
|
|
-- R.2.9. SFix < signed
|
|
function "<" (L: SFix; R: signed) return boolean;
|
|
|
|
-- R.2.10. signed < SFix
|
|
function "<" (L: signed; R: SFix) return boolean;
|
|
|
|
-- R.2.11. SFix < integer
|
|
function "<" (L: SFix; R: integer) return boolean;
|
|
|
|
-- R.2.12. integer < SFix
|
|
function "<" (L: integer; R: SFix) return boolean;
|
|
|
|
|
|
----------------------------------------
|
|
-- R.3. Binary "/=" inequality operator
|
|
----------------------------------------
|
|
|
|
-- R.3.1. UFix /= UFix
|
|
function "/=" (L: UFix; R: UFix) return boolean;
|
|
|
|
-- R.3.2. UFix /= unsigned
|
|
function "/=" (L: UFix; R: unsigned) return boolean;
|
|
|
|
-- R.3.3. unsigned /= UFix
|
|
function "/=" (L: unsigned; R: UFix) return boolean;
|
|
|
|
-- R.3.4. UFix /= integer
|
|
function "/=" (L: UFix; R: integer) return boolean;
|
|
|
|
-- R.3.5. integer /= UFix
|
|
function "/=" (L: integer; R: UFix) return boolean;
|
|
|
|
-- R.3.6. SFix /= SFix
|
|
function "/=" (L: SFix; R: SFix) return boolean;
|
|
|
|
-- R.3.7. SFix /= UFix
|
|
function "/=" (L: SFix; R: UFix) return boolean;
|
|
|
|
-- R.3.8. UFix /= SFix
|
|
function "/=" (L: UFix; R: SFix) return boolean;
|
|
|
|
-- R.3.9. SFix /= signed
|
|
function "/=" (L: SFix; R: signed) return boolean;
|
|
|
|
-- R.3.10. signed /= SFix
|
|
function "/=" (L: signed; R: SFix) return boolean;
|
|
|
|
-- R.3.11. SFix /= integer
|
|
function "/=" (L: SFix; R: integer) return boolean;
|
|
|
|
-- R.3.12. integer /= SFix
|
|
function "/=" (L: integer; R: SFix) return boolean;
|
|
|
|
|
|
-----------------------------------------
|
|
-- R.4. Binary ">" greater-than operator
|
|
-----------------------------------------
|
|
|
|
-- R.4.1. UFix > UFix
|
|
function ">" (L: UFix; R: UFix) return boolean;
|
|
|
|
-- R.4.2. UFix > unsigned
|
|
function ">" (L: UFix; R: unsigned) return boolean;
|
|
|
|
-- R.4.3. unsigned > UFix
|
|
function ">" (L: unsigned; R: UFix) return boolean;
|
|
|
|
-- R.4.4. UFix > integer
|
|
function ">" (L: UFix; R: integer) return boolean;
|
|
|
|
-- R.4.5. integer > UFix
|
|
function ">" (L: integer; R: UFix) return boolean;
|
|
|
|
-- R.4.6. SFix > SFix
|
|
function ">" (L: SFix; R: SFix) return boolean;
|
|
|
|
-- R.4.7. SFix > UFix
|
|
function ">" (L: SFix; R: UFix) return boolean;
|
|
|
|
-- R.4.8. UFix > SFix
|
|
function ">" (L: UFix; R: SFix) return boolean;
|
|
|
|
-- R.4.9. SFix > signed
|
|
function ">" (L: SFix; R: signed) return boolean;
|
|
|
|
-- R.4.10. signed > SFix
|
|
function ">" (L: signed; R: SFix) return boolean;
|
|
|
|
-- R.4.11. SFix > integer
|
|
function ">" (L: SFix; R: integer) return boolean;
|
|
|
|
-- R.4.12. integer > SFix
|
|
function ">" (L: integer; R: SFix) return boolean;
|
|
|
|
|
|
----------------------------------------------
|
|
-- R.5. Binary ">=" greater-or-equal operator
|
|
----------------------------------------------
|
|
|
|
-- R.5.1. UFix >= UFix
|
|
function ">=" (L: UFix; R: UFix) return boolean;
|
|
|
|
-- R.5.2. UFix >= unsigned
|
|
function ">=" (L: UFix; R: unsigned) return boolean;
|
|
|
|
-- R.5.3. unsigned >= UFix
|
|
function ">=" (L: unsigned; R: UFix) return boolean;
|
|
|
|
-- R.5.4. UFix >= integer
|
|
function ">=" (L: UFix; R: integer) return boolean;
|
|
|
|
-- R.5.5. integer >= UFix
|
|
function ">=" (L: integer; R: UFix) return boolean;
|
|
|
|
-- R.5.6. SFix >= SFix
|
|
function ">=" (L: SFix; R: SFix) return boolean;
|
|
|
|
-- R.5.7. SFix >= UFix
|
|
function ">=" (L: SFix; R: UFix) return boolean;
|
|
|
|
-- R.5.8. UFix >= SFix
|
|
function ">=" (L: UFix; R: SFix) return boolean;
|
|
|
|
-- R.5.9. SFix >= signed
|
|
function ">=" (L: SFix; R: signed) return boolean;
|
|
|
|
-- R.5.10. signed >= SFix
|
|
function ">=" (L: signed; R: SFix) return boolean;
|
|
|
|
-- R.5.11. SFix >= integer
|
|
function ">=" (L: SFix; R: integer) return boolean;
|
|
|
|
-- R.5.12. integer >= SFix
|
|
function ">=" (L: integer; R: SFix) return boolean;
|
|
|
|
|
|
-------------------------------------------
|
|
-- R.6. Binary "<=" less-or-equal operator
|
|
-------------------------------------------
|
|
|
|
-- R.6.1. UFix <= UFix
|
|
function "<=" (L: UFix; R: UFix) return boolean;
|
|
|
|
-- R.6.2. UFix <= unsigned
|
|
function "<=" (L: UFix; R: unsigned) return boolean;
|
|
|
|
-- R.6.3. unsigned <= UFix
|
|
function "<=" (L: unsigned; R: UFix) return boolean;
|
|
|
|
-- R.6.4. UFix <= integer
|
|
function "<=" (L: UFix; R: integer) return boolean;
|
|
|
|
-- R.6.5. integer <= UFix
|
|
function "<=" (L: integer; R: UFix) return boolean;
|
|
|
|
-- R.6.6. SFix <= SFix
|
|
function "<=" (L: SFix; R: SFix) return boolean;
|
|
|
|
-- R.6.7. SFix <= UFix
|
|
function "<=" (L: SFix; R: UFix) return boolean;
|
|
|
|
-- R.6.8. UFix <= SFix
|
|
function "<=" (L: UFix; R: SFix) return boolean;
|
|
|
|
-- R.6.9. SFix <= signed
|
|
function "<=" (L: SFix; R: signed) return boolean;
|
|
|
|
-- R.6.10. signed <= SFix
|
|
function "<=" (L: signed; R: SFix) return boolean;
|
|
|
|
-- R.6.11. SFix <= integer
|
|
function "<=" (L: SFix; R: integer) return boolean;
|
|
|
|
-- R.6.12. integer <= SFix
|
|
function "<=" (L: integer; R: SFix) return boolean;
|
|
|
|
|
|
------------------------------------------------------------------
|
|
-- C. Concatenation operators between fixed-point operands, and
|
|
-- between fixed-point operands and other reasonable types.
|
|
-- Unlike the implicitly defined "&" operator, they preserve
|
|
-- place value and return an appropriately aligned subtype.
|
|
-- Preservation of place value means that some concatenation
|
|
-- operations are illegal. In particular, operations
|
|
-- [SFix & SFix] and [UFix & SFix] are illegal, and
|
|
-- the place values of operands in [SFix & UFix] and
|
|
-- [UFix & UFix] must match up - the rightmost subscript of
|
|
-- the left operand must be one higher than the leftmost
|
|
-- subscript of the right operand.
|
|
-- Single bits of type std_ulogic may be concatenated with
|
|
-- fixed-point types where there is no risk of losing
|
|
-- sign-extension information.
|
|
-- Because of the way VHDL defines implicit concatenation,
|
|
-- it is impossible to detect all these errors at compile time.
|
|
-- Instead they are detected by assertion statements at run time.
|
|
-- Tool vendors may choose to implement compile-time checks
|
|
-- so that the run-time checking overhead can be avoided.
|
|
------------------------------------------------------------------
|
|
|
|
-- C.1.1. UFix := UFix & UFix
|
|
function "&" (L: UFix; R: UFix) return UFix;
|
|
|
|
-- No need to define "&"[UFix, SFix] explicitly, because
|
|
-- the types are incompatible and so there's no default
|
|
|
|
-- C.1.2. UFix := UFix & std_ulogic
|
|
function "&" (L: UFix; R: std_ulogic) return UFix;
|
|
|
|
-- C.1.3. UFix := std_ulogic & UFix
|
|
function "&" (L: std_ulogic; R: UFix) return UFix;
|
|
|
|
|
|
-- C.2.1. SFix := SFix & UFix
|
|
function "&" (L: SFix; R: UFix) return SFix;
|
|
|
|
-- C.2.2. SFix := SFix & SFix -- ILLEGAL
|
|
function "&" (L: SFix; R: SFix) return SFix;
|
|
|
|
-- C.2.3. SFix := SFix & std_ulogic
|
|
function "&" (L: SFix; R: std_ulogic) return SFix;
|
|
|
|
-- C.2.4. SFix := std_ulogic & SFix
|
|
function "&" (L: std_ulogic; R: SFix) return SFix;
|
|
|
|
|
|
end; -- package fix_std;
|