diff options
Diffstat (limited to 'ieee_proposed/rtl/fixed_pkg_c.vhd')
-rw-r--r-- | ieee_proposed/rtl/fixed_pkg_c.vhd | 8390 |
1 files changed, 0 insertions, 8390 deletions
diff --git a/ieee_proposed/rtl/fixed_pkg_c.vhd b/ieee_proposed/rtl/fixed_pkg_c.vhd deleted file mode 100644 index bb32709..0000000 --- a/ieee_proposed/rtl/fixed_pkg_c.vhd +++ /dev/null @@ -1,8390 +0,0 @@ --- -------------------------------------------------------------------- --- "fixed_pkg_c.vhdl" package contains functions for fixed point math. --- Please see the documentation for the fixed point package. --- This package should be compiled into "ieee_proposed" and used as follows: --- use ieee.std_logic_1164.all; --- use ieee.numeric_std.all; --- use ieee_proposed.fixed_float_types.all; --- use ieee_proposed.fixed_pkg.all; --- --- This verison is designed to work with the VHDL-93 compilers --- synthesis tools. Please note the "%%%" comments. These are where we --- diverge from the VHDL-200X LRM. --- -------------------------------------------------------------------- --- Version : $Revision: 1.21 $ --- Date : $Date: 2007/09/26 18:08:53 $ --- -------------------------------------------------------------------- - -use STD.TEXTIO.all; -library IEEE; -use IEEE.STD_LOGIC_1164.all; -use IEEE.NUMERIC_STD.all; -library IEEE_PROPOSED; -use IEEE_PROPOSED.fixed_float_types.all; - -package fixed_pkg is --- generic ( - -- Rounding routine to use in fixed point, fixed_round or fixed_truncate - constant fixed_round_style : fixed_round_style_type := fixed_round; - -- Overflow routine to use in fixed point, fixed_saturate or fixed_wrap - constant fixed_overflow_style : fixed_overflow_style_type := fixed_saturate; - -- Extra bits used in divide routines - constant fixed_guard_bits : NATURAL := 3; - -- If TRUE, then turn off warnings on "X" propagation - constant no_warning : BOOLEAN := (false - ); - - -- Author David Bishop (dbishop@vhdl.org) - - -- base Unsigned fixed point type, downto direction assumed - type UNRESOLVED_ufixed is array (INTEGER range <>) of STD_ULOGIC; - -- base Signed fixed point type, downto direction assumed - type UNRESOLVED_sfixed is array (INTEGER range <>) of STD_ULOGIC; - - subtype U_ufixed is UNRESOLVED_ufixed; - subtype U_sfixed is UNRESOLVED_sfixed; - - subtype ufixed is UNRESOLVED_ufixed; - subtype sfixed is UNRESOLVED_sfixed; - - --=========================================================================== - -- Arithmetic Operators: - --=========================================================================== - - -- Absolute value, 2's complement - -- abs sfixed(a downto b) = sfixed(a+1 downto b) - function "abs" (arg : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- Negation, 2's complement - -- - sfixed(a downto b) = sfixed(a+1 downto b) - function "-" (arg : UNRESOLVED_sfixed)return UNRESOLVED_sfixed; - - -- Addition - -- ufixed(a downto b) + ufixed(c downto d) - -- = ufixed(maximum(a,c)+1 downto minimum(b,d)) - function "+" (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- sfixed(a downto b) + sfixed(c downto d) - -- = sfixed(maximum(a,c)+1 downto minimum(b,d)) - function "+" (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- Subtraction - -- ufixed(a downto b) - ufixed(c downto d) - -- = ufixed(maximum(a,c)+1 downto minimum(b,d)) - function "-" (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- sfixed(a downto b) - sfixed(c downto d) - -- = sfixed(maximum(a,c)+1 downto minimum(b,d)) - function "-" (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- Multiplication - -- ufixed(a downto b) * ufixed(c downto d) = ufixed(a+c+1 downto b+d) - function "*" (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- sfixed(a downto b) * sfixed(c downto d) = sfixed(a+c+1 downto b+d) - function "*" (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- Division - -- ufixed(a downto b) / ufixed(c downto d) = ufixed(a-d downto b-c-1) --- function "/" (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- sfixed(a downto b) / sfixed(c downto d) = sfixed(a-d+1 downto b-c) --- function "/" (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- Remainder - -- ufixed (a downto b) rem ufixed (c downto d) - -- = ufixed (minimum(a,c) downto minimum(b,d)) --- function "rem" (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- sfixed (a downto b) rem sfixed (c downto d) - -- = sfixed (minimum(a,c) downto minimum(b,d)) --- function "rem" (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- Modulo - -- ufixed (a downto b) mod ufixed (c downto d) - -- = ufixed (minimum(a,c) downto minimum(b, d)) --- function "mod" (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- sfixed (a downto b) mod sfixed (c downto d) - -- = sfixed (c downto minimum(b, d)) --- function "mod" (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - ---------------------------------------------------------------------------- - -- In these routines the "real" or "natural" (integer) - -- are converted into a fixed point number and then the operation is - -- performed. It is assumed that the array will be large enough. - -- If the input is "real" then the real number is converted into a fixed of - -- the same size as the fixed point input. If the number is an "integer" - -- then it is converted into fixed with the range (l'high downto 0). - ---------------------------------------------------------------------------- - - -- ufixed(a downto b) + ufixed(a downto b) = ufixed(a+1 downto b) - function "+" (l : UNRESOLVED_ufixed; r : REAL) return UNRESOLVED_ufixed; - - -- ufixed(c downto d) + ufixed(c downto d) = ufixed(c+1 downto d) - function "+" (l : REAL; r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- ufixed(a downto b) + ufixed(a downto 0) = ufixed(a+1 downto minimum(0,b)) - function "+" (l : UNRESOLVED_ufixed; r : NATURAL) return UNRESOLVED_ufixed; - - -- ufixed(a downto 0) + ufixed(c downto d) = ufixed(c+1 downto minimum(0,d)) - function "+" (l : NATURAL; r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- ufixed(a downto b) - ufixed(a downto b) = ufixed(a+1 downto b) - function "-" (l : UNRESOLVED_ufixed; r : REAL) return UNRESOLVED_ufixed; - - -- ufixed(c downto d) - ufixed(c downto d) = ufixed(c+1 downto d) - function "-" (l : REAL; r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- ufixed(a downto b) - ufixed(a downto 0) = ufixed(a+1 downto minimum(0,b)) - function "-" (l : UNRESOLVED_ufixed; r : NATURAL) return UNRESOLVED_ufixed; - - -- ufixed(a downto 0) + ufixed(c downto d) = ufixed(c+1 downto minimum(0,d)) - function "-" (l : NATURAL; r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- ufixed(a downto b) * ufixed(a downto b) = ufixed(2a+1 downto 2b) - function "*" (l : UNRESOLVED_ufixed; r : REAL) return UNRESOLVED_ufixed; - - -- ufixed(c downto d) * ufixed(c downto d) = ufixed(2c+1 downto 2d) - function "*" (l : REAL; r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- ufixed (a downto b) * ufixed (a downto 0) = ufixed (2a+1 downto b) - function "*" (l : UNRESOLVED_ufixed; r : NATURAL) return UNRESOLVED_ufixed; - - -- ufixed (a downto b) * ufixed (a downto 0) = ufixed (2a+1 downto b) - function "*" (l : NATURAL; r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- ufixed(a downto b) / ufixed(a downto b) = ufixed(a-b downto b-a-1) --- function "/" (l : UNRESOLVED_ufixed; r : REAL) return UNRESOLVED_ufixed; - --- -- ufixed(a downto b) / ufixed(a downto b) = ufixed(a-b downto b-a-1) --- function "/" (l : REAL; r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- ufixed(a downto b) / ufixed(a downto 0) = ufixed(a downto b-a-1) --- function "/" (l : UNRESOLVED_ufixed; r : NATURAL) return UNRESOLVED_ufixed; - - -- ufixed(c downto 0) / ufixed(c downto d) = ufixed(c-d downto -c-1) --- function "/" (l : NATURAL; r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- ufixed (a downto b) rem ufixed (a downto b) = ufixed (a downto b) --- function "rem" (l : UNRESOLVED_ufixed; r : REAL) return UNRESOLVED_ufixed; - --- -- ufixed (c downto d) rem ufixed (c downto d) = ufixed (c downto d) --- function "rem" (l : REAL; r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - --- -- ufixed (a downto b) rem ufixed (a downto 0) = ufixed (a downto minimum(b,0)) --- function "rem" (l : UNRESOLVED_ufixed; r : NATURAL) return UNRESOLVED_ufixed; - --- -- ufixed (c downto 0) rem ufixed (c downto d) = ufixed (c downto minimum(d,0)) --- function "rem" (l : NATURAL; r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - --- -- ufixed (a downto b) mod ufixed (a downto b) = ufixed (a downto b) --- function "mod" (l : UNRESOLVED_ufixed; r : REAL) return UNRESOLVED_ufixed; - --- -- ufixed (c downto d) mod ufixed (c downto d) = ufixed (c downto d) --- function "mod" (l : REAL; r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - --- -- ufixed (a downto b) mod ufixed (a downto 0) = ufixed (a downto minimum(b,0)) --- function "mod" (l : UNRESOLVED_ufixed; r : NATURAL) return UNRESOLVED_ufixed; - --- -- ufixed (c downto 0) mod ufixed (c downto d) = ufixed (c downto minimum(d,0)) --- function "mod" (l : NATURAL; r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - - -- sfixed(a downto b) + sfixed(a downto b) = sfixed(a+1 downto b) - function "+" (l : UNRESOLVED_sfixed; r : REAL) return UNRESOLVED_sfixed; - - -- sfixed(c downto d) + sfixed(c downto d) = sfixed(c+1 downto d) - function "+" (l : REAL; r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- sfixed(a downto b) + sfixed(a downto 0) = sfixed(a+1 downto minimum(0,b)) - function "+" (l : UNRESOLVED_sfixed; r : INTEGER) return UNRESOLVED_sfixed; - - -- sfixed(c downto 0) + sfixed(c downto d) = sfixed(c+1 downto minimum(0,d)) - function "+" (l : INTEGER; r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- sfixed(a downto b) - sfixed(a downto b) = sfixed(a+1 downto b) - function "-" (l : UNRESOLVED_sfixed; r : REAL) return UNRESOLVED_sfixed; - - -- sfixed(c downto d) - sfixed(c downto d) = sfixed(c+1 downto d) - function "-" (l : REAL; r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- sfixed(a downto b) - sfixed(a downto 0) = sfixed(a+1 downto minimum(0,b)) - function "-" (l : UNRESOLVED_sfixed; r : INTEGER) return UNRESOLVED_sfixed; - - -- sfixed(c downto 0) - sfixed(c downto d) = sfixed(c+1 downto minimum(0,d)) - function "-" (l : INTEGER; r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- sfixed(a downto b) * sfixed(a downto b) = sfixed(2a+1 downto 2b) - function "*" (l : UNRESOLVED_sfixed; r : REAL) return UNRESOLVED_sfixed; - - -- sfixed(c downto d) * sfixed(c downto d) = sfixed(2c+1 downto 2d) - function "*" (l : REAL; r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- sfixed(a downto b) * sfixed(a downto 0) = sfixed(2a+1 downto b) - function "*" (l : UNRESOLVED_sfixed; r : INTEGER) return UNRESOLVED_sfixed; - - -- sfixed(c downto 0) * sfixed(c downto d) = sfixed(2c+1 downto d) - function "*" (l : INTEGER; r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- sfixed(a downto b) / sfixed(a downto b) = sfixed(a-b+1 downto b-a) --- function "/" (l : UNRESOLVED_sfixed; r : REAL) return UNRESOLVED_sfixed; - - -- sfixed(c downto d) / sfixed(c downto d) = sfixed(c-d+1 downto d-c) --- function "/" (l : REAL; r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- sfixed(a downto b) / sfixed(a downto 0) = sfixed(a+1 downto b-a) --- function "/" (l : UNRESOLVED_sfixed; r : INTEGER) return UNRESOLVED_sfixed; - - -- sfixed(c downto 0) / sfixed(c downto d) = sfixed(c-d+1 downto -c) --- function "/" (l : INTEGER; r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- sfixed (a downto b) rem sfixed (a downto b) = sfixed (a downto b) --- function "rem" (l : UNRESOLVED_sfixed; r : REAL) return UNRESOLVED_sfixed; - --- -- sfixed (c downto d) rem sfixed (c downto d) = sfixed (c downto d) --- function "rem" (l : REAL; r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - --- -- sfixed (a downto b) rem sfixed (a downto 0) = sfixed (a downto minimum(b,0)) --- function "rem" (l : UNRESOLVED_sfixed; r : INTEGER) return UNRESOLVED_sfixed; - --- -- sfixed (c downto 0) rem sfixed (c downto d) = sfixed (c downto minimum(d,0)) --- function "rem" (l : INTEGER; r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - --- -- sfixed (a downto b) mod sfixed (a downto b) = sfixed (a downto b) --- function "mod" (l : UNRESOLVED_sfixed; r : REAL) return UNRESOLVED_sfixed; - --- -- sfixed (c downto d) mod sfixed (c downto d) = sfixed (c downto d) --- function "mod" (l : REAL; r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - --- -- sfixed (a downto b) mod sfixed (a downto 0) = sfixed (a downto minimum(b,0)) --- function "mod" (l : UNRESOLVED_sfixed; r : INTEGER) return UNRESOLVED_sfixed; - --- -- sfixed (c downto 0) mod sfixed (c downto d) = sfixed (c downto minimum(d,0)) --- function "mod" (l : INTEGER; r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- This version of divide gives the user more control - -- ufixed(a downto b) / ufixed(c downto d) = ufixed(a-d downto b-c-1) --- function divide ( --- l, r : UNRESOLVED_ufixed; --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_ufixed; - - -- This version of divide gives the user more control - -- sfixed(a downto b) / sfixed(c downto d) = sfixed(a-d+1 downto b-c) --- function divide ( --- l, r : UNRESOLVED_sfixed; --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_sfixed; - - -- These functions return 1/X - -- 1 / ufixed(a downto b) = ufixed(-b downto -a-1) --- function reciprocal ( --- arg : UNRESOLVED_ufixed; -- fixed point input --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_ufixed; - - -- 1 / sfixed(a downto b) = sfixed(-b+1 downto -a) --- function reciprocal ( --- arg : UNRESOLVED_sfixed; -- fixed point input --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_sfixed; - - -- REM function - -- ufixed (a downto b) rem ufixed (c downto d) - -- = ufixed (minimum(a,c) downto minimum(b,d)) --- function remainder ( --- l, r : UNRESOLVED_ufixed; --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_ufixed; - - -- sfixed (a downto b) rem sfixed (c downto d) - -- = sfixed (minimum(a,c) downto minimum(b,d)) --- function remainder ( --- l, r : UNRESOLVED_sfixed; --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_sfixed; - - -- mod function - -- ufixed (a downto b) mod ufixed (c downto d) - -- = ufixed (minimum(a,c) downto minimum(b, d)) --- function modulo ( --- l, r : UNRESOLVED_ufixed; --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_ufixed; - - -- sfixed (a downto b) mod sfixed (c downto d) - -- = sfixed (c downto minimum(b, d)) --- function modulo ( --- l, r : UNRESOLVED_sfixed; --- constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_sfixed; - - -- Procedure for those who need an "accumulator" function. - -- add_carry (ufixed(a downto b), ufixed (c downto d)) - -- = ufixed (maximum(a,c) downto minimum(b,d)) - procedure add_carry ( - L, R : in UNRESOLVED_ufixed; - c_in : in STD_ULOGIC; - result : out UNRESOLVED_ufixed; - c_out : out STD_ULOGIC); - - -- add_carry (sfixed(a downto b), sfixed (c downto d)) - -- = sfixed (maximum(a,c) downto minimum(b,d)) - procedure add_carry ( - L, R : in UNRESOLVED_sfixed; - c_in : in STD_ULOGIC; - result : out UNRESOLVED_sfixed; - c_out : out STD_ULOGIC); - - -- Scales the result by a power of 2. Width of input = width of output with - -- the binary point moved. - function scalb (y : UNRESOLVED_ufixed; N : INTEGER) return UNRESOLVED_ufixed; - function scalb (y : UNRESOLVED_ufixed; N : SIGNED) return UNRESOLVED_ufixed; - function scalb (y : UNRESOLVED_sfixed; N : INTEGER) return UNRESOLVED_sfixed; - function scalb (y : UNRESOLVED_sfixed; N : SIGNED) return UNRESOLVED_sfixed; - - function Is_Negative (arg : UNRESOLVED_sfixed) return BOOLEAN; - - --=========================================================================== - -- Comparison Operators - --=========================================================================== - - function ">" (l, r : UNRESOLVED_ufixed) return BOOLEAN; - function ">" (l, r : UNRESOLVED_sfixed) return BOOLEAN; - function "<" (l, r : UNRESOLVED_ufixed) return BOOLEAN; - function "<" (l, r : UNRESOLVED_sfixed) return BOOLEAN; - function "<=" (l, r : UNRESOLVED_ufixed) return BOOLEAN; - function "<=" (l, r : UNRESOLVED_sfixed) return BOOLEAN; - function ">=" (l, r : UNRESOLVED_ufixed) return BOOLEAN; - function ">=" (l, r : UNRESOLVED_sfixed) return BOOLEAN; - function "=" (l, r : UNRESOLVED_ufixed) return BOOLEAN; - function "=" (l, r : UNRESOLVED_sfixed) return BOOLEAN; - function "/=" (l, r : UNRESOLVED_ufixed) return BOOLEAN; - function "/=" (l, r : UNRESOLVED_sfixed) return BOOLEAN; - - function \?=\ (l, r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?/=\ (l, r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?>\ (l, r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?>=\ (l, r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?<\ (l, r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?<=\ (l, r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?=\ (l, r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?/=\ (l, r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?>\ (l, r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?>=\ (l, r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?<\ (l, r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?<=\ (l, r : UNRESOLVED_sfixed) return STD_ULOGIC; - - function std_match (l, r : UNRESOLVED_ufixed) return BOOLEAN; - function std_match (l, r : UNRESOLVED_sfixed) return BOOLEAN; - - -- Overloads the default "maximum" and "minimum" function - - function maximum (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - function minimum (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - function maximum (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - function minimum (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - ---------------------------------------------------------------------------- - -- In these compare functions a natural is converted into a - -- fixed point number of the bounds "maximum(l'high,0) downto 0" - ---------------------------------------------------------------------------- - - function "=" (l : UNRESOLVED_ufixed; r : NATURAL) return BOOLEAN; - function "/=" (l : UNRESOLVED_ufixed; r : NATURAL) return BOOLEAN; - function ">=" (l : UNRESOLVED_ufixed; r : NATURAL) return BOOLEAN; - function "<=" (l : UNRESOLVED_ufixed; r : NATURAL) return BOOLEAN; - function ">" (l : UNRESOLVED_ufixed; r : NATURAL) return BOOLEAN; - function "<" (l : UNRESOLVED_ufixed; r : NATURAL) return BOOLEAN; - - function "=" (l : NATURAL; r : UNRESOLVED_ufixed) return BOOLEAN; - function "/=" (l : NATURAL; r : UNRESOLVED_ufixed) return BOOLEAN; - function ">=" (l : NATURAL; r : UNRESOLVED_ufixed) return BOOLEAN; - function "<=" (l : NATURAL; r : UNRESOLVED_ufixed) return BOOLEAN; - function ">" (l : NATURAL; r : UNRESOLVED_ufixed) return BOOLEAN; - function "<" (l : NATURAL; r : UNRESOLVED_ufixed) return BOOLEAN; - - function \?=\ (l : UNRESOLVED_ufixed; r : NATURAL) return STD_ULOGIC; - function \?/=\ (l : UNRESOLVED_ufixed; r : NATURAL) return STD_ULOGIC; - function \?>=\ (l : UNRESOLVED_ufixed; r : NATURAL) return STD_ULOGIC; - function \?<=\ (l : UNRESOLVED_ufixed; r : NATURAL) return STD_ULOGIC; - function \?>\ (l : UNRESOLVED_ufixed; r : NATURAL) return STD_ULOGIC; - function \?<\ (l : UNRESOLVED_ufixed; r : NATURAL) return STD_ULOGIC; - - function \?=\ (l : NATURAL; r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?/=\ (l : NATURAL; r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?>=\ (l : NATURAL; r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?<=\ (l : NATURAL; r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?>\ (l : NATURAL; r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?<\ (l : NATURAL; r : UNRESOLVED_ufixed) return STD_ULOGIC; - - function maximum (l : UNRESOLVED_ufixed; r : NATURAL) - return UNRESOLVED_ufixed; - function minimum (l : UNRESOLVED_ufixed; r : NATURAL) - return UNRESOLVED_ufixed; - function maximum (l : NATURAL; r : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed; - function minimum (l : NATURAL; r : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed; - ---------------------------------------------------------------------------- - -- In these compare functions a real is converted into a - -- fixed point number of the bounds "l'high+1 downto l'low" - ---------------------------------------------------------------------------- - - function "=" (l : UNRESOLVED_ufixed; r : REAL) return BOOLEAN; - function "/=" (l : UNRESOLVED_ufixed; r : REAL) return BOOLEAN; - function ">=" (l : UNRESOLVED_ufixed; r : REAL) return BOOLEAN; - function "<=" (l : UNRESOLVED_ufixed; r : REAL) return BOOLEAN; - function ">" (l : UNRESOLVED_ufixed; r : REAL) return BOOLEAN; - function "<" (l : UNRESOLVED_ufixed; r : REAL) return BOOLEAN; - - function "=" (l : REAL; r : UNRESOLVED_ufixed) return BOOLEAN; - function "/=" (l : REAL; r : UNRESOLVED_ufixed) return BOOLEAN; - function ">=" (l : REAL; r : UNRESOLVED_ufixed) return BOOLEAN; - function "<=" (l : REAL; r : UNRESOLVED_ufixed) return BOOLEAN; - function ">" (l : REAL; r : UNRESOLVED_ufixed) return BOOLEAN; - function "<" (l : REAL; r : UNRESOLVED_ufixed) return BOOLEAN; - - function \?=\ (l : UNRESOLVED_ufixed; r : REAL) return STD_ULOGIC; - function \?/=\ (l : UNRESOLVED_ufixed; r : REAL) return STD_ULOGIC; - function \?>=\ (l : UNRESOLVED_ufixed; r : REAL) return STD_ULOGIC; - function \?<=\ (l : UNRESOLVED_ufixed; r : REAL) return STD_ULOGIC; - function \?>\ (l : UNRESOLVED_ufixed; r : REAL) return STD_ULOGIC; - function \?<\ (l : UNRESOLVED_ufixed; r : REAL) return STD_ULOGIC; - - function \?=\ (l : REAL; r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?/=\ (l : REAL; r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?>=\ (l : REAL; r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?<=\ (l : REAL; r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?>\ (l : REAL; r : UNRESOLVED_ufixed) return STD_ULOGIC; - function \?<\ (l : REAL; r : UNRESOLVED_ufixed) return STD_ULOGIC; - - function maximum (l : UNRESOLVED_ufixed; r : REAL) return UNRESOLVED_ufixed; - function maximum (l : REAL; r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - function minimum (l : UNRESOLVED_ufixed; r : REAL) return UNRESOLVED_ufixed; - function minimum (l : REAL; r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - ---------------------------------------------------------------------------- - -- In these compare functions an integer is converted into a - -- fixed point number of the bounds "maximum(l'high,1) downto 0" - ---------------------------------------------------------------------------- - - function "=" (l : UNRESOLVED_sfixed; r : INTEGER) return BOOLEAN; - function "/=" (l : UNRESOLVED_sfixed; r : INTEGER) return BOOLEAN; - function ">=" (l : UNRESOLVED_sfixed; r : INTEGER) return BOOLEAN; - function "<=" (l : UNRESOLVED_sfixed; r : INTEGER) return BOOLEAN; - function ">" (l : UNRESOLVED_sfixed; r : INTEGER) return BOOLEAN; - function "<" (l : UNRESOLVED_sfixed; r : INTEGER) return BOOLEAN; - - function "=" (l : INTEGER; r : UNRESOLVED_sfixed) return BOOLEAN; - function "/=" (l : INTEGER; r : UNRESOLVED_sfixed) return BOOLEAN; - function ">=" (l : INTEGER; r : UNRESOLVED_sfixed) return BOOLEAN; - function "<=" (l : INTEGER; r : UNRESOLVED_sfixed) return BOOLEAN; - function ">" (l : INTEGER; r : UNRESOLVED_sfixed) return BOOLEAN; - function "<" (l : INTEGER; r : UNRESOLVED_sfixed) return BOOLEAN; - - function \?=\ (l : UNRESOLVED_sfixed; r : INTEGER) return STD_ULOGIC; - function \?/=\ (l : UNRESOLVED_sfixed; r : INTEGER) return STD_ULOGIC; - function \?>=\ (l : UNRESOLVED_sfixed; r : INTEGER) return STD_ULOGIC; - function \?<=\ (l : UNRESOLVED_sfixed; r : INTEGER) return STD_ULOGIC; - function \?>\ (l : UNRESOLVED_sfixed; r : INTEGER) return STD_ULOGIC; - function \?<\ (l : UNRESOLVED_sfixed; r : INTEGER) return STD_ULOGIC; - - function \?=\ (l : INTEGER; r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?/=\ (l : INTEGER; r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?>=\ (l : INTEGER; r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?<=\ (l : INTEGER; r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?>\ (l : INTEGER; r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?<\ (l : INTEGER; r : UNRESOLVED_sfixed) return STD_ULOGIC; - - function maximum (l : UNRESOLVED_sfixed; r : INTEGER) - return UNRESOLVED_sfixed; - function maximum (l : INTEGER; r : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed; - function minimum (l : UNRESOLVED_sfixed; r : INTEGER) - return UNRESOLVED_sfixed; - function minimum (l : INTEGER; r : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed; - ---------------------------------------------------------------------------- - -- In these compare functions a real is converted into a - -- fixed point number of the bounds "l'high+1 downto l'low" - ---------------------------------------------------------------------------- - - function "=" (l : UNRESOLVED_sfixed; r : REAL) return BOOLEAN; - function "/=" (l : UNRESOLVED_sfixed; r : REAL) return BOOLEAN; - function ">=" (l : UNRESOLVED_sfixed; r : REAL) return BOOLEAN; - function "<=" (l : UNRESOLVED_sfixed; r : REAL) return BOOLEAN; - function ">" (l : UNRESOLVED_sfixed; r : REAL) return BOOLEAN; - function "<" (l : UNRESOLVED_sfixed; r : REAL) return BOOLEAN; - - function "=" (l : REAL; r : UNRESOLVED_sfixed) return BOOLEAN; - function "/=" (l : REAL; r : UNRESOLVED_sfixed) return BOOLEAN; - function ">=" (l : REAL; r : UNRESOLVED_sfixed) return BOOLEAN; - function "<=" (l : REAL; r : UNRESOLVED_sfixed) return BOOLEAN; - function ">" (l : REAL; r : UNRESOLVED_sfixed) return BOOLEAN; - function "<" (l : REAL; r : UNRESOLVED_sfixed) return BOOLEAN; - - function \?=\ (l : UNRESOLVED_sfixed; r : REAL) return STD_ULOGIC; - function \?/=\ (l : UNRESOLVED_sfixed; r : REAL) return STD_ULOGIC; - function \?>=\ (l : UNRESOLVED_sfixed; r : REAL) return STD_ULOGIC; - function \?<=\ (l : UNRESOLVED_sfixed; r : REAL) return STD_ULOGIC; - function \?>\ (l : UNRESOLVED_sfixed; r : REAL) return STD_ULOGIC; - function \?<\ (l : UNRESOLVED_sfixed; r : REAL) return STD_ULOGIC; - - function \?=\ (l : REAL; r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?/=\ (l : REAL; r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?>=\ (l : REAL; r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?<=\ (l : REAL; r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?>\ (l : REAL; r : UNRESOLVED_sfixed) return STD_ULOGIC; - function \?<\ (l : REAL; r : UNRESOLVED_sfixed) return STD_ULOGIC; - - function maximum (l : UNRESOLVED_sfixed; r : REAL) return UNRESOLVED_sfixed; - function maximum (l : REAL; r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - function minimum (l : UNRESOLVED_sfixed; r : REAL) return UNRESOLVED_sfixed; - function minimum (l : REAL; r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - --=========================================================================== - -- Shift and Rotate Functions. - -- Note that sra and sla are not the same as the BIT_VECTOR version - --=========================================================================== - - function "sll" (ARG : UNRESOLVED_ufixed; COUNT : INTEGER) - return UNRESOLVED_ufixed; - function "srl" (ARG : UNRESOLVED_ufixed; COUNT : INTEGER) - return UNRESOLVED_ufixed; - function "rol" (ARG : UNRESOLVED_ufixed; COUNT : INTEGER) - return UNRESOLVED_ufixed; - function "ror" (ARG : UNRESOLVED_ufixed; COUNT : INTEGER) - return UNRESOLVED_ufixed; - function "sla" (ARG : UNRESOLVED_ufixed; COUNT : INTEGER) - return UNRESOLVED_ufixed; - function "sra" (ARG : UNRESOLVED_ufixed; COUNT : INTEGER) - return UNRESOLVED_ufixed; - function "sll" (ARG : UNRESOLVED_sfixed; COUNT : INTEGER) - return UNRESOLVED_sfixed; - function "srl" (ARG : UNRESOLVED_sfixed; COUNT : INTEGER) - return UNRESOLVED_sfixed; - function "rol" (ARG : UNRESOLVED_sfixed; COUNT : INTEGER) - return UNRESOLVED_sfixed; - function "ror" (ARG : UNRESOLVED_sfixed; COUNT : INTEGER) - return UNRESOLVED_sfixed; - function "sla" (ARG : UNRESOLVED_sfixed; COUNT : INTEGER) - return UNRESOLVED_sfixed; - function "sra" (ARG : UNRESOLVED_sfixed; COUNT : INTEGER) - return UNRESOLVED_sfixed; - function SHIFT_LEFT (ARG : UNRESOLVED_ufixed; COUNT : NATURAL) - return UNRESOLVED_ufixed; - function SHIFT_RIGHT (ARG : UNRESOLVED_ufixed; COUNT : NATURAL) - return UNRESOLVED_ufixed; - function SHIFT_LEFT (ARG : UNRESOLVED_sfixed; COUNT : NATURAL) - return UNRESOLVED_sfixed; - function SHIFT_RIGHT (ARG : UNRESOLVED_sfixed; COUNT : NATURAL) - return UNRESOLVED_sfixed; - - ---------------------------------------------------------------------------- - -- logical functions - ---------------------------------------------------------------------------- - - function "not" (l : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - function "and" (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - function "or" (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - function "nand" (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - function "nor" (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - function "xor" (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - function "xnor" (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - function "not" (l : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - function "and" (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - function "or" (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - function "nand" (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - function "nor" (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - function "xor" (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - function "xnor" (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- Vector and std_ulogic functions, same as functions in numeric_std - function "and" (l : STD_ULOGIC; r : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed; - function "and" (l : UNRESOLVED_ufixed; r : STD_ULOGIC) - return UNRESOLVED_ufixed; - function "or" (l : STD_ULOGIC; r : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed; - function "or" (l : UNRESOLVED_ufixed; r : STD_ULOGIC) - return UNRESOLVED_ufixed; - function "nand" (l : STD_ULOGIC; r : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed; - function "nand" (l : UNRESOLVED_ufixed; r : STD_ULOGIC) - return UNRESOLVED_ufixed; - function "nor" (l : STD_ULOGIC; r : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed; - function "nor" (l : UNRESOLVED_ufixed; r : STD_ULOGIC) - return UNRESOLVED_ufixed; - function "xor" (l : STD_ULOGIC; r : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed; - function "xor" (l : UNRESOLVED_ufixed; r : STD_ULOGIC) - return UNRESOLVED_ufixed; - function "xnor" (l : STD_ULOGIC; r : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed; - function "xnor" (l : UNRESOLVED_ufixed; r : STD_ULOGIC) - return UNRESOLVED_ufixed; - function "and" (l : STD_ULOGIC; r : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed; - function "and" (l : UNRESOLVED_sfixed; r : STD_ULOGIC) - return UNRESOLVED_sfixed; - function "or" (l : STD_ULOGIC; r : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed; - function "or" (l : UNRESOLVED_sfixed; r : STD_ULOGIC) - return UNRESOLVED_sfixed; - function "nand" (l : STD_ULOGIC; r : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed; - function "nand" (l : UNRESOLVED_sfixed; r : STD_ULOGIC) - return UNRESOLVED_sfixed; - function "nor" (l : STD_ULOGIC; r : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed; - function "nor" (l : UNRESOLVED_sfixed; r : STD_ULOGIC) - return UNRESOLVED_sfixed; - function "xor" (l : STD_ULOGIC; r : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed; - function "xor" (l : UNRESOLVED_sfixed; r : STD_ULOGIC) - return UNRESOLVED_sfixed; - function "xnor" (l : STD_ULOGIC; r : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed; - function "xnor" (l : UNRESOLVED_sfixed; r : STD_ULOGIC) - return UNRESOLVED_sfixed; - - -- Reduction operators, same as numeric_std functions - function and_reduce (l : UNRESOLVED_ufixed) return STD_ULOGIC; - function nand_reduce (l : UNRESOLVED_ufixed) return STD_ULOGIC; - function or_reduce (l : UNRESOLVED_ufixed) return STD_ULOGIC; - function nor_reduce (l : UNRESOLVED_ufixed) return STD_ULOGIC; - function xor_reduce (l : UNRESOLVED_ufixed) return STD_ULOGIC; - function xnor_reduce (l : UNRESOLVED_ufixed) return STD_ULOGIC; - function and_reduce (l : UNRESOLVED_sfixed) return STD_ULOGIC; - function nand_reduce (l : UNRESOLVED_sfixed) return STD_ULOGIC; - function or_reduce (l : UNRESOLVED_sfixed) return STD_ULOGIC; - function nor_reduce (l : UNRESOLVED_sfixed) return STD_ULOGIC; - function xor_reduce (l : UNRESOLVED_sfixed) return STD_ULOGIC; - function xnor_reduce (l : UNRESOLVED_sfixed) return STD_ULOGIC; - - -- returns arg'low-1 if not found - function find_leftmost (arg : UNRESOLVED_ufixed; y : STD_ULOGIC) - return INTEGER; - function find_leftmost (arg : UNRESOLVED_sfixed; y : STD_ULOGIC) - return INTEGER; - - -- returns arg'high+1 if not found - function find_rightmost (arg : UNRESOLVED_ufixed; y : STD_ULOGIC) - return INTEGER; - function find_rightmost (arg : UNRESOLVED_sfixed; y : STD_ULOGIC) - return INTEGER; - - --=========================================================================== - -- RESIZE Functions - --=========================================================================== - -- resizes the number (larger or smaller) - -- The returned result will be ufixed (left_index downto right_index) - -- If "round_style" is fixed_round, then the result will be rounded. - -- If the MSB of the remainder is a "1" AND the LSB of the unrounded result - -- is a '1' or the lower bits of the remainder include a '1' then the result - -- will be increased by the smallest representable number for that type. - -- "overflow_style" can be fixed_saturate or fixed_wrap. - -- In saturate mode, if the number overflows then the largest possible - -- representable number is returned. If wrap mode, then the upper bits - -- of the number are truncated. - - function resize ( - arg : UNRESOLVED_ufixed; -- input - constant left_index : INTEGER; -- integer portion - constant right_index : INTEGER; -- size of fraction - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_ufixed; - - -- "size_res" functions create the size of the output from the indices - -- of the "size_res" input. The actual value of "size_res" is not used. - function resize ( - arg : UNRESOLVED_ufixed; -- input - size_res : UNRESOLVED_ufixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_ufixed; - - -- Note that in "wrap" mode the sign bit is not replicated. Thus the - -- resize of a negative number can have a positive result in wrap mode. - function resize ( - arg : UNRESOLVED_sfixed; -- input - constant left_index : INTEGER; -- integer portion - constant right_index : INTEGER; -- size of fraction - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_sfixed; - - function resize ( - arg : UNRESOLVED_sfixed; -- input - size_res : UNRESOLVED_sfixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_sfixed; - - --=========================================================================== - -- Conversion Functions - --=========================================================================== - - -- integer (natural) to unsigned fixed point. - -- arguments are the upper and lower bounds of the number, thus - -- ufixed (7 downto -3) <= to_ufixed (int, 7, -3); - function to_ufixed ( - arg : NATURAL; -- integer - constant left_index : INTEGER; -- left index (high index) - constant right_index : INTEGER := 0; -- right index - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_ufixed; - - function to_ufixed ( - arg : NATURAL; -- integer - size_res : UNRESOLVED_ufixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_ufixed; - - -- real to unsigned fixed point - function to_ufixed ( - arg : REAL; -- real - constant left_index : INTEGER; -- left index (high index) - constant right_index : INTEGER; -- right index - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style; - constant guard_bits : NATURAL := fixed_guard_bits) - return UNRESOLVED_ufixed; - - function to_ufixed ( - arg : REAL; -- real - size_res : UNRESOLVED_ufixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style; - constant guard_bits : NATURAL := fixed_guard_bits) - return UNRESOLVED_ufixed; - - -- unsigned to unsigned fixed point - function to_ufixed ( - arg : UNSIGNED; -- unsigned - constant left_index : INTEGER; -- left index (high index) - constant right_index : INTEGER := 0; -- right index - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_ufixed; - - function to_ufixed ( - arg : UNSIGNED; -- unsigned - size_res : UNRESOLVED_ufixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_ufixed; - - -- Performs a conversion. ufixed (arg'range) is returned - function to_ufixed ( - arg : UNSIGNED) -- unsigned - return UNRESOLVED_ufixed; - - -- unsigned fixed point to unsigned - function to_unsigned ( - arg : UNRESOLVED_ufixed; -- fixed point input - constant size : NATURAL; -- length of output - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNSIGNED; - - -- unsigned fixed point to unsigned - function to_unsigned ( - arg : UNRESOLVED_ufixed; -- fixed point input - size_res : UNSIGNED; -- used for length of output - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNSIGNED; - - -- unsigned fixed point to real - function to_real ( - arg : UNRESOLVED_ufixed) -- fixed point input - return REAL; - - -- unsigned fixed point to integer - function to_integer ( - arg : UNRESOLVED_ufixed; -- fixed point input - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return NATURAL; - - -- Integer to UNRESOLVED_sfixed - function to_sfixed ( - arg : INTEGER; -- integer - constant left_index : INTEGER; -- left index (high index) - constant right_index : INTEGER := 0; -- right index - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_sfixed; - - function to_sfixed ( - arg : INTEGER; -- integer - size_res : UNRESOLVED_sfixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_sfixed; - - -- Real to sfixed - function to_sfixed ( - arg : REAL; -- real - constant left_index : INTEGER; -- left index (high index) - constant right_index : INTEGER; -- right index - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style; - constant guard_bits : NATURAL := fixed_guard_bits) - return UNRESOLVED_sfixed; - - function to_sfixed ( - arg : REAL; -- real - size_res : UNRESOLVED_sfixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style; - constant guard_bits : NATURAL := fixed_guard_bits) - return UNRESOLVED_sfixed; - - -- signed to sfixed - function to_sfixed ( - arg : SIGNED; -- signed - constant left_index : INTEGER; -- left index (high index) - constant right_index : INTEGER := 0; -- right index - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_sfixed; - - function to_sfixed ( - arg : SIGNED; -- signed - size_res : UNRESOLVED_sfixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_sfixed; - - -- signed to sfixed (output assumed to be size of signed input) - function to_sfixed ( - arg : SIGNED) -- signed - return UNRESOLVED_sfixed; - - -- Conversion from ufixed to sfixed - function to_sfixed ( - arg : UNRESOLVED_ufixed) - return UNRESOLVED_sfixed; - - -- signed fixed point to signed - function to_signed ( - arg : UNRESOLVED_sfixed; -- fixed point input - constant size : NATURAL; -- length of output - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return SIGNED; - - -- signed fixed point to signed - function to_signed ( - arg : UNRESOLVED_sfixed; -- fixed point input - size_res : SIGNED; -- used for length of output - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return SIGNED; - - -- signed fixed point to real - function to_real ( - arg : UNRESOLVED_sfixed) -- fixed point input - return REAL; - - -- signed fixed point to integer - function to_integer ( - arg : UNRESOLVED_sfixed; -- fixed point input - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return INTEGER; - - -- Because of the fairly complicated sizing rules in the fixed point - -- packages these functions are provided to compute the result ranges - -- Example: - -- signal uf1 : ufixed (3 downto -3); - -- signal uf2 : ufixed (4 downto -2); - -- signal uf1multuf2 : ufixed (ufixed_high (3, -3, '*', 4, -2) downto - -- ufixed_low (3, -3, '*', 4, -2)); - -- uf1multuf2 <= uf1 * uf2; - -- Valid characters: '+', '-', '*', '/', 'r' or 'R' (rem), 'm' or 'M' (mod), - -- '1' (reciprocal), 'a' or 'A' (abs), 'n' or 'N' (unary -) - function ufixed_high (left_index, right_index : INTEGER; - operation : CHARACTER := 'X'; - left_index2, right_index2 : INTEGER := 0) - return INTEGER; - - function ufixed_low (left_index, right_index : INTEGER; - operation : CHARACTER := 'X'; - left_index2, right_index2 : INTEGER := 0) - return INTEGER; - - function sfixed_high (left_index, right_index : INTEGER; - operation : CHARACTER := 'X'; - left_index2, right_index2 : INTEGER := 0) - return INTEGER; - - function sfixed_low (left_index, right_index : INTEGER; - operation : CHARACTER := 'X'; - left_index2, right_index2 : INTEGER := 0) - return INTEGER; - - -- Same as above, but using the "size_res" input only for their ranges: - -- signal uf1multuf2 : ufixed (ufixed_high (uf1, '*', uf2) downto - -- ufixed_low (uf1, '*', uf2)); - -- uf1multuf2 <= uf1 * uf2; - -- - function ufixed_high (size_res : UNRESOLVED_ufixed; - operation : CHARACTER := 'X'; - size_res2 : UNRESOLVED_ufixed) - return INTEGER; - - function ufixed_low (size_res : UNRESOLVED_ufixed; - operation : CHARACTER := 'X'; - size_res2 : UNRESOLVED_ufixed) - return INTEGER; - - function sfixed_high (size_res : UNRESOLVED_sfixed; - operation : CHARACTER := 'X'; - size_res2 : UNRESOLVED_sfixed) - return INTEGER; - - function sfixed_low (size_res : UNRESOLVED_sfixed; - operation : CHARACTER := 'X'; - size_res2 : UNRESOLVED_sfixed) - return INTEGER; - - -- purpose: returns a saturated number - function saturate ( - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_ufixed; - - -- purpose: returns a saturated number - function saturate ( - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_sfixed; - - function saturate ( - size_res : UNRESOLVED_ufixed) -- only the size of this is used - return UNRESOLVED_ufixed; - - function saturate ( - size_res : UNRESOLVED_sfixed) -- only the size of this is used - return UNRESOLVED_sfixed; - - --=========================================================================== - -- Translation Functions - --=========================================================================== - - -- maps meta-logical values - function to_01 ( - s : UNRESOLVED_ufixed; -- fixed point input - constant XMAP : STD_ULOGIC := '0') -- Map x to - return UNRESOLVED_ufixed; - - -- maps meta-logical values - function to_01 ( - s : UNRESOLVED_sfixed; -- fixed point input - constant XMAP : STD_ULOGIC := '0') -- Map x to - return UNRESOLVED_sfixed; - - function Is_X (arg : UNRESOLVED_ufixed) return BOOLEAN; - function Is_X (arg : UNRESOLVED_sfixed) return BOOLEAN; - function to_X01 (arg : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - function to_X01 (arg : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - function to_X01Z (arg : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - function to_X01Z (arg : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - function to_UX01 (arg : UNRESOLVED_ufixed) return UNRESOLVED_ufixed; - function to_UX01 (arg : UNRESOLVED_sfixed) return UNRESOLVED_sfixed; - - -- straight vector conversion routines, needed for synthesis. - -- These functions are here so that a std_logic_vector can be - -- converted to and from sfixed and ufixed. Note that you can - -- not convert these vectors because of their negative index. - - function to_slv ( - arg : UNRESOLVED_ufixed) -- fixed point vector - return STD_LOGIC_VECTOR; --- alias to_StdLogicVector is to_slv [UNRESOLVED_ufixed --- return STD_LOGIC_VECTOR]; --- alias to_Std_Logic_Vector is to_slv [UNRESOLVED_ufixed --- return STD_LOGIC_VECTOR]; - - function to_slv ( - arg : UNRESOLVED_sfixed) -- fixed point vector - return STD_LOGIC_VECTOR; --- alias to_StdLogicVector is to_slv [UNRESOLVED_sfixed --- return STD_LOGIC_VECTOR]; --- alias to_Std_Logic_Vector is to_slv [UNRESOLVED_sfixed --- return STD_LOGIC_VECTOR]; - - function to_sulv ( - arg : UNRESOLVED_ufixed) -- fixed point vector - return STD_ULOGIC_VECTOR; --- alias to_StdULogicVector is to_sulv [UNRESOLVED_ufixed --- return STD_ULOGIC_VECTOR]; --- alias to_Std_ULogic_Vector is to_sulv [UNRESOLVED_ufixed --- return STD_ULOGIC_VECTOR]; - - function to_sulv ( - arg : UNRESOLVED_sfixed) -- fixed point vector - return STD_ULOGIC_VECTOR; --- alias to_StdULogicVector is to_sulv [UNRESOLVED_sfixed --- return STD_ULOGIC_VECTOR]; --- alias to_Std_ULogic_Vector is to_sulv [UNRESOLVED_sfixed --- return STD_ULOGIC_VECTOR]; - - function to_ufixed ( - arg : STD_ULOGIC_VECTOR; -- shifted vector - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_ufixed; - - function to_ufixed ( - arg : STD_ULOGIC_VECTOR; -- shifted vector - size_res : UNRESOLVED_ufixed) -- for size only - return UNRESOLVED_ufixed; - - function to_sfixed ( - arg : STD_ULOGIC_VECTOR; -- shifted vector - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_sfixed; - - function to_sfixed ( - arg : STD_ULOGIC_VECTOR; -- shifted vector - size_res : UNRESOLVED_sfixed) -- for size only - return UNRESOLVED_sfixed; - - -- As a concession to those who use a graphical DSP environment, - -- these functions take parameters in those tools format and create - -- fixed point numbers. These functions are designed to convert from - -- a std_logic_vector to the VHDL fixed point format using the conventions - -- of these packages. In a pure VHDL environment you should use the - -- "to_ufixed" and "to_sfixed" routines. - - -- unsigned fixed point - function to_UFix ( - arg : STD_ULOGIC_VECTOR; - width : NATURAL; -- width of vector - fraction : NATURAL) -- width of fraction - return UNRESOLVED_ufixed; - - -- signed fixed point - function to_SFix ( - arg : STD_ULOGIC_VECTOR; - width : NATURAL; -- width of vector - fraction : NATURAL) -- width of fraction - return UNRESOLVED_sfixed; - - -- finding the bounds of a number. These functions can be used like this: - -- signal xxx : ufixed (7 downto -3); - -- -- Which is the same as "ufixed (UFix_high (11,3) downto UFix_low(11,3))" - -- signal yyy : ufixed (UFix_high (11, 3, "+", 11, 3) - -- downto UFix_low(11, 3, "+", 11, 3)); - -- Where "11" is the width of xxx (xxx'length), - -- and 3 is the lower bound (abs (xxx'low)) - -- In a pure VHDL environment use "ufixed_high" and "ufixed_low" - - function UFix_high (width, fraction : NATURAL; - operation : CHARACTER := 'X'; - width2, fraction2 : NATURAL := 0) - return INTEGER; - - function UFix_low (width, fraction : NATURAL; - operation : CHARACTER := 'X'; - width2, fraction2 : NATURAL := 0) - return INTEGER; - - -- Same as above but for signed fixed point. Note that the width - -- of a signed fixed point number ignores the sign bit, thus - -- width = sxxx'length-1 - - function SFix_high (width, fraction : NATURAL; - operation : CHARACTER := 'X'; - width2, fraction2 : NATURAL := 0) - return INTEGER; - - function SFix_low (width, fraction : NATURAL; - operation : CHARACTER := 'X'; - width2, fraction2 : NATURAL := 0) - return INTEGER; --- rtl_synthesis off --- pragma synthesis_off - --=========================================================================== - -- string and textio Functions - --=========================================================================== - - -- purpose: writes fixed point into a line - procedure WRITE ( - L : inout LINE; -- input line - VALUE : in UNRESOLVED_ufixed; -- fixed point input - JUSTIFIED : in SIDE := right; - FIELD : in WIDTH := 0); - - -- purpose: writes fixed point into a line - procedure WRITE ( - L : inout LINE; -- input line - VALUE : in UNRESOLVED_sfixed; -- fixed point input - JUSTIFIED : in SIDE := right; - FIELD : in WIDTH := 0); - - procedure READ(L : inout LINE; - VALUE : out UNRESOLVED_ufixed); - - procedure READ(L : inout LINE; - VALUE : out UNRESOLVED_ufixed; - GOOD : out BOOLEAN); - - procedure READ(L : inout LINE; - VALUE : out UNRESOLVED_sfixed); - - procedure READ(L : inout LINE; - VALUE : out UNRESOLVED_sfixed; - GOOD : out BOOLEAN); - - alias bwrite is WRITE [LINE, UNRESOLVED_ufixed, SIDE, width]; - alias bwrite is WRITE [LINE, UNRESOLVED_sfixed, SIDE, width]; - alias bread is READ [LINE, UNRESOLVED_ufixed]; - alias bread is READ [LINE, UNRESOLVED_ufixed, BOOLEAN]; - alias bread is READ [LINE, UNRESOLVED_sfixed]; - alias bread is READ [LINE, UNRESOLVED_sfixed, BOOLEAN]; - alias BINARY_WRITE is WRITE [LINE, UNRESOLVED_ufixed, SIDE, width]; - alias BINARY_WRITE is WRITE [LINE, UNRESOLVED_sfixed, SIDE, width]; - alias BINARY_READ is READ [LINE, UNRESOLVED_ufixed, BOOLEAN]; - alias BINARY_READ is READ [LINE, UNRESOLVED_ufixed]; - alias BINARY_READ is READ [LINE, UNRESOLVED_sfixed, BOOLEAN]; - alias BINARY_READ is READ [LINE, UNRESOLVED_sfixed]; - - -- octal read and write - procedure OWRITE ( - L : inout LINE; -- input line - VALUE : in UNRESOLVED_ufixed; -- fixed point input - JUSTIFIED : in SIDE := right; - FIELD : in WIDTH := 0); - - procedure OWRITE ( - L : inout LINE; -- input line - VALUE : in UNRESOLVED_sfixed; -- fixed point input - JUSTIFIED : in SIDE := right; - FIELD : in WIDTH := 0); - - procedure OREAD(L : inout LINE; - VALUE : out UNRESOLVED_ufixed); - - procedure OREAD(L : inout LINE; - VALUE : out UNRESOLVED_ufixed; - GOOD : out BOOLEAN); - - procedure OREAD(L : inout LINE; - VALUE : out UNRESOLVED_sfixed); - - procedure OREAD(L : inout LINE; - VALUE : out UNRESOLVED_sfixed; - GOOD : out BOOLEAN); - alias OCTAL_READ is OREAD [LINE, UNRESOLVED_ufixed, BOOLEAN]; - alias OCTAL_READ is OREAD [LINE, UNRESOLVED_ufixed]; - alias OCTAL_READ is OREAD [LINE, UNRESOLVED_sfixed, BOOLEAN]; - alias OCTAL_READ is OREAD [LINE, UNRESOLVED_sfixed]; - alias OCTAL_WRITE is OWRITE [LINE, UNRESOLVED_ufixed, SIDE, WIDTH]; - alias OCTAL_WRITE is OWRITE [LINE, UNRESOLVED_sfixed, SIDE, WIDTH]; - - -- hex read and write - procedure HWRITE ( - L : inout LINE; -- input line - VALUE : in UNRESOLVED_ufixed; -- fixed point input - JUSTIFIED : in SIDE := right; - FIELD : in WIDTH := 0); - - -- purpose: writes fixed point into a line - procedure HWRITE ( - L : inout LINE; -- input line - VALUE : in UNRESOLVED_sfixed; -- fixed point input - JUSTIFIED : in SIDE := right; - FIELD : in WIDTH := 0); - - procedure HREAD(L : inout LINE; - VALUE : out UNRESOLVED_ufixed); - - procedure HREAD(L : inout LINE; - VALUE : out UNRESOLVED_ufixed; - GOOD : out BOOLEAN); - - procedure HREAD(L : inout LINE; - VALUE : out UNRESOLVED_sfixed); - - procedure HREAD(L : inout LINE; - VALUE : out UNRESOLVED_sfixed; - GOOD : out BOOLEAN); - alias HEX_READ is HREAD [LINE, UNRESOLVED_ufixed, BOOLEAN]; - alias HEX_READ is HREAD [LINE, UNRESOLVED_sfixed, BOOLEAN]; - alias HEX_READ is HREAD [LINE, UNRESOLVED_ufixed]; - alias HEX_READ is HREAD [LINE, UNRESOLVED_sfixed]; - alias HEX_WRITE is HWRITE [LINE, UNRESOLVED_ufixed, SIDE, WIDTH]; - alias HEX_WRITE is HWRITE [LINE, UNRESOLVED_sfixed, SIDE, WIDTH]; - - -- returns a string, useful for: - -- assert (x = y) report "error found " & to_string(x) severity error; - function to_string (value : UNRESOLVED_ufixed) return STRING; - alias to_bstring is to_string [UNRESOLVED_ufixed return STRING]; - alias TO_BINARY_STRING is TO_STRING [UNRESOLVED_ufixed return STRING]; - - function to_ostring (value : UNRESOLVED_ufixed) return STRING; - alias TO_OCTAL_STRING is TO_OSTRING [UNRESOLVED_ufixed return STRING]; - - function to_hstring (value : UNRESOLVED_ufixed) return STRING; - alias TO_HEX_STRING is TO_HSTRING [UNRESOLVED_ufixed return STRING]; - - function to_string (value : UNRESOLVED_sfixed) return STRING; - alias to_bstring is to_string [UNRESOLVED_sfixed return STRING]; - alias TO_BINARY_STRING is TO_STRING [UNRESOLVED_sfixed return STRING]; - - function to_ostring (value : UNRESOLVED_sfixed) return STRING; - alias TO_OCTAL_STRING is TO_OSTRING [UNRESOLVED_sfixed return STRING]; - - function to_hstring (value : UNRESOLVED_sfixed) return STRING; - alias TO_HEX_STRING is TO_HSTRING [UNRESOLVED_sfixed return STRING]; - - -- From string functions allow you to convert a string into a fixed - -- point number. Example: - -- signal uf1 : ufixed (3 downto -3); - -- uf1 <= from_string ("0110.100", uf1'high, uf1'low); -- 6.5 - -- The "." is optional in this syntax, however it exist and is - -- in the wrong location an error is produced. Overflow will - -- result in saturation. - - function from_string ( - bstring : STRING; -- binary string - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_ufixed; - alias from_bstring is from_string [STRING, INTEGER, INTEGER - return UNRESOLVED_ufixed]; - alias from_binary_string is from_string [STRING, INTEGER, INTEGER - return UNRESOLVED_ufixed]; - - -- Octal and hex conversions work as follows: - -- uf1 <= from_hstring ("6.8", 3, -3); -- 6.5 (bottom zeros dropped) - -- uf1 <= from_ostring ("06.4", 3, -3); -- 6.5 (top zeros dropped) - - function from_ostring ( - ostring : STRING; -- Octal string - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_ufixed; - alias from_octal_string is from_ostring [STRING, INTEGER, INTEGER - return UNRESOLVED_ufixed]; - - function from_hstring ( - hstring : STRING; -- hex string - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_ufixed; - alias from_hex_string is from_hstring [STRING, INTEGER, INTEGER - return UNRESOLVED_ufixed]; - - function from_string ( - bstring : STRING; -- binary string - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_sfixed; - alias from_bstring is from_string [STRING, INTEGER, INTEGER - return UNRESOLVED_sfixed]; - alias from_binary_string is from_string [STRING, INTEGER, INTEGER - return UNRESOLVED_sfixed]; - - function from_ostring ( - ostring : STRING; -- Octal string - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_sfixed; - alias from_octal_string is from_ostring [STRING, INTEGER, INTEGER - return UNRESOLVED_sfixed]; - - function from_hstring ( - hstring : STRING; -- hex string - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_sfixed; - alias from_hex_string is from_hstring [STRING, INTEGER, INTEGER - return UNRESOLVED_sfixed]; - - -- Same as above, "size_res" is used for it's range only. - function from_string ( - bstring : STRING; -- binary string - size_res : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed; - alias from_bstring is from_string [STRING, UNRESOLVED_ufixed - return UNRESOLVED_ufixed]; - alias from_binary_string is from_string [STRING, UNRESOLVED_ufixed - return UNRESOLVED_ufixed]; - - function from_ostring ( - ostring : STRING; -- Octal string - size_res : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed; - alias from_octal_string is from_ostring [STRING, UNRESOLVED_ufixed - return UNRESOLVED_ufixed]; - - function from_hstring ( - hstring : STRING; -- hex string - size_res : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed; - alias from_hex_string is from_hstring [STRING, UNRESOLVED_ufixed - return UNRESOLVED_ufixed]; - - function from_string ( - bstring : STRING; -- binary string - size_res : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed; - alias from_bstring is from_string [STRING, UNRESOLVED_sfixed - return UNRESOLVED_sfixed]; - alias from_binary_string is from_string [STRING, UNRESOLVED_sfixed - return UNRESOLVED_sfixed]; - - function from_ostring ( - ostring : STRING; -- Octal string - size_res : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed; - alias from_octal_string is from_ostring [STRING, UNRESOLVED_sfixed - return UNRESOLVED_sfixed]; - - function from_hstring ( - hstring : STRING; -- hex string - size_res : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed; - alias from_hex_string is from_hstring [STRING, UNRESOLVED_sfixed - return UNRESOLVED_sfixed]; - - -- Direct conversion functions. Example: - -- signal uf1 : ufixed (3 downto -3); - -- uf1 <= from_string ("0110.100"); -- 6.5 - -- In this case the "." is not optional, and the size of - -- the output must match exactly. - - function from_string ( - bstring : STRING) -- binary string - return UNRESOLVED_ufixed; - alias from_bstring is from_string [STRING return UNRESOLVED_ufixed]; - alias from_binary_string is from_string [STRING return UNRESOLVED_ufixed]; - - -- Direct octal and hex conversion functions. In this case - -- the string lengths must match. Example: - -- signal sf1 := sfixed (5 downto -3); - -- sf1 <= from_ostring ("71.4") -- -6.5 - - function from_ostring ( - ostring : STRING) -- Octal string - return UNRESOLVED_ufixed; - alias from_octal_string is from_ostring [STRING return UNRESOLVED_ufixed]; - - function from_hstring ( - hstring : STRING) -- hex string - return UNRESOLVED_ufixed; - alias from_hex_string is from_hstring [STRING return UNRESOLVED_ufixed]; - - function from_string ( - bstring : STRING) -- binary string - return UNRESOLVED_sfixed; - alias from_bstring is from_string [STRING return UNRESOLVED_sfixed]; - alias from_binary_string is from_string [STRING return UNRESOLVED_sfixed]; - - function from_ostring ( - ostring : STRING) -- Octal string - return UNRESOLVED_sfixed; - alias from_octal_string is from_ostring [STRING return UNRESOLVED_sfixed]; - - function from_hstring ( - hstring : STRING) -- hex string - return UNRESOLVED_sfixed; - alias from_hex_string is from_hstring [STRING return UNRESOLVED_sfixed]; --- rtl_synthesis on --- pragma synthesis_on - - -- IN VHDL-2006 std_logic_vector is a subtype of std_ulogic_vector, so these - -- extra functions are needed for compatability. - function to_ufixed ( - arg : STD_LOGIC_VECTOR; -- shifted vector - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_ufixed; - - function to_ufixed ( - arg : STD_LOGIC_VECTOR; -- shifted vector - size_res : UNRESOLVED_ufixed) -- for size only - return UNRESOLVED_ufixed; - - function to_sfixed ( - arg : STD_LOGIC_VECTOR; -- shifted vector - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_sfixed; - - function to_sfixed ( - arg : STD_LOGIC_VECTOR; -- shifted vector - size_res : UNRESOLVED_sfixed) -- for size only - return UNRESOLVED_sfixed; - - -- unsigned fixed point - function to_UFix ( - arg : STD_LOGIC_VECTOR; - width : NATURAL; -- width of vector - fraction : NATURAL) -- width of fraction - return UNRESOLVED_ufixed; - - -- signed fixed point - function to_SFix ( - arg : STD_LOGIC_VECTOR; - width : NATURAL; -- width of vector - fraction : NATURAL) -- width of fraction - return UNRESOLVED_sfixed; - -end package fixed_pkg; -------------------------------------------------------------------------------- --- Proposed package body for the VHDL-200x-FT fixed_pkg package --- (Fixed point math package) --- This package body supplies a recommended implementation of these functions --- Version : $Revision: 1.21 $ --- Date : $Date: 2007/09/26 18:08:53 $ --- --- Created for VHDL-200X-ft, David Bishop (dbishop@vhdl.org) -------------------------------------------------------------------------------- -library IEEE; -use IEEE.MATH_REAL.all; - -package body fixed_pkg is - -- Author David Bishop (dbishop@vhdl.org) - -- Other contributers: Jim Lewis, Yannick Grugni, Ryan W. Hilton - -- null array constants - constant NAUF : UNRESOLVED_ufixed (0 downto 1) := (others => '0'); - constant NASF : UNRESOLVED_sfixed (0 downto 1) := (others => '0'); - constant NSLV : STD_ULOGIC_VECTOR (0 downto 1) := (others => '0'); - - -- This differed constant will tell you if the package body is synthesizable - -- or implemented as real numbers, set to "true" if synthesizable. - constant fixedsynth_or_real : BOOLEAN := true; - - -- %%% Replicated functions - function maximum ( - l, r : integer) -- inputs - return integer is - begin -- function max - if l > r then return l; - else return r; - end if; - end function maximum; - - function minimum ( - l, r : integer) -- inputs - return integer is - begin -- function min - if l > r then return r; - else return l; - end if; - end function minimum; - - function "sra" (arg : SIGNED; count : INTEGER) - return SIGNED is - begin - if (COUNT >= 0) then - return SHIFT_RIGHT(arg, count); - else - return SHIFT_LEFT(arg, -count); - end if; - end function "sra"; - - function or_reduce (arg : STD_ULOGIC_VECTOR) - return STD_LOGIC is - variable Upper, Lower : STD_ULOGIC; - variable Half : INTEGER; - variable BUS_int : STD_ULOGIC_VECTOR (arg'length - 1 downto 0); - variable Result : STD_ULOGIC; - begin - if (arg'length < 1) then -- In the case of a NULL range - Result := '0'; - else - BUS_int := to_ux01 (arg); - if (BUS_int'length = 1) then - Result := BUS_int (BUS_int'left); - elsif (BUS_int'length = 2) then - Result := BUS_int (BUS_int'right) or BUS_int (BUS_int'left); - else - Half := (BUS_int'length + 1) / 2 + BUS_int'right; - Upper := or_reduce (BUS_int (BUS_int'left downto Half)); - Lower := or_reduce (BUS_int (Half - 1 downto BUS_int'right)); - Result := Upper or Lower; - end if; - end if; - return Result; - end function or_reduce; - - -- purpose: AND all of the bits in a vector together - -- This is a copy of the proposed "and_reduce" from 1076.3 - function and_reduce (arg : STD_ULOGIC_VECTOR) - return STD_LOGIC is - variable Upper, Lower : STD_ULOGIC; - variable Half : INTEGER; - variable BUS_int : STD_ULOGIC_VECTOR (arg'length - 1 downto 0); - variable Result : STD_ULOGIC; - begin - if (arg'length < 1) then -- In the case of a NULL range - Result := '1'; - else - BUS_int := to_ux01 (arg); - if (BUS_int'length = 1) then - Result := BUS_int (BUS_int'left); - elsif (BUS_int'length = 2) then - Result := BUS_int (BUS_int'right) and BUS_int (BUS_int'left); - else - Half := (BUS_int'length + 1) / 2 + BUS_int'right; - Upper := and_reduce (BUS_int (BUS_int'left downto Half)); - Lower := and_reduce (BUS_int (Half - 1 downto BUS_int'right)); - Result := Upper and Lower; - end if; - end if; - return Result; - end function and_reduce; - - function xor_reduce (arg : STD_ULOGIC_VECTOR) return STD_ULOGIC is - variable Upper, Lower : STD_ULOGIC; - variable Half : INTEGER; - variable BUS_int : STD_ULOGIC_VECTOR (arg'length - 1 downto 0); - variable Result : STD_ULOGIC := '0'; -- In the case of a NULL range - begin - if (arg'length >= 1) then - BUS_int := to_ux01 (arg); - if (BUS_int'length = 1) then - Result := BUS_int (BUS_int'left); - elsif (BUS_int'length = 2) then - Result := BUS_int(BUS_int'right) xor BUS_int(BUS_int'left); - else - Half := (BUS_int'length + 1) / 2 + BUS_int'right; - Upper := xor_reduce (BUS_int (BUS_int'left downto Half)); - Lower := xor_reduce (BUS_int (Half - 1 downto BUS_int'right)); - Result := Upper xor Lower; - end if; - end if; - return Result; - end function xor_reduce; - - function nand_reduce(arg : std_ulogic_vector) return STD_ULOGIC is - begin - return not and_reduce (arg); - end function nand_reduce; - function nor_reduce(arg : std_ulogic_vector) return STD_ULOGIC is - begin - return not or_reduce (arg); - end function nor_reduce; - function xnor_reduce(arg : std_ulogic_vector) return STD_ULOGIC is - begin - return not xor_reduce (arg); - end function xnor_reduce; - -- Match table, copied form new std_logic_1164 --- type stdlogic_table is array(STD_ULOGIC, STD_ULOGIC) of STD_ULOGIC; --- constant match_logic_table : stdlogic_table := ( --- ----------------------------------------------------- --- -- U X 0 1 Z W L H - | | --- ----------------------------------------------------- --- ('U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', '1'), -- | U | --- ('U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', '1'), -- | X | --- ('U', 'X', '1', '0', 'X', 'X', '1', '0', '1'), -- | 0 | --- ('U', 'X', '0', '1', 'X', 'X', '0', '1', '1'), -- | 1 | --- ('U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', '1'), -- | Z | --- ('U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', '1'), -- | W | --- ('U', 'X', '1', '0', 'X', 'X', '1', '0', '1'), -- | L | --- ('U', 'X', '0', '1', 'X', 'X', '0', '1', '1'), -- | H | --- ('1', '1', '1', '1', '1', '1', '1', '1', '1') -- | - | --- ); - --- constant no_match_logic_table : stdlogic_table := ( --- ----------------------------------------------------- --- -- U X 0 1 Z W L H - | | --- ----------------------------------------------------- --- ('U', 'U', 'U', 'U', 'U', 'U', 'U', 'U', '0'), -- | U | --- ('U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', '0'), -- | X | --- ('U', 'X', '0', '1', 'X', 'X', '0', '1', '0'), -- | 0 | --- ('U', 'X', '1', '0', 'X', 'X', '1', '0', '0'), -- | 1 | --- ('U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', '0'), -- | Z | --- ('U', 'X', 'X', 'X', 'X', 'X', 'X', 'X', '0'), -- | W | --- ('U', 'X', '0', '1', 'X', 'X', '0', '1', '0'), -- | L | --- ('U', 'X', '1', '0', 'X', 'X', '1', '0', '0'), -- | H | --- ('0', '0', '0', '0', '0', '0', '0', '0', '0') -- | - | --- ); - - ------------------------------------------------------------------- - -- ?= functions, Similar to "std_match", but returns "std_ulogic". - ------------------------------------------------------------------- - function \?=\ (l, r : STD_ULOGIC) return STD_ULOGIC is - variable lx, rx : STD_ULOGIC; - begin --- return match_logic_table (l, r); - lx := to_x01(l); - rx := to_x01(r); - if lx = 'X' or rx = 'X' then - return 'X'; - elsif lx = rx then - return '1'; - else - return '0'; - end if; - end function \?=\; - function \?/=\ (l, r : STD_ULOGIC) return STD_ULOGIC is - begin --- return no_match_logic_table (l, r); - return not \?=\ (l, r); - end function \?/=\; - -- "?=" operator is similar to "std_match", but returns a std_ulogic.. - -- Id: M.2B - function \?=\ (L, R: UNSIGNED) return STD_ULOGIC is - constant L_LEFT : INTEGER := L'LENGTH-1; - constant R_LEFT : INTEGER := R'LENGTH-1; - alias XL : UNSIGNED(L_LEFT downto 0) is L; - alias XR : UNSIGNED(R_LEFT downto 0) is R; - constant SIZE : NATURAL := MAXIMUM(L'LENGTH, R'LENGTH); - variable LX : UNSIGNED(SIZE-1 downto 0); - variable RX : UNSIGNED(SIZE-1 downto 0); - variable result, result1 : STD_ULOGIC; -- result - begin - -- Logically identical to an "=" operator. - if ((L'LENGTH < 1) or (R'LENGTH < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?="": null detected, returning X" - severity warning; - return 'X'; - else - LX := RESIZE(XL, SIZE); - RX := RESIZE(XR, SIZE); - result := '1'; - for i in LX'low to LX'high loop - result1 := \?=\(LX(i), RX(i)); - if result1 = 'U' then - return 'U'; - elsif result1 = 'X' or result = 'X' then - result := 'X'; - else - result := result and result1; - end if; - end loop; - return result; - end if; - end function \?=\; - - -- Id: M.3B - function \?=\ (L, R: SIGNED) return std_ulogic is - constant L_LEFT : INTEGER := L'LENGTH-1; - constant R_LEFT : INTEGER := R'LENGTH-1; - alias XL : SIGNED(L_LEFT downto 0) is L; - alias XR : SIGNED(R_LEFT downto 0) is R; - constant SIZE : NATURAL := MAXIMUM(L'LENGTH, R'LENGTH); - variable LX : SIGNED(SIZE-1 downto 0); - variable RX : SIGNED(SIZE-1 downto 0); - variable result, result1 : STD_ULOGIC; -- result - begin -- ?= - if ((L'LENGTH < 1) or (R'LENGTH < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?="": null detected, returning X" - severity warning; - return 'X'; - else - LX := RESIZE(XL, SIZE); - RX := RESIZE(XR, SIZE); - result := '1'; - for i in LX'low to LX'high loop - result1 := \?=\ (LX(i), RX(i)); - if result1 = 'U' then - return 'U'; - elsif result1 = 'X' or result = 'X' then - result := 'X'; - else - result := result and result1; - end if; - end loop; - return result; - end if; - end function \?=\; - - function \?/=\ (L, R : UNSIGNED) return std_ulogic is - constant L_LEFT : INTEGER := L'LENGTH-1; - constant R_LEFT : INTEGER := R'LENGTH-1; - alias XL : UNSIGNED(L_LEFT downto 0) is L; - alias XR : UNSIGNED(R_LEFT downto 0) is R; - constant SIZE : NATURAL := MAXIMUM(L'LENGTH, R'LENGTH); - variable LX : UNSIGNED(SIZE-1 downto 0); - variable RX : UNSIGNED(SIZE-1 downto 0); - variable result, result1 : STD_ULOGIC; -- result - begin -- ?= - if ((L'LENGTH < 1) or (R'LENGTH < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?/="": null detected, returning X" - severity warning; - return 'X'; - else - LX := RESIZE(XL, SIZE); - RX := RESIZE(XR, SIZE); - result := '0'; - for i in LX'low to LX'high loop - result1 := \?/=\ (LX(i), RX(i)); - if result1 = 'U' then - return 'U'; - elsif result1 = 'X' or result = 'X' then - result := 'X'; - else - result := result or result1; - end if; - end loop; - return result; - end if; - end function \?/=\; - - function \?/=\ (L, R : SIGNED) return std_ulogic is - constant L_LEFT : INTEGER := L'LENGTH-1; - constant R_LEFT : INTEGER := R'LENGTH-1; - alias XL : SIGNED(L_LEFT downto 0) is L; - alias XR : SIGNED(R_LEFT downto 0) is R; - constant SIZE : NATURAL := MAXIMUM(L'LENGTH, R'LENGTH); - variable LX : SIGNED(SIZE-1 downto 0); - variable RX : SIGNED(SIZE-1 downto 0); - variable result, result1 : STD_ULOGIC; -- result - begin -- ?= - if ((L'LENGTH < 1) or (R'LENGTH < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?/="": null detected, returning X" - severity warning; - return 'X'; - else - LX := RESIZE(XL, SIZE); - RX := RESIZE(XR, SIZE); - result := '0'; - for i in LX'low to LX'high loop - result1 := \?/=\ (LX(i), RX(i)); - if result1 = 'U' then - return 'U'; - elsif result1 = 'X' or result = 'X' then - result := 'X'; - else - result := result or result1; - end if; - end loop; - return result; - end if; - end function \?/=\; - - function Is_X ( s : UNSIGNED ) return BOOLEAN is - begin - return Is_X (STD_LOGIC_VECTOR (s)); - end function Is_X; - - function Is_X ( s : SIGNED ) return BOOLEAN is - begin - return Is_X (STD_LOGIC_VECTOR (s)); - end function Is_X; - function \?>\ (L, R : UNSIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?>"": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?>"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?>"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l > r then - return '1'; - else - return '0'; - end if; - end if; - end function \?>\; - -- %%% function "?>" (L, R : UNSIGNED) return std_ulogic is - -- %%% end function "?>"\; - function \?>\ (L, R : SIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?>"": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?>"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?>"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l > r then - return '1'; - else - return '0'; - end if; - end if; - end function \?>\; - function \?>=\ (L, R : UNSIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?>="": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?>="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?>="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l >= r then - return '1'; - else - return '0'; - end if; - end if; - end function \?>=\; - -- %%% function "?>=" (L, R : UNSIGNED) return std_ulogic is - -- %%% end function "?>="; - function \?>=\ (L, R : SIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?>="": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?>="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?>="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l >= r then - return '1'; - else - return '0'; - end if; - end if; - end function \?>=\; - function \?<\ (L, R : UNSIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?<"": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?<"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?<"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l < r then - return '1'; - else - return '0'; - end if; - end if; - end function \?<\; - -- %%% function "?<" (L, R : UNSIGNED) return std_ulogic is - -- %%% end function "?<"; - function \?<\ (L, R : SIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?<"": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?<"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?<"": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l < r then - return '1'; - else - return '0'; - end if; - end if; - end function \?<\; - function \?<=\ (L, R : UNSIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?<="": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?<="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?<="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l <= r then - return '1'; - else - return '0'; - end if; - end if; - end function \?<=\; - -- %%% function "?<=" (L, R : UNSIGNED) return std_ulogic is - -- %%% end function "?<="; - function \?<=\ (L, R : SIGNED) return STD_ULOGIC is - begin - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "NUMERIC_STD.""?<="": null detected, returning X" - severity warning; - return 'X'; - else - for i in L'range loop - if L(i) = '-' then - report "NUMERIC_STD.""?<="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - for i in R'range loop - if R(i) = '-' then - report "NUMERIC_STD.""?<="": '-' found in compare string" - severity error; - return 'X'; - end if; - end loop; - if is_x(l) or is_x(r) then - return 'X'; - elsif l <= r then - return '1'; - else - return '0'; - end if; - end if; - end function \?<=\; - --- %%% END replicated functions - -- Special version of "minimum" to do some boundary checking without errors - function mins (l, r : INTEGER) - return INTEGER is - begin -- function mins - if (L = INTEGER'low or R = INTEGER'low) then - return 0; -- error condition, silent - end if; - return minimum (L, R); - end function mins; - - -- Special version of "minimum" to do some boundary checking with errors - function mine (l, r : INTEGER) - return INTEGER is - begin -- function mine - if (L = INTEGER'low or R = INTEGER'low) then - report "fixed_pkg:" - & " Unbounded number passed, was a literal used?" - severity error; - return 0; - end if; - return minimum (L, R); - end function mine; - - -- The following functions are used only internally. Every function - -- calls "cleanvec" either directly or indirectly. - -- purpose: Fixes "downto" problem and resolves meta states - function cleanvec ( - arg : UNRESOLVED_sfixed) -- input - return UNRESOLVED_sfixed is - constant left_index : INTEGER := maximum(arg'left, arg'right); - constant right_index : INTEGER := mins(arg'left, arg'right); - variable result : UNRESOLVED_sfixed (arg'range); - begin -- function cleanvec - assert not (arg'ascending and (arg'low /= INTEGER'low)) - report "fixed_pkg:" - & " Vector passed using a ""to"" range, expected is ""downto""" - severity error; - return arg; - end function cleanvec; - - -- purpose: Fixes "downto" problem and resolves meta states - function cleanvec ( - arg : UNRESOLVED_ufixed) -- input - return UNRESOLVED_ufixed is - constant left_index : INTEGER := maximum(arg'left, arg'right); - constant right_index : INTEGER := mins(arg'left, arg'right); - variable result : UNRESOLVED_ufixed (arg'range); - begin -- function cleanvec - assert not (arg'ascending and (arg'low /= INTEGER'low)) - report "fixed_pkg:" - & " Vector passed using a ""to"" range, expected is ""downto""" - severity error; - return arg; - end function cleanvec; - - -- Type convert a "unsigned" into a "ufixed", used internally - function to_fixed ( - arg : UNSIGNED; -- shifted vector - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (left_index downto right_index); - begin -- function to_fixed - result := UNRESOLVED_ufixed(arg); - return result; - end function to_fixed; - - -- Type convert a "signed" into an "sfixed", used internally - function to_fixed ( - arg : SIGNED; -- shifted vector - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (left_index downto right_index); - begin -- function to_fixed - result := UNRESOLVED_sfixed(arg); - return result; - end function to_fixed; - - -- Type convert a "ufixed" into an "unsigned", used internally - function to_uns ( - arg : UNRESOLVED_ufixed) -- fp vector - return UNSIGNED is - subtype t is UNSIGNED(arg'high - arg'low downto 0); - variable slv : t; - begin -- function to_uns - slv := t(arg); - return slv; - end function to_uns; - - -- Type convert an "sfixed" into a "signed", used internally - function to_s ( - arg : UNRESOLVED_sfixed) -- fp vector - return SIGNED is - subtype t is SIGNED(arg'high - arg'low downto 0); - variable slv : t; - begin -- function to_s - slv := t(arg); - return slv; - end function to_s; - - -- adds 1 to the LSB of the number - procedure round_up (arg : in UNRESOLVED_ufixed; - result : out UNRESOLVED_ufixed; - overflowx : out BOOLEAN) is - variable arguns, resuns : UNSIGNED (arg'high-arg'low+1 downto 0) - := (others => '0'); - begin -- round_up - arguns (arguns'high-1 downto 0) := to_uns (arg); - resuns := arguns + 1; - result := to_fixed(resuns(arg'high-arg'low - downto 0), arg'high, arg'low); - overflowx := (resuns(resuns'high) = '1'); - end procedure round_up; - - -- adds 1 to the LSB of the number - procedure round_up (arg : in UNRESOLVED_sfixed; - result : out UNRESOLVED_sfixed; - overflowx : out BOOLEAN) is - variable args, ress : SIGNED (arg'high-arg'low+1 downto 0); - begin -- round_up - args (args'high-1 downto 0) := to_s (arg); - args(args'high) := arg(arg'high); -- sign extend - ress := args + 1; - result := to_fixed(ress (ress'high-1 - downto 0), arg'high, arg'low); - overflowx := ((arg(arg'high) /= ress(ress'high-1)) - and (or_reduce (STD_ULOGIC_VECTOR(ress)) /= '0')); - end procedure round_up; - - -- Rounding - Performs a "round_nearest" (IEEE 754) which rounds up - -- when the remainder is > 0.5. If the remainder IS 0.5 then if the - -- bottom bit is a "1" it is rounded, otherwise it remains the same. - function round_fixed (arg : UNRESOLVED_ufixed; - remainder : UNRESOLVED_ufixed; - overflow_style : fixed_overflow_style_type := fixed_overflow_style) - return UNRESOLVED_ufixed is - variable rounds : BOOLEAN; - variable round_overflow : BOOLEAN; - variable result : UNRESOLVED_ufixed (arg'range); - begin - rounds := false; - if (remainder'length > 1) then - if (remainder (remainder'high) = '1') then - rounds := (arg(arg'low) = '1') - or (or_reduce (to_sulv(remainder(remainder'high-1 downto - remainder'low))) = '1'); - end if; - else - rounds := (arg(arg'low) = '1') and (remainder (remainder'high) = '1'); - end if; - if rounds then - round_up(arg => arg, - result => result, - overflowx => round_overflow); - else - result := arg; - end if; - if (overflow_style = fixed_saturate) and round_overflow then - result := saturate (result'high, result'low); - end if; - return result; - end function round_fixed; - - -- Rounding case statement - function round_fixed (arg : UNRESOLVED_sfixed; - remainder : UNRESOLVED_sfixed; - overflow_style : fixed_overflow_style_type := fixed_overflow_style) - return UNRESOLVED_sfixed is - variable rounds : BOOLEAN; - variable round_overflow : BOOLEAN; - variable result : UNRESOLVED_sfixed (arg'range); - begin - rounds := false; - if (remainder'length > 1) then - if (remainder (remainder'high) = '1') then - rounds := (arg(arg'low) = '1') - or (or_reduce (to_sulv(remainder(remainder'high-1 downto - remainder'low))) = '1'); - end if; - else - rounds := (arg(arg'low) = '1') and (remainder (remainder'high) = '1'); - end if; - if rounds then - round_up(arg => arg, - result => result, - overflowx => round_overflow); - else - result := arg; - end if; - if round_overflow then - if (overflow_style = fixed_saturate) then - if arg(arg'high) = '0' then - result := saturate (result'high, result'low); - else - result := not saturate (result'high, result'low); - end if; - -- Sign bit not fixed when wrapping - end if; - end if; - return result; - end function round_fixed; - - -- converts an sfixed into a ufixed. The output is the same length as the - -- input, because abs("1000") = "1000" = 8. - function to_ufixed ( - arg : UNRESOLVED_sfixed) - return UNRESOLVED_ufixed - is - constant left_index : INTEGER := arg'high; - constant right_index : INTEGER := mine(arg'low, arg'low); - variable xarg : UNRESOLVED_sfixed(left_index+1 downto right_index); - variable result : UNRESOLVED_ufixed(left_index downto right_index); - begin - if arg'length < 1 then - return NAUF; - end if; - xarg := abs(arg); - result := UNRESOLVED_ufixed (xarg (left_index downto right_index)); - return result; - end function to_ufixed; - ------------------------------------------------------------------------------ --- Visible functions ------------------------------------------------------------------------------ - - -- Conversion functions. These are needed for synthesis where typically - -- the only input and output type is a std_logic_vector. - function to_sulv ( - arg : UNRESOLVED_ufixed) -- fixed point vector - return STD_ULOGIC_VECTOR is - variable result : STD_ULOGIC_VECTOR (arg'length-1 downto 0); - begin - if arg'length < 1 then - return NSLV; - end if; - result := STD_ULOGIC_VECTOR (arg); - return result; - end function to_sulv; - - function to_sulv ( - arg : UNRESOLVED_sfixed) -- fixed point vector - return STD_ULOGIC_VECTOR is - variable result : STD_ULOGIC_VECTOR (arg'length-1 downto 0); - begin - if arg'length < 1 then - return NSLV; - end if; - result := STD_ULOGIC_VECTOR (arg); - return result; - end function to_sulv; - - function to_slv ( - arg : UNRESOLVED_ufixed) -- fixed point vector - return STD_LOGIC_VECTOR is - begin - return std_logic_vector(to_sulv(arg)); - end function to_slv; - - function to_slv ( - arg : UNRESOLVED_sfixed) -- fixed point vector - return STD_LOGIC_VECTOR is - begin - return std_logic_vector(to_sulv(arg)); - end function to_slv; - - function to_ufixed ( - arg : STD_ULOGIC_VECTOR; -- shifted vector - constant left_index : INTEGER; - constant right_index : INTEGER) - return unresolved_ufixed is - variable result : UNRESOLVED_ufixed (left_index downto right_index); - begin - if (arg'length < 1 or right_index > left_index) then - return NAUF; - end if; - if (arg'length /= result'length) then - report "fixed_pkg:" & "TO_UFIXED(SLV) " - & "Vector lengths do not match. Input length is " - & INTEGER'image(arg'length) & " and output will be " - & INTEGER'image(result'length) & " wide." - severity error; - return NAUF; - else - result := to_fixed (arg => UNSIGNED(arg), - left_index => left_index, - right_index => right_index); - return result; - end if; - end function to_ufixed; - - function to_sfixed ( - arg : STD_ULOGIC_VECTOR; -- shifted vector - constant left_index : INTEGER; - constant right_index : INTEGER) - return unresolved_sfixed is - variable result : UNRESOLVED_sfixed (left_index downto right_index); - begin - if (arg'length < 1 or right_index > left_index) then - return NASF; - end if; - if (arg'length /= result'length) then - report "fixed_pkg:" & "TO_SFIXED(SLV) " - & "Vector lengths do not match. Input length is " - & INTEGER'image(arg'length) & " and output will be " - & INTEGER'image(result'length) & " wide." - severity error; - return NASF; - else - result := to_fixed (arg => SIGNED(arg), - left_index => left_index, - right_index => right_index); - return result; - end if; - end function to_sfixed; - - -- Two's complement number, Grows the vector by 1 bit. - -- because "abs (1000.000) = 01000.000" or abs(-16) = 16. - function "abs" ( - arg : UNRESOLVED_sfixed) -- fixed point input - return UNRESOLVED_sfixed is - constant left_index : INTEGER := arg'high; - constant right_index : INTEGER := mine(arg'low, arg'low); - variable ressns : SIGNED (arg'length downto 0); - variable result : UNRESOLVED_sfixed (left_index+1 downto right_index); - begin - if (arg'length < 1 or result'length < 1) then - return NASF; - end if; - ressns (arg'length-1 downto 0) := to_s (cleanvec (arg)); - ressns (arg'length) := ressns (arg'length-1); -- expand sign bit - result := to_fixed (abs(ressns), left_index+1, right_index); - return result; - end function "abs"; - - -- also grows the vector by 1 bit. - function "-" ( - arg : UNRESOLVED_sfixed) -- fixed point input - return UNRESOLVED_sfixed is - constant left_index : INTEGER := arg'high+1; - constant right_index : INTEGER := mine(arg'low, arg'low); - variable ressns : SIGNED (arg'length downto 0); - variable result : UNRESOLVED_sfixed (left_index downto right_index); - begin - if (arg'length < 1 or result'length < 1) then - return NASF; - end if; - ressns (arg'length-1 downto 0) := to_s (cleanvec(arg)); - ressns (arg'length) := ressns (arg'length-1); -- expand sign bit - result := to_fixed (-ressns, left_index, right_index); - return result; - end function "-"; - - -- Addition - function "+" ( - l, r : UNRESOLVED_ufixed) -- ufixed(a downto b) + ufixed(c downto d) = - return UNRESOLVED_ufixed is -- ufixed(max(a,c)+1 downto min(b,d)) - constant left_index : INTEGER := maximum(l'high, r'high)+1; - constant right_index : INTEGER := mine(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable result : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (left_index-right_index - downto 0); - variable result_slv : UNSIGNED (left_index-right_index - downto 0); - begin - if (l'length < 1 or r'length < 1 or result'length < 1) then - return NAUF; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - result_slv := lslv + rslv; - result := to_fixed(result_slv, left_index, right_index); - return result; - end function "+"; - - function "+" ( - l, r : UNRESOLVED_sfixed) -- sfixed(a downto b) + sfixed(c downto d) = - return UNRESOLVED_sfixed is -- sfixed(max(a,c)+1 downto min(b,d)) - constant left_index : INTEGER := maximum(l'high, r'high)+1; - constant right_index : INTEGER := mine(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable result : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (left_index-right_index downto 0); - variable result_slv : SIGNED (left_index-right_index downto 0); - begin - if (l'length < 1 or r'length < 1 or result'length < 1) then - return NASF; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - result_slv := lslv + rslv; - result := to_fixed(result_slv, left_index, right_index); - return result; - end function "+"; - - -- Subtraction - function "-" ( - l, r : UNRESOLVED_ufixed) -- ufixed(a downto b) - ufixed(c downto d) = - return UNRESOLVED_ufixed is -- ufixed(max(a,c)+1 downto min(b,d)) - constant left_index : INTEGER := maximum(l'high, r'high)+1; - constant right_index : INTEGER := mine(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable result : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (left_index-right_index - downto 0); - variable result_slv : UNSIGNED (left_index-right_index - downto 0); - begin - if (l'length < 1 or r'length < 1 or result'length < 1) then - return NAUF; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - result_slv := lslv - rslv; - result := to_fixed(result_slv, left_index, right_index); - return result; - end function "-"; - - function "-" ( - l, r : UNRESOLVED_sfixed) -- sfixed(a downto b) - sfixed(c downto d) = - return UNRESOLVED_sfixed is -- sfixed(max(a,c)+1 downto min(b,d)) - constant left_index : INTEGER := maximum(l'high, r'high)+1; - constant right_index : INTEGER := mine(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable result : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (left_index-right_index downto 0); - variable result_slv : SIGNED (left_index-right_index downto 0); - begin - if (l'length < 1 or r'length < 1 or result'length < 1) then - return NASF; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - result_slv := lslv - rslv; - result := to_fixed(result_slv, left_index, right_index); - return result; - end function "-"; - - function "*" ( - l, r : UNRESOLVED_ufixed) -- ufixed(a downto b) * ufixed(c downto d) = - return UNRESOLVED_ufixed is -- ufixed(a+c+1 downto b+d) - variable lslv : UNSIGNED (l'length-1 downto 0); - variable rslv : UNSIGNED (r'length-1 downto 0); - variable result_slv : UNSIGNED (r'length+l'length-1 downto 0); - variable result : UNRESOLVED_ufixed (l'high + r'high+1 downto - mine(l'low, l'low) + mine(r'low, r'low)); - begin - if (l'length < 1 or r'length < 1 or - result'length /= result_slv'length) then - return NAUF; - end if; - lslv := to_uns (cleanvec(l)); - rslv := to_uns (cleanvec(r)); - result_slv := lslv * rslv; - result := to_fixed (result_slv, result'high, result'low); - return result; - end function "*"; - - function "*" ( - l, r : UNRESOLVED_sfixed) -- sfixed(a downto b) * sfixed(c downto d) = - return UNRESOLVED_sfixed is -- sfixed(a+c+1 downto b+d) - variable lslv : SIGNED (l'length-1 downto 0); - variable rslv : SIGNED (r'length-1 downto 0); - variable result_slv : SIGNED (r'length+l'length-1 downto 0); - variable result : UNRESOLVED_sfixed (l'high + r'high+1 downto - mine(l'low, l'low) + mine(r'low, r'low)); - begin - if (l'length < 1 or r'length < 1 or - result'length /= result_slv'length) then - return NASF; - end if; - lslv := to_s (cleanvec(l)); - rslv := to_s (cleanvec(r)); - result_slv := lslv * rslv; - result := to_fixed (result_slv, result'high, result'low); - return result; - end function "*"; - --- function "/" ( --- l, r : UNRESOLVED_ufixed) -- ufixed(a downto b) / ufixed(c downto d) = --- return UNRESOLVED_ufixed is -- ufixed(a-d downto b-c-1) --- begin --- return divide (l, r); --- end function "/"; - --- function "/" ( --- l, r : UNRESOLVED_sfixed) -- sfixed(a downto b) / sfixed(c downto d) = --- return UNRESOLVED_sfixed is -- sfixed(a-d+1 downto b-c) --- begin --- return divide (l, r); --- end function "/"; - - -- This version of divide gives the user more control - -- ufixed(a downto b) / ufixed(c downto d) = ufixed(a-d downto b-c-1) --- function divide ( --- l, r : UNRESOLVED_ufixed; --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_ufixed is --- variable result : UNRESOLVED_ufixed (l'high - mine(r'low, r'low) downto --- mine (l'low, l'low) - r'high -1); --- variable dresult : UNRESOLVED_ufixed (result'high downto result'low -guard_bits); --- variable lresize : UNRESOLVED_ufixed (l'high downto l'high - dresult'length+1); --- variable lslv : UNSIGNED (lresize'length-1 downto 0); --- variable rslv : UNSIGNED (r'length-1 downto 0); --- variable result_slv : UNSIGNED (lresize'length-1 downto 0); --- begin --- if (l'length < 1 or r'length < 1 or --- mins(r'low, r'low) /= r'low or mins(l'low, l'low) /= l'low) then --- return NAUF; --- end if; --- lresize := resize (arg => l, --- left_index => lresize'high, --- right_index => lresize'low, --- overflow_style => fixed_wrap, -- vector only grows --- round_style => fixed_truncate); --- lslv := to_uns (cleanvec (lresize)); --- rslv := to_uns (cleanvec (r)); --- if (rslv = 0) then --- report "fixed_pkg:" --- & "DIVIDE(ufixed) Division by zero" severity error; --- result := saturate (result'high, result'low); -- saturate --- else --- result_slv := lslv / rslv; --- dresult := to_fixed (result_slv, dresult'high, dresult'low); --- result := resize (arg => dresult, --- left_index => result'high, --- right_index => result'low, --- overflow_style => fixed_wrap, -- overflow impossible --- round_style => round_style); --- end if; --- return result; --- end function divide; - - -- sfixed(a downto b) / sfixed(c downto d) = sfixed(a-d+1 downto b-c) --- function divide ( --- l, r : UNRESOLVED_sfixed; --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_sfixed is --- variable result : UNRESOLVED_sfixed (l'high - mine(r'low, r'low) + 1 downto --- mine (l'low, l'low) - r'high); --- variable dresult : UNRESOLVED_sfixed (result'high downto result'low-guard_bits); --- variable lresize : UNRESOLVED_sfixed (l'high+1 downto l'high+1 -dresult'length+1); --- variable lslv : SIGNED (lresize'length-1 downto 0); --- variable rslv : SIGNED (r'length-1 downto 0); --- variable result_slv : SIGNED (lresize'length-1 downto 0); --- begin --- if (l'length < 1 or r'length < 1 or --- mins(r'low, r'low) /= r'low or mins(l'low, l'low) /= l'low) then --- return NASF; --- end if; --- lresize := resize (arg => l, --- left_index => lresize'high, --- right_index => lresize'low, --- overflow_style => fixed_wrap, -- vector only grows --- round_style => fixed_truncate); --- lslv := to_s (cleanvec (lresize)); --- rslv := to_s (cleanvec (r)); --- if (rslv = 0) then --- report "fixed_pkg:" --- & "DIVIDE(sfixed) Division by zero" severity error; --- result := saturate (result'high, result'low); --- else --- result_slv := lslv / rslv; --- dresult := to_fixed (result_slv, dresult'high, dresult'low); --- result := resize (arg => dresult, --- left_index => result'high, --- right_index => result'low, --- overflow_style => fixed_wrap, -- overflow impossible --- round_style => round_style); --- end if; --- return result; --- end function divide; - - -- 1 / ufixed(a downto b) = ufixed(-b downto -a-1) --- function reciprocal ( --- arg : UNRESOLVED_ufixed; -- fixed point input --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_ufixed is --- constant one : UNRESOLVED_ufixed (0 downto 0) := "1"; --- begin --- return divide (l => one, --- r => arg, --- round_style => round_style, --- guard_bits => guard_bits); --- end function reciprocal; - - -- 1 / sfixed(a downto b) = sfixed(-b+1 downto -a) --- function reciprocal ( --- arg : UNRESOLVED_sfixed; -- fixed point input --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_sfixed is --- constant one : UNRESOLVED_sfixed (1 downto 0) := "01"; -- extra bit. --- variable resultx : UNRESOLVED_sfixed (-mine(arg'low, arg'low)+2 downto -arg'high); --- begin --- if (arg'length < 1 or resultx'length < 1) then --- return NASF; --- else --- resultx := divide (l => one, --- r => arg, --- round_style => round_style, --- guard_bits => guard_bits); --- return resultx (resultx'high-1 downto resultx'low); -- remove extra bit --- end if; --- end function reciprocal; - - -- ufixed (a downto b) rem ufixed (c downto d) - -- = ufixed (min(a,c) downto min(b,d)) --- function "rem" ( --- l, r : UNRESOLVED_ufixed) -- fixed point input --- return UNRESOLVED_ufixed is --- begin --- return remainder (l, r); --- end function "rem"; - --- -- remainder --- -- sfixed (a downto b) rem sfixed (c downto d) --- -- = sfixed (min(a,c) downto min(b,d)) --- function "rem" ( --- l, r : UNRESOLVED_sfixed) -- fixed point input --- return UNRESOLVED_sfixed is --- begin --- return remainder (l, r); --- end function "rem"; - - -- ufixed (a downto b) rem ufixed (c downto d) - -- = ufixed (min(a,c) downto min(b,d)) --- function remainder ( --- l, r : UNRESOLVED_ufixed; -- fixed point input --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_ufixed is --- variable result : UNRESOLVED_ufixed (minimum(l'high, r'high) downto --- mine(l'low, r'low)); --- variable lresize : UNRESOLVED_ufixed (maximum(l'high, r'low) downto --- mins(r'low, r'low)-guard_bits); --- variable rresize : UNRESOLVED_ufixed (r'high downto r'low-guard_bits); --- variable dresult : UNRESOLVED_ufixed (rresize'range); --- variable lslv : UNSIGNED (lresize'length-1 downto 0); --- variable rslv : UNSIGNED (rresize'length-1 downto 0); --- variable result_slv : UNSIGNED (rslv'range); --- begin --- if (l'length < 1 or r'length < 1 or --- mins(r'low, r'low) /= r'low or mins(l'low, l'low) /= l'low) then --- return NAUF; --- end if; --- lresize := resize (arg => l, --- left_index => lresize'high, --- right_index => lresize'low, --- overflow_style => fixed_wrap, -- vector only grows --- round_style => fixed_truncate); --- lslv := to_uns (lresize); --- rresize := resize (arg => r, --- left_index => rresize'high, --- right_index => rresize'low, --- overflow_style => fixed_wrap, -- vector only grows --- round_style => fixed_truncate); --- rslv := to_uns (rresize); --- if (rslv = 0) then --- report "fixed_pkg:" --- & "remainder(ufixed) Division by zero" severity error; --- result := saturate (result'high, result'low); -- saturate --- else --- if (r'low <= l'high) then --- result_slv := lslv rem rslv; --- dresult := to_fixed (result_slv, dresult'high, dresult'low); --- result := resize (arg => dresult, --- left_index => result'high, --- right_index => result'low, --- overflow_style => fixed_wrap, -- can't overflow --- round_style => round_style); --- end if; --- if l'low < r'low then --- result(mins(r'low-1, l'high) downto l'low) := --- cleanvec(l(mins(r'low-1, l'high) downto l'low)); --- end if; --- end if; --- return result; --- end function remainder; - --- -- remainder --- -- sfixed (a downto b) rem sfixed (c downto d) --- -- = sfixed (min(a,c) downto min(b,d)) --- function remainder ( --- l, r : UNRESOLVED_sfixed; -- fixed point input --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_sfixed is --- variable l_abs : UNRESOLVED_ufixed (l'range); --- variable r_abs : UNRESOLVED_ufixed (r'range); --- variable result : UNRESOLVED_sfixed (minimum(r'high, l'high) downto --- mine(r'low, l'low)); --- variable neg_result : UNRESOLVED_sfixed (minimum(r'high, l'high)+1 downto --- mins(r'low, l'low)); --- begin --- if (l'length < 1 or r'length < 1 or --- mins(r'low, r'low) /= r'low or mins(l'low, l'low) /= l'low) then --- return NASF; --- end if; --- l_abs := to_ufixed (l); --- r_abs := to_ufixed (r); --- result := UNRESOLVED_sfixed (remainder ( --- l => l_abs, --- r => r_abs, --- round_style => round_style)); --- neg_result := -result; --- if l(l'high) = '1' then --- result := neg_result(result'range); --- end if; --- return result; --- end function remainder; - --- -- modulo --- -- ufixed (a downto b) mod ufixed (c downto d) --- -- = ufixed (min(a,c) downto min(b, d)) --- function "mod" ( --- l, r : UNRESOLVED_ufixed) -- fixed point input --- return UNRESOLVED_ufixed is --- begin --- return modulo (l, r); --- end function "mod"; - --- -- sfixed (a downto b) mod sfixed (c downto d) --- -- = sfixed (c downto min(b, d)) --- function "mod" ( --- l, r : UNRESOLVED_sfixed) -- fixed point input --- return UNRESOLVED_sfixed is --- begin --- return modulo(l, r); --- end function "mod"; - --- -- modulo --- -- ufixed (a downto b) mod ufixed (c downto d) --- -- = ufixed (min(a,c) downto min(b, d)) --- function modulo ( --- l, r : UNRESOLVED_ufixed; -- fixed point input --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_ufixed is --- begin --- return remainder(l => l, --- r => r, --- round_style => round_style, --- guard_bits => guard_bits); --- end function modulo; - --- -- sfixed (a downto b) mod sfixed (c downto d) --- -- = sfixed (c downto min(b, d)) --- function modulo ( --- l, r : UNRESOLVED_sfixed; -- fixed point input --- constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; --- constant round_style : fixed_round_style_type := fixed_round_style; --- constant guard_bits : NATURAL := fixed_guard_bits) --- return UNRESOLVED_sfixed is --- variable l_abs : UNRESOLVED_ufixed (l'range); --- variable r_abs : UNRESOLVED_ufixed (r'range); --- variable result : UNRESOLVED_sfixed (r'high downto --- mine(r'low, l'low)); --- variable dresult : UNRESOLVED_sfixed (minimum(r'high, l'high)+1 downto --- mins(r'low, l'low)); --- variable dresult_not_zero : BOOLEAN; --- begin --- if (l'length < 1 or r'length < 1 or --- mins(r'low, r'low) /= r'low or mins(l'low, l'low) /= l'low) then --- return NASF; --- end if; --- l_abs := to_ufixed (l); --- r_abs := to_ufixed (r); --- dresult := "0" & UNRESOLVED_sfixed(remainder (l => l_abs, --- r => r_abs, --- round_style => round_style)); --- if (to_s(dresult) = 0) then --- dresult_not_zero := false; --- else --- dresult_not_zero := true; --- end if; --- if to_x01(l(l'high)) = '1' and to_x01(r(r'high)) = '0' --- and dresult_not_zero then --- result := resize (arg => r - dresult, --- left_index => result'high, --- right_index => result'low, --- overflow_style => overflow_style, --- round_style => round_style); --- elsif to_x01(l(l'high)) = '1' and to_x01(r(r'high)) = '1' then --- result := resize (arg => -dresult, --- left_index => result'high, --- right_index => result'low, --- overflow_style => overflow_style, --- round_style => round_style); --- elsif to_x01(l(l'high)) = '0' and to_x01(r(r'high)) = '1' --- and dresult_not_zero then --- result := resize (arg => dresult + r, --- left_index => result'high, --- right_index => result'low, --- overflow_style => overflow_style, --- round_style => round_style); --- else --- result := resize (arg => dresult, --- left_index => result'high, --- right_index => result'low, --- overflow_style => overflow_style, --- round_style => round_style); --- end if; --- return result; --- end function modulo; - - -- Procedure for those who need an "accumulator" function - procedure add_carry ( - L, R : in UNRESOLVED_ufixed; - c_in : in STD_ULOGIC; - result : out UNRESOLVED_ufixed; - c_out : out STD_ULOGIC) is - constant left_index : INTEGER := maximum(l'high, r'high)+1; - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (left_index-right_index - downto 0); - variable result_slv : UNSIGNED (left_index-right_index - downto 0); - variable cx : UNSIGNED (0 downto 0); -- Carry in - begin - if (l'length < 1 or r'length < 1) then - result := NAUF; - c_out := '0'; - else - cx (0) := c_in; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - result_slv := lslv + rslv + cx; - c_out := result_slv(left_index); - result := to_fixed(result_slv (left_index-right_index-1 downto 0), - left_index-1, right_index); - end if; - end procedure add_carry; - - procedure add_carry ( - L, R : in UNRESOLVED_sfixed; - c_in : in STD_ULOGIC; - result : out UNRESOLVED_sfixed; - c_out : out STD_ULOGIC) is - constant left_index : INTEGER := maximum(l'high, r'high)+1; - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (left_index-right_index - downto 0); - variable result_slv : SIGNED (left_index-right_index - downto 0); - variable cx : SIGNED (1 downto 0); -- Carry in - begin - if (l'length < 1 or r'length < 1) then - result := NASF; - c_out := '0'; - else - cx (1) := '0'; - cx (0) := c_in; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - result_slv := lslv + rslv + cx; - c_out := result_slv(left_index); - result := to_fixed(result_slv (left_index-right_index-1 downto 0), - left_index-1, right_index); - end if; - end procedure add_carry; - - -- Scales the result by a power of 2. Width of input = width of output with - -- the decimal point moved. - function scalb (y : UNRESOLVED_ufixed; N : INTEGER) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (y'high+N downto y'low+N); - begin - if y'length < 1 then - return NAUF; - else - result := y; - return result; - end if; - end function scalb; - - function scalb (y : UNRESOLVED_ufixed; N : SIGNED) - return UNRESOLVED_ufixed is - begin - return scalb (y => y, - N => to_integer(N)); - end function scalb; - - function scalb (y : UNRESOLVED_sfixed; N : INTEGER) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (y'high+N downto y'low+N); - begin - if y'length < 1 then - return NASF; - else - result := y; - return result; - end if; - end function scalb; - - function scalb (y : UNRESOLVED_sfixed; N : SIGNED) - return UNRESOLVED_sfixed is - begin - return scalb (y => y, - N => to_integer(N)); - end function scalb; - - function Is_Negative (arg : UNRESOLVED_sfixed) return BOOLEAN is - begin - if to_X01(arg(arg'high)) = '1' then - return true; - else - return false; - end if; - end function Is_Negative; - - function find_rightmost (arg : UNRESOLVED_ufixed; y : STD_ULOGIC) - return INTEGER is - begin - for_loop : for i in arg'reverse_range loop - if \?=\ (arg(i), y) = '1' then - return i; - end if; - end loop; - return arg'high+1; -- return out of bounds 'high - end function find_rightmost; - - function find_leftmost (arg : UNRESOLVED_ufixed; y : STD_ULOGIC) - return INTEGER is - begin - for_loop : for i in arg'range loop - if \?=\ (arg(i), y) = '1' then - return i; - end if; - end loop; - return arg'low-1; -- return out of bounds 'low - end function find_leftmost; - - function find_rightmost (arg : UNRESOLVED_sfixed; y : STD_ULOGIC) - return INTEGER is - begin - for_loop : for i in arg'reverse_range loop - if \?=\ (arg(i), y) = '1' then - return i; - end if; - end loop; - return arg'high+1; -- return out of bounds 'high - end function find_rightmost; - - function find_leftmost (arg : UNRESOLVED_sfixed; y : STD_ULOGIC) - return INTEGER is - begin - for_loop : for i in arg'range loop - if \?=\ (arg(i), y) = '1' then - return i; - end if; - end loop; - return arg'low-1; -- return out of bounds 'low - end function find_leftmost; - - function "sll" (ARG : UNRESOLVED_ufixed; COUNT : INTEGER) - return UNRESOLVED_ufixed is - variable argslv : UNSIGNED (arg'length-1 downto 0); - variable result : UNRESOLVED_ufixed (arg'range); - begin - argslv := to_uns (arg); - argslv := argslv sll COUNT; - result := to_fixed (argslv, result'high, result'low); - return result; - end function "sll"; - - function "srl" (ARG : UNRESOLVED_ufixed; COUNT : INTEGER) - return UNRESOLVED_ufixed is - variable argslv : UNSIGNED (arg'length-1 downto 0); - variable result : UNRESOLVED_ufixed (arg'range); - begin - argslv := to_uns (arg); - argslv := argslv srl COUNT; - result := to_fixed (argslv, result'high, result'low); - return result; - end function "srl"; - - function "rol" (ARG : UNRESOLVED_ufixed; COUNT : INTEGER) - return UNRESOLVED_ufixed is - variable argslv : UNSIGNED (arg'length-1 downto 0); - variable result : UNRESOLVED_ufixed (arg'range); - begin - argslv := to_uns (arg); - argslv := argslv rol COUNT; - result := to_fixed (argslv, result'high, result'low); - return result; - end function "rol"; - - function "ror" (ARG : UNRESOLVED_ufixed; COUNT : INTEGER) - return UNRESOLVED_ufixed is - variable argslv : UNSIGNED (arg'length-1 downto 0); - variable result : UNRESOLVED_ufixed (arg'range); - begin - argslv := to_uns (arg); - argslv := argslv ror COUNT; - result := to_fixed (argslv, result'high, result'low); - return result; - end function "ror"; - - function "sla" (ARG : UNRESOLVED_ufixed; COUNT : INTEGER) - return UNRESOLVED_ufixed is - variable argslv : UNSIGNED (arg'length-1 downto 0); - variable result : UNRESOLVED_ufixed (arg'range); - begin - argslv := to_uns (arg); - -- Arithmetic shift on an unsigned is a logical shift - argslv := argslv sll COUNT; - result := to_fixed (argslv, result'high, result'low); - return result; - end function "sla"; - - function "sra" (ARG : UNRESOLVED_ufixed; COUNT : INTEGER) - return UNRESOLVED_ufixed is - variable argslv : UNSIGNED (arg'length-1 downto 0); - variable result : UNRESOLVED_ufixed (arg'range); - begin - argslv := to_uns (arg); - -- Arithmetic shift on an unsigned is a logical shift - argslv := argslv srl COUNT; - result := to_fixed (argslv, result'high, result'low); - return result; - end function "sra"; - - function "sll" (ARG : UNRESOLVED_sfixed; COUNT : INTEGER) - return UNRESOLVED_sfixed is - variable argslv : SIGNED (arg'length-1 downto 0); - variable result : UNRESOLVED_sfixed (arg'range); - begin - argslv := to_s (arg); - argslv := argslv sll COUNT; - result := to_fixed (argslv, result'high, result'low); - return result; - end function "sll"; - - function "srl" (ARG : UNRESOLVED_sfixed; COUNT : INTEGER) - return UNRESOLVED_sfixed is - variable argslv : SIGNED (arg'length-1 downto 0); - variable result : UNRESOLVED_sfixed (arg'range); - begin - argslv := to_s (arg); - argslv := argslv srl COUNT; - result := to_fixed (argslv, result'high, result'low); - return result; - end function "srl"; - - function "rol" (ARG : UNRESOLVED_sfixed; COUNT : INTEGER) - return UNRESOLVED_sfixed is - variable argslv : SIGNED (arg'length-1 downto 0); - variable result : UNRESOLVED_sfixed (arg'range); - begin - argslv := to_s (arg); - argslv := argslv rol COUNT; - result := to_fixed (argslv, result'high, result'low); - return result; - end function "rol"; - - function "ror" (ARG : UNRESOLVED_sfixed; COUNT : INTEGER) - return UNRESOLVED_sfixed is - variable argslv : SIGNED (arg'length-1 downto 0); - variable result : UNRESOLVED_sfixed (arg'range); - begin - argslv := to_s (arg); - argslv := argslv ror COUNT; - result := to_fixed (argslv, result'high, result'low); - return result; - end function "ror"; - - function "sla" (ARG : UNRESOLVED_sfixed; COUNT : INTEGER) - return UNRESOLVED_sfixed is - variable argslv : SIGNED (arg'length-1 downto 0); - variable result : UNRESOLVED_sfixed (arg'range); - begin - argslv := to_s (arg); - if COUNT > 0 then - -- Arithmetic shift left on a 2's complement number is a logic shift - argslv := argslv sll COUNT; - else - argslv := argslv sra -COUNT; - end if; - result := to_fixed (argslv, result'high, result'low); - return result; - end function "sla"; - - function "sra" (ARG : UNRESOLVED_sfixed; COUNT : INTEGER) - return UNRESOLVED_sfixed is - variable argslv : SIGNED (arg'length-1 downto 0); - variable result : UNRESOLVED_sfixed (arg'range); - begin - argslv := to_s (arg); - if COUNT > 0 then - argslv := argslv sra COUNT; - else - -- Arithmetic shift left on a 2's complement number is a logic shift - argslv := argslv sll -COUNT; - end if; - result := to_fixed (argslv, result'high, result'low); - return result; - end function "sra"; - - -- Because some people want the older functions. - function SHIFT_LEFT (ARG : UNRESOLVED_ufixed; COUNT : NATURAL) - return UNRESOLVED_ufixed is - begin - if (ARG'length < 1) then - return NAUF; - end if; - return ARG sla COUNT; - end function SHIFT_LEFT; - - function SHIFT_RIGHT (ARG : UNRESOLVED_ufixed; COUNT : NATURAL) - return UNRESOLVED_ufixed is - begin - if (ARG'length < 1) then - return NAUF; - end if; - return ARG sra COUNT; - end function SHIFT_RIGHT; - - function SHIFT_LEFT (ARG : UNRESOLVED_sfixed; COUNT : NATURAL) - return UNRESOLVED_sfixed is - begin - if (ARG'length < 1) then - return NASF; - end if; - return ARG sla COUNT; - end function SHIFT_LEFT; - - function SHIFT_RIGHT (ARG : UNRESOLVED_sfixed; COUNT : NATURAL) - return UNRESOLVED_sfixed is - begin - if (ARG'length < 1) then - return NASF; - end if; - return ARG sra COUNT; - end function SHIFT_RIGHT; - - ---------------------------------------------------------------------------- - -- logical functions - ---------------------------------------------------------------------------- - function "not" (L : UNRESOLVED_ufixed) return UNRESOLVED_ufixed is - variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto - begin - RESULT := not to_sulv(L); - return to_ufixed(RESULT, L'high, L'low); - end function "not"; - - function "and" (L, R : UNRESOLVED_ufixed) return UNRESOLVED_ufixed is - variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto - begin - if (L'high = R'high and L'low = R'low) then - RESULT := to_sulv(L) and to_sulv(R); - else - assert NO_WARNING - report "fixed_pkg:" - & """and"": Range error L'RANGE /= R'RANGE" - severity warning; - RESULT := (others => 'X'); - end if; - return to_ufixed(RESULT, L'high, L'low); - end function "and"; - - function "or" (L, R : UNRESOLVED_ufixed) return UNRESOLVED_ufixed is - variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto - begin - if (L'high = R'high and L'low = R'low) then - RESULT := to_sulv(L) or to_sulv(R); - else - assert NO_WARNING - report "fixed_pkg:" - & """or"": Range error L'RANGE /= R'RANGE" - severity warning; - RESULT := (others => 'X'); - end if; - return to_ufixed(RESULT, L'high, L'low); - end function "or"; - - function "nand" (L, R : UNRESOLVED_ufixed) return UNRESOLVED_ufixed is - variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto - begin - if (L'high = R'high and L'low = R'low) then - RESULT := to_sulv(L) nand to_sulv(R); - else - assert NO_WARNING - report "fixed_pkg:" - & """nand"": Range error L'RANGE /= R'RANGE" - severity warning; - RESULT := (others => 'X'); - end if; - return to_ufixed(RESULT, L'high, L'low); - end function "nand"; - - function "nor" (L, R : UNRESOLVED_ufixed) return UNRESOLVED_ufixed is - variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto - begin - if (L'high = R'high and L'low = R'low) then - RESULT := to_sulv(L) nor to_sulv(R); - else - assert NO_WARNING - report "fixed_pkg:" - & """nor"": Range error L'RANGE /= R'RANGE" - severity warning; - RESULT := (others => 'X'); - end if; - return to_ufixed(RESULT, L'high, L'low); - end function "nor"; - - function "xor" (L, R : UNRESOLVED_ufixed) return UNRESOLVED_ufixed is - variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto - begin - if (L'high = R'high and L'low = R'low) then - RESULT := to_sulv(L) xor to_sulv(R); - else - assert NO_WARNING - report "fixed_pkg:" - & """xor"": Range error L'RANGE /= R'RANGE" - severity warning; - RESULT := (others => 'X'); - end if; - return to_ufixed(RESULT, L'high, L'low); - end function "xor"; - - function "xnor" (L, R : UNRESOLVED_ufixed) return UNRESOLVED_ufixed is - variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto - begin - if (L'high = R'high and L'low = R'low) then - RESULT := to_sulv(L) xnor to_sulv(R); - else - assert NO_WARNING - report "fixed_pkg:" - & """xnor"": Range error L'RANGE /= R'RANGE" - severity warning; - RESULT := (others => 'X'); - end if; - return to_ufixed(RESULT, L'high, L'low); - end function "xnor"; - - function "not" (L : UNRESOLVED_sfixed) return UNRESOLVED_sfixed is - variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto - begin - RESULT := not to_sulv(L); - return to_sfixed(RESULT, L'high, L'low); - end function "not"; - - function "and" (L, R : UNRESOLVED_sfixed) return UNRESOLVED_sfixed is - variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto - begin - if (L'high = R'high and L'low = R'low) then - RESULT := to_sulv(L) and to_sulv(R); - else - assert NO_WARNING - report "fixed_pkg:" - & """and"": Range error L'RANGE /= R'RANGE" - severity warning; - RESULT := (others => 'X'); - end if; - return to_sfixed(RESULT, L'high, L'low); - end function "and"; - - function "or" (L, R : UNRESOLVED_sfixed) return UNRESOLVED_sfixed is - variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto - begin - if (L'high = R'high and L'low = R'low) then - RESULT := to_sulv(L) or to_sulv(R); - else - assert NO_WARNING - report "fixed_pkg:" - & """or"": Range error L'RANGE /= R'RANGE" - severity warning; - RESULT := (others => 'X'); - end if; - return to_sfixed(RESULT, L'high, L'low); - end function "or"; - - function "nand" (L, R : UNRESOLVED_sfixed) return UNRESOLVED_sfixed is - variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto - begin - if (L'high = R'high and L'low = R'low) then - RESULT := to_sulv(L) nand to_sulv(R); - else - assert NO_WARNING - report "fixed_pkg:" - & """nand"": Range error L'RANGE /= R'RANGE" - severity warning; - RESULT := (others => 'X'); - end if; - return to_sfixed(RESULT, L'high, L'low); - end function "nand"; - - function "nor" (L, R : UNRESOLVED_sfixed) return UNRESOLVED_sfixed is - variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto - begin - if (L'high = R'high and L'low = R'low) then - RESULT := to_sulv(L) nor to_sulv(R); - else - assert NO_WARNING - report "fixed_pkg:" - & """nor"": Range error L'RANGE /= R'RANGE" - severity warning; - RESULT := (others => 'X'); - end if; - return to_sfixed(RESULT, L'high, L'low); - end function "nor"; - - function "xor" (L, R : UNRESOLVED_sfixed) return UNRESOLVED_sfixed is - variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto - begin - if (L'high = R'high and L'low = R'low) then - RESULT := to_sulv(L) xor to_sulv(R); - else - assert NO_WARNING - report "fixed_pkg:" - & """xor"": Range error L'RANGE /= R'RANGE" - severity warning; - RESULT := (others => 'X'); - end if; - return to_sfixed(RESULT, L'high, L'low); - end function "xor"; - - function "xnor" (L, R : UNRESOLVED_sfixed) return UNRESOLVED_sfixed is - variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto - begin - if (L'high = R'high and L'low = R'low) then - RESULT := to_sulv(L) xnor to_sulv(R); - else - assert NO_WARNING - report "fixed_pkg:" - & """xnor"": Range error L'RANGE /= R'RANGE" - severity warning; - RESULT := (others => 'X'); - end if; - return to_sfixed(RESULT, L'high, L'low); - end function "xnor"; - - -- Vector and std_ulogic functions, same as functions in numeric_std - function "and" (L : STD_ULOGIC; R : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (R'range); - begin - for i in result'range loop - result(i) := L and R(i); - end loop; - return result; - end function "and"; - - function "and" (L : UNRESOLVED_ufixed; R : STD_ULOGIC) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (L'range); - begin - for i in result'range loop - result(i) := L(i) and R; - end loop; - return result; - end function "and"; - - function "or" (L : STD_ULOGIC; R : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (R'range); - begin - for i in result'range loop - result(i) := L or R(i); - end loop; - return result; - end function "or"; - - function "or" (L : UNRESOLVED_ufixed; R : STD_ULOGIC) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (L'range); - begin - for i in result'range loop - result(i) := L(i) or R; - end loop; - return result; - end function "or"; - - function "nand" (L : STD_ULOGIC; R : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (R'range); - begin - for i in result'range loop - result(i) := L nand R(i); - end loop; - return result; - end function "nand"; - - function "nand" (L : UNRESOLVED_ufixed; R : STD_ULOGIC) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (L'range); - begin - for i in result'range loop - result(i) := L(i) nand R; - end loop; - return result; - end function "nand"; - - function "nor" (L : STD_ULOGIC; R : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (R'range); - begin - for i in result'range loop - result(i) := L nor R(i); - end loop; - return result; - end function "nor"; - - function "nor" (L : UNRESOLVED_ufixed; R : STD_ULOGIC) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (L'range); - begin - for i in result'range loop - result(i) := L(i) nor R; - end loop; - return result; - end function "nor"; - - function "xor" (L : STD_ULOGIC; R : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (R'range); - begin - for i in result'range loop - result(i) := L xor R(i); - end loop; - return result; - end function "xor"; - - function "xor" (L : UNRESOLVED_ufixed; R : STD_ULOGIC) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (L'range); - begin - for i in result'range loop - result(i) := L(i) xor R; - end loop; - return result; - end function "xor"; - - function "xnor" (L : STD_ULOGIC; R : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (R'range); - begin - for i in result'range loop - result(i) := L xnor R(i); - end loop; - return result; - end function "xnor"; - - function "xnor" (L : UNRESOLVED_ufixed; R : STD_ULOGIC) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (L'range); - begin - for i in result'range loop - result(i) := L(i) xnor R; - end loop; - return result; - end function "xnor"; - - function "and" (L : STD_ULOGIC; R : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (R'range); - begin - for i in result'range loop - result(i) := L and R(i); - end loop; - return result; - end function "and"; - - function "and" (L : UNRESOLVED_sfixed; R : STD_ULOGIC) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (L'range); - begin - for i in result'range loop - result(i) := L(i) and R; - end loop; - return result; - end function "and"; - - function "or" (L : STD_ULOGIC; R : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (R'range); - begin - for i in result'range loop - result(i) := L or R(i); - end loop; - return result; - end function "or"; - - function "or" (L : UNRESOLVED_sfixed; R : STD_ULOGIC) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (L'range); - begin - for i in result'range loop - result(i) := L(i) or R; - end loop; - return result; - end function "or"; - - function "nand" (L : STD_ULOGIC; R : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (R'range); - begin - for i in result'range loop - result(i) := L nand R(i); - end loop; - return result; - end function "nand"; - - function "nand" (L : UNRESOLVED_sfixed; R : STD_ULOGIC) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (L'range); - begin - for i in result'range loop - result(i) := L(i) nand R; - end loop; - return result; - end function "nand"; - - function "nor" (L : STD_ULOGIC; R : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (R'range); - begin - for i in result'range loop - result(i) := L nor R(i); - end loop; - return result; - end function "nor"; - - function "nor" (L : UNRESOLVED_sfixed; R : STD_ULOGIC) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (L'range); - begin - for i in result'range loop - result(i) := L(i) nor R; - end loop; - return result; - end function "nor"; - - function "xor" (L : STD_ULOGIC; R : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (R'range); - begin - for i in result'range loop - result(i) := L xor R(i); - end loop; - return result; - end function "xor"; - - function "xor" (L : UNRESOLVED_sfixed; R : STD_ULOGIC) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (L'range); - begin - for i in result'range loop - result(i) := L(i) xor R; - end loop; - return result; - end function "xor"; - - function "xnor" (L : STD_ULOGIC; R : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (R'range); - begin - for i in result'range loop - result(i) := L xnor R(i); - end loop; - return result; - end function "xnor"; - - function "xnor" (L : UNRESOLVED_sfixed; R : STD_ULOGIC) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (L'range); - begin - for i in result'range loop - result(i) := L(i) xnor R; - end loop; - return result; - end function "xnor"; - - -- Reduction operator_reduces - function and_reduce (l : UNRESOLVED_ufixed) return STD_ULOGIC is - begin - return and_reduce (to_sulv(l)); - end function and_reduce; - - function nand_reduce (l : UNRESOLVED_ufixed) return STD_ULOGIC is - begin - return nand_reduce (to_sulv(l)); - end function nand_reduce; - - function or_reduce (l : UNRESOLVED_ufixed) return STD_ULOGIC is - begin - return or_reduce (to_sulv(l)); - end function or_reduce; - - function nor_reduce (l : UNRESOLVED_ufixed) return STD_ULOGIC is - begin - return nor_reduce (to_sulv(l)); - end function nor_reduce; - - function xor_reduce (l : UNRESOLVED_ufixed) return STD_ULOGIC is - begin - return xor_reduce (to_sulv(l)); - end function xor_reduce; - - function xnor_reduce (l : UNRESOLVED_ufixed) return STD_ULOGIC is - begin - return xnor_reduce (to_sulv(l)); - end function xnor_reduce; - - function and_reduce (l : UNRESOLVED_sfixed) return STD_ULOGIC is - begin - return and_reduce (to_sulv(l)); - end function and_reduce; - - function nand_reduce (l : UNRESOLVED_sfixed) return STD_ULOGIC is - begin - return nand_reduce (to_sulv(l)); - end function nand_reduce; - - function or_reduce (l : UNRESOLVED_sfixed) return STD_ULOGIC is - begin - return or_reduce (to_sulv(l)); - end function or_reduce; - - function nor_reduce (l : UNRESOLVED_sfixed) return STD_ULOGIC is - begin - return nor_reduce (to_sulv(l)); - end function nor_reduce; - - function xor_reduce (l : UNRESOLVED_sfixed) return STD_ULOGIC is - begin - return xor_reduce (to_sulv(l)); - end function xor_reduce; - - function xnor_reduce (l : UNRESOLVED_sfixed) return STD_ULOGIC is - begin - return xnor_reduce (to_sulv(l)); - end function xnor_reduce; - -- End reduction operator_reduces - - function \?=\ (L, R : UNRESOLVED_ufixed) return STD_ULOGIC is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (lresize'length-1 downto 0); - begin -- ?= - if ((L'length < 1) or (R'length < 1)) then - assert NO_WARNING - report "fixed_pkg:" - & """?="": null detected, returning X" - severity warning; - return 'X'; - else - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - return \?=\ (lslv, rslv); - end if; - end function \?=\; - - function \?/=\ (L, R : UNRESOLVED_ufixed) return STD_ULOGIC is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (lresize'length-1 downto 0); - begin -- ?/= - if ((L'length < 1) or (R'length < 1)) then - assert NO_WARNING - report "fixed_pkg:" - & """?/="": null detected, returning X" - severity warning; - return 'X'; - else - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - return \?/=\ (lslv, rslv); - end if; - end function \?/=\; - - function \?>\ (L, R : UNRESOLVED_ufixed) return STD_ULOGIC is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (lresize'length-1 downto 0); - begin -- ?> - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "fixed_pkg:" - & """?>"": null detected, returning X" - severity warning; - return 'X'; - else - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - return \?>\ (lslv, rslv); - end if; - end function \?>\; - - function \?>=\ (L, R : UNRESOLVED_ufixed) return STD_ULOGIC is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (lresize'length-1 downto 0); - begin -- ?>= - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "fixed_pkg:" - & """?>="": null detected, returning X" - severity warning; - return 'X'; - else - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - return \?>=\ (lslv, rslv); - end if; - end function \?>=\; - - function \?<\ (L, R : UNRESOLVED_ufixed) return STD_ULOGIC is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (lresize'length-1 downto 0); - begin -- ?< - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "fixed_pkg:" - & """?<"": null detected, returning X" - severity warning; - return 'X'; - else - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - return \?<\ (lslv, rslv); - end if; - end function \?<\; - - function \?<=\ (L, R : UNRESOLVED_ufixed) return STD_ULOGIC is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (lresize'length-1 downto 0); - begin -- ?<= - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "fixed_pkg:" - & """?<="": null detected, returning X" - severity warning; - return 'X'; - else - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - return \?<=\ (lslv, rslv); - end if; - end function \?<=\; - - function \?=\ (L, R : UNRESOLVED_sfixed) return STD_ULOGIC is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (lresize'length-1 downto 0); - begin -- ?= - if ((L'length < 1) or (R'length < 1)) then - assert NO_WARNING - report "fixed_pkg:" - & """?="": null detected, returning X" - severity warning; - return 'X'; - else - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - return \?=\ (lslv, rslv); - end if; - end function \?=\; - - function \?/=\ (L, R : UNRESOLVED_sfixed) return STD_ULOGIC is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (lresize'length-1 downto 0); - begin -- ?/= - if ((L'length < 1) or (R'length < 1)) then - assert NO_WARNING - report "fixed_pkg:" - & """?/="": null detected, returning X" - severity warning; - return 'X'; - else - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - return \?/=\ (lslv, rslv); - end if; - end function \?/=\; - - function \?>\ (L, R : UNRESOLVED_sfixed) return STD_ULOGIC is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (lresize'length-1 downto 0); - begin -- ?> - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "fixed_pkg:" - & """?>"": null detected, returning X" - severity warning; - return 'X'; - else - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - return \?>\ (lslv, rslv); - end if; - end function \?>\; - - function \?>=\ (L, R : UNRESOLVED_sfixed) return STD_ULOGIC is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (lresize'length-1 downto 0); - begin -- ?>= - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "fixed_pkg:" - & """?>="": null detected, returning X" - severity warning; - return 'X'; - else - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - return \?>=\ (lslv, rslv); - end if; - end function \?>=\; - - function \?<\ (L, R : UNRESOLVED_sfixed) return STD_ULOGIC is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (lresize'length-1 downto 0); - begin -- ?< - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "fixed_pkg:" - & """?<"": null detected, returning X" - severity warning; - return 'X'; - else - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - return \?<\ (lslv, rslv); - end if; - end function \?<\; - - function \?<=\ (L, R : UNRESOLVED_sfixed) return STD_ULOGIC is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (lresize'length-1 downto 0); - begin -- ?<= - if ((l'length < 1) or (r'length < 1)) then - assert NO_WARNING - report "fixed_pkg:" - & """?<="": null detected, returning X" - severity warning; - return 'X'; - else - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - return \?<=\ (lslv, rslv); - end if; - end function \?<=\; - - -- Match function, similar to "std_match" from numeric_std - function std_match (L, R : UNRESOLVED_ufixed) return BOOLEAN is - begin - if (L'high = R'high and L'low = R'low) then - return std_match(to_sulv(L), to_sulv(R)); - else - assert NO_WARNING - report "fixed_pkg:" - & "STD_MATCH: L'RANGE /= R'RANGE, returning FALSE" - severity warning; - return false; - end if; - end function std_match; - - function std_match (L, R : UNRESOLVED_sfixed) return BOOLEAN is - begin - if (L'high = R'high and L'low = R'low) then - return std_match(to_sulv(L), to_sulv(R)); - else - assert NO_WARNING - report "fixed_pkg:" - & "STD_MATCH: L'RANGE /= R'RANGE, returning FALSE" - severity warning; - return false; - end if; - end function std_match; - - -- compare functions - function "=" ( - l, r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (lresize'length-1 downto 0); - begin - if (l'length < 1 or r'length < 1) then - assert NO_WARNING - report "fixed_pkg:" - & """="": null argument detected, returning FALSE" - severity warning; - return false; - elsif (Is_X(l) or Is_X(r)) then - assert NO_WARNING - report "fixed_pkg:" - & """="": metavalue detected, returning FALSE" - severity warning; - return false; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - return lslv = rslv; - end function "="; - - function "=" ( - l, r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (lresize'length-1 downto 0); - begin - if (l'length < 1 or r'length < 1) then - assert NO_WARNING - report "fixed_pkg:" - & """="": null argument detected, returning FALSE" - severity warning; - return false; - elsif (Is_X(l) or Is_X(r)) then - assert NO_WARNING - report "fixed_pkg:" - & """="": metavalue detected, returning FALSE" - severity warning; - return false; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - return lslv = rslv; - end function "="; - - function "/=" ( - l, r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (lresize'length-1 downto 0); - begin - if (l'length < 1 or r'length < 1) then - assert NO_WARNING - report "fixed_pkg:" - & """/="": null argument detected, returning TRUE" - severity warning; - return true; - elsif (Is_X(l) or Is_X(r)) then - assert NO_WARNING - report "fixed_pkg:" - & """/="": metavalue detected, returning TRUE" - severity warning; - return true; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - return lslv /= rslv; - end function "/="; - - function "/=" ( - l, r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (lresize'length-1 downto 0); - begin - if (l'length < 1 or r'length < 1) then - assert NO_WARNING - report "fixed_pkg:" - & """/="": null argument detected, returning TRUE" - severity warning; - return true; - elsif (Is_X(l) or Is_X(r)) then - assert NO_WARNING - report "fixed_pkg:" - & """/="": metavalue detected, returning TRUE" - severity warning; - return true; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - return lslv /= rslv; - end function "/="; - - function ">" ( - l, r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (lresize'length-1 downto 0); - begin - if (l'length < 1 or r'length < 1) then - assert NO_WARNING - report "fixed_pkg:" - & """>"": null argument detected, returning FALSE" - severity warning; - return false; - elsif (Is_X(l) or Is_X(r)) then - assert NO_WARNING - report "fixed_pkg:" - & """>"": metavalue detected, returning FALSE" - severity warning; - return false; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - return lslv > rslv; - end function ">"; - - function ">" ( - l, r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (lresize'length-1 downto 0); - begin - if (l'length < 1 or r'length < 1) then - assert NO_WARNING - report "fixed_pkg:" - & """>"": null argument detected, returning FALSE" - severity warning; - return false; - elsif (Is_X(l) or Is_X(r)) then - assert NO_WARNING - report "fixed_pkg:" - & """>"": metavalue detected, returning FALSE" - severity warning; - return false; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - return lslv > rslv; - end function ">"; - - function "<" ( - l, r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (lresize'length-1 downto 0); - begin - if (l'length < 1 or r'length < 1) then - assert NO_WARNING - report "fixed_pkg:" - & """<"": null argument detected, returning FALSE" - severity warning; - return false; - elsif (Is_X(l) or Is_X(r)) then - assert NO_WARNING - report "fixed_pkg:" - & """<"": metavalue detected, returning FALSE" - severity warning; - return false; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - return lslv < rslv; - end function "<"; - - function "<" ( - l, r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (lresize'length-1 downto 0); - begin - if (l'length < 1 or r'length < 1) then - assert NO_WARNING - report "fixed_pkg:" - & """<"": null argument detected, returning FALSE" - severity warning; - return false; - elsif (Is_X(l) or Is_X(r)) then - assert NO_WARNING - report "fixed_pkg:" - & """<"": metavalue detected, returning FALSE" - severity warning; - return false; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - return lslv < rslv; - end function "<"; - - function ">=" ( - l, r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (lresize'length-1 downto 0); - begin - if (l'length < 1 or r'length < 1) then - assert NO_WARNING - report "fixed_pkg:" - & """>="": null argument detected, returning FALSE" - severity warning; - return false; - elsif (Is_X(l) or Is_X(r)) then - assert NO_WARNING - report "fixed_pkg:" - & """>="": metavalue detected, returning FALSE" - severity warning; - return false; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - return lslv >= rslv; - end function ">="; - - function ">=" ( - l, r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (lresize'length-1 downto 0); - begin - if (l'length < 1 or r'length < 1) then - assert NO_WARNING - report "fixed_pkg:" - & """>="": null argument detected, returning FALSE" - severity warning; - return false; - elsif (Is_X(l) or Is_X(r)) then - assert NO_WARNING - report "fixed_pkg:" - & """>="": metavalue detected, returning FALSE" - severity warning; - return false; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - return lslv >= rslv; - end function ">="; - - function "<=" ( - l, r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - variable lslv, rslv : UNSIGNED (lresize'length-1 downto 0); - begin - if (l'length < 1 or r'length < 1) then - assert NO_WARNING - report "fixed_pkg:" - & """<="": null argument detected, returning FALSE" - severity warning; - return false; - elsif (Is_X(l) or Is_X(r)) then - assert NO_WARNING - report "fixed_pkg:" - & """<="": metavalue detected, returning FALSE" - severity warning; - return false; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_uns (lresize); - rslv := to_uns (rresize); - return lslv <= rslv; - end function "<="; - - function "<=" ( - l, r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - variable lslv, rslv : SIGNED (lresize'length-1 downto 0); - begin - if (l'length < 1 or r'length < 1) then - assert NO_WARNING - report "fixed_pkg:" - & """<="": null argument detected, returning FALSE" - severity warning; - return false; - elsif (Is_X(l) or Is_X(r)) then - assert NO_WARNING - report "fixed_pkg:" - & """<="": metavalue detected, returning FALSE" - severity warning; - return false; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - lslv := to_s (lresize); - rslv := to_s (rresize); - return lslv <= rslv; - end function "<="; - - -- overloads of the default maximum and minimum functions - function maximum (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - begin - if (l'length < 1 or r'length < 1) then - return NAUF; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - if lresize > rresize then return lresize; - else return rresize; - end if; - end function maximum; - - function maximum (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - begin - if (l'length < 1 or r'length < 1) then - return NASF; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - if lresize > rresize then return lresize; - else return rresize; - end if; - end function maximum; - - function minimum (l, r : UNRESOLVED_ufixed) return UNRESOLVED_ufixed is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_ufixed (left_index downto right_index); - begin - if (l'length < 1 or r'length < 1) then - return NAUF; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - if lresize > rresize then return rresize; - else return lresize; - end if; - end function minimum; - - function minimum (l, r : UNRESOLVED_sfixed) return UNRESOLVED_sfixed is - constant left_index : INTEGER := maximum(l'high, r'high); - constant right_index : INTEGER := mins(l'low, r'low); - variable lresize, rresize : UNRESOLVED_sfixed (left_index downto right_index); - begin - if (l'length < 1 or r'length < 1) then - return NASF; - end if; - lresize := resize (l, left_index, right_index); - rresize := resize (r, left_index, right_index); - if lresize > rresize then return rresize; - else return lresize; - end if; - end function minimum; - - function to_ufixed ( - arg : NATURAL; -- integer - constant left_index : INTEGER; -- left index (high index) - constant right_index : INTEGER := 0; -- right index - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_ufixed is - constant fw : INTEGER := mins (right_index, right_index); -- catch literals - variable result : UNRESOLVED_ufixed (left_index downto fw); - variable sresult : UNRESOLVED_ufixed (left_index downto 0) := - (others => '0'); -- integer portion - variable argx : NATURAL; -- internal version of arg - begin - if (result'length < 1) then - return NAUF; - end if; - if arg /= 0 then - argx := arg; - for I in 0 to sresult'left loop - if (argx mod 2) = 0 then - sresult(I) := '0'; - else - sresult(I) := '1'; - end if; - argx := argx/2; - end loop; - if argx /= 0 then - assert NO_WARNING - report "fixed_pkg:" - & "TO_UFIXED(NATURAL): vector truncated" - severity warning; - if overflow_style = fixed_saturate then - return saturate (left_index, right_index); - end if; - end if; - result := resize (arg => sresult, - left_index => left_index, - right_index => right_index, - round_style => round_style, - overflow_style => overflow_style); - else - result := (others => '0'); - end if; - return result; - end function to_ufixed; - - function to_sfixed ( - arg : INTEGER; -- integer - constant left_index : INTEGER; -- left index (high index) - constant right_index : INTEGER := 0; -- right index - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_sfixed is - constant fw : INTEGER := mins (right_index, right_index); -- catch literals - variable result : UNRESOLVED_sfixed (left_index downto fw); - variable sresult : UNRESOLVED_sfixed (left_index downto 0) := - (others => '0'); -- integer portion - variable argx : INTEGER; -- internal version of arg - variable sign : STD_ULOGIC; -- sign of input - begin - if (result'length < 1) then -- null range - return NASF; - end if; - if arg /= 0 then - if (arg < 0) then - sign := '1'; - argx := -(arg + 1); - else - sign := '0'; - argx := arg; - end if; - for I in 0 to sresult'left loop - if (argx mod 2) = 0 then - sresult(I) := sign; - else - sresult(I) := not sign; - end if; - argx := argx/2; - end loop; - if argx /= 0 or left_index < 0 or sign /= sresult(sresult'left) then - assert NO_WARNING - report "fixed_pkg:" - & "TO_SFIXED(INTEGER): vector truncated" - severity warning; - if overflow_style = fixed_saturate then -- saturate - if arg < 0 then - result := not saturate (result'high, result'low); -- underflow - else - result := saturate (result'high, result'low); -- overflow - end if; - return result; - end if; - end if; - result := resize (arg => sresult, - left_index => left_index, - right_index => right_index, - round_style => round_style, - overflow_style => overflow_style); - else - result := (others => '0'); - end if; - return result; - end function to_sfixed; - - function to_ufixed ( - arg : REAL; -- real - constant left_index : INTEGER; -- left index (high index) - constant right_index : INTEGER; -- right index - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style; - constant guard_bits : NATURAL := fixed_guard_bits) -- # of guard bits - return UNRESOLVED_ufixed is - constant fw : INTEGER := mins (right_index, right_index); -- catch literals - variable result : UNRESOLVED_ufixed (left_index downto fw) := - (others => '0'); - variable Xresult : UNRESOLVED_ufixed (left_index downto - fw-guard_bits) := - (others => '0'); - variable presult : REAL; --- variable overflow_needed : BOOLEAN; - begin - -- If negative or null range, return. - if (left_index < fw) then - return NAUF; - end if; - if (arg < 0.0) then - report "fixed_pkg:" - & "TO_UFIXED: Negative argument passed " - & REAL'image(arg) severity error; - return result; - end if; - presult := arg; - if presult >= (2.0**(left_index+1)) then - assert NO_WARNING report "fixed_pkg:" - & "TO_UFIXED(REAL): vector truncated" - severity warning; - if overflow_style = fixed_wrap then - presult := presult mod (2.0**(left_index+1)); -- wrap - else - return saturate (result'high, result'low); - end if; - end if; - for i in Xresult'range loop - if presult >= 2.0**i then - Xresult(i) := '1'; - presult := presult - 2.0**i; - else - Xresult(i) := '0'; - end if; - end loop; - if guard_bits > 0 and round_style = fixed_round then - result := round_fixed (arg => Xresult (left_index - downto right_index), - remainder => Xresult (right_index-1 downto - right_index-guard_bits), - overflow_style => overflow_style); - else - result := Xresult (result'range); - end if; - return result; - end function to_ufixed; - - function to_sfixed ( - arg : REAL; -- real - constant left_index : INTEGER; -- left index (high index) - constant right_index : INTEGER; -- right index - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style; - constant guard_bits : NATURAL := fixed_guard_bits) -- # of guard bits - return UNRESOLVED_sfixed is - constant fw : INTEGER := mins (right_index, right_index); -- catch literals - variable result : UNRESOLVED_sfixed (left_index downto fw) := - (others => '0'); - variable Xresult : UNRESOLVED_sfixed (left_index+1 downto fw-guard_bits) := - (others => '0'); - variable presult : REAL; - begin - if (left_index < fw) then -- null range - return NASF; - end if; - if (arg >= (2.0**left_index) or arg < -(2.0**left_index)) then - assert NO_WARNING report "fixed_pkg:" - & "TO_SFIXED(REAL): vector truncated" - severity warning; - if overflow_style = fixed_saturate then - if arg < 0.0 then -- saturate - result := not saturate (result'high, result'low); -- underflow - else - result := saturate (result'high, result'low); -- overflow - end if; - return result; - else - presult := abs(arg) mod (2.0**(left_index+1)); -- wrap - end if; - else - presult := abs(arg); - end if; - for i in Xresult'range loop - if presult >= 2.0**i then - Xresult(i) := '1'; - presult := presult - 2.0**i; - else - Xresult(i) := '0'; - end if; - end loop; - if arg < 0.0 then - Xresult := to_fixed(-to_s(Xresult), Xresult'high, Xresult'low); - end if; - if guard_bits > 0 and round_style = fixed_round then - result := round_fixed (arg => Xresult (left_index - downto right_index), - remainder => Xresult (right_index-1 downto - right_index-guard_bits), - overflow_style => overflow_style); - else - result := Xresult (result'range); - end if; - return result; - end function to_sfixed; - - function to_ufixed ( - arg : UNSIGNED; -- unsigned - constant left_index : INTEGER; -- left index (high index) - constant right_index : INTEGER := 0; -- right index - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_ufixed is - constant ARG_LEFT : INTEGER := ARG'length-1; - alias XARG : UNSIGNED(ARG_LEFT downto 0) is ARG; - variable result : UNRESOLVED_ufixed (left_index downto right_index); - begin - if arg'length < 1 or (left_index < right_index) then - return NAUF; - end if; - result := resize (arg => UNRESOLVED_ufixed (XARG), - left_index => left_index, - right_index => right_index, - round_style => round_style, - overflow_style => overflow_style); - return result; - end function to_ufixed; - - -- converted version - function to_ufixed ( - arg : UNSIGNED) -- unsigned - return UNRESOLVED_ufixed is - constant ARG_LEFT : INTEGER := ARG'length-1; - alias XARG : UNSIGNED(ARG_LEFT downto 0) is ARG; - begin - if arg'length < 1 then - return NAUF; - end if; - return UNRESOLVED_ufixed(xarg); - end function to_ufixed; - - function to_sfixed ( - arg : SIGNED; -- signed - constant left_index : INTEGER; -- left index (high index) - constant right_index : INTEGER := 0; -- right index - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_sfixed is - constant ARG_LEFT : INTEGER := ARG'length-1; - alias XARG : SIGNED(ARG_LEFT downto 0) is ARG; - variable result : UNRESOLVED_sfixed (left_index downto right_index); - begin - if arg'length < 1 or (left_index < right_index) then - return NASF; - end if; - result := resize (arg => UNRESOLVED_sfixed (XARG), - left_index => left_index, - right_index => right_index, - round_style => round_style, - overflow_style => overflow_style); - return result; - end function to_sfixed; - - -- converted version - function to_sfixed ( - arg : SIGNED) -- signed - return UNRESOLVED_sfixed is - constant ARG_LEFT : INTEGER := ARG'length-1; - alias XARG : SIGNED(ARG_LEFT downto 0) is ARG; - begin - if arg'length < 1 then - return NASF; - end if; - return UNRESOLVED_sfixed(xarg); - end function to_sfixed; - - function to_sfixed (arg : UNRESOLVED_ufixed) return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (arg'high+1 downto arg'low); - begin - if arg'length < 1 then - return NASF; - end if; - result (arg'high downto arg'low) := UNRESOLVED_sfixed(cleanvec(arg)); - result (arg'high+1) := '0'; - return result; - end function to_sfixed; - - -- Because of the fairly complicated sizing rules in the fixed point - -- packages these functions are provided to compute the result ranges - -- Example: - -- signal uf1 : ufixed (3 downto -3); - -- signal uf2 : ufixed (4 downto -2); - -- signal uf1multuf2 : ufixed (ufixed_high (3, -3, '*', 4, -2) downto - -- ufixed_low (3, -3, '*', 4, -2)); - -- uf1multuf2 <= uf1 * uf2; - -- Valid characters: '+', '-', '*', '/', 'r' or 'R' (rem), 'm' or 'M' (mod), - -- '1' (reciprocal), 'A', 'a' (abs), 'N', 'n' (-sfixed) - function ufixed_high (left_index, right_index : INTEGER; - operation : CHARACTER := 'X'; - left_index2, right_index2 : INTEGER := 0) - return INTEGER is - begin - case operation is - when '+'| '-' => return maximum (left_index, left_index2) + 1; - when '*' => return left_index + left_index2 + 1; - when '/' => return left_index - right_index2; - when '1' => return -right_index; -- reciprocal - when 'R'|'r' => return mins (left_index, left_index2); -- "rem" - when 'M'|'m' => return mins (left_index, left_index2); -- "mod" - when others => return left_index; -- For abs and default - end case; - end function ufixed_high; - - function ufixed_low (left_index, right_index : INTEGER; - operation : CHARACTER := 'X'; - left_index2, right_index2 : INTEGER := 0) - return INTEGER is - begin - case operation is - when '+'| '-' => return mins (right_index, right_index2); - when '*' => return right_index + right_index2; - when '/' => return right_index - left_index2 - 1; - when '1' => return -left_index - 1; -- reciprocal - when 'R'|'r' => return mins (right_index, right_index2); -- "rem" - when 'M'|'m' => return mins (right_index, right_index2); -- "mod" - when others => return right_index; -- for abs and default - end case; - end function ufixed_low; - - function sfixed_high (left_index, right_index : INTEGER; - operation : CHARACTER := 'X'; - left_index2, right_index2 : INTEGER := 0) - return INTEGER is - begin - case operation is - when '+'| '-' => return maximum (left_index, left_index2) + 1; - when '*' => return left_index + left_index2 + 1; - when '/' => return left_index - right_index2 + 1; - when '1' => return -right_index + 1; -- reciprocal - when 'R'|'r' => return mins (left_index, left_index2); -- "rem" - when 'M'|'m' => return left_index2; -- "mod" - when 'A'|'a' => return left_index + 1; -- "abs" - when 'N'|'n' => return left_index + 1; -- -sfixed - when others => return left_index; - end case; - end function sfixed_high; - - function sfixed_low (left_index, right_index : INTEGER; - operation : CHARACTER := 'X'; - left_index2, right_index2 : INTEGER := 0) - return INTEGER is - begin - case operation is - when '+'| '-' => return mins (right_index, right_index2); - when '*' => return right_index + right_index2; - when '/' => return right_index - left_index2; - when '1' => return -left_index; -- reciprocal - when 'R'|'r' => return mins (right_index, right_index2); -- "rem" - when 'M'|'m' => return mins (right_index, right_index2); -- "mod" - when others => return right_index; -- default for abs, neg and default - end case; - end function sfixed_low; - - -- Same as above, but using the "size_res" input only for their ranges: - -- signal uf1multuf2 : ufixed (ufixed_high (uf1, '*', uf2) downto - -- ufixed_low (uf1, '*', uf2)); - -- uf1multuf2 <= uf1 * uf2; - function ufixed_high (size_res : UNRESOLVED_ufixed; - operation : CHARACTER := 'X'; - size_res2 : UNRESOLVED_ufixed) - return INTEGER is - begin - return ufixed_high (left_index => size_res'high, - right_index => size_res'low, - operation => operation, - left_index2 => size_res2'high, - right_index2 => size_res2'low); - end function ufixed_high; - - function ufixed_low (size_res : UNRESOLVED_ufixed; - operation : CHARACTER := 'X'; - size_res2 : UNRESOLVED_ufixed) - return INTEGER is - begin - return ufixed_low (left_index => size_res'high, - right_index => size_res'low, - operation => operation, - left_index2 => size_res2'high, - right_index2 => size_res2'low); - end function ufixed_low; - - function sfixed_high (size_res : UNRESOLVED_sfixed; - operation : CHARACTER := 'X'; - size_res2 : UNRESOLVED_sfixed) - return INTEGER is - begin - return sfixed_high (left_index => size_res'high, - right_index => size_res'low, - operation => operation, - left_index2 => size_res2'high, - right_index2 => size_res2'low); - end function sfixed_high; - - function sfixed_low (size_res : UNRESOLVED_sfixed; - operation : CHARACTER := 'X'; - size_res2 : UNRESOLVED_sfixed) - return INTEGER is - begin - return sfixed_low (left_index => size_res'high, - right_index => size_res'low, - operation => operation, - left_index2 => size_res2'high, - right_index2 => size_res2'low); - end function sfixed_low; - - -- purpose: returns a saturated number - function saturate ( - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_ufixed is - constant sat : UNRESOLVED_ufixed (left_index downto right_index) := - (others => '1'); - begin - return sat; - end function saturate; - - -- purpose: returns a saturated number - function saturate ( - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_sfixed is - variable sat : UNRESOLVED_sfixed (left_index downto right_index) := - (others => '1'); - begin - -- saturate positive, to saturate negative, just do "not saturate()" - sat (left_index) := '0'; - return sat; - end function saturate; - - function saturate ( - size_res : UNRESOLVED_ufixed) -- only the size of this is used - return UNRESOLVED_ufixed is - begin - return saturate (size_res'high, size_res'low); - end function saturate; - - function saturate ( - size_res : UNRESOLVED_sfixed) -- only the size of this is used - return UNRESOLVED_sfixed is - begin - return saturate (size_res'high, size_res'low); - end function saturate; - - -- As a concession to those who use a graphical DSP environment, - -- these functions take parameters in those tools format and create - -- fixed point numbers. These functions are designed to convert from - -- a std_logic_vector to the VHDL fixed point format using the conventions - -- of these packages. In a pure VHDL environment you should use the - -- "to_ufixed" and "to_sfixed" routines. - -- Unsigned fixed point - function to_UFix ( - arg : STD_ULOGIC_VECTOR; - width : NATURAL; -- width of vector - fraction : NATURAL) -- width of fraction - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (width-fraction-1 downto -fraction); - begin - if (arg'length /= result'length) then - report "fixed_pkg:" - & "TO_UFIX (STD_ULOGIC_VECTOR) " - & "Vector lengths do not match. Input length is " - & INTEGER'image(arg'length) & " and output will be " - & INTEGER'image(result'length) & " wide." - severity error; - return NAUF; - else - result := to_ufixed (arg, result'high, result'low); - return result; - end if; - end function to_UFix; - - -- signed fixed point - function to_SFix ( - arg : STD_ULOGIC_VECTOR; - width : NATURAL; -- width of vector - fraction : NATURAL) -- width of fraction - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (width-fraction-1 downto -fraction); - begin - if (arg'length /= result'length) then - report "fixed_pkg:" - & "TO_SFIX (STD_ULOGIC_VECTOR) " - & "Vector lengths do not match. Input length is " - & INTEGER'image(arg'length) & " and output will be " - & INTEGER'image(result'length) & " wide." - severity error; - return NASF; - else - result := to_sfixed (arg, result'high, result'low); - return result; - end if; - end function to_SFix; - - -- finding the bounds of a number. These functions can be used like this: - -- signal xxx : ufixed (7 downto -3); - -- -- Which is the same as "ufixed (UFix_high (11,3) downto UFix_low(11,3))" - -- signal yyy : ufixed (UFix_high (11, 3, "+", 11, 3) - -- downto UFix_low(11, 3, "+", 11, 3)); - -- Where "11" is the width of xxx (xxx'length), - -- and 3 is the lower bound (abs (xxx'low)) - -- In a pure VHDL environment use "ufixed_high" and "ufixed_low" - function ufix_high ( - width, fraction : NATURAL; - operation : CHARACTER := 'X'; - width2, fraction2 : NATURAL := 0) - return INTEGER is - begin - return ufixed_high (left_index => width - 1 - fraction, - right_index => -fraction, - operation => operation, - left_index2 => width2 - 1 - fraction2, - right_index2 => -fraction2); - end function ufix_high; - - function ufix_low ( - width, fraction : NATURAL; - operation : CHARACTER := 'X'; - width2, fraction2 : NATURAL := 0) - return INTEGER is - begin - return ufixed_low (left_index => width - 1 - fraction, - right_index => -fraction, - operation => operation, - left_index2 => width2 - 1 - fraction2, - right_index2 => -fraction2); - end function ufix_low; - - function sfix_high ( - width, fraction : NATURAL; - operation : CHARACTER := 'X'; - width2, fraction2 : NATURAL := 0) - return INTEGER is - begin - return sfixed_high (left_index => width - fraction, - right_index => -fraction, - operation => operation, - left_index2 => width2 - fraction2, - right_index2 => -fraction2); - end function sfix_high; - - function sfix_low ( - width, fraction : NATURAL; - operation : CHARACTER := 'X'; - width2, fraction2 : NATURAL := 0) - return INTEGER is - begin - return sfixed_low (left_index => width - fraction, - right_index => -fraction, - operation => operation, - left_index2 => width2 - fraction2, - right_index2 => -fraction2); - end function sfix_low; - - function to_unsigned ( - arg : UNRESOLVED_ufixed; -- ufixed point input - constant size : NATURAL; -- length of output - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNSIGNED is - begin - return to_uns(resize (arg => arg, - left_index => size-1, - right_index => 0, - round_style => round_style, - overflow_style => overflow_style)); - end function to_unsigned; - - function to_unsigned ( - arg : UNRESOLVED_ufixed; -- ufixed point input - size_res : UNSIGNED; -- length of output - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNSIGNED is - begin - return to_unsigned (arg => arg, - size => size_res'length, - round_style => round_style, - overflow_style => overflow_style); - end function to_unsigned; - - function to_signed ( - arg : UNRESOLVED_sfixed; -- sfixed point input - constant size : NATURAL; -- length of output - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return SIGNED is - begin - return to_s(resize (arg => arg, - left_index => size-1, - right_index => 0, - round_style => round_style, - overflow_style => overflow_style)); - end function to_signed; - - function to_signed ( - arg : UNRESOLVED_sfixed; -- sfixed point input - size_res : SIGNED; -- used for length of output - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return SIGNED is - begin - return to_signed (arg => arg, - size => size_res'length, - round_style => round_style, - overflow_style => overflow_style); - end function to_signed; - - function to_real ( - arg : UNRESOLVED_ufixed) -- ufixed point input - return REAL is - constant left_index : INTEGER := arg'high; - constant right_index : INTEGER := arg'low; - variable result : REAL; -- result - variable arg_int : UNRESOLVED_ufixed (left_index downto right_index); - begin - if (arg'length < 1) then - return 0.0; - end if; - arg_int := to_x01(cleanvec(arg)); - if (Is_X(arg_int)) then - assert NO_WARNING - report "fixed_pkg:" - & "TO_REAL (ufixed): metavalue detected, returning 0.0" - severity warning; - return 0.0; - end if; - result := 0.0; - for i in arg_int'range loop - if (arg_int(i) = '1') then - result := result + (2.0**i); - end if; - end loop; - return result; - end function to_real; - - function to_real ( - arg : UNRESOLVED_sfixed) -- ufixed point input - return REAL is - constant left_index : INTEGER := arg'high; - constant right_index : INTEGER := arg'low; - variable result : REAL; -- result - variable arg_int : UNRESOLVED_sfixed (left_index downto right_index); - -- unsigned version of argument - variable arg_uns : UNRESOLVED_ufixed (left_index downto right_index); - -- absolute of argument - begin - if (arg'length < 1) then - return 0.0; - end if; - arg_int := to_x01(cleanvec(arg)); - if (Is_X(arg_int)) then - assert NO_WARNING - report "fixed_pkg:" - & "TO_REAL (sfixed): metavalue detected, returning 0.0" - severity warning; - return 0.0; - end if; - arg_uns := to_ufixed (arg_int); - result := to_real (arg_uns); - if (arg_int(arg_int'high) = '1') then - result := -result; - end if; - return result; - end function to_real; - - function to_integer ( - arg : UNRESOLVED_ufixed; -- fixed point input - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return NATURAL is - constant left_index : INTEGER := arg'high; - variable arg_uns : UNSIGNED (left_index+1 downto 0) - := (others => '0'); - begin - if (arg'length < 1) then - return 0; - end if; - if (Is_X (arg)) then - assert NO_WARNING - report "fixed_pkg:" - & "TO_INTEGER (ufixed): metavalue detected, returning 0" - severity warning; - return 0; - end if; - if (left_index < -1) then - return 0; - end if; - arg_uns := to_uns(resize (arg => arg, - left_index => arg_uns'high, - right_index => 0, - round_style => round_style, - overflow_style => overflow_style)); - return to_integer (arg_uns); - end function to_integer; - - function to_integer ( - arg : UNRESOLVED_sfixed; -- fixed point input - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return INTEGER is - constant left_index : INTEGER := arg'high; - constant right_index : INTEGER := arg'low; - variable arg_s : SIGNED (left_index+1 downto 0); - begin - if (arg'length < 1) then - return 0; - end if; - if (Is_X (arg)) then - assert NO_WARNING - report "fixed_pkg:" - & "TO_INTEGER (sfixed): metavalue detected, returning 0" - severity warning; - return 0; - end if; - if (left_index < -1) then - return 0; - end if; - arg_s := to_s(resize (arg => arg, - left_index => arg_s'high, - right_index => 0, - round_style => round_style, - overflow_style => overflow_style)); - return to_integer (arg_s); - end function to_integer; - - function to_01 ( - s : UNRESOLVED_ufixed; -- ufixed point input - constant XMAP : STD_ULOGIC := '0') -- Map x to - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (s'range); -- result - begin - if (s'length < 1) then - assert NO_WARNING - report "fixed_pkg:" - & "TO_01(ufixed): null detected, returning NULL" - severity warning; - return NAUF; - end if; - return to_fixed (to_01(to_uns(s), XMAP), s'high, s'low); - end function to_01; - - function to_01 ( - s : UNRESOLVED_sfixed; -- sfixed point input - constant XMAP : STD_ULOGIC := '0') -- Map x to - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (s'range); - begin - if (s'length < 1) then - assert NO_WARNING - report "fixed_pkg:" - & "TO_01(sfixed): null detected, returning NULL" - severity warning; - return NASF; - end if; - return to_fixed (to_01(to_s(s), XMAP), s'high, s'low); - end function to_01; - - function Is_X ( - arg : UNRESOLVED_ufixed) - return BOOLEAN is - variable argslv : STD_ULOGIC_VECTOR (arg'length-1 downto 0); -- slv - begin - argslv := to_sulv(arg); - return Is_X (argslv); - end function Is_X; - - function Is_X ( - arg : UNRESOLVED_sfixed) - return BOOLEAN is - variable argslv : STD_ULOGIC_VECTOR (arg'length-1 downto 0); -- slv - begin - argslv := to_sulv(arg); - return Is_X (argslv); - end function Is_X; - - function To_X01 ( - arg : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed is - begin - return to_ufixed (To_X01(to_sulv(arg)), arg'high, arg'low); - end function To_X01; - - function to_X01 ( - arg : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - begin - return to_sfixed (To_X01(to_sulv(arg)), arg'high, arg'low); - end function To_X01; - - function To_X01Z ( - arg : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed is - begin - return to_ufixed (To_X01Z(to_sulv(arg)), arg'high, arg'low); - end function To_X01Z; - - function to_X01Z ( - arg : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - begin - return to_sfixed (To_X01Z(to_sulv(arg)), arg'high, arg'low); - end function To_X01Z; - - function To_UX01 ( - arg : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed is - begin - return to_ufixed (To_UX01(to_sulv(arg)), arg'high, arg'low); - end function To_UX01; - - function to_UX01 ( - arg : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - begin - return to_sfixed (To_UX01(to_sulv(arg)), arg'high, arg'low); - end function To_UX01; - - function resize ( - arg : UNRESOLVED_ufixed; -- input - constant left_index : INTEGER; -- integer portion - constant right_index : INTEGER; -- size of fraction - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_ufixed is - constant arghigh : INTEGER := maximum (arg'high, arg'low); - constant arglow : INTEGER := mine (arg'high, arg'low); - variable invec : UNRESOLVED_ufixed (arghigh downto arglow); - variable result : UNRESOLVED_ufixed(left_index downto right_index) := - (others => '0'); - variable needs_rounding : BOOLEAN := false; - begin -- resize - if (arg'length < 1) or (result'length < 1) then - return NAUF; - elsif (invec'length < 1) then - return result; -- string literal value - else - invec := cleanvec(arg); - if (right_index > arghigh) then -- return top zeros - needs_rounding := (round_style = fixed_round) and - (right_index = arghigh+1); - elsif (left_index < arglow) then -- return overflow - if (overflow_style = fixed_saturate) and - (or_reduce(to_sulv(invec)) = '1') then - result := saturate (result'high, result'low); -- saturate - end if; - elsif (arghigh > left_index) then - -- wrap or saturate? - if (overflow_style = fixed_saturate and - or_reduce (to_sulv(invec(arghigh downto left_index+1))) = '1') - then - result := saturate (result'high, result'low); -- saturate - else - if (arglow >= right_index) then - result (left_index downto arglow) := - invec(left_index downto arglow); - else - result (left_index downto right_index) := - invec (left_index downto right_index); - needs_rounding := (round_style = fixed_round); -- round - end if; - end if; - else -- arghigh <= integer width - if (arglow >= right_index) then - result (arghigh downto arglow) := invec; - else - result (arghigh downto right_index) := - invec (arghigh downto right_index); - needs_rounding := (round_style = fixed_round); -- round - end if; - end if; - -- Round result - if needs_rounding then - result := round_fixed (arg => result, - remainder => invec (right_index-1 - downto arglow), - overflow_style => overflow_style); - end if; - return result; - end if; - end function resize; - - function resize ( - arg : UNRESOLVED_sfixed; -- input - constant left_index : INTEGER; -- integer portion - constant right_index : INTEGER; -- size of fraction - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_sfixed is - constant arghigh : INTEGER := maximum (arg'high, arg'low); - constant arglow : INTEGER := mine (arg'high, arg'low); - variable invec : UNRESOLVED_sfixed (arghigh downto arglow); - variable result : UNRESOLVED_sfixed(left_index downto right_index) := - (others => '0'); - variable reduced : STD_ULOGIC; - variable needs_rounding : BOOLEAN := false; -- rounding - begin -- resize - if (arg'length < 1) or (result'length < 1) then - return NASF; - elsif (invec'length < 1) then - return result; -- string literal value - else - invec := cleanvec(arg); - if (right_index > arghigh) then -- return top zeros - if (arg'low /= INTEGER'low) then -- check for a literal - result := (others => arg(arghigh)); -- sign extend - end if; - needs_rounding := (round_style = fixed_round) and - (right_index = arghigh+1); - elsif (left_index < arglow) then -- return overflow - if (overflow_style = fixed_saturate) then - reduced := or_reduce (to_sulv(invec)); - if (reduced = '1') then - if (invec(arghigh) = '0') then - -- saturate POSITIVE - result := saturate (result'high, result'low); - else - -- saturate negative - result := not saturate (result'high, result'low); - end if; - -- else return 0 (input was 0) - end if; - -- else return 0 (wrap) - end if; - elsif (arghigh > left_index) then - if (invec(arghigh) = '0') then - reduced := or_reduce (to_sulv(invec(arghigh-1 downto - left_index))); - if overflow_style = fixed_saturate and reduced = '1' then - -- saturate positive - result := saturate (result'high, result'low); - else - if (right_index > arglow) then - result := invec (left_index downto right_index); - needs_rounding := (round_style = fixed_round); - else - result (left_index downto arglow) := - invec (left_index downto arglow); - end if; - end if; - else - reduced := and_reduce (to_sulv(invec(arghigh-1 downto - left_index))); - if overflow_style = fixed_saturate and reduced = '0' then - result := not saturate (result'high, result'low); - else - if (right_index > arglow) then - result := invec (left_index downto right_index); - needs_rounding := (round_style = fixed_round); - else - result (left_index downto arglow) := - invec (left_index downto arglow); - end if; - end if; - end if; - else -- arghigh <= integer width - if (arglow >= right_index) then - result (arghigh downto arglow) := invec; - else - result (arghigh downto right_index) := - invec (arghigh downto right_index); - needs_rounding := (round_style = fixed_round); -- round - end if; - if (left_index > arghigh) then -- sign extend - result(left_index downto arghigh+1) := (others => invec(arghigh)); - end if; - end if; - -- Round result - if (needs_rounding) then - result := round_fixed (arg => result, - remainder => invec (right_index-1 - downto arglow), - overflow_style => overflow_style); - end if; - return result; - end if; - end function resize; - - -- size_res functions - -- These functions compute the size from a passed variable named "size_res" - -- The only part of this variable used it it's size, it is never passed - -- to a lower level routine. - function to_ufixed ( - arg : STD_ULOGIC_VECTOR; -- shifted vector - size_res : UNRESOLVED_ufixed) -- for size only - return UNRESOLVED_ufixed is - constant fw : INTEGER := mine (size_res'low, size_res'low); -- catch literals - variable result : UNRESOLVED_ufixed (size_res'left downto fw); - begin - if (result'length < 1 or arg'length < 1) then - return NAUF; - else - result := to_ufixed (arg => arg, - left_index => size_res'high, - right_index => size_res'low); - return result; - end if; - end function to_ufixed; - - function to_sfixed ( - arg : STD_ULOGIC_VECTOR; -- shifted vector - size_res : UNRESOLVED_sfixed) -- for size only - return UNRESOLVED_sfixed is - constant fw : INTEGER := mine (size_res'low, size_res'low); -- catch literals - variable result : UNRESOLVED_sfixed (size_res'left downto fw); - begin - if (result'length < 1 or arg'length < 1) then - return NASF; - else - result := to_sfixed (arg => arg, - left_index => size_res'high, - right_index => size_res'low); - return result; - end if; - end function to_sfixed; - - function to_ufixed ( - arg : NATURAL; -- integer - size_res : UNRESOLVED_ufixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_ufixed is - constant fw : INTEGER := mine (size_res'low, size_res'low); -- catch literals - variable result : UNRESOLVED_ufixed (size_res'left downto fw); - begin - if (result'length < 1) then - return NAUF; - else - result := to_ufixed (arg => arg, - left_index => size_res'high, - right_index => size_res'low, - round_style => round_style, - overflow_style => overflow_style); - return result; - end if; - end function to_ufixed; - - function to_sfixed ( - arg : INTEGER; -- integer - size_res : UNRESOLVED_sfixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_sfixed is - constant fw : INTEGER := mine (size_res'low, size_res'low); -- catch literals - variable result : UNRESOLVED_sfixed (size_res'left downto fw); - begin - if (result'length < 1) then - return NASF; - else - result := to_sfixed (arg => arg, - left_index => size_res'high, - right_index => size_res'low, - round_style => round_style, - overflow_style => overflow_style); - return result; - end if; - end function to_sfixed; - - function to_ufixed ( - arg : REAL; -- real - size_res : UNRESOLVED_ufixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style; - constant guard_bits : NATURAL := fixed_guard_bits) -- # of guard bits - return UNRESOLVED_ufixed is - constant fw : INTEGER := mine (size_res'low, size_res'low); -- catch literals - variable result : UNRESOLVED_ufixed (size_res'left downto fw); - begin - if (result'length < 1) then - return NAUF; - else - result := to_ufixed (arg => arg, - left_index => size_res'high, - right_index => size_res'low, - guard_bits => guard_bits, - round_style => round_style, - overflow_style => overflow_style); - return result; - end if; - end function to_ufixed; - - function to_sfixed ( - arg : REAL; -- real - size_res : UNRESOLVED_sfixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style; - constant guard_bits : NATURAL := fixed_guard_bits) -- # of guard bits - return UNRESOLVED_sfixed is - constant fw : INTEGER := mine (size_res'low, size_res'low); -- catch literals - variable result : UNRESOLVED_sfixed (size_res'left downto fw); - begin - if (result'length < 1) then - return NASF; - else - result := to_sfixed (arg => arg, - left_index => size_res'high, - right_index => size_res'low, - guard_bits => guard_bits, - round_style => round_style, - overflow_style => overflow_style); - return result; - end if; - end function to_sfixed; - - function to_ufixed ( - arg : UNSIGNED; -- unsigned - size_res : UNRESOLVED_ufixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_ufixed is - constant fw : INTEGER := mine (size_res'low, size_res'low); -- catch literals - variable result : UNRESOLVED_ufixed (size_res'left downto fw); - begin - if (result'length < 1 or arg'length < 1) then - return NAUF; - else - result := to_ufixed (arg => arg, - left_index => size_res'high, - right_index => size_res'low, - round_style => round_style, - overflow_style => overflow_style); - return result; - end if; - end function to_ufixed; - - function to_sfixed ( - arg : SIGNED; -- signed - size_res : UNRESOLVED_sfixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_sfixed is - constant fw : INTEGER := mine (size_res'low, size_res'low); -- catch literals - variable result : UNRESOLVED_sfixed (size_res'left downto fw); - begin - if (result'length < 1 or arg'length < 1) then - return NASF; - else - result := to_sfixed (arg => arg, - left_index => size_res'high, - right_index => size_res'low, - round_style => round_style, - overflow_style => overflow_style); - return result; - end if; - end function to_sfixed; - - function resize ( - arg : UNRESOLVED_ufixed; -- input - size_res : UNRESOLVED_ufixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_ufixed is - constant fw : INTEGER := mine (size_res'low, size_res'low); -- catch literals - variable result : UNRESOLVED_ufixed (size_res'high downto fw); - begin - if (result'length < 1 or arg'length < 1) then - return NAUF; - else - result := resize (arg => arg, - left_index => size_res'high, - right_index => size_res'low, - round_style => round_style, - overflow_style => overflow_style); - return result; - end if; - end function resize; - - function resize ( - arg : UNRESOLVED_sfixed; -- input - size_res : UNRESOLVED_sfixed; -- for size only - constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; - constant round_style : fixed_round_style_type := fixed_round_style) - return UNRESOLVED_sfixed is - constant fw : INTEGER := mine (size_res'low, size_res'low); -- catch literals - variable result : UNRESOLVED_sfixed (size_res'high downto fw); - begin - if (result'length < 1 or arg'length < 1) then - return NASF; - else - result := resize (arg => arg, - left_index => size_res'high, - right_index => size_res'low, - round_style => round_style, - overflow_style => overflow_style); - return result; - end if; - end function resize; - - -- Overloaded math functions for real - function "+" ( - l : UNRESOLVED_ufixed; -- fixed point input - r : REAL) - return UNRESOLVED_ufixed is - begin - return (l + to_ufixed (r, l'high, l'low)); - end function "+"; - - function "+" ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return UNRESOLVED_ufixed is - begin - return (to_ufixed (l, r'high, r'low) + r); - end function "+"; - - function "+" ( - l : UNRESOLVED_sfixed; -- fixed point input - r : REAL) - return UNRESOLVED_sfixed is - begin - return (l + to_sfixed (r, l'high, l'low)); - end function "+"; - - function "+" ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return UNRESOLVED_sfixed is - begin - return (to_sfixed (l, r'high, r'low) + r); - end function "+"; - - function "-" ( - l : UNRESOLVED_ufixed; -- fixed point input - r : REAL) - return UNRESOLVED_ufixed is - begin - return (l - to_ufixed (r, l'high, l'low)); - end function "-"; - - function "-" ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return UNRESOLVED_ufixed is - begin - return (to_ufixed (l, r'high, r'low) - r); - end function "-"; - - function "-" ( - l : UNRESOLVED_sfixed; -- fixed point input - r : REAL) - return UNRESOLVED_sfixed is - begin - return (l - to_sfixed (r, l'high, l'low)); - end function "-"; - - function "-" ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return UNRESOLVED_sfixed is - begin - return (to_sfixed (l, r'high, r'low) - r); - end function "-"; - - function "*" ( - l : UNRESOLVED_ufixed; -- fixed point input - r : REAL) - return UNRESOLVED_ufixed is - begin - return (l * to_ufixed (r, l'high, l'low)); - end function "*"; - - function "*" ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return UNRESOLVED_ufixed is - begin - return (to_ufixed (l, r'high, r'low) * r); - end function "*"; - - function "*" ( - l : UNRESOLVED_sfixed; -- fixed point input - r : REAL) - return UNRESOLVED_sfixed is - begin - return (l * to_sfixed (r, l'high, l'low)); - end function "*"; - - function "*" ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return UNRESOLVED_sfixed is - begin - return (to_sfixed (l, r'high, r'low) * r); - end function "*"; - --- function "/" ( --- l : UNRESOLVED_ufixed; -- fixed point input --- r : REAL) --- return UNRESOLVED_ufixed is --- begin --- return (l / to_ufixed (r, l'high, l'low)); --- end function "/"; - --- function "/" ( --- l : REAL; --- r : UNRESOLVED_ufixed) -- fixed point input --- return UNRESOLVED_ufixed is --- begin --- return (to_ufixed (l, r'high, r'low) / r); --- end function "/"; - --- function "/" ( --- l : UNRESOLVED_sfixed; -- fixed point input --- r : REAL) --- return UNRESOLVED_sfixed is --- begin --- return (l / to_sfixed (r, l'high, l'low)); --- end function "/"; - --- function "/" ( --- l : REAL; --- r : UNRESOLVED_sfixed) -- fixed point input --- return UNRESOLVED_sfixed is --- begin --- return (to_sfixed (l, r'high, r'low) / r); --- end function "/"; - --- function "rem" ( --- l : UNRESOLVED_ufixed; -- fixed point input --- r : REAL) --- return UNRESOLVED_ufixed is --- begin --- return (l rem to_ufixed (r, l'high, l'low)); --- end function "rem"; - --- function "rem" ( --- l : REAL; --- r : UNRESOLVED_ufixed) -- fixed point input --- return UNRESOLVED_ufixed is --- begin --- return (to_ufixed (l, r'high, r'low) rem r); --- end function "rem"; - --- function "rem" ( --- l : UNRESOLVED_sfixed; -- fixed point input --- r : REAL) --- return UNRESOLVED_sfixed is --- begin --- return (l rem to_sfixed (r, l'high, l'low)); --- end function "rem"; - --- function "rem" ( --- l : REAL; --- r : UNRESOLVED_sfixed) -- fixed point input --- return UNRESOLVED_sfixed is --- begin --- return (to_sfixed (l, r'high, r'low) rem r); --- end function "rem"; - --- function "mod" ( --- l : UNRESOLVED_ufixed; -- fixed point input --- r : REAL) --- return UNRESOLVED_ufixed is --- begin --- return (l mod to_ufixed (r, l'high, l'low)); --- end function "mod"; - --- function "mod" ( --- l : REAL; --- r : UNRESOLVED_ufixed) -- fixed point input --- return UNRESOLVED_ufixed is --- begin --- return (to_ufixed (l, r'high, r'low) mod r); --- end function "mod"; - --- function "mod" ( --- l : UNRESOLVED_sfixed; -- fixed point input --- r : REAL) --- return UNRESOLVED_sfixed is --- begin --- return (l mod to_sfixed (r, l'high, l'low)); --- end function "mod"; - --- function "mod" ( --- l : REAL; --- r : UNRESOLVED_sfixed) -- fixed point input --- return UNRESOLVED_sfixed is --- begin --- return (to_sfixed (l, r'high, r'low) mod r); --- end function "mod"; - - -- Overloaded math functions for integers - function "+" ( - l : UNRESOLVED_ufixed; -- fixed point input - r : NATURAL) - return UNRESOLVED_ufixed is - begin - return (l + to_ufixed (r, l'high, 0)); - end function "+"; - - function "+" ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return UNRESOLVED_ufixed is - begin - return (to_ufixed (l, r'high, 0) + r); - end function "+"; - - function "+" ( - l : UNRESOLVED_sfixed; -- fixed point input - r : INTEGER) - return UNRESOLVED_sfixed is - begin - return (l + to_sfixed (r, l'high, 0)); - end function "+"; - - function "+" ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return UNRESOLVED_sfixed is - begin - return (to_sfixed (l, r'high, 0) + r); - end function "+"; - - -- Overloaded functions - function "-" ( - l : UNRESOLVED_ufixed; -- fixed point input - r : NATURAL) - return UNRESOLVED_ufixed is - begin - return (l - to_ufixed (r, l'high, 0)); - end function "-"; - - function "-" ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return UNRESOLVED_ufixed is - begin - return (to_ufixed (l, r'high, 0) - r); - end function "-"; - - function "-" ( - l : UNRESOLVED_sfixed; -- fixed point input - r : INTEGER) - return UNRESOLVED_sfixed is - begin - return (l - to_sfixed (r, l'high, 0)); - end function "-"; - - function "-" ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return UNRESOLVED_sfixed is - begin - return (to_sfixed (l, r'high, 0) - r); - end function "-"; - - -- Overloaded functions - function "*" ( - l : UNRESOLVED_ufixed; -- fixed point input - r : NATURAL) - return UNRESOLVED_ufixed is - begin - return (l * to_ufixed (r, l'high, 0)); - end function "*"; - - function "*" ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return UNRESOLVED_ufixed is - begin - return (to_ufixed (l, r'high, 0) * r); - end function "*"; - - function "*" ( - l : UNRESOLVED_sfixed; -- fixed point input - r : INTEGER) - return UNRESOLVED_sfixed is - begin - return (l * to_sfixed (r, l'high, 0)); - end function "*"; - - function "*" ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return UNRESOLVED_sfixed is - begin - return (to_sfixed (l, r'high, 0) * r); - end function "*"; - - -- Overloaded functions --- function "/" ( --- l : UNRESOLVED_ufixed; -- fixed point input --- r : NATURAL) --- return UNRESOLVED_ufixed is --- begin --- return (l / to_ufixed (r, l'high, 0)); --- end function "/"; - --- function "/" ( --- l : NATURAL; --- r : UNRESOLVED_ufixed) -- fixed point input --- return UNRESOLVED_ufixed is --- begin --- return (to_ufixed (l, r'high, 0) / r); --- end function "/"; - --- function "/" ( --- l : UNRESOLVED_sfixed; -- fixed point input --- r : INTEGER) --- return UNRESOLVED_sfixed is --- begin --- return (l / to_sfixed (r, l'high, 0)); --- end function "/"; - --- function "/" ( --- l : INTEGER; --- r : UNRESOLVED_sfixed) -- fixed point input --- return UNRESOLVED_sfixed is --- begin --- return (to_sfixed (l, r'high, 0) / r); --- end function "/"; - --- function "rem" ( --- l : UNRESOLVED_ufixed; -- fixed point input --- r : NATURAL) --- return UNRESOLVED_ufixed is --- begin --- return (l rem to_ufixed (r, l'high, 0)); --- end function "rem"; - --- function "rem" ( --- l : NATURAL; --- r : UNRESOLVED_ufixed) -- fixed point input --- return UNRESOLVED_ufixed is --- begin --- return (to_ufixed (l, r'high, 0) rem r); --- end function "rem"; - --- function "rem" ( --- l : UNRESOLVED_sfixed; -- fixed point input --- r : INTEGER) --- return UNRESOLVED_sfixed is --- begin --- return (l rem to_sfixed (r, l'high, 0)); --- end function "rem"; - --- function "rem" ( --- l : INTEGER; --- r : UNRESOLVED_sfixed) -- fixed point input --- return UNRESOLVED_sfixed is --- begin --- return (to_sfixed (l, r'high, 0) rem r); --- end function "rem"; - --- function "mod" ( --- l : UNRESOLVED_ufixed; -- fixed point input --- r : NATURAL) --- return UNRESOLVED_ufixed is --- begin --- return (l mod to_ufixed (r, l'high, 0)); --- end function "mod"; - --- function "mod" ( --- l : NATURAL; --- r : UNRESOLVED_ufixed) -- fixed point input --- return UNRESOLVED_ufixed is --- begin --- return (to_ufixed (l, r'high, 0) mod r); --- end function "mod"; - --- function "mod" ( --- l : UNRESOLVED_sfixed; -- fixed point input --- r : INTEGER) --- return UNRESOLVED_sfixed is --- begin --- return (l mod to_sfixed (r, l'high, 0)); --- end function "mod"; - --- function "mod" ( --- l : INTEGER; --- r : UNRESOLVED_sfixed) -- fixed point input --- return UNRESOLVED_sfixed is --- begin --- return (to_sfixed (l, r'high, 0) mod r); --- end function "mod"; - - -- overloaded ufixed compare functions with integer - function "=" ( - l : UNRESOLVED_ufixed; - r : NATURAL) -- fixed point input - return BOOLEAN is - begin - return (l = to_ufixed (r, l'high, l'low)); - end function "="; - - function "/=" ( - l : UNRESOLVED_ufixed; - r : NATURAL) -- fixed point input - return BOOLEAN is - begin - return (l /= to_ufixed (r, l'high, l'low)); - end function "/="; - - function ">=" ( - l : UNRESOLVED_ufixed; - r : NATURAL) -- fixed point input - return BOOLEAN is - begin - return (l >= to_ufixed (r, l'high, l'low)); - end function ">="; - - function "<=" ( - l : UNRESOLVED_ufixed; - r : NATURAL) -- fixed point input - return BOOLEAN is - begin - return (l <= to_ufixed (r, l'high, l'low)); - end function "<="; - - function ">" ( - l : UNRESOLVED_ufixed; - r : NATURAL) -- fixed point input - return BOOLEAN is - begin - return (l > to_ufixed (r, l'high, l'low)); - end function ">"; - - function "<" ( - l : UNRESOLVED_ufixed; - r : NATURAL) -- fixed point input - return BOOLEAN is - begin - return (l < to_ufixed (r, l'high, l'low)); - end function "<"; - - function \?=\ ( - l : UNRESOLVED_ufixed; - r : NATURAL) -- fixed point input - return STD_ULOGIC is - begin - return \?=\ (l, to_ufixed (r, l'high, l'low)); - end function \?=\; - - function \?/=\ ( - l : UNRESOLVED_ufixed; - r : NATURAL) -- fixed point input - return STD_ULOGIC is - begin - return \?/=\ (l, to_ufixed (r, l'high, l'low)); - end function \?/=\; - - function \?>=\ ( - l : UNRESOLVED_ufixed; - r : NATURAL) -- fixed point input - return STD_ULOGIC is - begin - return \?>=\ (l, to_ufixed (r, l'high, l'low)); - end function \?>=\; - - function \?<=\ ( - l : UNRESOLVED_ufixed; - r : NATURAL) -- fixed point input - return STD_ULOGIC is - begin - return \?<=\ (l, to_ufixed (r, l'high, l'low)); - end function \?<=\; - - function \?>\ ( - l : UNRESOLVED_ufixed; - r : NATURAL) -- fixed point input - return STD_ULOGIC is - begin - return \?>\ (l, to_ufixed (r, l'high, l'low)); - end function \?>\; - - function \?<\ ( - l : UNRESOLVED_ufixed; - r : NATURAL) -- fixed point input - return STD_ULOGIC is - begin - return \?<\ (l, to_ufixed (r, l'high, l'low)); - end function \?<\; - - function maximum ( - l : UNRESOLVED_ufixed; -- fixed point input - r : NATURAL) - return UNRESOLVED_ufixed is - begin - return maximum (l, to_ufixed (r, l'high, l'low)); - end function maximum; - - function minimum ( - l : UNRESOLVED_ufixed; -- fixed point input - r : NATURAL) - return UNRESOLVED_ufixed is - begin - return minimum (l, to_ufixed (r, l'high, l'low)); - end function minimum; - - -- NATURAL to ufixed - function "=" ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - begin - return (to_ufixed (l, r'high, r'low) = r); - end function "="; - - function "/=" ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - begin - return (to_ufixed (l, r'high, r'low) /= r); - end function "/="; - - function ">=" ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - begin - return (to_ufixed (l, r'high, r'low) >= r); - end function ">="; - - function "<=" ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - begin - return (to_ufixed (l, r'high, r'low) <= r); - end function "<="; - - function ">" ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - begin - return (to_ufixed (l, r'high, r'low) > r); - end function ">"; - - function "<" ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - begin - return (to_ufixed (l, r'high, r'low) < r); - end function "<"; - - function \?=\ ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return STD_ULOGIC is - begin - return \?=\ (to_ufixed (l, r'high, r'low), r); - end function \?=\; - - function \?/=\ ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return STD_ULOGIC is - begin - return \?/=\ (to_ufixed (l, r'high, r'low), r); - end function \?/=\; - - function \?>=\ ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return STD_ULOGIC is - begin - return \?>=\ (to_ufixed (l, r'high, r'low), r); - end function \?>=\; - - function \?<=\ ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return STD_ULOGIC is - begin - return \?<=\ (to_ufixed (l, r'high, r'low), r); - end function \?<=\; - - function \?>\ ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return STD_ULOGIC is - begin - return \?>\ (to_ufixed (l, r'high, r'low), r); - end function \?>\; - - function \?<\ ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return STD_ULOGIC is - begin - return \?<\ (to_ufixed (l, r'high, r'low), r); - end function \?<\; - - function maximum ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return UNRESOLVED_ufixed is - begin - return maximum (to_ufixed (l, r'high, r'low), r); - end function maximum; - - function minimum ( - l : NATURAL; - r : UNRESOLVED_ufixed) -- fixed point input - return UNRESOLVED_ufixed is - begin - return minimum (to_ufixed (l, r'high, r'low), r); - end function minimum; - - -- overloaded ufixed compare functions with real - function "=" ( - l : UNRESOLVED_ufixed; - r : REAL) - return BOOLEAN is - begin - return (l = to_ufixed (r, l'high, l'low)); - end function "="; - - function "/=" ( - l : UNRESOLVED_ufixed; - r : REAL) - return BOOLEAN is - begin - return (l /= to_ufixed (r, l'high, l'low)); - end function "/="; - - function ">=" ( - l : UNRESOLVED_ufixed; - r : REAL) - return BOOLEAN is - begin - return (l >= to_ufixed (r, l'high, l'low)); - end function ">="; - - function "<=" ( - l : UNRESOLVED_ufixed; - r : REAL) - return BOOLEAN is - begin - return (l <= to_ufixed (r, l'high, l'low)); - end function "<="; - - function ">" ( - l : UNRESOLVED_ufixed; - r : REAL) - return BOOLEAN is - begin - return (l > to_ufixed (r, l'high, l'low)); - end function ">"; - - function "<" ( - l : UNRESOLVED_ufixed; - r : REAL) - return BOOLEAN is - begin - return (l < to_ufixed (r, l'high, l'low)); - end function "<"; - - function \?=\ ( - l : UNRESOLVED_ufixed; - r : REAL) - return STD_ULOGIC is - begin - return \?=\ (l, to_ufixed (r, l'high, l'low)); - end function \?=\; - - function \?/=\ ( - l : UNRESOLVED_ufixed; - r : REAL) - return STD_ULOGIC is - begin - return \?/=\ (l, to_ufixed (r, l'high, l'low)); - end function \?/=\; - - function \?>=\ ( - l : UNRESOLVED_ufixed; - r : REAL) - return STD_ULOGIC is - begin - return \?>=\ (l, to_ufixed (r, l'high, l'low)); - end function \?>=\; - - function \?<=\ ( - l : UNRESOLVED_ufixed; - r : REAL) - return STD_ULOGIC is - begin - return \?<=\ (l, to_ufixed (r, l'high, l'low)); - end function \?<=\; - - function \?>\ ( - l : UNRESOLVED_ufixed; - r : REAL) - return STD_ULOGIC is - begin - return \?>\ (l, to_ufixed (r, l'high, l'low)); - end function \?>\; - - function \?<\ ( - l : UNRESOLVED_ufixed; - r : REAL) - return STD_ULOGIC is - begin - return \?<\ (l, to_ufixed (r, l'high, l'low)); - end function \?<\; - - function maximum ( - l : UNRESOLVED_ufixed; - r : REAL) - return UNRESOLVED_ufixed is - begin - return maximum (l, to_ufixed (r, l'high, l'low)); - end function maximum; - - function minimum ( - l : UNRESOLVED_ufixed; - r : REAL) - return UNRESOLVED_ufixed is - begin - return minimum (l, to_ufixed (r, l'high, l'low)); - end function minimum; - - -- real and ufixed - function "=" ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - begin - return (to_ufixed (l, r'high, r'low) = r); - end function "="; - - function "/=" ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - begin - return (to_ufixed (l, r'high, r'low) /= r); - end function "/="; - - function ">=" ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - begin - return (to_ufixed (l, r'high, r'low) >= r); - end function ">="; - - function "<=" ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - begin - return (to_ufixed (l, r'high, r'low) <= r); - end function "<="; - - function ">" ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - begin - return (to_ufixed (l, r'high, r'low) > r); - end function ">"; - - function "<" ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return BOOLEAN is - begin - return (to_ufixed (l, r'high, r'low) < r); - end function "<"; - - function \?=\ ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return STD_ULOGIC is - begin - return \?=\ (to_ufixed (l, r'high, r'low), r); - end function \?=\; - - function \?/=\ ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return STD_ULOGIC is - begin - return \?/=\ (to_ufixed (l, r'high, r'low), r); - end function \?/=\; - - function \?>=\ ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return STD_ULOGIC is - begin - return \?>=\ (to_ufixed (l, r'high, r'low), r); - end function \?>=\; - - function \?<=\ ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return STD_ULOGIC is - begin - return \?<=\ (to_ufixed (l, r'high, r'low), r); - end function \?<=\; - - function \?>\ ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return STD_ULOGIC is - begin - return \?>\ (to_ufixed (l, r'high, r'low), r); - end function \?>\; - - function \?<\ ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return STD_ULOGIC is - begin - return \?<\ (to_ufixed (l, r'high, r'low), r); - end function \?<\; - - function maximum ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return UNRESOLVED_ufixed is - begin - return maximum (to_ufixed (l, r'high, r'low), r); - end function maximum; - - function minimum ( - l : REAL; - r : UNRESOLVED_ufixed) -- fixed point input - return UNRESOLVED_ufixed is - begin - return minimum (to_ufixed (l, r'high, r'low), r); - end function minimum; - - -- overloaded sfixed compare functions with integer - function "=" ( - l : UNRESOLVED_sfixed; - r : INTEGER) - return BOOLEAN is - begin - return (l = to_sfixed (r, l'high, l'low)); - end function "="; - - function "/=" ( - l : UNRESOLVED_sfixed; - r : INTEGER) - return BOOLEAN is - begin - return (l /= to_sfixed (r, l'high, l'low)); - end function "/="; - - function ">=" ( - l : UNRESOLVED_sfixed; - r : INTEGER) - return BOOLEAN is - begin - return (l >= to_sfixed (r, l'high, l'low)); - end function ">="; - - function "<=" ( - l : UNRESOLVED_sfixed; - r : INTEGER) - return BOOLEAN is - begin - return (l <= to_sfixed (r, l'high, l'low)); - end function "<="; - - function ">" ( - l : UNRESOLVED_sfixed; - r : INTEGER) - return BOOLEAN is - begin - return (l > to_sfixed (r, l'high, l'low)); - end function ">"; - - function "<" ( - l : UNRESOLVED_sfixed; - r : INTEGER) - return BOOLEAN is - begin - return (l < to_sfixed (r, l'high, l'low)); - end function "<"; - - function \?=\ ( - l : UNRESOLVED_sfixed; - r : INTEGER) - return STD_ULOGIC is - begin - return \?=\ (l, to_sfixed (r, l'high, l'low)); - end function \?=\; - - function \?/=\ ( - l : UNRESOLVED_sfixed; - r : INTEGER) - return STD_ULOGIC is - begin - return \?/=\ (l, to_sfixed (r, l'high, l'low)); - end function \?/=\; - - function \?>=\ ( - l : UNRESOLVED_sfixed; - r : INTEGER) - return STD_ULOGIC is - begin - return \?>=\ (l, to_sfixed (r, l'high, l'low)); - end function \?>=\; - - function \?<=\ ( - l : UNRESOLVED_sfixed; - r : INTEGER) - return STD_ULOGIC is - begin - return \?<=\ (l, to_sfixed (r, l'high, l'low)); - end function \?<=\; - - function \?>\ ( - l : UNRESOLVED_sfixed; - r : INTEGER) - return STD_ULOGIC is - begin - return \?>\ (l, to_sfixed (r, l'high, l'low)); - end function \?>\; - - function \?<\ ( - l : UNRESOLVED_sfixed; - r : INTEGER) - return STD_ULOGIC is - begin - return \?<\ (l, to_sfixed (r, l'high, l'low)); - end function \?<\; - - function maximum ( - l : UNRESOLVED_sfixed; - r : INTEGER) - return UNRESOLVED_sfixed is - begin - return maximum (l, to_sfixed (r, l'high, l'low)); - end function maximum; - - function minimum ( - l : UNRESOLVED_sfixed; - r : INTEGER) - return UNRESOLVED_sfixed is - begin - return minimum (l, to_sfixed (r, l'high, l'low)); - end function minimum; - - -- integer and sfixed - function "=" ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - begin - return (to_sfixed (l, r'high, r'low) = r); - end function "="; - - function "/=" ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - begin - return (to_sfixed (l, r'high, r'low) /= r); - end function "/="; - - function ">=" ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - begin - return (to_sfixed (l, r'high, r'low) >= r); - end function ">="; - - function "<=" ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - begin - return (to_sfixed (l, r'high, r'low) <= r); - end function "<="; - - function ">" ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - begin - return (to_sfixed (l, r'high, r'low) > r); - end function ">"; - - function "<" ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - begin - return (to_sfixed (l, r'high, r'low) < r); - end function "<"; - - function \?=\ ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return STD_ULOGIC is - begin - return \?=\ (to_sfixed (l, r'high, r'low), r); - end function \?=\; - - function \?/=\ ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return STD_ULOGIC is - begin - return \?/=\ (to_sfixed (l, r'high, r'low), r); - end function \?/=\; - - function \?>=\ ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return STD_ULOGIC is - begin - return \?>=\ (to_sfixed (l, r'high, r'low), r); - end function \?>=\; - - function \?<=\ ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return STD_ULOGIC is - begin - return \?<=\ (to_sfixed (l, r'high, r'low), r); - end function \?<=\; - - function \?>\ ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return STD_ULOGIC is - begin - return \?>\ (to_sfixed (l, r'high, r'low), r); - end function \?>\; - - function \?<\ ( - l : INTEGER; - r : UNRESOLVED_sfixed) -- fixed point input - return STD_ULOGIC is - begin - return \?<\ (to_sfixed (l, r'high, r'low), r); - end function \?<\; - - function maximum ( - l : INTEGER; - r : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - begin - return maximum (to_sfixed (l, r'high, r'low), r); - end function maximum; - - function minimum ( - l : INTEGER; - r : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - begin - return minimum (to_sfixed (l, r'high, r'low), r); - end function minimum; - - -- overloaded sfixed compare functions with real - function "=" ( - l : UNRESOLVED_sfixed; - r : REAL) - return BOOLEAN is - begin - return (l = to_sfixed (r, l'high, l'low)); - end function "="; - - function "/=" ( - l : UNRESOLVED_sfixed; - r : REAL) - return BOOLEAN is - begin - return (l /= to_sfixed (r, l'high, l'low)); - end function "/="; - - function ">=" ( - l : UNRESOLVED_sfixed; - r : REAL) - return BOOLEAN is - begin - return (l >= to_sfixed (r, l'high, l'low)); - end function ">="; - - function "<=" ( - l : UNRESOLVED_sfixed; - r : REAL) - return BOOLEAN is - begin - return (l <= to_sfixed (r, l'high, l'low)); - end function "<="; - - function ">" ( - l : UNRESOLVED_sfixed; - r : REAL) - return BOOLEAN is - begin - return (l > to_sfixed (r, l'high, l'low)); - end function ">"; - - function "<" ( - l : UNRESOLVED_sfixed; - r : REAL) - return BOOLEAN is - begin - return (l < to_sfixed (r, l'high, l'low)); - end function "<"; - - function \?=\ ( - l : UNRESOLVED_sfixed; - r : REAL) - return STD_ULOGIC is - begin - return \?=\ (l, to_sfixed (r, l'high, l'low)); - end function \?=\; - - function \?/=\ ( - l : UNRESOLVED_sfixed; - r : REAL) - return STD_ULOGIC is - begin - return \?/=\ (l, to_sfixed (r, l'high, l'low)); - end function \?/=\; - - function \?>=\ ( - l : UNRESOLVED_sfixed; - r : REAL) - return STD_ULOGIC is - begin - return \?>=\ (l, to_sfixed (r, l'high, l'low)); - end function \?>=\; - - function \?<=\ ( - l : UNRESOLVED_sfixed; - r : REAL) - return STD_ULOGIC is - begin - return \?<=\ (l, to_sfixed (r, l'high, l'low)); - end function \?<=\; - - function \?>\ ( - l : UNRESOLVED_sfixed; - r : REAL) - return STD_ULOGIC is - begin - return \?>\ (l, to_sfixed (r, l'high, l'low)); - end function \?>\; - - function \?<\ ( - l : UNRESOLVED_sfixed; - r : REAL) - return STD_ULOGIC is - begin - return \?<\ (l, to_sfixed (r, l'high, l'low)); - end function \?<\; - - function maximum ( - l : UNRESOLVED_sfixed; - r : REAL) - return UNRESOLVED_sfixed is - begin - return maximum (l, to_sfixed (r, l'high, l'low)); - end function maximum; - - function minimum ( - l : UNRESOLVED_sfixed; - r : REAL) - return UNRESOLVED_sfixed is - begin - return minimum (l, to_sfixed (r, l'high, l'low)); - end function minimum; - - -- REAL and sfixed - function "=" ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - begin - return (to_sfixed (l, r'high, r'low) = r); - end function "="; - - function "/=" ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - begin - return (to_sfixed (l, r'high, r'low) /= r); - end function "/="; - - function ">=" ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - begin - return (to_sfixed (l, r'high, r'low) >= r); - end function ">="; - - function "<=" ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - begin - return (to_sfixed (l, r'high, r'low) <= r); - end function "<="; - - function ">" ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - begin - return (to_sfixed (l, r'high, r'low) > r); - end function ">"; - - function "<" ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return BOOLEAN is - begin - return (to_sfixed (l, r'high, r'low) < r); - end function "<"; - - function \?=\ ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return STD_ULOGIC is - begin - return \?=\ (to_sfixed (l, r'high, r'low), r); - end function \?=\; - - function \?/=\ ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return STD_ULOGIC is - begin - return \?/=\ (to_sfixed (l, r'high, r'low), r); - end function \?/=\; - - function \?>=\ ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return STD_ULOGIC is - begin - return \?>=\ (to_sfixed (l, r'high, r'low), r); - end function \?>=\; - - function \?<=\ ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return STD_ULOGIC is - begin - return \?<=\ (to_sfixed (l, r'high, r'low), r); - end function \?<=\; - - function \?>\ ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return STD_ULOGIC is - begin - return \?>\ (to_sfixed (l, r'high, r'low), r); - end function \?>\; - - function \?<\ ( - l : REAL; - r : UNRESOLVED_sfixed) -- fixed point input - return STD_ULOGIC is - begin - return \?<\ (to_sfixed (l, r'high, r'low), r); - end function \?<\; - - function maximum ( - l : REAL; - r : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - begin - return maximum (to_sfixed (l, r'high, r'low), r); - end function maximum; - - function minimum ( - l : REAL; - r : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - begin - return minimum (to_sfixed (l, r'high, r'low), r); - end function minimum; --- rtl_synthesis off --- pragma synthesis_off - -- copied from std_logic_textio - type MVL9plus is ('U', 'X', '0', '1', 'Z', 'W', 'L', 'H', '-', error); - type char_indexed_by_MVL9 is array (STD_ULOGIC) of CHARACTER; - type MVL9_indexed_by_char is array (CHARACTER) of STD_ULOGIC; - type MVL9plus_indexed_by_char is array (CHARACTER) of MVL9plus; - - constant MVL9_to_char : char_indexed_by_MVL9 := "UX01ZWLH-"; - constant char_to_MVL9 : MVL9_indexed_by_char := - ('U' => 'U', 'X' => 'X', '0' => '0', '1' => '1', 'Z' => 'Z', - 'W' => 'W', 'L' => 'L', 'H' => 'H', '-' => '-', others => 'U'); - constant char_to_MVL9plus : MVL9plus_indexed_by_char := - ('U' => 'U', 'X' => 'X', '0' => '0', '1' => '1', 'Z' => 'Z', - 'W' => 'W', 'L' => 'L', 'H' => 'H', '-' => '-', others => error); - constant NBSP : CHARACTER := CHARACTER'val(160); -- space character - constant NUS : STRING(2 to 1) := (others => ' '); - - -- %%% Replicated Textio functions - procedure Char2TriBits (C : CHARACTER; - RESULT : out STD_ULOGIC_VECTOR(2 downto 0); - GOOD : out BOOLEAN; - ISSUE_ERROR : in BOOLEAN) is - begin - case c is - when '0' => result := o"0"; good := true; - when '1' => result := o"1"; good := true; - when '2' => result := o"2"; good := true; - when '3' => result := o"3"; good := true; - when '4' => result := o"4"; good := true; - when '5' => result := o"5"; good := true; - when '6' => result := o"6"; good := true; - when '7' => result := o"7"; good := true; - when 'Z' => result := "ZZZ"; good := true; - when 'X' => result := "XXX"; good := true; - when others => - assert not ISSUE_ERROR - report "fixed_pkg:" - & "OREAD Error: Read a '" & c & - "', expected an Octal character (0-7)." - severity error; - result := "UUU"; - good := false; - end case; - end procedure Char2TriBits; - -- Hex Read and Write procedures for STD_ULOGIC_VECTOR. - -- Modified from the original to be more forgiving. - - procedure Char2QuadBits (C : CHARACTER; - RESULT : out STD_ULOGIC_VECTOR(3 downto 0); - GOOD : out BOOLEAN; - ISSUE_ERROR : in BOOLEAN) is - begin - case c is - when '0' => result := x"0"; good := true; - when '1' => result := x"1"; good := true; - when '2' => result := x"2"; good := true; - when '3' => result := x"3"; good := true; - when '4' => result := x"4"; good := true; - when '5' => result := x"5"; good := true; - when '6' => result := x"6"; good := true; - when '7' => result := x"7"; good := true; - when '8' => result := x"8"; good := true; - when '9' => result := x"9"; good := true; - when 'A' | 'a' => result := x"A"; good := true; - when 'B' | 'b' => result := x"B"; good := true; - when 'C' | 'c' => result := x"C"; good := true; - when 'D' | 'd' => result := x"D"; good := true; - when 'E' | 'e' => result := x"E"; good := true; - when 'F' | 'f' => result := x"F"; good := true; - when 'Z' => result := "ZZZZ"; good := true; - when 'X' => result := "XXXX"; good := true; - when others => - assert not ISSUE_ERROR - report "fixed_pkg:" - & "HREAD Error: Read a '" & c & - "', expected a Hex character (0-F)." - severity error; - result := "UUUU"; - good := false; - end case; - end procedure Char2QuadBits; - - -- purpose: Skips white space - procedure skip_whitespace ( - L : inout LINE) is - variable readOk : BOOLEAN; - variable c : CHARACTER; - begin - while L /= null and L.all'length /= 0 loop - if (L.all(1) = ' ' or L.all(1) = NBSP or L.all(1) = HT) then - read (l, c, readOk); - else - exit; - end if; - end loop; - end procedure skip_whitespace; - - function to_ostring (value : STD_ULOGIC_VECTOR) return STRING is - constant ne : INTEGER := (value'length+2)/3; - variable pad : STD_ULOGIC_VECTOR(0 to (ne*3 - value'length) - 1); - variable ivalue : STD_ULOGIC_VECTOR(0 to ne*3 - 1); - variable result : STRING(1 to ne); - variable tri : STD_ULOGIC_VECTOR(0 to 2); - begin - if value'length < 1 then - return NUS; - else - if value (value'left) = 'Z' then - pad := (others => 'Z'); - else - pad := (others => '0'); - end if; - ivalue := pad & value; - for i in 0 to ne-1 loop - tri := To_X01Z(ivalue(3*i to 3*i+2)); - case tri is - when o"0" => result(i+1) := '0'; - when o"1" => result(i+1) := '1'; - when o"2" => result(i+1) := '2'; - when o"3" => result(i+1) := '3'; - when o"4" => result(i+1) := '4'; - when o"5" => result(i+1) := '5'; - when o"6" => result(i+1) := '6'; - when o"7" => result(i+1) := '7'; - when "ZZZ" => result(i+1) := 'Z'; - when others => result(i+1) := 'X'; - end case; - end loop; - return result; - end if; - end function to_ostring; - ------------------------------------------------------------------- - function to_hstring (value : STD_ULOGIC_VECTOR) return STRING is - constant ne : INTEGER := (value'length+3)/4; - variable pad : STD_ULOGIC_VECTOR(0 to (ne*4 - value'length) - 1); - variable ivalue : STD_ULOGIC_VECTOR(0 to ne*4 - 1); - variable result : STRING(1 to ne); - variable quad : STD_ULOGIC_VECTOR(0 to 3); - begin - if value'length < 1 then - return NUS; - else - if value (value'left) = 'Z' then - pad := (others => 'Z'); - else - pad := (others => '0'); - end if; - ivalue := pad & value; - for i in 0 to ne-1 loop - quad := To_X01Z(ivalue(4*i to 4*i+3)); - case quad is - when x"0" => result(i+1) := '0'; - when x"1" => result(i+1) := '1'; - when x"2" => result(i+1) := '2'; - when x"3" => result(i+1) := '3'; - when x"4" => result(i+1) := '4'; - when x"5" => result(i+1) := '5'; - when x"6" => result(i+1) := '6'; - when x"7" => result(i+1) := '7'; - when x"8" => result(i+1) := '8'; - when x"9" => result(i+1) := '9'; - when x"A" => result(i+1) := 'A'; - when x"B" => result(i+1) := 'B'; - when x"C" => result(i+1) := 'C'; - when x"D" => result(i+1) := 'D'; - when x"E" => result(i+1) := 'E'; - when x"F" => result(i+1) := 'F'; - when "ZZZZ" => result(i+1) := 'Z'; - when others => result(i+1) := 'X'; - end case; - end loop; - return result; - end if; - end function to_hstring; - - --- %%% END replicated textio functions - - -- purpose: writes fixed point into a line - procedure write ( - L : inout LINE; -- input line - VALUE : in UNRESOLVED_ufixed; -- fixed point input - JUSTIFIED : in SIDE := right; - FIELD : in WIDTH := 0) is - variable s : STRING(1 to value'length +1) := (others => ' '); - variable sindx : INTEGER; - begin -- function write Example: 0011.1100 - sindx := 1; - for i in value'high downto value'low loop - if i = -1 then - s(sindx) := '.'; - sindx := sindx + 1; - end if; - s(sindx) := MVL9_to_char(STD_ULOGIC(value(i))); - sindx := sindx + 1; - end loop; - write(l, s, justified, field); - end procedure write; - - -- purpose: writes fixed point into a line - procedure write ( - L : inout LINE; -- input line - VALUE : in UNRESOLVED_sfixed; -- fixed point input - JUSTIFIED : in SIDE := right; - FIELD : in WIDTH := 0) is - variable s : STRING(1 to value'length +1); - variable sindx : INTEGER; - begin -- function write Example: 0011.1100 - sindx := 1; - for i in value'high downto value'low loop - if i = -1 then - s(sindx) := '.'; - sindx := sindx + 1; - end if; - s(sindx) := MVL9_to_char(STD_ULOGIC(value(i))); - sindx := sindx + 1; - end loop; - write(l, s, justified, field); - end procedure write; - - procedure READ(L : inout LINE; - VALUE : out UNRESOLVED_ufixed) is - -- Possible data: 00000.0000000 - -- 000000000000 - variable c : CHARACTER; - variable readOk : BOOLEAN; - variable i : INTEGER; -- index variable - variable mv : ufixed (VALUE'range); - variable lastu : BOOLEAN := false; -- last character was an "_" - variable founddot : BOOLEAN := false; -- found a "." - begin -- READ - VALUE := (VALUE'range => 'U'); - Skip_whitespace (L); - if VALUE'length > 0 then -- non Null input string - read (l, c, readOk); - i := value'high; - while i >= VALUE'low loop - if readOk = false then -- Bail out if there was a bad read - report "fixed_pkg:" & "READ(ufixed) " - & "End of string encountered" - severity error; - return; - elsif c = '_' then - if i = value'high then - report "fixed_pkg:" & "READ(ufixed) " - & "String begins with an ""_""" severity error; - return; - elsif lastu then - report "fixed_pkg:" & "READ(ufixed) " - & "Two underscores detected in input string ""__""" - severity error; - return; - else - lastu := true; - end if; - elsif c = '.' then -- binary point - if founddot then - report "fixed_pkg:" & "READ(ufixed) " - & "Two binary points found in input string" severity error; - return; - elsif i /= -1 then -- Seperator in the wrong spot - report "fixed_pkg:" & "READ(ufixed) " - & "Decimal point does not match number format " - severity error; - return; - end if; - founddot := true; - lastu := false; - elsif c = ' ' or c = NBSP or c = HT then -- reading done. - report "fixed_pkg:" & "READ(ufixed) " - & "Short read, Space encounted in input string" - severity error; - return; - elsif char_to_MVL9plus(c) = error then - report "fixed_pkg:" & "READ(ufixed) " - & "Character '" & - c & "' read, expected STD_ULOGIC literal." - severity error; - return; - else - mv(i) := char_to_MVL9(c); - i := i - 1; - if i < mv'low then - VALUE := mv; - return; - end if; - lastu := false; - end if; - read(L, c, readOk); - end loop; - end if; - end procedure READ; - - procedure READ(L : inout LINE; - VALUE : out UNRESOLVED_ufixed; - GOOD : out BOOLEAN) is - -- Possible data: 00000.0000000 - -- 000000000000 - variable c : CHARACTER; - variable readOk : BOOLEAN; - variable mv : ufixed (VALUE'range); - variable i : INTEGER; -- index variable - variable lastu : BOOLEAN := false; -- last character was an "_" - variable founddot : BOOLEAN := false; -- found a "." - begin -- READ - VALUE := (VALUE'range => 'U'); - Skip_whitespace (L); - if VALUE'length > 0 then - read (l, c, readOk); - i := value'high; - GOOD := false; - while i >= VALUE'low loop - if not readOk then -- Bail out if there was a bad read - return; - elsif c = '_' then - if i = value'high then -- Begins with an "_" - return; - elsif lastu then -- "__" detected - return; - else - lastu := true; - end if; - elsif c = '.' then -- binary point - if founddot then - return; - elsif i /= -1 then -- Seperator in the wrong spot - return; - end if; - founddot := true; - lastu := false; - elsif (char_to_MVL9plus(c) = error) then -- Illegal character/short read - return; - else - mv(i) := char_to_MVL9(c); - i := i - 1; - if i < mv'low then -- reading done - GOOD := true; - VALUE := mv; - return; - end if; - lastu := false; - end if; - read(L, c, readOk); - end loop; - else - GOOD := true; -- read into a null array - end if; - end procedure READ; - - procedure READ(L : inout LINE; - VALUE : out UNRESOLVED_sfixed) is - variable c : CHARACTER; - variable readOk : BOOLEAN; - variable i : INTEGER; -- index variable - variable mv : sfixed (VALUE'range); - variable lastu : BOOLEAN := false; -- last character was an "_" - variable founddot : BOOLEAN := false; -- found a "." - begin -- READ - VALUE := (VALUE'range => 'U'); - Skip_whitespace (L); - if VALUE'length > 0 then -- non Null input string - read (l, c, readOk); - i := value'high; - while i >= VALUE'low loop - if readOk = false then -- Bail out if there was a bad read - report "fixed_pkg:" & "READ(sfixed) " - & "End of string encountered" - severity error; - return; - elsif c = '_' then - if i = value'high then - report "fixed_pkg:" & "READ(sfixed) " - & "String begins with an ""_""" severity error; - return; - elsif lastu then - report "fixed_pkg:" & "READ(sfixed) " - & "Two underscores detected in input string ""__""" - severity error; - return; - else - lastu := true; - end if; - elsif c = '.' then -- binary point - if founddot then - report "fixed_pkg:" & "READ(sfixed) " - & "Two binary points found in input string" severity error; - return; - elsif i /= -1 then -- Seperator in the wrong spot - report "fixed_pkg:" & "READ(sfixed) " - & "Decimal point does not match number format " - severity error; - return; - end if; - founddot := true; - lastu := false; - elsif c = ' ' or c = NBSP or c = HT then -- reading done. - report "fixed_pkg:" & "READ(sfixed) " - & "Short read, Space encounted in input string" - severity error; - return; - elsif char_to_MVL9plus(c) = error then - report "fixed_pkg:" & "READ(sfixed) " - & "Character '" & - c & "' read, expected STD_ULOGIC literal." - severity error; - return; - else - mv(i) := char_to_MVL9(c); - i := i - 1; - if i < mv'low then - VALUE := mv; - return; - end if; - lastu := false; - end if; - read(L, c, readOk); - end loop; - end if; - end procedure READ; - - procedure READ(L : inout LINE; - VALUE : out UNRESOLVED_sfixed; - GOOD : out BOOLEAN) is - variable value_ufixed : UNRESOLVED_ufixed (VALUE'range); - begin -- READ - READ (L => L, VALUE => value_ufixed, GOOD => GOOD); - VALUE := UNRESOLVED_sfixed (value_ufixed); - end procedure READ; - - -- octal read and write - procedure owrite ( - L : inout LINE; -- input line - VALUE : in UNRESOLVED_ufixed; -- fixed point input - JUSTIFIED : in SIDE := right; - FIELD : in WIDTH := 0) is - begin -- Example 03.30 - write (L => L, - VALUE => to_ostring (VALUE), - JUSTIFIED => JUSTIFIED, - FIELD => FIELD); - end procedure owrite; - - procedure owrite ( - L : inout LINE; -- input line - VALUE : in UNRESOLVED_sfixed; -- fixed point input - JUSTIFIED : in SIDE := right; - FIELD : in WIDTH := 0) is - begin -- Example 03.30 - write (L => L, - VALUE => to_ostring (VALUE), - JUSTIFIED => JUSTIFIED, - FIELD => FIELD); - end procedure owrite; - - -- purpose: Routines common to the OREAD routines - procedure OREAD_common ( - L : inout LINE; - slv : out STD_ULOGIC_VECTOR; - igood : out BOOLEAN; - idex : out INTEGER; - constant bpoint : in INTEGER; -- binary point - constant message : in BOOLEAN; - constant smath : in BOOLEAN) is - - -- purpose: error message routine - procedure errmes ( - constant mess : in STRING) is -- error message - begin - if message then - if smath then - report "fixed_pkg:" - & "OREAD(sfixed) " - & mess - severity error; - else - report "fixed_pkg:" - & "OREAD(ufixed) " - & mess - severity error; - end if; - end if; - end procedure errmes; - variable xgood : BOOLEAN; - variable nybble : STD_ULOGIC_VECTOR (2 downto 0); -- 3 bits - variable c : CHARACTER; - variable i : INTEGER; - variable lastu : BOOLEAN := false; -- last character was an "_" - variable founddot : BOOLEAN := false; -- found a dot. - begin - Skip_whitespace (L); - if slv'length > 0 then - i := slv'high; - read (l, c, xgood); - while i > 0 loop - if xgood = false then - errmes ("Error: end of string encountered"); - exit; - elsif c = '_' then - if i = slv'length then - errmes ("Error: String begins with an ""_"""); - xgood := false; - exit; - elsif lastu then - errmes ("Error: Two underscores detected in input string ""__"""); - xgood := false; - exit; - else - lastu := true; - end if; - elsif (c = '.') then - if (i + 1 /= bpoint) then - errmes ("encountered ""."" at wrong index"); - xgood := false; - exit; - elsif i = slv'length then - errmes ("encounted a ""."" at the beginning of the line"); - xgood := false; - exit; - elsif founddot then - errmes ("Two ""."" encounted in input string"); - xgood := false; - exit; - end if; - founddot := true; - lastu := false; - else - Char2triBits(c, nybble, xgood, message); - if not xgood then - exit; - end if; - slv (i downto i-2) := nybble; - i := i - 3; - lastu := false; - end if; - if i > 0 then - read (L, c, xgood); - end if; - end loop; - idex := i; - igood := xgood; - else - igood := true; -- read into a null array - idex := -1; - end if; - end procedure OREAD_common; - - -- Note that for Octal and Hex read, you can not start with a ".", - -- the read is for numbers formatted "A.BC". These routines go to - -- the nearest bounds, so "F.E" will fit into an sfixed (2 downto -3). - procedure OREAD (L : inout LINE; - VALUE : out UNRESOLVED_ufixed) is - constant hbv : INTEGER := (((maximum(3, (VALUE'high+1))+2)/3)*3)-1; - constant lbv : INTEGER := ((mine(0, VALUE'low)-2)/3)*3; - variable slv : STD_ULOGIC_VECTOR (hbv-lbv downto 0); -- high bits - variable valuex : UNRESOLVED_ufixed (hbv downto lbv); - variable igood : BOOLEAN; - variable i : INTEGER; - begin - VALUE := (VALUE'range => 'U'); - OREAD_common ( L => L, - slv => slv, - igood => igood, - idex => i, - bpoint => -lbv, - message => true, - smath => false); - if igood then -- We did not get another error - if not ((i = -1) and -- We read everything, and high bits 0 - (or_reduce (slv(hbv-lbv downto VALUE'high+1-lbv)) = '0')) then - report "fixed_pkg:" - & "OREAD(ufixed): Vector truncated." - severity error; - else - if (or_reduce (slv(VALUE'low-lbv-1 downto 0)) = '1') then - assert NO_WARNING - report "fixed_pkg:" - & "OREAD(ufixed): Vector truncated" - severity warning; - end if; - valuex := to_ufixed (slv, hbv, lbv); - VALUE := valuex (VALUE'range); - end if; - end if; - end procedure OREAD; - - procedure OREAD(L : inout LINE; - VALUE : out UNRESOLVED_ufixed; - GOOD : out BOOLEAN) is - constant hbv : INTEGER := (((maximum(3, (VALUE'high+1))+2)/3)*3)-1; - constant lbv : INTEGER := ((mine(0, VALUE'low)-2)/3)*3; - variable slv : STD_ULOGIC_VECTOR (hbv-lbv downto 0); -- high bits - variable valuex : UNRESOLVED_ufixed (hbv downto lbv); - variable igood : BOOLEAN; - variable i : INTEGER; - begin - VALUE := (VALUE'range => 'U'); - OREAD_common ( L => L, - slv => slv, - igood => igood, - idex => i, - bpoint => -lbv, - message => false, - smath => false); - if (igood and -- We did not get another error - (i = -1) and -- We read everything, and high bits 0 - (or_reduce (slv(hbv-lbv downto VALUE'high+1-lbv)) = '0')) then - valuex := to_ufixed (slv, hbv, lbv); - VALUE := valuex (VALUE'range); - good := true; - else - good := false; - end if; - end procedure OREAD; - - procedure OREAD(L : inout LINE; - VALUE : out UNRESOLVED_sfixed) is - constant hbv : INTEGER := (((maximum(3, (VALUE'high+1))+2)/3)*3)-1; - constant lbv : INTEGER := ((mine(0, VALUE'low)-2)/3)*3; - variable slv : STD_ULOGIC_VECTOR (hbv-lbv downto 0); -- high bits - variable valuex : UNRESOLVED_sfixed (hbv downto lbv); - variable igood : BOOLEAN; - variable i : INTEGER; - begin - VALUE := (VALUE'range => 'U'); - OREAD_common ( L => L, - slv => slv, - igood => igood, - idex => i, - bpoint => -lbv, - message => true, - smath => true); - if igood then -- We did not get another error - if not ((i = -1) and -- We read everything - ((slv(VALUE'high-lbv) = '0' and -- sign bits = extra bits - or_reduce (slv(hbv-lbv downto VALUE'high+1-lbv)) = '0') or - (slv(VALUE'high-lbv) = '1' and - and_reduce (slv(hbv-lbv downto VALUE'high+1-lbv)) = '1'))) then - report "fixed_pkg:" - & "OREAD(sfixed): Vector truncated." - severity error; - else - if (or_reduce (slv(VALUE'low-lbv-1 downto 0)) = '1') then - assert NO_WARNING - report "fixed_pkg:" - & "OREAD(sfixed): Vector truncated" - severity warning; - end if; - valuex := to_sfixed (slv, hbv, lbv); - VALUE := valuex (VALUE'range); - end if; - end if; - end procedure OREAD; - - procedure OREAD(L : inout LINE; - VALUE : out UNRESOLVED_sfixed; - GOOD : out BOOLEAN) is - constant hbv : INTEGER := (((maximum(3, (VALUE'high+1))+2)/3)*3)-1; - constant lbv : INTEGER := ((mine(0, VALUE'low)-2)/3)*3; - variable slv : STD_ULOGIC_VECTOR (hbv-lbv downto 0); -- high bits - variable valuex : UNRESOLVED_sfixed (hbv downto lbv); - variable igood : BOOLEAN; - variable i : INTEGER; - begin - VALUE := (VALUE'range => 'U'); - OREAD_common ( L => L, - slv => slv, - igood => igood, - idex => i, - bpoint => -lbv, - message => false, - smath => true); - if (igood -- We did not get another error - and (i = -1) -- We read everything - and ((slv(VALUE'high-lbv) = '0' and -- sign bits = extra bits - or_reduce (slv(hbv-lbv downto VALUE'high+1-lbv)) = '0') or - (slv(VALUE'high-lbv) = '1' and - and_reduce (slv(hbv-lbv downto VALUE'high+1-lbv)) = '1'))) then - valuex := to_sfixed (slv, hbv, lbv); - VALUE := valuex (VALUE'range); - good := true; - else - good := false; - end if; - end procedure OREAD; - - -- hex read and write - procedure hwrite ( - L : inout LINE; -- input line - VALUE : in UNRESOLVED_ufixed; -- fixed point input - JUSTIFIED : in SIDE := right; - FIELD : in WIDTH := 0) is - begin -- Example 03.30 - write (L => L, - VALUE => to_hstring (VALUE), - JUSTIFIED => JUSTIFIED, - FIELD => FIELD); - end procedure hwrite; - - -- purpose: writes fixed point into a line - procedure hwrite ( - L : inout LINE; -- input line - VALUE : in UNRESOLVED_sfixed; -- fixed point input - JUSTIFIED : in SIDE := right; - FIELD : in WIDTH := 0) is - begin -- Example 03.30 - write (L => L, - VALUE => to_hstring (VALUE), - JUSTIFIED => JUSTIFIED, - FIELD => FIELD); - end procedure hwrite; - - -- purpose: Routines common to the OREAD routines - procedure HREAD_common ( - L : inout LINE; - slv : out STD_ULOGIC_VECTOR; - igood : out BOOLEAN; - idex : out INTEGER; - constant bpoint : in INTEGER; -- binary point - constant message : in BOOLEAN; - constant smath : in BOOLEAN) is - - -- purpose: error message routine - procedure errmes ( - constant mess : in STRING) is -- error message - begin - if message then - if smath then - report "fixed_pkg:" - & "HREAD(sfixed) " - & mess - severity error; - else - report "fixed_pkg:" - & "HREAD(ufixed) " - & mess - severity error; - end if; - end if; - end procedure errmes; - variable xgood : BOOLEAN; - variable nybble : STD_ULOGIC_VECTOR (3 downto 0); -- 4 bits - variable c : CHARACTER; - variable i : INTEGER; - variable lastu : BOOLEAN := false; -- last character was an "_" - variable founddot : BOOLEAN := false; -- found a dot. - begin - Skip_whitespace (L); - if slv'length > 0 then - i := slv'high; - read (l, c, xgood); - while i > 0 loop - if xgood = false then - errmes ("Error: end of string encountered"); - exit; - elsif c = '_' then - if i = slv'length then - errmes ("Error: String begins with an ""_"""); - xgood := false; - exit; - elsif lastu then - errmes ("Error: Two underscores detected in input string ""__"""); - xgood := false; - exit; - else - lastu := true; - end if; - elsif (c = '.') then - if (i + 1 /= bpoint) then - errmes ("encountered ""."" at wrong index"); - xgood := false; - exit; - elsif i = slv'length then - errmes ("encounted a ""."" at the beginning of the line"); - xgood := false; - exit; - elsif founddot then - errmes ("Two ""."" encounted in input string"); - xgood := false; - exit; - end if; - founddot := true; - lastu := false; - else - Char2QuadBits(c, nybble, xgood, message); - if not xgood then - exit; - end if; - slv (i downto i-3) := nybble; - i := i - 4; - lastu := false; - end if; - if i > 0 then - read (L, c, xgood); - end if; - end loop; - idex := i; - igood := xgood; - else - idex := -1; - igood := true; -- read null string - end if; - end procedure HREAD_common; - - procedure HREAD(L : inout LINE; - VALUE : out UNRESOLVED_ufixed) is - constant hbv : INTEGER := (((maximum(4, (VALUE'high+1))+3)/4)*4)-1; - constant lbv : INTEGER := ((mine(0, VALUE'low)-3)/4)*4; - variable slv : STD_ULOGIC_VECTOR (hbv-lbv downto 0); -- high bits - variable valuex : UNRESOLVED_ufixed (hbv downto lbv); - variable igood : BOOLEAN; - variable i : INTEGER; - begin - VALUE := (VALUE'range => 'U'); - HREAD_common ( L => L, - slv => slv, - igood => igood, - idex => i, - bpoint => -lbv, - message => false, - smath => false); - if igood then - if not ((i = -1) and -- We read everything, and high bits 0 - (or_reduce (slv(hbv-lbv downto VALUE'high+1-lbv)) = '0')) then - report "fixed_pkg:" - & "HREAD(ufixed): Vector truncated." - severity error; - else - if (or_reduce (slv(VALUE'low-lbv-1 downto 0)) = '1') then - assert NO_WARNING - report "fixed_pkg:" - & "HREAD(ufixed): Vector truncated" - severity warning; - end if; - valuex := to_ufixed (slv, hbv, lbv); - VALUE := valuex (VALUE'range); - end if; - end if; - end procedure HREAD; - - procedure HREAD(L : inout LINE; - VALUE : out UNRESOLVED_ufixed; - GOOD : out BOOLEAN) is - constant hbv : INTEGER := (((maximum(4, (VALUE'high+1))+3)/4)*4)-1; - constant lbv : INTEGER := ((mine(0, VALUE'low)-3)/4)*4; - variable slv : STD_ULOGIC_VECTOR (hbv-lbv downto 0); -- high bits - variable valuex : UNRESOLVED_ufixed (hbv downto lbv); - variable igood : BOOLEAN; - variable i : INTEGER; - begin - VALUE := (VALUE'range => 'U'); - HREAD_common ( L => L, - slv => slv, - igood => igood, - idex => i, - bpoint => -lbv, - message => false, - smath => false); - if (igood and -- We did not get another error - (i = -1) and -- We read everything, and high bits 0 - (or_reduce (slv(hbv-lbv downto VALUE'high+1-lbv)) = '0')) then - valuex := to_ufixed (slv, hbv, lbv); - VALUE := valuex (VALUE'range); - good := true; - else - good := false; - end if; - end procedure HREAD; - - procedure HREAD(L : inout LINE; - VALUE : out UNRESOLVED_sfixed) is - constant hbv : INTEGER := (((maximum(4, (VALUE'high+1))+3)/4)*4)-1; - constant lbv : INTEGER := ((mine(0, VALUE'low)-3)/4)*4; - variable slv : STD_ULOGIC_VECTOR (hbv-lbv downto 0); -- high bits - variable valuex : UNRESOLVED_sfixed (hbv downto lbv); - variable igood : BOOLEAN; - variable i : INTEGER; - begin - VALUE := (VALUE'range => 'U'); - HREAD_common ( L => L, - slv => slv, - igood => igood, - idex => i, - bpoint => -lbv, - message => true, - smath => true); - if igood then -- We did not get another error - if not ((i = -1) -- We read everything - and ((slv(VALUE'high-lbv) = '0' and -- sign bits = extra bits - or_reduce (slv(hbv-lbv downto VALUE'high+1-lbv)) = '0') or - (slv(VALUE'high-lbv) = '1' and - and_reduce (slv(hbv-lbv downto VALUE'high+1-lbv)) = '1'))) then - report "fixed_pkg:" - & "HREAD(sfixed): Vector truncated." - severity error; - else - if (or_reduce (slv(VALUE'low-lbv-1 downto 0)) = '1') then - assert NO_WARNING - report "fixed_pkg:" - & "HREAD(sfixed): Vector truncated" - severity warning; - end if; - valuex := to_sfixed (slv, hbv, lbv); - VALUE := valuex (VALUE'range); - end if; - end if; - end procedure HREAD; - - procedure HREAD(L : inout LINE; - VALUE : out UNRESOLVED_sfixed; - GOOD : out BOOLEAN) is - constant hbv : INTEGER := (((maximum(4, (VALUE'high+1))+3)/4)*4)-1; - constant lbv : INTEGER := ((mine(0, VALUE'low)-3)/4)*4; - variable slv : STD_ULOGIC_VECTOR (hbv-lbv downto 0); -- high bits - variable valuex : UNRESOLVED_sfixed (hbv downto lbv); - variable igood : BOOLEAN; - variable i : INTEGER; - begin - VALUE := (VALUE'range => 'U'); - HREAD_common ( L => L, - slv => slv, - igood => igood, - idex => i, - bpoint => -lbv, - message => false, - smath => true); - if (igood and -- We did not get another error - (i = -1) and -- We read everything - ((slv(VALUE'high-lbv) = '0' and -- sign bits = extra bits - or_reduce (slv(hbv-lbv downto VALUE'high+1-lbv)) = '0') or - (slv(VALUE'high-lbv) = '1' and - and_reduce (slv(hbv-lbv downto VALUE'high+1-lbv)) = '1'))) then - valuex := to_sfixed (slv, hbv, lbv); - VALUE := valuex (VALUE'range); - good := true; - else - good := false; - end if; - end procedure HREAD; - - function to_string (value : UNRESOLVED_ufixed) return STRING is - variable s : STRING(1 to value'length +1) := (others => ' '); - variable subval : UNRESOLVED_ufixed (value'high downto -1); - variable sindx : INTEGER; - begin - if value'length < 1 then - return NUS; - else - if value'high < 0 then - if value(value'high) = 'Z' then - return to_string (resize (sfixed(value), 0, value'low)); - else - return to_string (resize (value, 0, value'low)); - end if; - elsif value'low >= 0 then - if Is_X (value(value'low)) then - subval := (others => value(value'low)); - subval (value'range) := value; - return to_string(subval); - else - return to_string (resize (value, value'high, -1)); - end if; - else - sindx := 1; - for i in value'high downto value'low loop - if i = -1 then - s(sindx) := '.'; - sindx := sindx + 1; - end if; - s(sindx) := MVL9_to_char(STD_ULOGIC(value(i))); - sindx := sindx + 1; - end loop; - return s; - end if; - end if; - end function to_string; - - function to_string (value : UNRESOLVED_sfixed) return STRING is - variable s : STRING(1 to value'length + 1) := (others => ' '); - variable subval : UNRESOLVED_sfixed (value'high downto -1); - variable sindx : INTEGER; - begin - if value'length < 1 then - return NUS; - else - if value'high < 0 then - return to_string (resize (value, 0, value'low)); - elsif value'low >= 0 then - if Is_X (value(value'low)) then - subval := (others => value(value'low)); - subval (value'range) := value; - return to_string(subval); - else - return to_string (resize (value, value'high, -1)); - end if; - else - sindx := 1; - for i in value'high downto value'low loop - if i = -1 then - s(sindx) := '.'; - sindx := sindx + 1; - end if; - s(sindx) := MVL9_to_char(STD_ULOGIC(value(i))); - sindx := sindx + 1; - end loop; - return s; - end if; - end if; - end function to_string; - - function to_ostring (value : UNRESOLVED_ufixed) return STRING is - constant lne : INTEGER := (-VALUE'low+2)/3; - variable subval : UNRESOLVED_ufixed (value'high downto -3); - variable lpad : STD_ULOGIC_VECTOR (0 to (lne*3 + VALUE'low) -1); - variable slv : STD_ULOGIC_VECTOR (value'length-1 downto 0); - begin - if value'length < 1 then - return NUS; - else - if value'high < 0 then - if value(value'high) = 'Z' then - return to_ostring (resize (sfixed(value), 2, value'low)); - else - return to_ostring (resize (value, 2, value'low)); - end if; - elsif value'low >= 0 then - if Is_X (value(value'low)) then - subval := (others => value(value'low)); - subval (value'range) := value; - return to_ostring(subval); - else - return to_ostring (resize (value, value'high, -3)); - end if; - else - slv := to_sulv (value); - if Is_X (value (value'low)) then - lpad := (others => value (value'low)); - else - lpad := (others => '0'); - end if; - return to_ostring(slv(slv'high downto slv'high-VALUE'high)) - & "." - & to_ostring(slv(slv'high-VALUE'high-1 downto 0) & lpad); - end if; - end if; - end function to_ostring; - - function to_hstring (value : UNRESOLVED_ufixed) return STRING is - constant lne : INTEGER := (-VALUE'low+3)/4; - variable subval : UNRESOLVED_ufixed (value'high downto -4); - variable lpad : STD_ULOGIC_VECTOR (0 to (lne*4 + VALUE'low) -1); - variable slv : STD_ULOGIC_VECTOR (value'length-1 downto 0); - begin - if value'length < 1 then - return NUS; - else - if value'high < 0 then - if value(value'high) = 'Z' then - return to_hstring (resize (sfixed(value), 3, value'low)); - else - return to_hstring (resize (value, 3, value'low)); - end if; - elsif value'low >= 0 then - if Is_X (value(value'low)) then - subval := (others => value(value'low)); - subval (value'range) := value; - return to_hstring(subval); - else - return to_hstring (resize (value, value'high, -4)); - end if; - else - slv := to_sulv (value); - if Is_X (value (value'low)) then - lpad := (others => value(value'low)); - else - lpad := (others => '0'); - end if; - return to_hstring(slv(slv'high downto slv'high-VALUE'high)) - & "." - & to_hstring(slv(slv'high-VALUE'high-1 downto 0)&lpad); - end if; - end if; - end function to_hstring; - - function to_ostring (value : UNRESOLVED_sfixed) return STRING is - constant ne : INTEGER := ((value'high+1)+2)/3; - variable pad : STD_ULOGIC_VECTOR(0 to (ne*3 - (value'high+1)) - 1); - constant lne : INTEGER := (-VALUE'low+2)/3; - variable subval : UNRESOLVED_sfixed (value'high downto -3); - variable lpad : STD_ULOGIC_VECTOR (0 to (lne*3 + VALUE'low) -1); - variable slv : STD_ULOGIC_VECTOR (VALUE'high - VALUE'low downto 0); - begin - if value'length < 1 then - return NUS; - else - if value'high < 0 then - return to_ostring (resize (value, 2, value'low)); - elsif value'low >= 0 then - if Is_X (value(value'low)) then - subval := (others => value(value'low)); - subval (value'range) := value; - return to_ostring(subval); - else - return to_ostring (resize (value, value'high, -3)); - end if; - else - pad := (others => value(value'high)); - slv := to_sulv (value); - if Is_X (value (value'low)) then - lpad := (others => value(value'low)); - else - lpad := (others => '0'); - end if; - return to_ostring(pad & slv(slv'high downto slv'high-VALUE'high)) - & "." - & to_ostring(slv(slv'high-VALUE'high-1 downto 0) & lpad); - end if; - end if; - end function to_ostring; - - function to_hstring (value : UNRESOLVED_sfixed) return STRING is - constant ne : INTEGER := ((value'high+1)+3)/4; - variable pad : STD_ULOGIC_VECTOR(0 to (ne*4 - (value'high+1)) - 1); - constant lne : INTEGER := (-VALUE'low+3)/4; - variable subval : UNRESOLVED_sfixed (value'high downto -4); - variable lpad : STD_ULOGIC_VECTOR (0 to (lne*4 + VALUE'low) -1); - variable slv : STD_ULOGIC_VECTOR (value'length-1 downto 0); - begin - if value'length < 1 then - return NUS; - else - if value'high < 0 then - return to_hstring (resize (value, 3, value'low)); - elsif value'low >= 0 then - if Is_X (value(value'low)) then - subval := (others => value(value'low)); - subval (value'range) := value; - return to_hstring(subval); - else - return to_hstring (resize (value, value'high, -4)); - end if; - else - slv := to_sulv (value); - pad := (others => value(value'high)); - if Is_X (value (value'low)) then - lpad := (others => value(value'low)); - else - lpad := (others => '0'); - end if; - return to_hstring(pad & slv(slv'high downto slv'high-VALUE'high)) - & "." - & to_hstring(slv(slv'high-VALUE'high-1 downto 0) & lpad); - end if; - end if; - end function to_hstring; - - -- From string functions allow you to convert a string into a fixed - -- point number. Example: - -- signal uf1 : ufixed (3 downto -3); - -- uf1 <= from_string ("0110.100", uf1'high, uf1'low); -- 6.5 - -- The "." is optional in this syntax, however it exist and is - -- in the wrong location an error is produced. Overflow will - -- result in saturation. - - function from_string ( - bstring : STRING; -- binary string - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (left_index downto right_index); - variable L : LINE; - variable good : BOOLEAN; - begin - L := new STRING'(bstring); - read (L, result, good); - deallocate (L); - assert (good) - report "fixed_pkg:" - & "from_string: Bad string "& bstring severity error; - return result; - end function from_string; - - -- Octal and hex conversions work as follows: - -- uf1 <= from_hstring ("6.8", 3, -3); -- 6.5 (bottom zeros dropped) - -- uf1 <= from_ostring ("06.4", 3, -3); -- 6.5 (top zeros dropped) - function from_ostring ( - ostring : STRING; -- Octal string - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (left_index downto right_index); - variable L : LINE; - variable good : BOOLEAN; - begin - L := new STRING'(ostring); - oread (L, result, good); - deallocate (L); - assert (good) - report "fixed_pkg:" - & "from_ostring: Bad string "& ostring severity error; - return result; - end function from_ostring; - - function from_hstring ( - hstring : STRING; -- hex string - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_ufixed is - variable result : UNRESOLVED_ufixed (left_index downto right_index); - variable L : LINE; - variable good : BOOLEAN; - begin - L := new STRING'(hstring); - hread (L, result, good); - deallocate (L); - assert (good) - report "fixed_pkg:" - & "from_hstring: Bad string "& hstring severity error; - return result; - end function from_hstring; - - function from_string ( - bstring : STRING; -- binary string - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (left_index downto right_index); - variable L : LINE; - variable good : BOOLEAN; - begin - L := new STRING'(bstring); - read (L, result, good); - deallocate (L); - assert (good) - report "fixed_pkg:" - & "from_string: Bad string "& bstring severity error; - return result; - end function from_string; - - function from_ostring ( - ostring : STRING; -- Octal string - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (left_index downto right_index); - variable L : LINE; - variable good : BOOLEAN; - begin - L := new STRING'(ostring); - oread (L, result, good); - deallocate (L); - assert (good) - report "fixed_pkg:" - & "from_ostring: Bad string "& ostring severity error; - return result; - end function from_ostring; - - function from_hstring ( - hstring : STRING; -- hex string - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_sfixed is - variable result : UNRESOLVED_sfixed (left_index downto right_index); - variable L : LINE; - variable good : BOOLEAN; - begin - L := new STRING'(hstring); - hread (L, result, good); - deallocate (L); - assert (good) - report "fixed_pkg:" - & "from_hstring: Bad string "& hstring severity error; - return result; - end function from_hstring; - - -- Same as above, "size_res" is used for it's range only. - function from_string ( - bstring : STRING; -- binary string - size_res : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed is - begin - return from_string (bstring, size_res'high, size_res'low); - end function from_string; - - function from_ostring ( - ostring : STRING; -- Octal string - size_res : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed is - begin - return from_ostring (ostring, size_res'high, size_res'low); - end function from_ostring; - - function from_hstring ( - hstring : STRING; -- hex string - size_res : UNRESOLVED_ufixed) - return UNRESOLVED_ufixed is - begin - return from_hstring(hstring, size_res'high, size_res'low); - end function from_hstring; - - function from_string ( - bstring : STRING; -- binary string - size_res : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - begin - return from_string (bstring, size_res'high, size_res'low); - end function from_string; - - function from_ostring ( - ostring : STRING; -- Octal string - size_res : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - begin - return from_ostring (ostring, size_res'high, size_res'low); - end function from_ostring; - - function from_hstring ( - hstring : STRING; -- hex string - size_res : UNRESOLVED_sfixed) - return UNRESOLVED_sfixed is - begin - return from_hstring (hstring, size_res'high, size_res'low); - end function from_hstring; - - -- purpose: Calculate the string boundaries - procedure calculate_string_boundry ( - arg : in STRING; -- input string - left_index : out INTEGER; -- left - right_index : out INTEGER) is -- right - -- examples "10001.111" would return +4, -3 - -- "07X.44" would return +2, -2 (then the octal routine would multiply) - -- "A_B_._C" would return +1, -1 (then the hex routine would multiply) - alias xarg : STRING (arg'length downto 1) is arg; -- make it downto range - variable l, r : INTEGER; -- internal indexes - variable founddot : BOOLEAN := false; - begin - if arg'length > 0 then - l := xarg'high - 1; - r := 0; - for i in xarg'range loop - if xarg(i) = '_' then - if r = 0 then - l := l - 1; - else - r := r + 1; - end if; - elsif xarg(i) = ' ' or xarg(i) = NBSP or xarg(i) = HT then - report "fixed_pkg:" - & "Found a space in the input STRING " & xarg - severity error; - elsif xarg(i) = '.' then - if founddot then - report "fixed_pkg:" - & "Found two binary points in input string " & xarg - severity error; - else - l := l - i; - r := -i + 1; - founddot := true; - end if; - end if; - end loop; - left_index := l; - right_index := r; - else - left_index := 0; - right_index := 0; - end if; - end procedure calculate_string_boundry; - - -- Direct conversion functions. Example: - -- signal uf1 : ufixed (3 downto -3); - -- uf1 <= from_string ("0110.100"); -- 6.5 - -- In this case the "." is not optional, and the size of - -- the output must match exactly. - function from_string ( - bstring : STRING) -- binary string - return UNRESOLVED_ufixed is - variable left_index, right_index : INTEGER; - begin - calculate_string_boundry (bstring, left_index, right_index); - return from_string (bstring, left_index, right_index); - end function from_string; - - -- Direct octal and hex conversion functions. In this case - -- the string lengths must match. Example: - -- signal sf1 := sfixed (5 downto -3); - -- sf1 <= from_ostring ("71.4") -- -6.5 - function from_ostring ( - ostring : STRING) -- Octal string - return UNRESOLVED_ufixed is - variable left_index, right_index : INTEGER; - begin - calculate_string_boundry (ostring, left_index, right_index); - return from_ostring (ostring, ((left_index+1)*3)-1, right_index*3); - end function from_ostring; - - function from_hstring ( - hstring : STRING) -- hex string - return UNRESOLVED_ufixed is - variable left_index, right_index : INTEGER; - begin - calculate_string_boundry (hstring, left_index, right_index); - return from_hstring (hstring, ((left_index+1)*4)-1, right_index*4); - end function from_hstring; - - function from_string ( - bstring : STRING) -- binary string - return UNRESOLVED_sfixed is - variable left_index, right_index : INTEGER; - begin - calculate_string_boundry (bstring, left_index, right_index); - return from_string (bstring, left_index, right_index); - end function from_string; - - function from_ostring ( - ostring : STRING) -- Octal string - return UNRESOLVED_sfixed is - variable left_index, right_index : INTEGER; - begin - calculate_string_boundry (ostring, left_index, right_index); - return from_ostring (ostring, ((left_index+1)*3)-1, right_index*3); - end function from_ostring; - - function from_hstring ( - hstring : STRING) -- hex string - return UNRESOLVED_sfixed is - variable left_index, right_index : INTEGER; - begin - calculate_string_boundry (hstring, left_index, right_index); - return from_hstring (hstring, ((left_index+1)*4)-1, right_index*4); - end function from_hstring; --- pragma synthesis_on --- rtl_synthesis on - -- IN VHDL-2006 std_logic_vector is a subtype of std_ulogic_vector, so these - -- extra functions are needed for compatability. - function to_ufixed ( - arg : STD_LOGIC_VECTOR; -- shifted vector - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_ufixed is - begin - return to_ufixed ( - arg => std_ulogic_vector (arg), - left_index => left_index, - right_index => right_index); - end function to_ufixed; - - function to_ufixed ( - arg : STD_LOGIC_VECTOR; -- shifted vector - size_res : UNRESOLVED_ufixed) -- for size only - return UNRESOLVED_ufixed is - begin - return to_ufixed ( - arg => std_ulogic_vector (arg), - size_res => size_res); - end function to_ufixed; - - function to_sfixed ( - arg : STD_LOGIC_VECTOR; -- shifted vector - constant left_index : INTEGER; - constant right_index : INTEGER) - return UNRESOLVED_sfixed is - begin - return to_sfixed ( - arg => std_ulogic_vector (arg), - left_index => left_index, - right_index => right_index); - end function to_sfixed; - - function to_sfixed ( - arg : STD_LOGIC_VECTOR; -- shifted vector - size_res : UNRESOLVED_sfixed) -- for size only - return UNRESOLVED_sfixed is - begin - return to_sfixed ( - arg => std_ulogic_vector (arg), - size_res => size_res); - end function to_sfixed; - - -- unsigned fixed point - function to_UFix ( - arg : STD_LOGIC_VECTOR; - width : NATURAL; -- width of vector - fraction : NATURAL) -- width of fraction - return UNRESOLVED_ufixed is - begin - return to_UFix ( - arg => std_ulogic_vector (arg), - width => width, - fraction => fraction); - end function to_UFix; - - -- signed fixed point - function to_SFix ( - arg : STD_LOGIC_VECTOR; - width : NATURAL; -- width of vector - fraction : NATURAL) -- width of fraction - return UNRESOLVED_sfixed is - begin - return to_SFix ( - arg => std_ulogic_vector (arg), - width => width, - fraction => fraction); - end function to_SFix; - -end package body fixed_pkg; |