summaryrefslogtreecommitdiffstats
path: root/ieee_proposed/rtl
diff options
context:
space:
mode:
Diffstat (limited to 'ieee_proposed/rtl')
-rw-r--r--ieee_proposed/rtl/env_c.vhd48
-rw-r--r--ieee_proposed/rtl/fixed_float_types_c.vhd34
-rw-r--r--ieee_proposed/rtl/fixed_pkg_c.vhd8390
-rw-r--r--ieee_proposed/rtl/float_pkg_c.vhd7190
-rw-r--r--ieee_proposed/rtl/numeric_std_additions.vhd2886
-rw-r--r--ieee_proposed/rtl/numeric_std_unsigned_c.vhd2207
-rw-r--r--ieee_proposed/rtl/standard_additions_c.vhd2073
-rw-r--r--ieee_proposed/rtl/standard_textio_additions_c.vhd478
-rw-r--r--ieee_proposed/rtl/std_logic_1164_additions.vhd1808
9 files changed, 0 insertions, 25114 deletions
diff --git a/ieee_proposed/rtl/env_c.vhd b/ieee_proposed/rtl/env_c.vhd
deleted file mode 100644
index e6703fa..0000000
--- a/ieee_proposed/rtl/env_c.vhd
+++ /dev/null
@@ -1,48 +0,0 @@
-package ENV is
-
- procedure STOP (STATUS : INTEGER);
- procedure FINISH (STATUS : INTEGER);
-
- function RESOLUTION_LIMIT return DELAY_LENGTH;
-
-end package ENV;
-library ieee_proposed;
-use ieee_proposed.standard_additions.all;
-package body ENV is
-
- procedure STOP (STATUS : INTEGER) is
- begin
- report "Procedure STOP called with status: " & INTEGER'image(STATUS)
- severity failure;
- end procedure STOP;
- procedure FINISH (STATUS : INTEGER) is
- begin
- report "Procedure FINISH called with status: " & INTEGER'image(STATUS)
- severity failure;
- end procedure FINISH;
-
- constant BASE_TIME_ARRAY : time_vector :=
- (
- 1 fs, 10 fs, 100 fs,
- 1 ps, 10 ps, 100 ps,
- 1 ns, 10 ns, 100 ns,
- 1 us, 10 us, 100 us,
- 1 ms, 10 ms, 100 ms,
- 1 sec, 10 sec, 100 sec,
- 1 min, 10 min, 100 min,
- 1 hr, 10 hr, 100 hr
- ) ;
-
- function RESOLUTION_LIMIT return DELAY_LENGTH is
- begin
- for i in BASE_TIME_ARRAY'range loop
- if BASE_TIME_ARRAY(i) > 0 hr then
- return BASE_TIME_ARRAY(i);
- end if;
- end loop;
- report "STANDATD.RESOLUTION_LIMIT: Simulator resolution not less than 100 hr"
- severity failure;
- return 1 ns;
- end function RESOLUTION_LIMIT;
-
-end package body ENV;
diff --git a/ieee_proposed/rtl/fixed_float_types_c.vhd b/ieee_proposed/rtl/fixed_float_types_c.vhd
deleted file mode 100644
index 315b628..0000000
--- a/ieee_proposed/rtl/fixed_float_types_c.vhd
+++ /dev/null
@@ -1,34 +0,0 @@
--- --------------------------------------------------------------------
--- "fixed_float_types" package contains types used in the fixed and floating
--- point packages..
--- Please see the documentation for the floating point package.
--- This package should be compiled into "ieee_proposed" and used as follows:
---
--- This verison is designed to work with the VHDL-93 compilers. Please
--- note the "%%%" comments. These are where we diverge from the
--- VHDL-200X LRM.
---
--- --------------------------------------------------------------------
--- Version : $Revision: 1.21 $
--- Date : $Date: 2007-09-11 14:52:13-04 $
--- --------------------------------------------------------------------
-
-package fixed_float_types is
-
- -- Types used for generics of fixed_generic_pkg
-
- type fixed_round_style_type is (fixed_round, fixed_truncate);
-
- type fixed_overflow_style_type is (fixed_saturate, fixed_wrap);
-
- -- Type used for generics of float_generic_pkg
-
- -- These are the same as the C FE_TONEAREST, FE_UPWARD, FE_DOWNWARD,
- -- and FE_TOWARDZERO floating point rounding macros.
-
- type round_type is (round_nearest, -- Default, nearest LSB '0'
- round_inf, -- Round toward positive infinity
- round_neginf, -- Round toward negative infinity
- round_zero); -- Round toward zero (truncate)
-
-end package fixed_float_types;
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;
diff --git a/ieee_proposed/rtl/float_pkg_c.vhd b/ieee_proposed/rtl/float_pkg_c.vhd
deleted file mode 100644
index 8abbff6..0000000
--- a/ieee_proposed/rtl/float_pkg_c.vhd
+++ /dev/null
@@ -1,7190 +0,0 @@
--- --------------------------------------------------------------------
--- "float_pkg" package contains functions for floating point math.
--- Please see the documentation for the floating 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;
--- use ieee_proposed.float_pkg.all;
---
--- This verison is designed to work with the VHDL-93 compilers. Please
--- note the "%%%" comments. These are where we diverge from the
--- VHDL-200X LRM.
---
--- --------------------------------------------------------------------
--- Version : $Revision: 2.0 $
--- Date : $Date: 2009/01/27 20:45:30 $
--- --------------------------------------------------------------------
-
-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;
-use ieee_proposed.fixed_pkg.all;
-
-package float_pkg is
--- generic (
- -- Defaults for sizing routines, when you do a "to_float" this will be
- -- the default size. Example float32 would be 8 and 23 (8 downto -23)
- constant float_exponent_width : NATURAL := 8;
- constant float_fraction_width : NATURAL := 23;
- -- Rounding algorithm, "round_nearest" is default, other valid values
- -- are "round_zero" (truncation), "round_inf" (round up), and
- -- "round_neginf" (round down)
- constant float_round_style : round_type := round_nearest;
- -- Denormal numbers (very small numbers near zero) true or false
- constant float_denormalize : BOOLEAN := true;
- -- Turns on NAN processing (invalid numbers and overflow) true of false
- constant float_check_error : BOOLEAN := true;
- -- Guard bits are added to the bottom of every operation for rounding.
- -- any natural number (including 0) are valid.
- constant float_guard_bits : NATURAL := 3;
- -- If TRUE, then turn off warnings on "X" propagation
- constant no_warning : BOOLEAN := (false
- );
-
- -- Author David Bishop (dbishop@vhdl.org)
-
- -- Note that the size of the vector is not defined here, but in
- -- the package which calls this one.
- type UNRESOLVED_float is array (INTEGER range <>) of STD_ULOGIC; -- main type
- subtype U_float is UNRESOLVED_float;
-
- subtype float is UNRESOLVED_float;
- -----------------------------------------------------------------------------
- -- Use the float type to define your own floating point numbers.
- -- There must be a negative index or the packages will error out.
- -- Minimum supported is "subtype float7 is float (3 downto -3);"
- -- "subtype float16 is float (6 downto -9);" is probably the smallest
- -- practical one to use.
- -----------------------------------------------------------------------------
-
- -- IEEE 754 single precision
- subtype UNRESOLVED_float32 is UNRESOLVED_float (8 downto -23);
--- alias U_float32 is UNRESOLVED_float32;
- subtype float32 is float (8 downto -23);
- -----------------------------------------------------------------------------
- -- IEEE-754 single precision floating point. This is a "float"
- -- in C, and a FLOAT in Fortran. The exponent is 8 bits wide, and
- -- the fraction is 23 bits wide. This format can hold roughly 7 decimal
- -- digits. Infinity is 2**127 = 1.7E38 in this number system.
- -- The bit representation is as follows:
- -- 1 09876543 21098765432109876543210
- -- 8 76543210 12345678901234567890123
- -- 0 00000000 00000000000000000000000
- -- 8 7 0 -1 -23
- -- +/- exp. fraction
- -----------------------------------------------------------------------------
-
- -- IEEE 754 double precision
- subtype UNRESOLVED_float64 is UNRESOLVED_float (11 downto -52);
--- alias U_float64 is UNRESOLVED_float64;
- subtype float64 is float (11 downto -52);
- -----------------------------------------------------------------------------
- -- IEEE-754 double precision floating point. This is a "double float"
- -- in C, and a FLOAT*8 in Fortran. The exponent is 11 bits wide, and
- -- the fraction is 52 bits wide. This format can hold roughly 15 decimal
- -- digits. Infinity is 2**2047 in this number system.
- -- The bit representation is as follows:
- -- 3 21098765432 1098765432109876543210987654321098765432109876543210
- -- 1 09876543210 1234567890123456789012345678901234567890123456789012
- -- S EEEEEEEEEEE FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
- -- 11 10 0 -1 -52
- -- +/- exponent fraction
- -----------------------------------------------------------------------------
-
- -- IEEE 854 & C extended precision
- subtype UNRESOLVED_float128 is UNRESOLVED_float (15 downto -112);
--- alias U_float128 is UNRESOLVED_float128;
- subtype float128 is float (15 downto -112);
- -----------------------------------------------------------------------------
- -- The 128 bit floating point number is "long double" in C (on
- -- some systems this is a 70 bit floating point number) and FLOAT*32
- -- in Fortran. The exponent is 15 bits wide and the fraction is 112
- -- bits wide. This number can handle approximately 33 decimal digits.
- -- Infinity is 2**32,767 in this number system.
- -----------------------------------------------------------------------------
-
- -- purpose: Checks for a valid floating point number
- type valid_fpstate is (nan, -- Signaling NaN (C FP_NAN)
- quiet_nan, -- Quiet NaN (C FP_NAN)
- neg_inf, -- Negative infinity (C FP_INFINITE)
- neg_normal, -- negative normalized nonzero
- neg_denormal, -- negative denormalized (FP_SUBNORMAL)
- neg_zero, -- -0 (C FP_ZERO)
- pos_zero, -- +0 (C FP_ZERO)
- pos_denormal, -- Positive denormalized (FP_SUBNORMAL)
- pos_normal, -- positive normalized nonzero
- pos_inf, -- positive infinity
- isx); -- at least one input is unknown
-
- -- This deferred constant will tell you if the package body is synthesizable
- -- or implemented as real numbers.
- constant fphdlsynth_or_real : BOOLEAN; -- deferred constant
-
- -- Returns the class which X falls into
- function Classfp (
- x : UNRESOLVED_float; -- floating point input
- check_error : BOOLEAN := float_check_error) -- check for errors
- return valid_fpstate;
-
- -- Arithmetic functions, these operators do not require parameters.
- function "abs" (arg : UNRESOLVED_float) return UNRESOLVED_float;
- function "-" (arg : UNRESOLVED_float) return UNRESOLVED_float;
-
- -- These allows the base math functions to use the default values
- -- of their parameters. Thus they do full IEEE floating point.
-
- function "+" (l, r : UNRESOLVED_float) return UNRESOLVED_float;
- function "-" (l, r : UNRESOLVED_float) return UNRESOLVED_float;
- function "*" (l, r : UNRESOLVED_float) return UNRESOLVED_float;
- function "/" (l, r : UNRESOLVED_float) return UNRESOLVED_float;
--- function "rem" (l, r : UNRESOLVED_float) return UNRESOLVED_float;
--- function "mod" (l, r : UNRESOLVED_float) return UNRESOLVED_float;
-
- -- Basic parameter list
- -- round_style - Selects the rounding algorithm to use
- -- guard - extra bits added to the end if the operation to add precision
- -- check_error - When "false" turns off NAN and overflow checks
- -- denormalize - When "false" turns off denormal number processing
-
- function add (
- l, r : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant guard : NATURAL := float_guard_bits; -- number of guard bits
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float;
-
- function subtract (
- l, r : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant guard : NATURAL := float_guard_bits; -- number of guard bits
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float;
-
- function multiply (
- l, r : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant guard : NATURAL := float_guard_bits; -- number of guard bits
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float;
-
- function divide (
- l, r : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant guard : NATURAL := float_guard_bits; -- number of guard bits
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float;
-
--- function remainder (
--- l, r : UNRESOLVED_float; -- floating point input
--- constant round_style : round_type := float_round_style; -- rounding option
--- constant guard : NATURAL := float_guard_bits; -- number of guard bits
--- constant check_error : BOOLEAN := float_check_error; -- check for errors
--- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
--- return UNRESOLVED_float;
-
--- function modulo (
--- l, r : UNRESOLVED_float; -- floating point input
--- constant round_style : round_type := float_round_style; -- rounding option
--- constant guard : NATURAL := float_guard_bits; -- number of guard bits
--- constant check_error : BOOLEAN := float_check_error; -- check for errors
--- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
--- return UNRESOLVED_float;
-
- -- reciprocal
- function reciprocal (
- arg : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant guard : NATURAL := float_guard_bits; -- number of guard bits
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float;
-
- function dividebyp2 (
- l, r : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant guard : NATURAL := float_guard_bits; -- number of guard bits
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float;
-
- -- Multiply accumulate result = l*r + c
- function mac (
- l, r, c : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant guard : NATURAL := float_guard_bits; -- number of guard bits
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float;
-
- -- Square root (all 754 based implementations need this)
--- function sqrt (
--- arg : UNRESOLVED_float; -- floating point input
--- constant round_style : round_type := float_round_style;
--- constant guard : NATURAL := float_guard_bits;
--- constant check_error : BOOLEAN := float_check_error;
--- constant denormalize : BOOLEAN := float_denormalize)
--- return UNRESOLVED_float;
-
- function Is_Negative (arg : UNRESOLVED_float) return BOOLEAN;
-
- -----------------------------------------------------------------------------
- -- compare functions
- -- =, /=, >=, <=, <, >, maximum, minimum
-
- function eq ( -- equal =
- l, r : UNRESOLVED_float; -- floating point input
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize : BOOLEAN := float_denormalize)
- return BOOLEAN;
-
- function ne ( -- not equal /=
- l, r : UNRESOLVED_float; -- floating point input
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize : BOOLEAN := float_denormalize)
- return BOOLEAN;
-
- function lt ( -- less than <
- l, r : UNRESOLVED_float; -- floating point input
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize : BOOLEAN := float_denormalize)
- return BOOLEAN;
-
- function gt ( -- greater than >
- l, r : UNRESOLVED_float; -- floating point input
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize : BOOLEAN := float_denormalize)
- return BOOLEAN;
-
- function le ( -- less than or equal to <=
- l, r : UNRESOLVED_float; -- floating point input
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize : BOOLEAN := float_denormalize)
- return BOOLEAN;
-
- function ge ( -- greater than or equal to >=
- l, r : UNRESOLVED_float; -- floating point input
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize : BOOLEAN := float_denormalize)
- return BOOLEAN;
-
- -- Need to overload the default versions of these
- function "=" (l, r : UNRESOLVED_float) return BOOLEAN;
- function "/=" (l, r : UNRESOLVED_float) return BOOLEAN;
- function ">=" (l, r : UNRESOLVED_float) return BOOLEAN;
- function "<=" (l, r : UNRESOLVED_float) return BOOLEAN;
- function ">" (l, r : UNRESOLVED_float) return BOOLEAN;
- function "<" (l, r : UNRESOLVED_float) return BOOLEAN;
-
- function \?=\ (l, r : UNRESOLVED_float) return STD_ULOGIC;
- function \?/=\ (l, r : UNRESOLVED_float) return STD_ULOGIC;
- function \?>\ (l, r : UNRESOLVED_float) return STD_ULOGIC;
- function \?>=\ (l, r : UNRESOLVED_float) return STD_ULOGIC;
- function \?<\ (l, r : UNRESOLVED_float) return STD_ULOGIC;
- function \?<=\ (l, r : UNRESOLVED_float) return STD_ULOGIC;
-
- function std_match (l, r : UNRESOLVED_float) return BOOLEAN;
- function find_rightmost (arg : UNRESOLVED_float; y : STD_ULOGIC)
- return INTEGER;
- function find_leftmost (arg : UNRESOLVED_float; y : STD_ULOGIC)
- return INTEGER;
- function maximum (l, r : UNRESOLVED_float) return UNRESOLVED_float;
- function minimum (l, r : UNRESOLVED_float) return UNRESOLVED_float;
-
- -- conversion functions
- -- Converts one floating point number into another.
-
- function resize (
- arg : UNRESOLVED_float; -- Floating point input
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- length of FP output fraction
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize_in : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float;
-
- function resize (
- arg : UNRESOLVED_float; -- Floating point input
- size_res : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize_in : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float;
-
- function to_float32 (
- arg : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize_in : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float32;
-
- function to_float64 (
- arg : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize_in : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float64;
-
- function to_float128 (
- arg : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize_in : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float128;
-
- -- Converts an fp into an SLV (needed for synthesis)
- function to_slv (arg : UNRESOLVED_float) return STD_LOGIC_VECTOR;
--- alias to_StdLogicVector is to_slv [UNRESOLVED_float return STD_LOGIC_VECTOR];
--- alias to_Std_Logic_Vector is to_slv [UNRESOLVED_float return STD_LOGIC_VECTOR];
-
- -- Converts an fp into an std_ulogic_vector (sulv)
- function to_sulv (arg : UNRESOLVED_float) return STD_ULOGIC_VECTOR;
--- alias to_StdULogicVector is to_sulv [UNRESOLVED_float return STD_ULOGIC_VECTOR];
--- alias to_Std_ULogic_Vector is to_sulv [UNRESOLVED_float return STD_ULOGIC_VECTOR];
-
- -- std_ulogic_vector to float
- function to_float (
- arg : STD_ULOGIC_VECTOR;
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width) -- length of FP output fraction
- return UNRESOLVED_float;
-
- -- Integer to float
- function to_float (
- arg : INTEGER;
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- length of FP output fraction
- constant round_style : round_type := float_round_style) -- rounding option
- return UNRESOLVED_float;
-
- -- real to float
- function to_float (
- arg : REAL;
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- length of FP output fraction
- constant round_style : round_type := float_round_style; -- rounding option
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float;
-
- -- unsigned to float
- function to_float (
- arg : UNSIGNED;
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- length of FP output fraction
- constant round_style : round_type := float_round_style) -- rounding option
- return UNRESOLVED_float;
-
- -- signed to float
- function to_float (
- arg : SIGNED;
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- length of FP output fraction
- constant round_style : round_type := float_round_style) -- rounding option
- return UNRESOLVED_float;
-
- -- unsigned fixed point to float
- function to_float (
- arg : UNRESOLVED_ufixed; -- unsigned fixed point input
- constant exponent_width : NATURAL := float_exponent_width; -- width of exponent
- constant fraction_width : NATURAL := float_fraction_width; -- width of fraction
- constant round_style : round_type := float_round_style; -- rounding
- constant denormalize : BOOLEAN := float_denormalize) -- use ieee extensions
- return UNRESOLVED_float;
-
- -- signed fixed point to float
- function to_float (
- arg : UNRESOLVED_sfixed;
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- length of FP output fraction
- constant round_style : round_type := float_round_style; -- rounding
- constant denormalize : BOOLEAN := float_denormalize) -- rounding option
- return UNRESOLVED_float;
-
- -- size_res functions
- -- Integer to float
- function to_float (
- arg : INTEGER;
- size_res : UNRESOLVED_float;
- constant round_style : round_type := float_round_style) -- rounding option
- return UNRESOLVED_float;
-
- -- real to float
- function to_float (
- arg : REAL;
- size_res : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding option
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float;
-
- -- unsigned to float
- function to_float (
- arg : UNSIGNED;
- size_res : UNRESOLVED_float;
- constant round_style : round_type := float_round_style) -- rounding option
- return UNRESOLVED_float;
-
- -- signed to float
- function to_float (
- arg : SIGNED;
- size_res : UNRESOLVED_float;
- constant round_style : round_type := float_round_style) -- rounding option
- return UNRESOLVED_float;
-
- -- sulv to float
- function to_float (
- arg : STD_ULOGIC_VECTOR;
- size_res : UNRESOLVED_float)
- return UNRESOLVED_float;
-
- -- unsigned fixed point to float
- function to_float (
- arg : UNRESOLVED_ufixed; -- unsigned fixed point input
- size_res : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding
- constant denormalize : BOOLEAN := float_denormalize) -- use ieee extensions
- return UNRESOLVED_float;
-
- -- signed fixed point to float
- function to_float (
- arg : UNRESOLVED_sfixed;
- size_res : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding
- constant denormalize : BOOLEAN := float_denormalize) -- rounding option
- return UNRESOLVED_float;
-
- -- float to unsigned
- function to_unsigned (
- arg : UNRESOLVED_float; -- floating point input
- constant size : NATURAL; -- length of output
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error) -- check for errors
- return UNSIGNED;
-
- -- float to signed
- function to_signed (
- arg : UNRESOLVED_float; -- floating point input
- constant size : NATURAL; -- length of output
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error) -- check for errors
- return SIGNED;
-
- -- purpose: Converts a float to unsigned fixed point
- function to_ufixed (
- arg : UNRESOLVED_float; -- fp input
- constant left_index : INTEGER; -- integer part
- constant right_index : INTEGER; -- fraction part
- constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; -- saturate
- constant round_style : fixed_round_style_type := fixed_round_style; -- rounding
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize)
- return UNRESOLVED_ufixed;
-
- -- float to signed fixed point
- function to_sfixed (
- arg : UNRESOLVED_float; -- fp input
- constant left_index : INTEGER; -- integer part
- constant right_index : INTEGER; -- fraction part
- constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; -- saturate
- constant round_style : fixed_round_style_type := fixed_round_style; -- rounding
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize)
- return UNRESOLVED_sfixed;
-
- -- size_res versions
- -- float to unsigned
- function to_unsigned (
- arg : UNRESOLVED_float; -- floating point input
- size_res : UNSIGNED;
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error) -- check for errors
- return UNSIGNED;
-
- -- float to signed
- function to_signed (
- arg : UNRESOLVED_float; -- floating point input
- size_res : SIGNED;
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error) -- check for errors
- return SIGNED;
-
- -- purpose: Converts a float to unsigned fixed point
- function to_ufixed (
- arg : UNRESOLVED_float; -- fp input
- size_res : UNRESOLVED_ufixed;
- constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; -- saturate
- constant round_style : fixed_round_style_type := fixed_round_style; -- rounding
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize)
- return UNRESOLVED_ufixed;
-
- -- float to signed fixed point
- function to_sfixed (
- arg : UNRESOLVED_float; -- fp input
- size_res : UNRESOLVED_sfixed;
- constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; -- saturate
- constant round_style : fixed_round_style_type := fixed_round_style; -- rounding
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize)
- return UNRESOLVED_sfixed;
-
- -- float to real
- function to_real (
- arg : UNRESOLVED_float; -- floating point input
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return REAL;
-
- -- float to integer
- function to_integer (
- arg : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error) -- check for errors
- return INTEGER;
-
- -- For Verilog compatability
- function realtobits (arg : REAL) return STD_ULOGIC_VECTOR;
- function bitstoreal (arg : STD_ULOGIC_VECTOR) return REAL;
-
- -- Maps metalogical values
- function to_01 (
- arg : UNRESOLVED_float; -- floating point input
- XMAP : STD_LOGIC := '0')
- return UNRESOLVED_float;
-
- function Is_X (arg : UNRESOLVED_float) return BOOLEAN;
- function to_X01 (arg : UNRESOLVED_float) return UNRESOLVED_float;
- function to_X01Z (arg : UNRESOLVED_float) return UNRESOLVED_float;
- function to_UX01 (arg : UNRESOLVED_float) return UNRESOLVED_float;
-
- -- These two procedures were copied out of the body because they proved
- -- very useful for vendor specific algorithm development
- -- Break_number converts a floating point number into it's parts
- -- Exponent is biased by -1
-
- procedure break_number (
- arg : in UNRESOLVED_float;
- denormalize : in BOOLEAN := float_denormalize;
- check_error : in BOOLEAN := float_check_error;
- fract : out UNSIGNED;
- expon : out SIGNED; -- NOTE: Add 1 to get the real exponent!
- sign : out STD_ULOGIC);
-
- procedure break_number (
- arg : in UNRESOLVED_float;
- denormalize : in BOOLEAN := float_denormalize;
- check_error : in BOOLEAN := float_check_error;
- fract : out ufixed; -- a number between 1.0 and 2.0
- expon : out SIGNED; -- NOTE: Add 1 to get the real exponent!
- sign : out STD_ULOGIC);
-
- -- Normalize takes a fraction and and exponent and converts them into
- -- a floating point number. Does the shifting and the rounding.
- -- Exponent is assumed to be biased by -1
-
- function normalize (
- fract : UNSIGNED; -- fraction, unnormalized
- expon : SIGNED; -- exponent - 1, normalized
- sign : STD_ULOGIC; -- sign bit
- sticky : STD_ULOGIC := '0'; -- Sticky bit (rounding)
- constant exponent_width : NATURAL := float_exponent_width; -- size of output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- size of output fraction
- constant round_style : round_type := float_round_style; -- rounding option
- constant denormalize : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant nguard : NATURAL := float_guard_bits) -- guard bits
- return UNRESOLVED_float;
-
- -- Exponent is assumed to be biased by -1
- function normalize (
- fract : ufixed; -- unsigned fixed point
- expon : SIGNED; -- exponent - 1, normalized
- sign : STD_ULOGIC; -- sign bit
- sticky : STD_ULOGIC := '0'; -- Sticky bit (rounding)
- constant exponent_width : NATURAL := float_exponent_width; -- size of output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- size of output fraction
- constant round_style : round_type := float_round_style; -- rounding option
- constant denormalize : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant nguard : NATURAL := float_guard_bits) -- guard bits
- return UNRESOLVED_float;
-
- function normalize (
- fract : UNSIGNED; -- unsigned
- expon : SIGNED; -- exponent - 1, normalized
- sign : STD_ULOGIC; -- sign bit
- sticky : STD_ULOGIC := '0'; -- Sticky bit (rounding)
- size_res : UNRESOLVED_float; -- used for sizing only
- constant round_style : round_type := float_round_style; -- rounding option
- constant denormalize : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant nguard : NATURAL := float_guard_bits) -- guard bits
- return UNRESOLVED_float;
-
- -- Exponent is assumed to be biased by -1
- function normalize (
- fract : ufixed; -- unsigned fixed point
- expon : SIGNED; -- exponent - 1, normalized
- sign : STD_ULOGIC; -- sign bit
- sticky : STD_ULOGIC := '0'; -- Sticky bit (rounding)
- size_res : UNRESOLVED_float; -- used for sizing only
- constant round_style : round_type := float_round_style; -- rounding option
- constant denormalize : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant nguard : NATURAL := float_guard_bits) -- guard bits
- return UNRESOLVED_float;
-
- -- overloaded versions
- function "+" (l : UNRESOLVED_float; r : REAL) return UNRESOLVED_float;
- function "+" (l : REAL; r : UNRESOLVED_float) return UNRESOLVED_float;
- function "+" (l : UNRESOLVED_float; r : INTEGER) return UNRESOLVED_float;
- function "+" (l : INTEGER; r : UNRESOLVED_float) return UNRESOLVED_float;
- function "-" (l : UNRESOLVED_float; r : REAL) return UNRESOLVED_float;
- function "-" (l : REAL; r : UNRESOLVED_float) return UNRESOLVED_float;
- function "-" (l : UNRESOLVED_float; r : INTEGER) return UNRESOLVED_float;
- function "-" (l : INTEGER; r : UNRESOLVED_float) return UNRESOLVED_float;
- function "*" (l : UNRESOLVED_float; r : REAL) return UNRESOLVED_float;
- function "*" (l : REAL; r : UNRESOLVED_float) return UNRESOLVED_float;
- function "*" (l : UNRESOLVED_float; r : INTEGER) return UNRESOLVED_float;
- function "*" (l : INTEGER; r : UNRESOLVED_float) return UNRESOLVED_float;
- function "/" (l : UNRESOLVED_float; r : REAL) return UNRESOLVED_float;
- function "/" (l : REAL; r : UNRESOLVED_float) return UNRESOLVED_float;
- function "/" (l : UNRESOLVED_float; r : INTEGER) return UNRESOLVED_float;
- function "/" (l : INTEGER; r : UNRESOLVED_float) return UNRESOLVED_float;
--- function "rem" (l : UNRESOLVED_float; r : REAL) return UNRESOLVED_float;
--- function "rem" (l : REAL; r : UNRESOLVED_float) return UNRESOLVED_float;
--- function "rem" (l : UNRESOLVED_float; r : INTEGER) return UNRESOLVED_float;
--- function "rem" (l : INTEGER; r : UNRESOLVED_float) return UNRESOLVED_float;
--- function "mod" (l : UNRESOLVED_float; r : REAL) return UNRESOLVED_float;
--- function "mod" (l : REAL; r : UNRESOLVED_float) return UNRESOLVED_float;
--- function "mod" (l : UNRESOLVED_float; r : INTEGER) return UNRESOLVED_float;
--- function "mod" (l : INTEGER; r : UNRESOLVED_float) return UNRESOLVED_float;
-
- -- overloaded compare functions
- function "=" (l : UNRESOLVED_float; r : REAL) return BOOLEAN;
- function "/=" (l : UNRESOLVED_float; r : REAL) return BOOLEAN;
- function ">=" (l : UNRESOLVED_float; r : REAL) return BOOLEAN;
- function "<=" (l : UNRESOLVED_float; r : REAL) return BOOLEAN;
- function ">" (l : UNRESOLVED_float; r : REAL) return BOOLEAN;
- function "<" (l : UNRESOLVED_float; r : REAL) return BOOLEAN;
- function "=" (l : REAL; r : UNRESOLVED_float) return BOOLEAN;
- function "/=" (l : REAL; r : UNRESOLVED_float) return BOOLEAN;
- function ">=" (l : REAL; r : UNRESOLVED_float) return BOOLEAN;
- function "<=" (l : REAL; r : UNRESOLVED_float) return BOOLEAN;
- function ">" (l : REAL; r : UNRESOLVED_float) return BOOLEAN;
- function "<" (l : REAL; r : UNRESOLVED_float) return BOOLEAN;
- function "=" (l : UNRESOLVED_float; r : INTEGER) return BOOLEAN;
- function "/=" (l : UNRESOLVED_float; r : INTEGER) return BOOLEAN;
- function ">=" (l : UNRESOLVED_float; r : INTEGER) return BOOLEAN;
- function "<=" (l : UNRESOLVED_float; r : INTEGER) return BOOLEAN;
- function ">" (l : UNRESOLVED_float; r : INTEGER) return BOOLEAN;
- function "<" (l : UNRESOLVED_float; r : INTEGER) return BOOLEAN;
- function "=" (l : INTEGER; r : UNRESOLVED_float) return BOOLEAN;
- function "/=" (l : INTEGER; r : UNRESOLVED_float) return BOOLEAN;
- function ">=" (l : INTEGER; r : UNRESOLVED_float) return BOOLEAN;
- function "<=" (l : INTEGER; r : UNRESOLVED_float) return BOOLEAN;
- function ">" (l : INTEGER; r : UNRESOLVED_float) return BOOLEAN;
- function "<" (l : INTEGER; r : UNRESOLVED_float) return BOOLEAN;
- function \?=\ (l : UNRESOLVED_float; r : REAL) return STD_ULOGIC;
- function \?/=\ (l : UNRESOLVED_float; r : REAL) return STD_ULOGIC;
- function \?>\ (l : UNRESOLVED_float; r : REAL) return STD_ULOGIC;
- function \?>=\ (l : UNRESOLVED_float; r : REAL) return STD_ULOGIC;
- function \?<\ (l : UNRESOLVED_float; r : REAL) return STD_ULOGIC;
- function \?<=\ (l : UNRESOLVED_float; r : REAL) return STD_ULOGIC;
- function \?=\ (l : REAL; r : UNRESOLVED_float) return STD_ULOGIC;
- function \?/=\ (l : REAL; r : UNRESOLVED_float) return STD_ULOGIC;
- function \?>\ (l : REAL; r : UNRESOLVED_float) return STD_ULOGIC;
- function \?>=\ (l : REAL; r : UNRESOLVED_float) return STD_ULOGIC;
- function \?<\ (l : REAL; r : UNRESOLVED_float) return STD_ULOGIC;
- function \?<=\ (l : REAL; r : UNRESOLVED_float) return STD_ULOGIC;
- function \?=\ (l : UNRESOLVED_float; r : INTEGER) return STD_ULOGIC;
- function \?/=\ (l : UNRESOLVED_float; r : INTEGER) return STD_ULOGIC;
- function \?>\ (l : UNRESOLVED_float; r : INTEGER) return STD_ULOGIC;
- function \?>=\ (l : UNRESOLVED_float; r : INTEGER) return STD_ULOGIC;
- function \?<\ (l : UNRESOLVED_float; r : INTEGER) return STD_ULOGIC;
- function \?<=\ (l : UNRESOLVED_float; r : INTEGER) return STD_ULOGIC;
- function \?=\ (l : INTEGER; r : UNRESOLVED_float) return STD_ULOGIC;
- function \?/=\ (l : INTEGER; r : UNRESOLVED_float) return STD_ULOGIC;
- function \?>\ (l : INTEGER; r : UNRESOLVED_float) return STD_ULOGIC;
- function \?>=\ (l : INTEGER; r : UNRESOLVED_float) return STD_ULOGIC;
- function \?<\ (l : INTEGER; r : UNRESOLVED_float) return STD_ULOGIC;
- function \?<=\ (l : INTEGER; r : UNRESOLVED_float) return STD_ULOGIC;
- -- minimum and maximum overloads
- function maximum (l : UNRESOLVED_float; r : REAL) return UNRESOLVED_float;
- function minimum (l : UNRESOLVED_float; r : REAL) return UNRESOLVED_float;
- function maximum (l : REAL; r : UNRESOLVED_float) return UNRESOLVED_float;
- function minimum (l : REAL; r : UNRESOLVED_float) return UNRESOLVED_float;
- function maximum (l : UNRESOLVED_float; r : INTEGER) return UNRESOLVED_float;
- function minimum (l : UNRESOLVED_float; r : INTEGER) return UNRESOLVED_float;
- function maximum (l : INTEGER; r : UNRESOLVED_float) return UNRESOLVED_float;
- function minimum (l : INTEGER; r : UNRESOLVED_float) return UNRESOLVED_float;
-----------------------------------------------------------------------------
- -- logical functions
- ----------------------------------------------------------------------------
-
- function "not" (l : UNRESOLVED_float) return UNRESOLVED_float;
- function "and" (l, r : UNRESOLVED_float) return UNRESOLVED_float;
- function "or" (l, r : UNRESOLVED_float) return UNRESOLVED_float;
- function "nand" (l, r : UNRESOLVED_float) return UNRESOLVED_float;
- function "nor" (l, r : UNRESOLVED_float) return UNRESOLVED_float;
- function "xor" (l, r : UNRESOLVED_float) return UNRESOLVED_float;
- function "xnor" (l, r : UNRESOLVED_float) return UNRESOLVED_float;
- -- Vector and std_ulogic functions, same as functions in numeric_std
- function "and" (l : STD_ULOGIC; r : UNRESOLVED_float)
- return UNRESOLVED_float;
- function "and" (l : UNRESOLVED_float; r : STD_ULOGIC)
- return UNRESOLVED_float;
- function "or" (l : STD_ULOGIC; r : UNRESOLVED_float)
- return UNRESOLVED_float;
- function "or" (l : UNRESOLVED_float; r : STD_ULOGIC)
- return UNRESOLVED_float;
- function "nand" (l : STD_ULOGIC; r : UNRESOLVED_float)
- return UNRESOLVED_float;
- function "nand" (l : UNRESOLVED_float; r : STD_ULOGIC)
- return UNRESOLVED_float;
- function "nor" (l : STD_ULOGIC; r : UNRESOLVED_float)
- return UNRESOLVED_float;
- function "nor" (l : UNRESOLVED_float; r : STD_ULOGIC)
- return UNRESOLVED_float;
- function "xor" (l : STD_ULOGIC; r : UNRESOLVED_float)
- return UNRESOLVED_float;
- function "xor" (l : UNRESOLVED_float; r : STD_ULOGIC)
- return UNRESOLVED_float;
- function "xnor" (l : STD_ULOGIC; r : UNRESOLVED_float)
- return UNRESOLVED_float;
- function "xnor" (l : UNRESOLVED_float; r : STD_ULOGIC)
- return UNRESOLVED_float;
- -- Reduction operators, same as numeric_std functions
- function and_reduce (l : UNRESOLVED_float) return STD_ULOGIC;
- function nand_reduce (l : UNRESOLVED_float) return STD_ULOGIC;
- function or_reduce (l : UNRESOLVED_float) return STD_ULOGIC;
- function nor_reduce (l : UNRESOLVED_float) return STD_ULOGIC;
- function xor_reduce (l : UNRESOLVED_float) return STD_ULOGIC;
- function xnor_reduce (l : UNRESOLVED_float) return STD_ULOGIC;
-
- -- Note: "sla", "sra", "sll", "slr", "rol" and "ror" not implemented.
-
- -----------------------------------------------------------------------------
- -- Recommended Functions from the IEEE 754 Appendix
- -----------------------------------------------------------------------------
-
- -- returns x with the sign of y.
- function Copysign (x, y : UNRESOLVED_float) return UNRESOLVED_float;
-
- -- Returns y * 2**n for integral values of N without computing 2**n
- function Scalb (
- y : UNRESOLVED_float; -- floating point input
- N : INTEGER; -- exponent to add
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float;
-
- -- Returns y * 2**n for integral values of N without computing 2**n
- function Scalb (
- y : UNRESOLVED_float; -- floating point input
- N : SIGNED; -- exponent to add
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float;
-
- -- returns the unbiased exponent of x
- function Logb (x : UNRESOLVED_float) return INTEGER;
- function Logb (x : UNRESOLVED_float) return SIGNED;
-
- -- returns the next representable neighbor of x in the direction toward y
--- function Nextafter (
--- x, y : UNRESOLVED_float; -- floating point input
--- constant check_error : BOOLEAN := float_check_error; -- check for errors
--- constant denormalize : BOOLEAN := float_denormalize)
--- return UNRESOLVED_float;
-
- -- Returns TRUE if X is unordered with Y.
- function Unordered (x, y : UNRESOLVED_float) return BOOLEAN;
- function Finite (x : UNRESOLVED_float) return BOOLEAN;
- function Isnan (x : UNRESOLVED_float) return BOOLEAN;
-
- -- Function to return constants.
- function zerofp (
- constant exponent_width : NATURAL := float_exponent_width; -- exponent
- constant fraction_width : NATURAL := float_fraction_width) -- fraction
- return UNRESOLVED_float;
- function nanfp (
- constant exponent_width : NATURAL := float_exponent_width; -- exponent
- constant fraction_width : NATURAL := float_fraction_width) -- fraction
- return UNRESOLVED_float;
- function qnanfp (
- constant exponent_width : NATURAL := float_exponent_width; -- exponent
- constant fraction_width : NATURAL := float_fraction_width) -- fraction
- return UNRESOLVED_float;
- function pos_inffp (
- constant exponent_width : NATURAL := float_exponent_width; -- exponent
- constant fraction_width : NATURAL := float_fraction_width) -- fraction
- return UNRESOLVED_float;
- function neg_inffp (
- constant exponent_width : NATURAL := float_exponent_width; -- exponent
- constant fraction_width : NATURAL := float_fraction_width) -- fraction
- return UNRESOLVED_float;
- function neg_zerofp (
- constant exponent_width : NATURAL := float_exponent_width; -- exponent
- constant fraction_width : NATURAL := float_fraction_width) -- fraction
- return UNRESOLVED_float;
- -- size_res versions
- function zerofp (
- size_res : UNRESOLVED_float) -- variable is only use for sizing
- return UNRESOLVED_float;
- function nanfp (
- size_res : UNRESOLVED_float) -- variable is only use for sizing
- return UNRESOLVED_float;
- function qnanfp (
- size_res : UNRESOLVED_float) -- variable is only use for sizing
- return UNRESOLVED_float;
- function pos_inffp (
- size_res : UNRESOLVED_float) -- variable is only use for sizing
- return UNRESOLVED_float;
- function neg_inffp (
- size_res : UNRESOLVED_float) -- variable is only use for sizing
- return UNRESOLVED_float;
- function neg_zerofp (
- size_res : UNRESOLVED_float) -- variable is only use for sizing
- return UNRESOLVED_float;
-
- -- ===========================================================================
- -- string and textio Functions
- -- ===========================================================================
--- rtl_synthesis off
--- pragma synthesis_off
- -- writes S:EEEE:FFFFFFFF
- procedure WRITE (
- L : inout LINE; -- access type (pointer)
- VALUE : in UNRESOLVED_float; -- value to write
- JUSTIFIED : in SIDE := right; -- which side to justify text
- FIELD : in WIDTH := 0); -- width of field
-
- -- Reads SEEEEFFFFFFFF, "." and ":" are ignored
- procedure READ (L : inout LINE; VALUE : out UNRESOLVED_float);
- procedure READ (L : inout LINE; VALUE : out UNRESOLVED_float;
- GOOD : out BOOLEAN);
-
- alias BREAD is READ [LINE, UNRESOLVED_float, BOOLEAN];
- alias BREAD is READ [LINE, UNRESOLVED_float];
- alias BWRITE is WRITE [LINE, UNRESOLVED_float, SIDE, WIDTH];
- alias BINARY_READ is READ [LINE, UNRESOLVED_FLOAT, BOOLEAN];
- alias BINARY_READ is READ [LINE, UNRESOLVED_FLOAT];
- alias BINARY_WRITE is WRITE [LINE, UNRESOLVED_float, SIDE, WIDTH];
-
- procedure OWRITE (
- L : inout LINE; -- access type (pointer)
- VALUE : in UNRESOLVED_float; -- value to write
- JUSTIFIED : in SIDE := right; -- which side to justify text
- FIELD : in WIDTH := 0); -- width of field
-
- -- Octal read with padding, no separators used
- procedure OREAD (L : inout LINE; VALUE : out UNRESOLVED_float);
- procedure OREAD (L : inout LINE; VALUE : out UNRESOLVED_float;
- GOOD : out BOOLEAN);
- alias OCTAL_READ is OREAD [LINE, UNRESOLVED_FLOAT, BOOLEAN];
- alias OCTAL_READ is OREAD [LINE, UNRESOLVED_FLOAT];
- alias OCTAL_WRITE is OWRITE [LINE, UNRESOLVED_FLOAT, SIDE, WIDTH];
-
- -- Hex write with padding, no separators
- procedure HWRITE (
- L : inout LINE; -- access type (pointer)
- VALUE : in UNRESOLVED_float; -- value to write
- JUSTIFIED : in SIDE := right; -- which side to justify text
- FIELD : in WIDTH := 0); -- width of field
-
- -- Hex read with padding, no separators used
- procedure HREAD (L : inout LINE; VALUE : out UNRESOLVED_float);
- procedure HREAD (L : inout LINE; VALUE : out UNRESOLVED_float;
- GOOD : out BOOLEAN);
- alias HEX_READ is HREAD [LINE, UNRESOLVED_FLOAT, BOOLEAN];
- alias HEX_READ is HREAD [LINE, UNRESOLVED_FLOAT];
- alias HEX_WRITE is HWRITE [LINE, UNRESOLVED_FLOAT, SIDE, WIDTH];
-
- -- returns "S:EEEE:FFFFFFFF"
- function to_string (value : UNRESOLVED_float) return STRING;
- alias TO_BSTRING is TO_STRING [UNRESOLVED_FLOAT return STRING];
- alias TO_BINARY_STRING is TO_STRING [UNRESOLVED_FLOAT return STRING];
-
- -- Returns a HEX string, with padding
- function to_hstring (value : UNRESOLVED_float) return STRING;
- alias TO_HEX_STRING is TO_HSTRING [UNRESOLVED_FLOAT return STRING];
-
- -- Returns and octal string, with padding
- function to_ostring (value : UNRESOLVED_float) return STRING;
- alias TO_OCTAL_STRING is TO_OSTRING [UNRESOLVED_FLOAT return STRING];
-
- function from_string (
- bstring : STRING; -- binary string
- constant exponent_width : NATURAL := float_exponent_width;
- constant fraction_width : NATURAL := float_fraction_width)
- return UNRESOLVED_float;
- alias from_bstring is from_string [STRING, NATURAL, NATURAL
- return UNRESOLVED_float];
- alias from_binary_string is from_string [STRING, NATURAL, NATURAL
- return UNRESOLVED_float];
- function from_ostring (
- ostring : STRING; -- Octal string
- constant exponent_width : NATURAL := float_exponent_width;
- constant fraction_width : NATURAL := float_fraction_width)
- return UNRESOLVED_float;
- alias from_octal_string is from_ostring [STRING, NATURAL, NATURAL
- return UNRESOLVED_float];
-
- function from_hstring (
- hstring : STRING; -- hex string
- constant exponent_width : NATURAL := float_exponent_width;
- constant fraction_width : NATURAL := float_fraction_width)
- return UNRESOLVED_float;
- alias from_hex_string is from_hstring [STRING, NATURAL, NATURAL
- return UNRESOLVED_float];
-
- function from_string (
- bstring : STRING; -- binary string
- size_res : UNRESOLVED_float) -- used for sizing only
- return UNRESOLVED_float;
- alias from_bstring is from_string [STRING, UNRESOLVED_float
- return UNRESOLVED_float];
- alias from_binary_string is from_string [STRING, UNRESOLVED_float
- return UNRESOLVED_float];
-
- function from_ostring (
- ostring : STRING; -- Octal string
- size_res : UNRESOLVED_float) -- used for sizing only
- return UNRESOLVED_float;
- alias from_octal_string is from_ostring [STRING, UNRESOLVED_float
- return UNRESOLVED_float];
-
- function from_hstring (
- hstring : STRING; -- hex string
- size_res : UNRESOLVED_float) -- used for sizing only
- return UNRESOLVED_float;
- alias from_hex_string is from_hstring [STRING, UNRESOLVED_float
- return UNRESOLVED_float];
--- 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_float (
- arg : STD_LOGIC_VECTOR;
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width) -- length of FP output fraction
- return UNRESOLVED_float;
-
- function to_float (
- arg : STD_LOGIC_VECTOR;
- size_res : UNRESOLVED_float)
- return UNRESOLVED_float;
-
- -- For Verilog compatability
- function realtobits (arg : REAL) return STD_LOGIC_VECTOR;
- function bitstoreal (arg : STD_LOGIC_VECTOR) return REAL;
-
-end package float_pkg;
--------------------------------------------------------------------------------
--- Proposed package body for the VHDL-200x-FT float_pkg package
--- This version is optimized for Synthesis, and not for simulation.
--- Note that there are functional differences between the synthesis and
--- simulation packages bodies. The Synthesis version is preferred.
--- This package body supplies a recommended implementation of these functions
--- Version : $Revision: 2.0 $
--- Date : $Date: 2009/01/27 20:45:30 $
---
--- Created for VHDL-200X par, David Bishop (dbishop@vhdl.org)
--------------------------------------------------------------------------------
-
-package body float_pkg is
-
- -- Author David Bishop (dbishop@vhdl.org)
- -----------------------------------------------------------------------------
- -- type declarations
- -----------------------------------------------------------------------------
-
- -- This deferred constant will tell you if the package body is synthesizable
- -- or implemented as real numbers, set to "true" if synthesizable.
- constant fphdlsynth_or_real : BOOLEAN := true; -- deferred constant
-
- -- types of boundary conditions
- type boundary_type is (normal, infinity, zero, denormal);
-
- -- null range array constant
- constant NAFP : UNRESOLVED_float (0 downto 1) := (others => '0');
- constant NSLV : STD_ULOGIC_VECTOR (0 downto 1) := (others => '0');
-
- -- %%% Replicated functions
- -- These functions are replicated so that we don't need to reference the new
- -- 2006 package std.standard, std_logic_1164 and numeric_std.
- 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 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;
-
- function or_reduce (arg : UNSIGNED)
- return STD_ULOGIC is
- begin
- return or_reduce (STD_ULOGIC_VECTOR (arg));
- end function or_reduce;
-
- function or_reduce (arg : SIGNED)
- return STD_ULOGIC is
- begin
- return or_reduce (STD_ULOGIC_VECTOR (arg));
- end function or_reduce;
-
- function or_reduce (arg : STD_LOGIC_VECTOR)
- return STD_ULOGIC is
- begin
- return or_reduce (STD_ULOGIC_VECTOR (arg));
- 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 and_reduce (arg : UNSIGNED)
- return STD_ULOGIC is
- begin
- return and_reduce (STD_ULOGIC_VECTOR (arg));
- end function and_reduce;
-
- function and_reduce (arg : SIGNED)
- return STD_ULOGIC is
- begin
- return and_reduce (STD_ULOGIC_VECTOR (arg));
- 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;
-
- function find_leftmost (ARG : UNSIGNED; Y : STD_ULOGIC)
- return INTEGER is
- begin
- for INDEX in ARG'range loop
- if ARG(INDEX) = Y then
- return INDEX;
- end if;
- end loop;
- return -1;
- end function find_leftmost;
-
- -- 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
- 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 \?/=\;
-
--- -- %%% FUNCTION "?=" ( l, r : std_logic_vector ) RETURN std_ulogic IS
--- function \?=\ (l, r : STD_LOGIC_VECTOR) return STD_ULOGIC is
--- alias lv : STD_LOGIC_VECTOR(1 to l'length) is l;
--- alias rv : STD_LOGIC_VECTOR(1 to r'length) is r;
--- variable result, result1 : STD_ULOGIC; -- result
--- begin
--- -- Logically identical to an "=" operator.
--- if ((l'length < 1) or (r'length < 1)) then
--- report "STD_LOGIC_1164.""?="": null detected, returning X"
--- severity warning;
--- return 'X';
--- end if;
--- if lv'length /= rv'length then
--- report "STD_LOGIC_1164.""?="": L'LENGTH /= R'LENGTH, returning X"
--- severity warning;
--- return 'X';
--- else
--- result := '1';
--- for i in lv'low to lv'high loop
--- result1 := match_logic_table(lv(i), rv(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 \?=\;
--- -- %%% END FUNCTION "?=";
--- -------------------------------------------------------------------
--- -- %%% FUNCTION "?=" ( l, r : std_ulogic_vector ) RETURN std_ulogic IS
- function \?=\ (l, r : STD_ULOGIC_VECTOR) return STD_ULOGIC is
- alias lv : STD_ULOGIC_VECTOR(1 to l'length) is l;
- alias rv : STD_ULOGIC_VECTOR(1 to r'length) is r;
- variable result, result1 : STD_ULOGIC;
- begin
- if ((l'length < 1) or (r'length < 1)) then
- report "STD_LOGIC_1164.""?="": null detected, returning X"
- severity warning;
- return 'X';
- end if;
- if lv'length /= rv'length then
- report "STD_LOGIC_1164.""?="": L'LENGTH /= R'LENGTH, returning X"
- severity warning;
- return 'X';
- else
- result := '1';
- for i in lv'low to lv'high loop
- result1 := \?=\ (lv(i), rv(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 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;
--- %%% END replicated functions
-
- -- Special version of "minimum" to do some boundary checking
- function mine (L, R : INTEGER)
- return INTEGER is
- begin -- function minimum
- if (L = INTEGER'low or R = INTEGER'low) then
- report "float_pkg:"
- & " Unbounded number passed, was a literal used?"
- severity error;
- return 0;
- end if;
- return minimum (L, R);
- end function mine;
-
- -- Generates the base number for the exponent normalization offset.
- function gen_expon_base (
- constant exponent_width : NATURAL)
- return SIGNED is
- variable result : SIGNED (exponent_width-1 downto 0);
- begin
- result := (others => '1');
- result (exponent_width-1) := '0';
- return result;
- end function gen_expon_base;
-
- -- Integer version of the "log2" command (contributed by Peter Ashenden)
- function log2 (A : NATURAL) return NATURAL is
- variable quotient : NATURAL;
- variable result : NATURAL := 0;
- begin
- quotient := A / 2;
- while quotient > 0 loop
- quotient := quotient / 2;
- result := result + 1;
- end loop;
- return result;
- end function log2;
-
- -- Function similar to the ILOGB function in MATH_REAL
- function log2 (A : REAL) return INTEGER is
- variable Y : REAL;
- variable N : INTEGER := 0;
- begin
- if (A = 1.0 or A = 0.0) then
- return 0;
- end if;
- Y := A;
- if(A > 1.0) then
- while Y >= 2.0 loop
- Y := Y / 2.0;
- N := N + 1;
- end loop;
- return N;
- end if;
- -- O < Y < 1
- while Y < 1.0 loop
- Y := Y * 2.0;
- N := N - 1;
- end loop;
- return N;
- end function log2;
-
- -- purpose: Test the boundary conditions of a Real number
- procedure test_boundary (
- arg : in REAL; -- Input, converted to real
- constant fraction_width : in NATURAL; -- length of FP output fraction
- constant exponent_width : in NATURAL; -- length of FP exponent
- constant denormalize : in BOOLEAN := true; -- Use IEEE extended FP
- variable btype : out boundary_type;
- variable log2i : out INTEGER
- ) is
- constant expon_base : SIGNED (exponent_width-1 downto 0) :=
- gen_expon_base(exponent_width); -- exponent offset
- constant exp_min : SIGNED (12 downto 0) :=
- -(resize(expon_base, 13)) + 1; -- Minimum normal exponent
- constant exp_ext_min : SIGNED (12 downto 0) :=
- exp_min - fraction_width; -- Minimum for denormal exponent
- variable log2arg : INTEGER; -- log2 of argument
- begin -- function test_boundary
- -- Check to see if the exponent is big enough
- -- Note that the argument is always an absolute value at this point.
- log2arg := log2(arg);
- if arg = 0.0 then
- btype := zero;
- elsif exponent_width > 11 then -- Exponent for Real is 11 (64 bit)
- btype := normal;
- else
- if log2arg < to_integer(exp_min) then
- if denormalize then
- if log2arg < to_integer(exp_ext_min) then
- btype := zero;
- else
- btype := denormal;
- end if;
- else
- if log2arg < to_integer(exp_min)-1 then
- btype := zero;
- else
- btype := normal; -- Can still represent this number
- end if;
- end if;
- elsif exponent_width < 11 then
- if log2arg > to_integer(expon_base)+1 then
- btype := infinity;
- else
- btype := normal;
- end if;
- else
- btype := normal;
- end if;
- end if;
- log2i := log2arg;
- end procedure test_boundary;
-
- -- purpose: Rounds depending on the state of the "round_style"
- -- Logic taken from
- -- "What Every Computer Scientist Should Know About Floating Point Arithmetic"
- -- by David Goldberg (1991)
- function check_round (
- fract_in : STD_ULOGIC; -- input fraction
- sign : STD_ULOGIC; -- sign bit
- remainder : UNSIGNED; -- remainder to round from
- sticky : STD_ULOGIC := '0'; -- Sticky bit
- constant round_style : round_type) -- rounding type
- return BOOLEAN is
- variable result : BOOLEAN;
- variable or_reduced : STD_ULOGIC;
- begin -- function check_round
- result := false;
- if (remainder'length > 0) then -- if remainder in a null array
- or_reduced := or_reduce (remainder & sticky);
- rounding_case : case round_style is
- when round_nearest => -- Round Nearest, default mode
- if remainder(remainder'high) = '1' then -- round
- if (remainder'length > 1) then
- if ((or_reduce (remainder(remainder'high-1
- downto remainder'low)) = '1'
- or sticky = '1')
- or fract_in = '1') then
- -- Make the bottom bit zero if possible if we are at 1/2
- result := true;
- end if;
- else
- result := (fract_in = '1' or sticky = '1');
- end if;
- end if;
- when round_inf => -- round up if positive, else truncate.
- if or_reduced = '1' and sign = '0' then
- result := true;
- end if;
- when round_neginf => -- round down if negative, else truncate.
- if or_reduced = '1' and sign = '1' then
- result := true;
- end if;
- when round_zero => -- round toward 0 Truncate
- null;
- end case rounding_case;
- end if;
- return result;
- end function check_round;
-
- -- purpose: Rounds depending on the state of the "round_style"
- -- unsigned version
- procedure fp_round (
- fract_in : in UNSIGNED; -- input fraction
- expon_in : in SIGNED; -- input exponent
- fract_out : out UNSIGNED; -- output fraction
- expon_out : out SIGNED) is -- output exponent
- begin -- procedure fp_round
- if and_reduce (fract_in) = '1' then -- Fraction is all "1"
- expon_out := expon_in + 1;
- fract_out := to_unsigned(0, fract_out'high+1);
- else
- expon_out := expon_in;
- fract_out := fract_in + 1;
- end if;
- end procedure fp_round;
-
- -- This version of break_number doesn't call "classfp"
- procedure break_number ( -- internal version
- arg : in UNRESOLVED_float;
- fptyp : in valid_fpstate;
- denormalize : in BOOLEAN := true;
- fract : out UNSIGNED;
- expon : out SIGNED) is
- constant fraction_width : NATURAL := -arg'low; -- length of FP output fraction
- constant exponent_width : NATURAL := arg'high; -- length of FP output exponent
- constant expon_base : SIGNED (exponent_width-1 downto 0) :=
- gen_expon_base(exponent_width); -- exponent offset
- variable exp : SIGNED (expon'range);
- begin
- fract (fraction_width-1 downto 0) :=
- UNSIGNED (to_slv(arg(-1 downto -fraction_width)));
- breakcase : case fptyp is
- when pos_zero | neg_zero =>
- fract (fraction_width) := '0';
- exp := -expon_base;
- when pos_denormal | neg_denormal =>
- if denormalize then
- exp := -expon_base;
- fract (fraction_width) := '0';
- else
- exp := -expon_base - 1;
- fract (fraction_width) := '1';
- end if;
- when pos_normal | neg_normal | pos_inf | neg_inf =>
- fract (fraction_width) := '1';
- exp := SIGNED(arg(exponent_width-1 downto 0));
- exp (exponent_width-1) := not exp(exponent_width-1);
- when others =>
- assert NO_WARNING
- report "float_pkg:"
- & "BREAK_NUMBER: " &
- "Meta state detected in fp_break_number process"
- severity warning;
- -- complete the case, if a NAN goes in, a NAN comes out.
- exp := (others => '1');
- fract (fraction_width) := '1';
- end case breakcase;
- expon := exp;
- end procedure break_number;
-
- -- purpose: floating point to UNSIGNED
- -- Used by to_integer, to_unsigned, and to_signed functions
- procedure float_to_unsigned (
- arg : in UNRESOLVED_float; -- floating point input
- variable sign : out STD_ULOGIC; -- sign of output
- variable frac : out UNSIGNED; -- unsigned biased output
- constant denormalize : in BOOLEAN; -- turn on denormalization
- constant bias : in NATURAL; -- bias for fixed point
- constant round_style : in round_type) is -- rounding method
- constant fraction_width : INTEGER := -mine(arg'low, arg'low); -- length of FP output fraction
- constant exponent_width : INTEGER := arg'high; -- length of FP output exponent
- variable fract : UNSIGNED (frac'range); -- internal version of frac
- variable isign : STD_ULOGIC; -- internal version of sign
- variable exp : INTEGER; -- Exponent
- variable expon : SIGNED (exponent_width-1 downto 0); -- Vectorized exp
- -- Base to divide fraction by
- variable frac_shift : UNSIGNED (frac'high+3 downto 0); -- Fraction shifted
- variable shift : INTEGER;
- variable remainder : UNSIGNED (2 downto 0);
- variable round : STD_ULOGIC; -- round BIT
- begin
- isign := to_x01(arg(arg'high));
- -- exponent /= '0', normal floating point
- expon := to_01(SIGNED(arg (exponent_width-1 downto 0)), 'X');
- expon(exponent_width-1) := not expon(exponent_width-1);
- exp := to_integer (expon);
- -- Figure out the fraction
- fract := (others => '0'); -- fill with zero
- fract (fract'high) := '1'; -- Add the "1.0".
- shift := (fract'high-1) - exp;
- if fraction_width > fract'high then -- Can only use size-2 bits
- fract (fract'high-1 downto 0) := UNSIGNED (to_slv (arg(-1 downto
- -fract'high)));
- else -- can use all bits
- fract (fract'high-1 downto fract'high-fraction_width) :=
- UNSIGNED (to_slv (arg(-1 downto -fraction_width)));
- end if;
- frac_shift := fract & "000";
- if shift < 0 then -- Overflow
- fract := (others => '1');
- else
- frac_shift := shift_right (frac_shift, shift);
- fract := frac_shift (frac_shift'high downto 3);
- remainder := frac_shift (2 downto 0);
- -- round (round_zero will bypass this and truncate)
- case round_style is
- when round_nearest =>
- round := remainder(2) and
- (fract (0) or (or_reduce (remainder (1 downto 0))));
- when round_inf =>
- round := remainder(2) and not isign;
- when round_neginf =>
- round := remainder(2) and isign;
- when others =>
- round := '0';
- end case;
- if round = '1' then
- fract := fract + 1;
- end if;
- end if;
- frac := fract;
- sign := isign;
- end procedure float_to_unsigned;
-
- -- purpose: returns a part of a vector, this function is here because
- -- or (fractr (to_integer(shiftx) downto 0));
- -- can't be synthesized in some synthesis tools.
- function smallfract (
- arg : UNSIGNED;
- shift : NATURAL)
- return STD_ULOGIC is
- variable orx : STD_ULOGIC;
- begin
- orx := arg(shift);
- for i in arg'range loop
- if i < shift then
- orx := arg(i) or orx;
- end if;
- end loop;
- return orx;
- end function smallfract;
- ---------------------------------------------------------------------------
- -- Visible functions
- ---------------------------------------------------------------------------
-
- -- purpose: converts the negative index to a positive one
- -- negative indices are illegal in 1164 and 1076.3
- function to_sulv (
- arg : UNRESOLVED_float) -- fp vector
- return STD_ULOGIC_VECTOR is
- variable result : STD_ULOGIC_VECTOR (arg'length-1 downto 0);
- begin -- function to_std_ulogic_vector
- if arg'length < 1 then
- return NSLV;
- end if;
- result := STD_ULOGIC_VECTOR (arg);
- return result;
- end function to_sulv;
-
- -- Converts an fp into an SLV
- function to_slv (arg : UNRESOLVED_float) return STD_LOGIC_VECTOR is
- begin
- return std_logic_vector (to_sulv (arg));
- end function to_slv;
-
- -- purpose: normalizes a floating point number
- -- This version assumes an "unsigned" input with
- function normalize (
- fract : UNSIGNED; -- fraction, unnormalized
- expon : SIGNED; -- exponent, normalized by -1
- sign : STD_ULOGIC; -- sign BIT
- sticky : STD_ULOGIC := '0'; -- Sticky bit (rounding)
- constant exponent_width : NATURAL := float_exponent_width; -- size of output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- size of output fraction
- constant round_style : round_type := float_round_style; -- rounding option
- constant denormalize : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant nguard : NATURAL := float_guard_bits) -- guard bits
- return UNRESOLVED_float is
- variable sfract : UNSIGNED (fract'high downto 0); -- shifted fraction
- variable rfract : UNSIGNED (fraction_width-1 downto 0); -- fraction
- variable exp : SIGNED (exponent_width+1 downto 0); -- exponent
- variable rexp : SIGNED (exponent_width+1 downto 0); -- result exponent
- variable rexpon : UNSIGNED (exponent_width-1 downto 0); -- exponent
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width); -- result
- variable shiftr : INTEGER; -- shift amount
- variable stickyx : STD_ULOGIC; -- version of sticky
- constant expon_base : SIGNED (exponent_width-1 downto 0) :=
- gen_expon_base(exponent_width); -- exponent offset
- variable round, zerores, infres : BOOLEAN;
- begin -- function normalize
- zerores := false;
- infres := false;
- round := false;
- shiftr := find_leftmost (to_01(fract), '1') -- Find the first "1"
- - fraction_width - nguard; -- subtract the length we want
- exp := resize (expon, exp'length) + shiftr;
- if (or_reduce (fract) = '0') then -- Zero
- zerores := true;
- elsif ((exp <= -resize(expon_base, exp'length)-1) and denormalize)
- or ((exp < -resize(expon_base, exp'length)-1) and not denormalize) then
- if (exp >= -resize(expon_base, exp'length)-fraction_width-1)
- and denormalize then
- exp := -resize(expon_base, exp'length)-1;
- shiftr := -to_integer (expon + expon_base); -- new shift
- else -- return zero
- zerores := true;
- end if;
- elsif (exp > expon_base-1) then -- infinity
- infres := true;
- end if;
- if zerores then
- result := zerofp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- elsif infres then
- result := pos_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- else
- sfract := fract srl shiftr; -- shift
- if shiftr > 0 then
--- stickyx := sticky or (or_reduce(fract (shiftr-1 downto 0)));
- stickyx := sticky or smallfract (fract, shiftr-1);
- else
- stickyx := sticky;
- end if;
- if nguard > 0 then
- round := check_round (
- fract_in => sfract (nguard),
- sign => sign,
- remainder => sfract(nguard-1 downto 0),
- sticky => stickyx,
- round_style => round_style);
- end if;
- if round then
- fp_round(fract_in => sfract (fraction_width-1+nguard downto nguard),
- expon_in => exp(rexp'range),
- fract_out => rfract,
- expon_out => rexp);
- else
- rfract := sfract (fraction_width-1+nguard downto nguard);
- rexp := exp(rexp'range);
- end if;
- -- result
- rexpon := UNSIGNED (rexp(exponent_width-1 downto 0));
- rexpon (exponent_width-1) := not rexpon(exponent_width-1);
- result (rexpon'range) := UNRESOLVED_float(rexpon);
- result (-1 downto -fraction_width) := UNRESOLVED_float(rfract);
- end if;
- result (exponent_width) := sign; -- sign BIT
- return result;
- end function normalize;
-
- -- purpose: normalizes a floating point number
- -- This version assumes a "ufixed" input
- function normalize (
- fract : ufixed; -- unsigned fixed point
- expon : SIGNED; -- exponent, normalized by -1
- sign : STD_ULOGIC; -- sign bit
- sticky : STD_ULOGIC := '0'; -- Sticky bit (rounding)
- constant exponent_width : NATURAL := float_exponent_width; -- size of output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- size of output fraction
- constant round_style : round_type := float_round_style; -- rounding option
- constant denormalize : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant nguard : NATURAL := float_guard_bits) -- guard bits
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable arguns : UNSIGNED (fract'high + fraction_width + nguard
- downto 0) := (others => '0');
- begin -- function normalize
- arguns (arguns'high downto maximum (arguns'high-fract'length+1, 0)) :=
- UNSIGNED (to_slv (fract));
- result := normalize (fract => arguns,
- expon => expon,
- sign => sign,
- sticky => sticky,
- fraction_width => fraction_width,
- exponent_width => exponent_width,
- round_style => round_style,
- denormalize => denormalize,
- nguard => nguard);
- return result;
- end function normalize;
-
- -- purpose: normalizes a floating point number
- -- This version assumes a "ufixed" input with a "size_res" input
- function normalize (
- fract : ufixed; -- unsigned fixed point
- expon : SIGNED; -- exponent, normalized by -1
- sign : STD_ULOGIC; -- sign bit
- sticky : STD_ULOGIC := '0'; -- Sticky bit (rounding)
- size_res : UNRESOLVED_float; -- used for sizing only
- constant round_style : round_type := float_round_style; -- rounding option
- constant denormalize : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant nguard : NATURAL := float_guard_bits) -- guard bits
- return UNRESOLVED_float is
- constant fraction_width : NATURAL := -size_res'low;
- constant exponent_width : NATURAL := size_res'high;
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable arguns : UNSIGNED (fract'high + fraction_width + nguard
- downto 0) := (others => '0');
- begin -- function normalize
- arguns (arguns'high downto maximum (arguns'high-fract'length+1, 0)) :=
- UNSIGNED (to_slv (fract));
- result := normalize (fract => arguns,
- expon => expon,
- sign => sign,
- sticky => sticky,
- fraction_width => fraction_width,
- exponent_width => exponent_width,
- round_style => round_style,
- denormalize => denormalize,
- nguard => nguard);
- return result;
- end function normalize;
-
- -- Regular "normalize" function with a "size_res" input.
- function normalize (
- fract : UNSIGNED; -- unsigned
- expon : SIGNED; -- exponent - 1, normalized
- sign : STD_ULOGIC; -- sign bit
- sticky : STD_ULOGIC := '0'; -- Sticky bit (rounding)
- size_res : UNRESOLVED_float; -- used for sizing only
- constant round_style : round_type := float_round_style; -- rounding option
- constant denormalize : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant nguard : NATURAL := float_guard_bits) -- guard bits
- return UNRESOLVED_float is
- begin
- return normalize (fract => fract,
- expon => expon,
- sign => sign,
- sticky => sticky,
- fraction_width => -size_res'low,
- exponent_width => size_res'high,
- round_style => round_style,
- denormalize => denormalize,
- nguard => nguard);
- end function normalize;
-
- -- Returns the class which X falls into
- function Classfp (
- x : UNRESOLVED_float; -- floating point input
- check_error : BOOLEAN := float_check_error) -- check for errors
- return valid_fpstate is
- constant fraction_width : INTEGER := -mine(x'low, x'low); -- length of FP output fraction
- constant exponent_width : INTEGER := x'high; -- length of FP output exponent
- variable arg : UNRESOLVED_float (exponent_width downto -fraction_width);
- begin -- classfp
- if (arg'length < 1 or fraction_width < 3 or exponent_width < 3
- or x'left < x'right) then
- report "float_pkg:"
- & "CLASSFP: " &
- "Floating point number detected with a bad range"
- severity error;
- return isx;
- end if;
- -- Check for "X".
- arg := to_01 (x, 'X');
- if (arg(0) = 'X') then
- return isx; -- If there is an X in the number
- -- Special cases, check for illegal number
- elsif check_error and
- (and_reduce (STD_ULOGIC_VECTOR (arg (exponent_width-1 downto 0)))
- = '1') then -- Exponent is all "1".
- if or_reduce (to_slv (arg (-1 downto -fraction_width)))
- /= '0' then -- Fraction must be all "0" or this is not a number.
- if (arg(-1) = '1') then -- From "W. Khan - IEEE standard
- return nan; -- 754 binary FP Signaling nan (Not a number)
- else
- return quiet_nan;
- end if;
- -- Check for infinity
- elsif arg(exponent_width) = '0' then
- return pos_inf; -- Positive infinity
- else
- return neg_inf; -- Negative infinity
- end if;
- -- check for "0"
- elsif or_reduce (STD_LOGIC_VECTOR (arg (exponent_width-1 downto 0)))
- = '0' then -- Exponent is all "0"
- if or_reduce (to_slv (arg (-1 downto -fraction_width)))
- = '0' then -- Fraction is all "0"
- if arg(exponent_width) = '0' then
- return pos_zero; -- Zero
- else
- return neg_zero;
- end if;
- else
- if arg(exponent_width) = '0' then
- return pos_denormal; -- Denormal number (ieee extended fp)
- else
- return neg_denormal;
- end if;
- end if;
- else
- if arg(exponent_width) = '0' then
- return pos_normal; -- Normal FP number
- else
- return neg_normal;
- end if;
- end if;
- end function Classfp;
-
- procedure break_number (
- arg : in UNRESOLVED_float;
- denormalize : in BOOLEAN := float_denormalize;
- check_error : in BOOLEAN := float_check_error;
- fract : out UNSIGNED;
- expon : out SIGNED;
- sign : out STD_ULOGIC) is
- constant fraction_width : NATURAL := -mine(arg'low, arg'low); -- length of FP output fraction
- variable fptyp : valid_fpstate;
- begin
- fptyp := Classfp (arg, check_error);
- sign := to_x01(arg(arg'high));
- break_number (
- arg => arg,
- fptyp => fptyp,
- denormalize => denormalize,
- fract => fract,
- expon => expon);
- end procedure break_number;
-
- procedure break_number (
- arg : in UNRESOLVED_float;
- denormalize : in BOOLEAN := float_denormalize;
- check_error : in BOOLEAN := float_check_error;
- fract : out ufixed; -- 1 downto -fraction_width
- expon : out SIGNED; -- exponent_width-1 downto 0
- sign : out STD_ULOGIC) is
- constant fraction_width : NATURAL := -mine(arg'low, arg'low); -- length of FP output fraction
- variable fptyp : valid_fpstate;
- variable ufract : UNSIGNED (fraction_width downto 0); -- unsigned fraction
- begin
- fptyp := Classfp (arg, check_error);
- sign := to_x01(arg(arg'high));
- break_number (
- arg => arg,
- fptyp => fptyp,
- denormalize => denormalize,
- fract => ufract,
- expon => expon);
- fract (0 downto -fraction_width) := ufixed (ufract);
- end procedure break_number;
-
- -- Arithmetic functions
- function "abs" (
- arg : UNRESOLVED_float) -- floating point input
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (arg'range); -- result
- begin
- if (arg'length > 0) then
- result := to_01 (arg, 'X');
- result (arg'high) := '0'; -- set the sign bit to positive
- return result;
- else
- return NAFP;
- end if;
- end function "abs";
-
- -- IEEE 754 "negative" function
- function "-" (
- arg : UNRESOLVED_float) -- floating point input
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (arg'range); -- result
- begin
- if (arg'length > 0) then
- result := to_01 (arg, 'X');
- result (arg'high) := not result (arg'high); -- invert sign bit
- return result;
- else
- return NAFP;
- end if;
- end function "-";
-
- -- Addition, adds two floating point numbers
- function add (
- l, r : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant guard : NATURAL := float_guard_bits; -- number of guard bits
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float is
- constant fraction_width : NATURAL := -mine(l'low, r'low); -- length of FP output fraction
- constant exponent_width : NATURAL := maximum(l'high, r'high); -- length of FP output exponent
- constant addguard : NATURAL := guard; -- add one guard bit
- variable lfptype, rfptype : valid_fpstate;
- variable fpresult : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable fractl, fractr : UNSIGNED (fraction_width+1+addguard downto 0); -- fractions
- variable fractc, fracts : UNSIGNED (fractl'range); -- constant and shifted variables
- variable urfract, ulfract : UNSIGNED (fraction_width downto 0);
- variable ufract : UNSIGNED (fraction_width+1+addguard downto 0);
- variable exponl, exponr : SIGNED (exponent_width-1 downto 0); -- exponents
- variable rexpon : SIGNED (exponent_width downto 0); -- result exponent
- variable shiftx : SIGNED (exponent_width downto 0); -- shift fractions
- variable sign : STD_ULOGIC; -- sign of the output
- variable leftright : BOOLEAN; -- left or right used
- variable lresize, rresize : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable sticky : STD_ULOGIC; -- Holds precision for rounding
- begin -- addition
- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
- lfptype := isx;
- else
- lfptype := classfp (l, check_error);
- rfptype := classfp (r, check_error);
- end if;
- if (lfptype = isx or rfptype = isx) then
- fpresult := (others => 'X');
- elsif (lfptype = nan or lfptype = quiet_nan or
- rfptype = nan or rfptype = quiet_nan)
- -- Return quiet NAN, IEEE754-1985-7.1,1
- or (lfptype = pos_inf and rfptype = neg_inf)
- or (lfptype = neg_inf and rfptype = pos_inf) then
- -- Return quiet NAN, IEEE754-1985-7.1,2
- fpresult := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- elsif (lfptype = pos_inf or rfptype = pos_inf) then -- x + inf = inf
- fpresult := pos_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- elsif (lfptype = neg_inf or rfptype = neg_inf) then -- x - inf = -inf
- fpresult := neg_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- elsif (lfptype = neg_zero and rfptype = neg_zero) then -- -0 + -0 = -0
- fpresult := neg_zerofp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- else
- lresize := resize (arg => to_x01(l),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- lfptype := classfp (lresize, false); -- errors already checked
- rresize := resize (arg => to_x01(r),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- rfptype := classfp (rresize, false); -- errors already checked
- break_number (
- arg => lresize,
- fptyp => lfptype,
- denormalize => denormalize,
- fract => ulfract,
- expon => exponl);
- fractl := (others => '0');
- fractl (fraction_width+addguard downto addguard) := ulfract;
- break_number (
- arg => rresize,
- fptyp => rfptype,
- denormalize => denormalize,
- fract => urfract,
- expon => exponr);
- fractr := (others => '0');
- fractr (fraction_width+addguard downto addguard) := urfract;
- shiftx := (exponl(exponent_width-1) & exponl) - exponr;
- if shiftx < -fractl'high then
- rexpon := exponr(exponent_width-1) & exponr;
- fractc := fractr;
- fracts := (others => '0'); -- add zero
- leftright := false;
- sticky := or_reduce (fractl);
- elsif shiftx < 0 then
- shiftx := - shiftx;
- fracts := shift_right (fractl, to_integer(shiftx));
- fractc := fractr;
- rexpon := exponr(exponent_width-1) & exponr;
- leftright := false;
--- sticky := or_reduce (fractl (to_integer(shiftx) downto 0));
- sticky := smallfract (fractl, to_integer(shiftx));
- elsif shiftx = 0 then
- rexpon := exponl(exponent_width-1) & exponl;
- sticky := '0';
- if fractr > fractl then
- fractc := fractr;
- fracts := fractl;
- leftright := false;
- else
- fractc := fractl;
- fracts := fractr;
- leftright := true;
- end if;
- elsif shiftx > fractr'high then
- rexpon := exponl(exponent_width-1) & exponl;
- fracts := (others => '0'); -- add zero
- fractc := fractl;
- leftright := true;
- sticky := or_reduce (fractr);
- elsif shiftx > 0 then
- fracts := shift_right (fractr, to_integer(shiftx));
- fractc := fractl;
- rexpon := exponl(exponent_width-1) & exponl;
- leftright := true;
--- sticky := or_reduce (fractr (to_integer(shiftx) downto 0));
- sticky := smallfract (fractr, to_integer(shiftx));
- end if;
- -- add
- fracts (0) := fracts (0) or sticky; -- Or the sticky bit into the LSB
- if l(l'high) = r(r'high) then
- ufract := fractc + fracts;
- sign := l(l'high);
- else -- signs are different
- ufract := fractc - fracts; -- always positive result
- if leftright then -- Figure out which sign to use
- sign := l(l'high);
- else
- sign := r(r'high);
- end if;
- end if;
- if or_reduce (ufract) = '0' then
- sign := '0'; -- IEEE 854, 6.3, paragraph 2.
- end if;
- -- normalize
- fpresult := normalize (fract => ufract,
- expon => rexpon,
- sign => sign,
- sticky => sticky,
- fraction_width => fraction_width,
- exponent_width => exponent_width,
- round_style => round_style,
- denormalize => denormalize,
- nguard => addguard);
- end if;
- return fpresult;
- end function add;
-
- -- Subtraction, Calls "add".
- function subtract (
- l, r : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant guard : NATURAL := float_guard_bits; -- number of guard bits
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float is
- variable negr : UNRESOLVED_float (r'range); -- negative version of r
- begin
- negr := -r;
- return add (l => l,
- r => negr,
- round_style => round_style,
- guard => guard,
- check_error => check_error,
- denormalize => denormalize);
- end function subtract;
-
- -- Floating point multiply
- function multiply (
- l, r : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant guard : NATURAL := float_guard_bits; -- number of guard bits
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float is
- constant fraction_width : NATURAL := -mine(l'low, r'low); -- length of FP output fraction
- constant exponent_width : NATURAL := maximum(l'high, r'high); -- length of FP output exponent
- constant multguard : NATURAL := guard; -- guard bits
- variable lfptype, rfptype : valid_fpstate;
- variable fpresult : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable fractl, fractr : UNSIGNED (fraction_width downto 0); -- fractions
- variable rfract : UNSIGNED ((2*(fraction_width))+1 downto 0); -- result fraction
- variable sfract : UNSIGNED (fraction_width+1+multguard downto 0); -- result fraction
- variable shifty : INTEGER; -- denormal shift
- variable exponl, exponr : SIGNED (exponent_width-1 downto 0); -- exponents
- variable rexpon : SIGNED (exponent_width+1 downto 0); -- result exponent
- variable fp_sign : STD_ULOGIC; -- sign of result
- variable lresize, rresize : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable sticky : STD_ULOGIC; -- Holds precision for rounding
- begin -- multiply
- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
- lfptype := isx;
- else
- lfptype := classfp (l, check_error);
- rfptype := classfp (r, check_error);
- end if;
- if (lfptype = isx or rfptype = isx) then
- fpresult := (others => 'X');
- elsif ((lfptype = nan or lfptype = quiet_nan or
- rfptype = nan or rfptype = quiet_nan)) then
- -- Return quiet NAN, IEEE754-1985-7.1,1
- fpresult := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- elsif (((lfptype = pos_inf or lfptype = neg_inf) and
- (rfptype = pos_zero or rfptype = neg_zero)) or
- ((rfptype = pos_inf or rfptype = neg_inf) and
- (lfptype = pos_zero or lfptype = neg_zero))) then -- 0 * inf
- -- Return quiet NAN, IEEE754-1985-7.1,3
- fpresult := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- elsif (lfptype = pos_inf or rfptype = pos_inf
- or lfptype = neg_inf or rfptype = neg_inf) then -- x * inf = inf
- fpresult := pos_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- -- figure out the sign
- fp_sign := l(l'high) xor r(r'high); -- figure out the sign
- fpresult (exponent_width) := fp_sign;
- else
- fp_sign := l(l'high) xor r(r'high); -- figure out the sign
- lresize := resize (arg => to_x01(l),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- lfptype := classfp (lresize, false); -- errors already checked
- rresize := resize (arg => to_x01(r),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- rfptype := classfp (rresize, false); -- errors already checked
- break_number (
- arg => lresize,
- fptyp => lfptype,
- denormalize => denormalize,
- fract => fractl,
- expon => exponl);
- break_number (
- arg => rresize,
- fptyp => rfptype,
- denormalize => denormalize,
- fract => fractr,
- expon => exponr);
- if (rfptype = pos_denormal or rfptype = neg_denormal) then
- shifty := fraction_width - find_leftmost(fractr, '1');
- fractr := shift_left (fractr, shifty);
- elsif (lfptype = pos_denormal or lfptype = neg_denormal) then
- shifty := fraction_width - find_leftmost(fractl, '1');
- fractl := shift_left (fractl, shifty);
- else
- shifty := 0;
- -- Note that a denormal number * a denormal number is always zero.
- end if;
- -- multiply
- -- add the exponents
- rexpon := resize (exponl, rexpon'length) + exponr - shifty + 1;
- rfract := fractl * fractr; -- Multiply the fraction
- sfract := rfract (rfract'high downto
- rfract'high - (fraction_width+1+multguard));
- sticky := or_reduce (rfract (rfract'high-(fraction_width+1+multguard)
- downto 0));
- -- normalize
- fpresult := normalize (fract => sfract,
- expon => rexpon,
- sign => fp_sign,
- sticky => sticky,
- fraction_width => fraction_width,
- exponent_width => exponent_width,
- round_style => round_style,
- denormalize => denormalize,
- nguard => multguard);
- end if;
- return fpresult;
- end function multiply;
-
- function short_divide (
- lx, rx : UNSIGNED)
- return UNSIGNED is
- -- This is a special divider for the floating point routines.
- -- For a true unsigned divider, "stages" needs to = lx'high
- constant stages : INTEGER := lx'high - rx'high; -- number of stages
- variable partial : UNSIGNED (lx'range);
- variable q : UNSIGNED (stages downto 0);
- variable partial_argl : SIGNED (rx'high + 2 downto 0);
- variable partial_arg : SIGNED (rx'high + 2 downto 0);
- begin
- partial := lx;
- for i in stages downto 0 loop
- partial_argl := resize ("0" & SIGNED (partial(lx'high downto i)),
- partial_argl'length);
- partial_arg := partial_argl - SIGNED ("0" & rx);
- if (partial_arg (partial_arg'high) = '1') then -- negative
- q(i) := '0';
- else
- q(i) := '1';
- partial (lx'high+i-stages downto lx'high+i-stages-rx'high) :=
- UNSIGNED (partial_arg(rx'range));
- end if;
- end loop;
- -- to make the output look like that of the unsigned IEEE divide.
- return resize (q, lx'length);
- end function short_divide;
-
- -- 1/X function. Needed for algorithm development.
- function reciprocal (
- arg : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding option
- constant guard : NATURAL := float_guard_bits; -- number of guard bits
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float is
- constant fraction_width : NATURAL := -mine(arg'low, arg'low); -- length of FP output fraction
- constant exponent_width : NATURAL := arg'high; -- length of FP output exponent
- constant divguard : NATURAL := guard; -- guard bits
- function onedivy (
- arg : UNSIGNED)
- return UNSIGNED is
- variable q : UNSIGNED((2*arg'high)+1 downto 0);
- variable one : UNSIGNED (q'range);
- begin
- one := (others => '0');
- one(one'high) := '1';
- q := short_divide (one, arg); -- Unsigned divide
- return resize (q, arg'length+1);
- end function onedivy;
- variable fptype : valid_fpstate;
- variable expon : SIGNED (exponent_width-1 downto 0); -- exponents
- variable denorm_offset : NATURAL range 0 to 2;
- variable fract : UNSIGNED (fraction_width downto 0);
- variable fractg : UNSIGNED (fraction_width+divguard downto 0);
- variable sfract : UNSIGNED (fraction_width+1+divguard downto 0); -- result fraction
- variable fpresult : UNRESOLVED_float (exponent_width downto -fraction_width);
- begin -- reciprocal
- fptype := classfp(arg, check_error);
- classcase : case fptype is
- when isx =>
- fpresult := (others => 'X');
- when nan | quiet_nan =>
- -- Return quiet NAN, IEEE754-1985-7.1,1
- fpresult := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- when pos_inf | neg_inf => -- 1/inf, return 0
- fpresult := zerofp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- when neg_zero | pos_zero => -- 1/0
- report "float_pkg:"
- & "RECIPROCAL: Floating Point divide by zero"
- severity error;
- fpresult := pos_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- when others =>
- if (fptype = pos_denormal or fptype = neg_denormal)
- and ((arg (-1) or arg(-2)) /= '1') then
- -- 1/denormal = infinity, with the exception of 2**-expon_base
- fpresult := pos_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- fpresult (exponent_width) := to_x01 (arg (exponent_width));
- else
- break_number (
- arg => arg,
- fptyp => fptype,
- denormalize => denormalize,
- fract => fract,
- expon => expon);
- fractg := (others => '0');
- if (fptype = pos_denormal or fptype = neg_denormal) then
- -- The reciprocal of a denormal number is typically zero,
- -- except for two special cases which are trapped here.
- if (to_x01(arg (-1)) = '1') then
- fractg (fractg'high downto divguard+1) :=
- fract (fract'high-1 downto 0); -- Shift to not denormal
- denorm_offset := 1; -- add 1 to exponent compensate
- else -- arg(-2) = '1'
- fractg (fractg'high downto divguard+2) :=
- fract (fract'high-2 downto 0); -- Shift to not denormal
- denorm_offset := 2; -- add 2 to exponent compensate
- end if;
- else
- fractg (fractg'high downto divguard) := fract;
- denorm_offset := 0;
- end if;
- expon := - expon - 3 + denorm_offset;
- sfract := onedivy (fractg);
- -- normalize
- fpresult := normalize (fract => sfract,
- expon => expon,
- sign => arg(exponent_width),
- sticky => '1',
- fraction_width => fraction_width,
- exponent_width => exponent_width,
- round_style => round_style,
- denormalize => denormalize,
- nguard => divguard);
- end if;
- end case classcase;
- return fpresult;
- end function reciprocal;
-
- -- floating point division
- function divide (
- l, r : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant guard : NATURAL := float_guard_bits; -- number of guard bits
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float is
- constant fraction_width : NATURAL := -mine(l'low, r'low); -- length of FP output fraction
- constant exponent_width : NATURAL := maximum(l'high, r'high); -- length of FP output exponent
- constant divguard : NATURAL := guard; -- division guard bits
- variable lfptype, rfptype : valid_fpstate;
- variable fpresult : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable ulfract, urfract : UNSIGNED (fraction_width downto 0);
- variable fractl : UNSIGNED ((2*(fraction_width+divguard)+1) downto 0); -- left
- variable fractr : UNSIGNED (fraction_width+divguard downto 0); -- right
- variable rfract : UNSIGNED (fractl'range); -- result fraction
- variable sfract : UNSIGNED (fraction_width+1+divguard downto 0); -- result fraction
- variable exponl, exponr : SIGNED (exponent_width-1 downto 0); -- exponents
- variable rexpon : SIGNED (exponent_width+1 downto 0); -- result exponent
- variable fp_sign, sticky : STD_ULOGIC; -- sign of result
- variable shifty, shiftx : INTEGER; -- denormal number shift
- variable lresize, rresize : UNRESOLVED_float (exponent_width downto -fraction_width);
- begin -- divide
- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
- lfptype := isx;
- else
- lfptype := classfp (l, check_error);
- rfptype := classfp (r, check_error);
- end if;
- classcase : case rfptype is
- when isx =>
- fpresult := (others => 'X');
- when nan | quiet_nan =>
- -- Return quiet NAN, IEEE754-1985-7.1,1
- fpresult := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- when pos_inf | neg_inf =>
- if lfptype = pos_inf or lfptype = neg_inf -- inf / inf
- or lfptype = quiet_nan or lfptype = nan then
- -- Return quiet NAN, IEEE754-1985-7.1,4
- fpresult := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- else -- x / inf = 0
- fpresult := zerofp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- fp_sign := l(l'high) xor r(r'high); -- sign
- fpresult (fpresult'high) := fp_sign; -- sign
- end if;
- when pos_zero | neg_zero =>
- if lfptype = pos_zero or lfptype = neg_zero -- 0 / 0
- or lfptype = quiet_nan or lfptype = nan then
- -- Return quiet NAN, IEEE754-1985-7.1,4
- fpresult := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- else
- report "float_pkg:"
- & "DIVIDE: Floating Point divide by zero"
- severity error;
- -- Infinity, define in 754-1985-7.2
- fpresult := pos_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- fp_sign := l(l'high) xor r(r'high); -- sign
- fpresult (fpresult'high) := fp_sign; -- sign
- end if;
- when others =>
- classcase2 : case lfptype is
- when isx =>
- fpresult := (others => 'X');
- when nan | quiet_nan =>
- -- Return quiet NAN, IEEE754-1985-7.1,1
- fpresult := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- when pos_inf | neg_inf => -- inf / x = inf
- fpresult := pos_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- fp_sign := l(l'high) xor r(r'high); -- sign
- fpresult(exponent_width) := fp_sign;
- when pos_zero | neg_zero => -- 0 / X = 0
- fpresult := zerofp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- fp_sign := l(l'high) xor r(r'high); -- sign
- fpresult(exponent_width) := fp_sign;
- when others =>
- fp_sign := l(l'high) xor r(r'high); -- sign
- lresize := resize (arg => to_x01(l),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- lfptype := classfp (lresize, false); -- errors already checked
- rresize := resize (arg => to_x01(r),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- rfptype := classfp (rresize, false); -- errors already checked
- break_number (
- arg => lresize,
- fptyp => lfptype,
- denormalize => denormalize,
- fract => ulfract,
- expon => exponl);
- -- right side
- break_number (
- arg => rresize,
- fptyp => rfptype,
- denormalize => denormalize,
- fract => urfract,
- expon => exponr);
- -- Compute the exponent
- rexpon := resize (exponl, rexpon'length) - exponr - 2;
- if (rfptype = pos_denormal or rfptype = neg_denormal) then
- -- Do the shifting here not after. That way we have a smaller
- -- shifter, and need a smaller divider, because the top
- -- bit in the divisor will always be a "1".
- shifty := fraction_width - find_leftmost(urfract, '1');
- urfract := shift_left (urfract, shifty);
- rexpon := rexpon + shifty;
- end if;
- fractr := (others => '0');
- fractr (fraction_width+divguard downto divguard) := urfract;
- if (lfptype = pos_denormal or lfptype = neg_denormal) then
- shiftx := fraction_width - find_leftmost(ulfract, '1');
- ulfract := shift_left (ulfract, shiftx);
- rexpon := rexpon - shiftx;
- end if;
- fractl := (others => '0');
- fractl (fractl'high downto fractl'high-fraction_width) := ulfract;
- -- divide
- rfract := short_divide (fractl, fractr); -- unsigned divide
- sfract := rfract (sfract'range); -- lower bits
- sticky := '1';
- -- normalize
- fpresult := normalize (fract => sfract,
- expon => rexpon,
- sign => fp_sign,
- sticky => sticky,
- fraction_width => fraction_width,
- exponent_width => exponent_width,
- round_style => round_style,
- denormalize => denormalize,
- nguard => divguard);
- end case classcase2;
- end case classcase;
- return fpresult;
- end function divide;
-
- -- division by a power of 2
- function dividebyp2 (
- l, r : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant guard : NATURAL := float_guard_bits; -- number of guard bits
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float is
- constant fraction_width : NATURAL := -mine(l'low, r'low); -- length of FP output fraction
- constant exponent_width : NATURAL := maximum(l'high, r'high); -- length of FP output exponent
- variable lfptype, rfptype : valid_fpstate;
- variable fpresult : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable ulfract, urfract : UNSIGNED (fraction_width downto 0);
- variable exponl, exponr : SIGNED(exponent_width-1 downto 0); -- exponents
- variable rexpon : SIGNED(exponent_width downto 0); -- result exponent
- variable fp_sign : STD_ULOGIC; -- sign of result
- variable lresize, rresize : UNRESOLVED_float (exponent_width downto -fraction_width);
- begin -- divisionbyp2
- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
- lfptype := isx;
- else
- lfptype := classfp (l, check_error);
- rfptype := classfp (r, check_error);
- end if;
- classcase : case rfptype is
- when isx =>
- fpresult := (others => 'X');
- when nan | quiet_nan =>
- -- Return quiet NAN, IEEE754-1985-7.1,1
- fpresult := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- when pos_inf | neg_inf =>
- if lfptype = pos_inf or lfptype = neg_inf then -- inf / inf
- -- Return quiet NAN, IEEE754-1985-7.1,4
- fpresult := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- else -- x / inf = 0
- fpresult := zerofp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- fp_sign := l(l'high) xor r(r'high); -- sign
- fpresult (fpresult'high) := fp_sign; -- sign
- end if;
- when pos_zero | neg_zero =>
- if lfptype = pos_zero or lfptype = neg_zero then -- 0 / 0
- -- Return quiet NAN, IEEE754-1985-7.1,4
- fpresult := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- else
- report "float_pkg:"
- & "DIVIDEBYP2: Floating Point divide by zero"
- severity error;
- -- Infinity, define in 754-1985-7.2
- fpresult := pos_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- fp_sign := l(l'high) xor r(r'high); -- sign
- fpresult (fpresult'high) := fp_sign; -- sign
- end if;
- when others =>
- classcase2 : case lfptype is
- when isx =>
- fpresult := (others => 'X');
- when nan | quiet_nan =>
- -- Return quiet NAN, IEEE754-1985-7.1,1
- fpresult := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- when pos_inf | neg_inf => -- inf / x = inf
- fpresult := pos_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- fp_sign := l(l'high) xor r(r'high); -- sign
- fpresult (exponent_width) := fp_sign; -- sign
- when pos_zero | neg_zero => -- 0 / X = 0
- fpresult := zerofp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- fp_sign := l(l'high) xor r(r'high); -- sign
- fpresult (exponent_width) := fp_sign; -- sign
- when others =>
- fp_sign := l(l'high) xor r(r'high); -- sign
- lresize := resize (arg => to_x01(l),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- lfptype := classfp (lresize, false); -- errors already checked
- rresize := resize (arg => to_x01(r),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- rfptype := classfp (rresize, false); -- errors already checked
- break_number (
- arg => lresize,
- fptyp => lfptype,
- denormalize => denormalize,
- fract => ulfract,
- expon => exponl);
- -- right side
- break_number (
- arg => rresize,
- fptyp => rfptype,
- denormalize => denormalize,
- fract => urfract,
- expon => exponr);
- assert (or_reduce (urfract (fraction_width-1 downto 0)) = '0')
- report "float_pkg:"
- & "DIVIDEBYP2: "
- & "Dividebyp2 called with a non power of two divisor"
- severity error;
- rexpon := (exponl(exponl'high)&exponl)
- - (exponr(exponr'high)&exponr) - 1;
- -- normalize
- fpresult := normalize (fract => ulfract,
- expon => rexpon,
- sign => fp_sign,
- sticky => '1',
- fraction_width => fraction_width,
- exponent_width => exponent_width,
- round_style => round_style,
- denormalize => denormalize,
- nguard => 0);
- end case classcase2;
- end case classcase;
- return fpresult;
- end function dividebyp2;
-
- -- Multiply accumulate result = l*r + c
- function mac (
- l, r, c : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant guard : NATURAL := float_guard_bits; -- number of guard bits
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float is
- constant fraction_width : NATURAL :=
- -mine (mine(l'low, r'low), c'low); -- length of FP output fraction
- constant exponent_width : NATURAL :=
- maximum (maximum(l'high, r'high), c'high); -- length of FP output exponent
- variable lfptype, rfptype, cfptype : valid_fpstate;
- variable fpresult : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable fractl, fractr : UNSIGNED (fraction_width downto 0); -- fractions
- variable fractx : UNSIGNED (fraction_width+guard downto 0);
- variable fractc, fracts : UNSIGNED (fraction_width+1+guard downto 0);
- variable rfract : UNSIGNED ((2*(fraction_width))+1 downto 0); -- result fraction
- variable sfract, ufract : UNSIGNED (fraction_width+1+guard downto 0); -- result fraction
- variable exponl, exponr, exponc : SIGNED (exponent_width-1 downto 0); -- exponents
- variable rexpon, rexpon2 : SIGNED (exponent_width+1 downto 0); -- result exponent
- variable shifty : INTEGER; -- denormal shift
- variable shiftx : SIGNED (rexpon'range); -- shift fractions
- variable fp_sign : STD_ULOGIC; -- sign of result
- variable lresize, rresize : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable cresize : UNRESOLVED_float (exponent_width downto -fraction_width - guard);
- variable leftright : BOOLEAN; -- left or right used
- variable sticky : STD_ULOGIC; -- Holds precision for rounding
- begin -- multiply
- if (fraction_width = 0 or l'length < 7 or r'length < 7 or c'length < 7) then
- lfptype := isx;
- else
- lfptype := classfp (l, check_error);
- rfptype := classfp (r, check_error);
- cfptype := classfp (c, check_error);
- end if;
- if (lfptype = isx or rfptype = isx or cfptype = isx) then
- fpresult := (others => 'X');
- elsif (lfptype = nan or lfptype = quiet_nan or
- rfptype = nan or rfptype = quiet_nan or
- cfptype = nan or cfptype = quiet_nan) then
- -- Return quiet NAN, IEEE754-1985-7.1,1
- fpresult := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- elsif (((lfptype = pos_inf or lfptype = neg_inf) and
- (rfptype = pos_zero or rfptype = neg_zero)) or
- ((rfptype = pos_inf or rfptype = neg_inf) and
- (lfptype = pos_zero or lfptype = neg_zero))) then -- 0 * inf
- -- Return quiet NAN, IEEE754-1985-7.1,3
- fpresult := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- elsif (lfptype = pos_inf or rfptype = pos_inf
- or lfptype = neg_inf or rfptype = neg_inf -- x * inf = inf
- or cfptype = neg_inf or cfptype = pos_inf) then -- x + inf = inf
- fpresult := pos_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- -- figure out the sign
- fpresult (exponent_width) := l(l'high) xor r(r'high);
- else
- fp_sign := l(l'high) xor r(r'high); -- figure out the sign
- lresize := resize (arg => to_x01(l),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- lfptype := classfp (lresize, false); -- errors already checked
- rresize := resize (arg => to_x01(r),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- rfptype := classfp (rresize, false); -- errors already checked
- cresize := resize (arg => to_x01(c),
- exponent_width => exponent_width,
- fraction_width => -cresize'low,
- denormalize_in => denormalize,
- denormalize => denormalize);
- cfptype := classfp (cresize, false); -- errors already checked
- break_number (
- arg => lresize,
- fptyp => lfptype,
- denormalize => denormalize,
- fract => fractl,
- expon => exponl);
- break_number (
- arg => rresize,
- fptyp => rfptype,
- denormalize => denormalize,
- fract => fractr,
- expon => exponr);
- break_number (
- arg => cresize,
- fptyp => cfptype,
- denormalize => denormalize,
- fract => fractx,
- expon => exponc);
- if (rfptype = pos_denormal or rfptype = neg_denormal) then
- shifty := fraction_width - find_leftmost(fractr, '1');
- fractr := shift_left (fractr, shifty);
- elsif (lfptype = pos_denormal or lfptype = neg_denormal) then
- shifty := fraction_width - find_leftmost(fractl, '1');
- fractl := shift_left (fractl, shifty);
- else
- shifty := 0;
- -- Note that a denormal number * a denormal number is always zero.
- end if;
- -- multiply
- rfract := fractl * fractr; -- Multiply the fraction
- -- add the exponents
- rexpon := resize (exponl, rexpon'length) + exponr - shifty + 1;
- shiftx := rexpon - exponc;
- if shiftx < -fractl'high then
- rexpon2 := resize (exponc, rexpon2'length);
- fractc := "0" & fractx;
- fracts := (others => '0');
- sticky := or_reduce (rfract);
- elsif shiftx < 0 then
- shiftx := - shiftx;
- fracts := shift_right (rfract (rfract'high downto rfract'high
- - fracts'length+1),
- to_integer(shiftx));
- fractc := "0" & fractx;
- rexpon2 := resize (exponc, rexpon2'length);
- leftright := false;
- sticky := or_reduce (rfract (to_integer(shiftx)+rfract'high
- - fracts'length downto 0));
- elsif shiftx = 0 then
- rexpon2 := resize (exponc, rexpon2'length);
- sticky := or_reduce (rfract (rfract'high - fractc'length downto 0));
- if rfract (rfract'high downto rfract'high - fractc'length+1) > fractx
- then
- fractc := "0" & fractx;
- fracts := rfract (rfract'high downto rfract'high
- - fracts'length+1);
- leftright := false;
- else
- fractc := rfract (rfract'high downto rfract'high
- - fractc'length+1);
- fracts := "0" & fractx;
- leftright := true;
- end if;
- elsif shiftx > fractx'high then
- rexpon2 := rexpon;
- fracts := (others => '0');
- fractc := rfract (rfract'high downto rfract'high - fractc'length+1);
- leftright := true;
- sticky := or_reduce (fractx & rfract (rfract'high - fractc'length
- downto 0));
- else -- fractx'high > shiftx > 0
- rexpon2 := rexpon;
- fracts := "0" & shift_right (fractx, to_integer (shiftx));
- fractc := rfract (rfract'high downto rfract'high - fractc'length+1);
- leftright := true;
- sticky := or_reduce (fractx (to_integer (shiftx) downto 0)
- & rfract (rfract'high - fractc'length downto 0));
- end if;
- fracts (0) := fracts (0) or sticky; -- Or the sticky bit into the LSB
- if fp_sign = to_X01(c(c'high)) then
- ufract := fractc + fracts;
- fp_sign := fp_sign;
- else -- signs are different
- ufract := fractc - fracts; -- always positive result
- if leftright then -- Figure out which sign to use
- fp_sign := fp_sign;
- else
- fp_sign := c(c'high);
- end if;
- end if;
- -- normalize
- fpresult := normalize (fract => ufract,
- expon => rexpon2,
- sign => fp_sign,
- sticky => sticky,
- fraction_width => fraction_width,
- exponent_width => exponent_width,
- round_style => round_style,
- denormalize => denormalize,
- nguard => guard);
- end if;
- return fpresult;
- end function mac;
-
- -- "rem" function
--- function remainder (
--- l, r : UNRESOLVED_float; -- floating point input
--- constant round_style : round_type := float_round_style; -- rounding option
--- constant guard : NATURAL := float_guard_bits; -- number of guard bits
--- constant check_error : BOOLEAN := float_check_error; -- check for errors
--- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
--- return UNRESOLVED_float is
--- constant fraction_width : NATURAL := -mine(l'low, r'low); -- length of FP output fraction
--- constant exponent_width : NATURAL := maximum(l'high, r'high); -- length of FP output exponent
--- constant divguard : NATURAL := guard; -- division guard bits
--- variable lfptype, rfptype : valid_fpstate;
--- variable fpresult : UNRESOLVED_float (exponent_width downto -fraction_width);
--- variable ulfract, urfract : UNSIGNED (fraction_width downto 0);
--- variable fractr, fractl : UNSIGNED (fraction_width+divguard downto 0); -- right
--- variable rfract : UNSIGNED (fractr'range); -- result fraction
--- variable sfract : UNSIGNED (fraction_width+divguard downto 0); -- result fraction
--- variable exponl, exponr : SIGNED (exponent_width-1 downto 0); -- exponents
--- variable rexpon : SIGNED (exponent_width downto 0); -- result exponent
--- variable fp_sign : STD_ULOGIC; -- sign of result
--- variable shifty : INTEGER; -- denormal number shift
--- variable lresize, rresize : UNRESOLVED_float (exponent_width downto -fraction_width);
--- begin -- remainder
--- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
--- lfptype := isx;
--- else
--- lfptype := classfp (l, check_error);
--- rfptype := classfp (r, check_error);
--- end if;
--- if (lfptype = isx or rfptype = isx) then
--- fpresult := (others => 'X');
--- elsif (lfptype = nan or lfptype = quiet_nan)
--- or (rfptype = nan or rfptype = quiet_nan)
--- -- Return quiet NAN, IEEE754-1985-7.1,1
--- or (lfptype = pos_inf or lfptype = neg_inf) -- inf rem x
--- -- Return quiet NAN, IEEE754-1985-7.1,5
--- or (rfptype = pos_zero or rfptype = neg_zero) then -- x rem 0
--- -- Return quiet NAN, IEEE754-1985-7.1,5
--- fpresult := qnanfp (fraction_width => fraction_width,
--- exponent_width => exponent_width);
--- elsif (rfptype = pos_inf or rfptype = neg_inf) then -- x rem inf = 0
--- fpresult := zerofp (fraction_width => fraction_width,
--- exponent_width => exponent_width);
--- elsif (abs(l) < abs(r)) then
--- fpresult := l;
--- else
--- fp_sign := to_X01(l(l'high)); -- sign
--- lresize := resize (arg => to_x01(l),
--- exponent_width => exponent_width,
--- fraction_width => fraction_width,
--- denormalize_in => denormalize,
--- denormalize => denormalize);
--- lfptype := classfp (lresize, false); -- errors already checked
--- rresize := resize (arg => to_x01(r),
--- exponent_width => exponent_width,
--- fraction_width => fraction_width,
--- denormalize_in => denormalize,
--- denormalize => denormalize);
--- rfptype := classfp (rresize, false); -- errors already checked
--- fractl := (others => '0');
--- break_number (
--- arg => lresize,
--- fptyp => lfptype,
--- denormalize => denormalize,
--- fract => ulfract,
--- expon => exponl);
--- fractl (fraction_width+divguard downto divguard) := ulfract;
--- -- right side
--- fractr := (others => '0');
--- break_number (
--- arg => rresize,
--- fptyp => rfptype,
--- denormalize => denormalize,
--- fract => urfract,
--- expon => exponr);
--- fractr (fraction_width+divguard downto divguard) := urfract;
--- rexpon := (exponr(exponr'high)&exponr);
--- shifty := to_integer(exponl - rexpon);
--- if (shifty > 0) then
--- fractr := shift_right (fractr, shifty);
--- rexpon := rexpon + shifty;
--- end if;
--- if (fractr /= 0) then
--- -- rem
--- rfract := fractl rem fractr; -- unsigned rem
--- sfract := rfract (sfract'range); -- lower bits
--- -- normalize
--- fpresult := normalize (fract => sfract,
--- expon => rexpon,
--- sign => fp_sign,
--- fraction_width => fraction_width,
--- exponent_width => exponent_width,
--- round_style => round_style,
--- denormalize => denormalize,
--- nguard => divguard);
--- else
--- -- If we shift "fractr" so far that it becomes zero, return zero.
--- fpresult := zerofp (fraction_width => fraction_width,
--- exponent_width => exponent_width);
--- end if;
--- end if;
--- return fpresult;
--- end function remainder;
-
--- -- "mod" function
--- function modulo (
--- l, r : UNRESOLVED_float; -- floating point input
--- constant round_style : round_type := float_round_style; -- rounding option
--- constant guard : NATURAL := float_guard_bits; -- number of guard bits
--- constant check_error : BOOLEAN := float_check_error; -- check for errors
--- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
--- return UNRESOLVED_float is
--- constant fraction_width : NATURAL := - mine(l'low, r'low); -- length of FP output fraction
--- constant exponent_width : NATURAL := maximum(l'high, r'high); -- length of FP output exponent
--- variable lfptype, rfptype : valid_fpstate;
--- variable fpresult : UNRESOLVED_float (exponent_width downto -fraction_width);
--- variable remres : UNRESOLVED_float (exponent_width downto -fraction_width);
--- begin -- remainder
--- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
--- lfptype := isx;
--- else
--- lfptype := classfp (l, check_error);
--- rfptype := classfp (r, check_error);
--- end if;
--- if (lfptype = isx or rfptype = isx) then
--- fpresult := (others => 'X');
--- elsif (lfptype = nan or lfptype = quiet_nan)
--- or (rfptype = nan or rfptype = quiet_nan)
--- -- Return quiet NAN, IEEE754-1985-7.1,1
--- or (lfptype = pos_inf or lfptype = neg_inf) -- inf rem x
--- -- Return quiet NAN, IEEE754-1985-7.1,5
--- or (rfptype = pos_zero or rfptype = neg_zero) then -- x rem 0
--- -- Return quiet NAN, IEEE754-1985-7.1,5
--- fpresult := qnanfp (fraction_width => fraction_width,
--- exponent_width => exponent_width);
--- elsif (rfptype = pos_inf or rfptype = neg_inf) then -- x rem inf = 0
--- fpresult := zerofp (fraction_width => fraction_width,
--- exponent_width => exponent_width);
--- else
--- remres := remainder (l => abs(l),
--- r => abs(r),
--- round_style => round_style,
--- guard => guard,
--- check_error => false,
--- denormalize => denormalize);
--- -- MOD is the same as REM, but you do something different with
--- -- negative values
--- if (is_negative (l)) then
--- remres := - remres;
--- end if;
--- if (is_negative (l) = is_negative (r) or remres = 0) then
--- fpresult := remres;
--- else
--- fpresult := add (l => remres,
--- r => r,
--- round_style => round_style,
--- guard => guard,
--- check_error => false,
--- denormalize => denormalize);
--- end if;
--- end if;
--- return fpresult;
--- end function modulo;
-
- -- Square root of a floating point number. Done using Newton's Iteration.
--- function sqrt (
--- arg : UNRESOLVED_float; -- floating point input
--- constant round_style : round_type := float_round_style;
--- constant guard : NATURAL := float_guard_bits;
--- constant check_error : BOOLEAN := float_check_error;
--- constant denormalize : BOOLEAN := float_denormalize)
--- return UNRESOLVED_float is
--- constant fraction_width : NATURAL := guard-arg'low; -- length of FP output fraction
--- constant exponent_width : NATURAL := arg'high; -- length of FP output exponent
--- variable sign : STD_ULOGIC;
--- variable fpresult : float (arg'range);
--- variable fptype : valid_fpstate;
--- variable iexpon : SIGNED(exponent_width-1 downto 0); -- exponents
--- variable expon : SIGNED(exponent_width downto 0); -- exponents
--- variable ufact : ufixed (0 downto arg'low);
--- variable fact : ufixed (2 downto -fraction_width); -- fraction
--- variable resb : ufixed (fact'high+1 downto fact'low);
--- begin -- square root
--- fptype := Classfp (arg, check_error);
--- classcase : case fptype is
--- when isx =>
--- fpresult := (others => 'X');
--- when nan | quiet_nan |
--- -- Return quiet NAN, IEEE754-1985-7.1,1
--- neg_normal | neg_denormal | neg_inf => -- sqrt (neg)
--- -- Return quiet NAN, IEEE754-1985-7.1.6
--- fpresult := qnanfp (fraction_width => fraction_width-guard,
--- exponent_width => exponent_width);
--- when pos_inf => -- Sqrt (inf), return infinity
--- fpresult := pos_inffp (fraction_width => fraction_width-guard,
--- exponent_width => exponent_width);
--- when pos_zero => -- return 0
--- fpresult := zerofp (fraction_width => fraction_width-guard,
--- exponent_width => exponent_width);
--- when neg_zero => -- IEEE754-1985-6.3 return -0
--- fpresult := neg_zerofp (fraction_width => fraction_width-guard,
--- exponent_width => exponent_width);
--- when others =>
--- break_number (arg => arg,
--- denormalize => denormalize,
--- check_error => false,
--- fract => ufact,
--- expon => iexpon,
--- sign => sign);
--- expon := resize (iexpon+1, expon'length); -- get exponent
--- fact := resize (ufact, fact'high, fact'low);
--- if (expon(0) = '1') then
--- fact := fact sla 1; -- * 2.0
--- end if;
--- expon := shift_right (expon, 1); -- exponent/2
--- -- Newton's iteration - root := (1 + arg) / 2
--- resb := (fact + 1) sra 1;
--- for j in 0 to fraction_width/4 loop
--- -- root := (root + (arg/root))/2
--- resb := resize (arg => (resb + (fact/resb)) sra 1,
--- left_index => resb'high,
--- right_index => resb'low,
--- round_style => fixed_truncate,
--- overflow_style => fixed_wrap);
--- end loop;
--- fpresult := normalize (fract => resb,
--- expon => expon-1,
--- sign => '0',
--- exponent_width => arg'high,
--- fraction_width => -arg'low,
--- round_style => round_style,
--- denormalize => denormalize,
--- nguard => guard);
--- end case classcase;
--- return fpresult;
--- end function sqrt;
-
- function Is_Negative (arg : UNRESOLVED_float) return BOOLEAN is
- -- Technically -0 should return "false", but I'm leaving that case out.
- begin
- return (to_x01(arg(arg'high)) = '1');
- end function Is_Negative;
-
- -- compare functions
- -- =, /=, >=, <=, <, >
-
- function eq ( -- equal =
- l, r : UNRESOLVED_float; -- floating point input
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize : BOOLEAN := float_denormalize)
- return BOOLEAN is
- variable lfptype, rfptype : valid_fpstate;
- variable is_equal, is_unordered : BOOLEAN;
- constant fraction_width : NATURAL := -mine(l'low, r'low); -- length of FP output fraction
- constant exponent_width : NATURAL := maximum(l'high, r'high); -- length of FP output exponent
- variable lresize, rresize : UNRESOLVED_float (exponent_width downto -fraction_width);
- begin -- equal
- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
- return false;
- else
- lfptype := classfp (l, check_error);
- rfptype := classfp (r, check_error);
- end if;
- if (lfptype = neg_zero or lfptype = pos_zero) and
- (rfptype = neg_zero or rfptype = pos_zero) then
- is_equal := true;
- else
- lresize := resize (arg => to_x01(l),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- rresize := resize (arg => to_x01(r),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- is_equal := (to_slv(lresize) = to_slv(rresize));
- end if;
- if (check_error) then
- is_unordered := Unordered (x => l,
- y => r);
- else
- is_unordered := false;
- end if;
- return is_equal and not is_unordered;
- end function eq;
-
- function lt ( -- less than <
- l, r : UNRESOLVED_float; -- floating point input
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize : BOOLEAN := float_denormalize)
- return BOOLEAN is
- constant fraction_width : NATURAL := -mine(l'low, r'low); -- length of FP output fraction
- constant exponent_width : NATURAL := maximum(l'high, r'high); -- length of FP output exponent
- variable lfptype, rfptype : valid_fpstate;
- variable expl, expr : UNSIGNED (exponent_width-1 downto 0);
- variable fractl, fractr : UNSIGNED (fraction_width-1 downto 0);
- variable is_less_than, is_unordered : BOOLEAN;
- variable lresize, rresize : UNRESOLVED_float (exponent_width downto -fraction_width);
- begin
- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
- is_less_than := false;
- else
- lresize := resize (arg => to_x01(l),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- rresize := resize (arg => to_x01(r),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- if to_x01(l(l'high)) = to_x01(r(r'high)) then -- sign bits
- expl := UNSIGNED(lresize(exponent_width-1 downto 0));
- expr := UNSIGNED(rresize(exponent_width-1 downto 0));
- if expl = expr then
- fractl := UNSIGNED (to_slv(lresize(-1 downto -fraction_width)));
- fractr := UNSIGNED (to_slv(rresize(-1 downto -fraction_width)));
- if to_x01(l(l'high)) = '0' then -- positive number
- is_less_than := (fractl < fractr);
- else
- is_less_than := (fractl > fractr); -- negative
- end if;
- else
- if to_x01(l(l'high)) = '0' then -- positive number
- is_less_than := (expl < expr);
- else
- is_less_than := (expl > expr); -- negative
- end if;
- end if;
- else
- lfptype := classfp (l, check_error);
- rfptype := classfp (r, check_error);
- if (lfptype = neg_zero and rfptype = pos_zero) then
- is_less_than := false; -- -0 < 0 returns false.
- else
- is_less_than := (to_x01(l(l'high)) > to_x01(r(r'high)));
- end if;
- end if;
- end if;
- if check_error then
- is_unordered := Unordered (x => l,
- y => r);
- else
- is_unordered := false;
- end if;
- return is_less_than and not is_unordered;
- end function lt;
-
- function gt ( -- greater than >
- l, r : UNRESOLVED_float; -- floating point input
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize : BOOLEAN := float_denormalize)
- return BOOLEAN is
- constant fraction_width : NATURAL := -mine(l'low, r'low); -- length of FP output fraction
- constant exponent_width : NATURAL := maximum(l'high, r'high); -- length of FP output exponent
- variable lfptype, rfptype : valid_fpstate;
- variable expl, expr : UNSIGNED (exponent_width-1 downto 0);
- variable fractl, fractr : UNSIGNED (fraction_width-1 downto 0);
- variable is_greater_than : BOOLEAN;
- variable is_unordered : BOOLEAN;
- variable lresize, rresize : UNRESOLVED_float (exponent_width downto -fraction_width);
- begin -- greater_than
- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
- is_greater_than := false;
- else
- lresize := resize (arg => to_x01(l),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- rresize := resize (arg => to_x01(r),
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => denormalize,
- denormalize => denormalize);
- if to_x01(l(l'high)) = to_x01(r(r'high)) then -- sign bits
- expl := UNSIGNED(lresize(exponent_width-1 downto 0));
- expr := UNSIGNED(rresize(exponent_width-1 downto 0));
- if expl = expr then
- fractl := UNSIGNED (to_slv(lresize(-1 downto -fraction_width)));
- fractr := UNSIGNED (to_slv(rresize(-1 downto -fraction_width)));
- if to_x01(l(l'high)) = '0' then -- positive number
- is_greater_than := fractl > fractr;
- else
- is_greater_than := fractl < fractr; -- negative
- end if;
- else
- if to_x01(l(l'high)) = '0' then -- positive number
- is_greater_than := expl > expr;
- else
- is_greater_than := expl < expr; -- negative
- end if;
- end if;
- else
- lfptype := classfp (l, check_error);
- rfptype := classfp (r, check_error);
- if (lfptype = pos_zero and rfptype = neg_zero) then
- is_greater_than := false; -- 0 > -0 returns false.
- else
- is_greater_than := to_x01(l(l'high)) < to_x01(r(r'high));
- end if;
- end if;
- end if;
- if check_error then
- is_unordered := Unordered (x => l,
- y => r);
- else
- is_unordered := false;
- end if;
- return is_greater_than and not is_unordered;
- end function gt;
-
- -- purpose: /= function
- function ne ( -- not equal /=
- l, r : UNRESOLVED_float;
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize : BOOLEAN := float_denormalize)
- return BOOLEAN is
- variable is_equal, is_unordered : BOOLEAN;
- begin
- is_equal := eq (l => l,
- r => r,
- check_error => false,
- denormalize => denormalize);
- if check_error then
- is_unordered := Unordered (x => l,
- y => r);
- else
- is_unordered := false;
- end if;
- return not (is_equal and not is_unordered);
- end function ne;
-
- function le ( -- less than or equal to <=
- l, r : UNRESOLVED_float; -- floating point input
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize : BOOLEAN := float_denormalize)
- return BOOLEAN is
- variable is_greater_than, is_unordered : BOOLEAN;
- begin
- is_greater_than := gt (l => l,
- r => r,
- check_error => false,
- denormalize => denormalize);
- if check_error then
- is_unordered := Unordered (x => l,
- y => r);
- else
- is_unordered := false;
- end if;
- return not is_greater_than and not is_unordered;
- end function le;
-
- function ge ( -- greater than or equal to >=
- l, r : UNRESOLVED_float; -- floating point input
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize : BOOLEAN := float_denormalize)
- return BOOLEAN is
- variable is_less_than, is_unordered : BOOLEAN;
- begin
- is_less_than := lt (l => l,
- r => r,
- check_error => false,
- denormalize => denormalize);
- if check_error then
- is_unordered := Unordered (x => l,
- y => r);
- else
- is_unordered := false;
- end if;
- return not is_less_than and not is_unordered;
- end function ge;
-
- function \?=\ (L, R : UNRESOLVED_float) return STD_ULOGIC is
- constant fraction_width : NATURAL := -mine(l'low, r'low); -- length of FP output fraction
- constant exponent_width : NATURAL := maximum(l'high, r'high); -- length of FP output exponent
- variable lfptype, rfptype : valid_fpstate;
- variable is_equal, is_unordered : STD_ULOGIC;
- variable lresize, rresize : UNRESOLVED_float (exponent_width downto -fraction_width);
- begin -- ?=
- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
- return 'X';
- else
- lfptype := classfp (l, float_check_error);
- rfptype := classfp (r, float_check_error);
- end if;
- if (lfptype = neg_zero or lfptype = pos_zero) and
- (rfptype = neg_zero or rfptype = pos_zero) then
- is_equal := '1';
- else
- lresize := resize (arg => l,
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => float_denormalize,
- denormalize => float_denormalize);
- rresize := resize (arg => r,
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => float_denormalize,
- denormalize => float_denormalize);
- is_equal := \?=\ (to_sulv(lresize), to_sulv(rresize));
- end if;
- if (float_check_error) then
- if (lfptype = nan or lfptype = quiet_nan or
- rfptype = nan or rfptype = quiet_nan) then
- is_unordered := '1';
- else
- is_unordered := '0';
- end if;
- else
- is_unordered := '0';
- end if;
- return is_equal and not is_unordered;
- end function \?=\;
-
- function \?/=\ (L, R : UNRESOLVED_float) return STD_ULOGIC is
- constant fraction_width : NATURAL := -mine(l'low, r'low); -- length of FP output fraction
- constant exponent_width : NATURAL := maximum(l'high, r'high); -- length of FP output exponent
- variable lfptype, rfptype : valid_fpstate;
- variable is_equal, is_unordered : STD_ULOGIC;
- variable lresize, rresize : UNRESOLVED_float (exponent_width downto -fraction_width);
- begin -- ?/=
- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
- return 'X';
- else
- lfptype := classfp (l, float_check_error);
- rfptype := classfp (r, float_check_error);
- end if;
- if (lfptype = neg_zero or lfptype = pos_zero) and
- (rfptype = neg_zero or rfptype = pos_zero) then
- is_equal := '1';
- else
- lresize := resize (arg => l,
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => float_denormalize,
- denormalize => float_denormalize);
- rresize := resize (arg => r,
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- denormalize_in => float_denormalize,
- denormalize => float_denormalize);
- is_equal := \?=\ (to_sulv(lresize), to_sulv(rresize));
- end if;
- if (float_check_error) then
- if (lfptype = nan or lfptype = quiet_nan or
- rfptype = nan or rfptype = quiet_nan) then
- is_unordered := '1';
- else
- is_unordered := '0';
- end if;
- else
- is_unordered := '0';
- end if;
- return not (is_equal and not is_unordered);
- end function \?/=\;
-
- function \?>\ (L, R : UNRESOLVED_float) return STD_ULOGIC is
- constant fraction_width : NATURAL := -mine(l'low, r'low);
- variable founddash : BOOLEAN := false;
- begin
- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
- return 'X';
- else
- for i in L'range loop
- if L(i) = '-' then
- founddash := true;
- end if;
- end loop;
- for i in R'range loop
- if R(i) = '-' then
- founddash := true;
- end if;
- end loop;
- if founddash then
- report "float_pkg:"
- & " ""?>"": '-' found in compare string"
- severity error;
- return 'X';
- elsif 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 : UNRESOLVED_float) return STD_ULOGIC is
- constant fraction_width : NATURAL := -mine(l'low, r'low);
- variable founddash : BOOLEAN := false;
- begin
- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
- return 'X';
- else
- for i in L'range loop
- if L(i) = '-' then
- founddash := true;
- end if;
- end loop;
- for i in R'range loop
- if R(i) = '-' then
- founddash := true;
- end if;
- end loop;
- if founddash then
- report "float_pkg:"
- & " ""?>="": '-' found in compare string"
- severity error;
- return 'X';
- elsif 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 : UNRESOLVED_float) return STD_ULOGIC is
- constant fraction_width : NATURAL := -mine(l'low, r'low);
- variable founddash : BOOLEAN := false;
- begin
- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
- return 'X';
- else
- for i in L'range loop
- if L(i) = '-' then
- founddash := true;
- end if;
- end loop;
- for i in R'range loop
- if R(i) = '-' then
- founddash := true;
- end if;
- end loop;
- if founddash then
- report "float_pkg:"
- & " ""?<"": '-' found in compare string"
- severity error;
- return 'X';
- elsif 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 : UNRESOLVED_float) return STD_ULOGIC is
- constant fraction_width : NATURAL := -mine(l'low, r'low);
- variable founddash : BOOLEAN := false;
- begin
- if (fraction_width = 0 or l'length < 7 or r'length < 7) then
- return 'X';
- else
- for i in L'range loop
- if L(i) = '-' then
- founddash := true;
- end if;
- end loop;
- for i in R'range loop
- if R(i) = '-' then
- founddash := true;
- end if;
- end loop;
- if founddash then
- report "float_pkg:"
- & " ""?<="": '-' found in compare string"
- severity error;
- return 'X';
- elsif 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 std_match (L, R : UNRESOLVED_float) 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
- report "float_pkg:"
- & "STD_MATCH: L'RANGE /= R'RANGE, returning FALSE"
- severity warning;
- return false;
- end if;
- end function std_match;
-
- function find_rightmost (arg : UNRESOLVED_float; y : STD_ULOGIC) return INTEGER is
- begin
- for_loop : for i in arg'reverse_range loop
- if arg(i) = y 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_float; y : STD_ULOGIC) return INTEGER is
- begin
- for_loop : for i in arg'range loop
- if arg(i) = y then
- return i;
- end if;
- end loop;
- return arg'low-1; -- return out of bounds 'low
- end function find_leftmost;
-
- -- These override the defaults for the compare operators.
- function "=" (l, r : UNRESOLVED_float) return BOOLEAN is
- begin
- return eq(l, r);
- end function "=";
-
- function "/=" (l, r : UNRESOLVED_float) return BOOLEAN is
- begin
- return ne(l, r);
- end function "/=";
-
- function ">=" (l, r : UNRESOLVED_float) return BOOLEAN is
- begin
- return ge(l, r);
- end function ">=";
-
- function "<=" (l, r : UNRESOLVED_float) return BOOLEAN is
- begin
- return le(l, r);
- end function "<=";
-
- function ">" (l, r : UNRESOLVED_float) return BOOLEAN is
- begin
- return gt(l, r);
- end function ">";
-
- function "<" (l, r : UNRESOLVED_float) return BOOLEAN is
- begin
- return lt(l, r);
- end function "<";
-
- -- purpose: maximum of two numbers (overrides default)
- function maximum (
- L, R : UNRESOLVED_float)
- return UNRESOLVED_float is
- constant fraction_width : NATURAL := -mine(l'low, r'low); -- length of FP output fraction
- constant exponent_width : NATURAL := maximum(l'high, r'high); -- length of FP output exponent
- variable lresize, rresize : UNRESOLVED_float (exponent_width downto -fraction_width);
- begin
- if ((L'length < 1) or (R'length < 1)) then return NAFP;
- end if;
- lresize := resize (l, exponent_width, fraction_width);
- rresize := resize (r, exponent_width, fraction_width);
- if lresize > rresize then return lresize;
- else return rresize;
- end if;
- end function maximum;
-
- function minimum (
- L, R : UNRESOLVED_float)
- return UNRESOLVED_float is
- constant fraction_width : NATURAL := -mine(l'low, r'low); -- length of FP output fraction
- constant exponent_width : NATURAL := maximum(l'high, r'high); -- length of FP output exponent
- variable lresize, rresize : UNRESOLVED_float (exponent_width downto -fraction_width);
- begin
- if ((L'length < 1) or (R'length < 1)) then return NAFP;
- end if;
- lresize := resize (l, exponent_width, fraction_width);
- rresize := resize (r, exponent_width, fraction_width);
- if lresize > rresize then return rresize;
- else return lresize;
- end if;
- end function minimum;
-
- -----------------------------------------------------------------------------
- -- conversion functions
- -----------------------------------------------------------------------------
-
- -- Converts a floating point number of one format into another format
- function resize (
- arg : UNRESOLVED_float; -- Floating point input
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- length of FP output fraction
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize_in : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float is
- constant in_fraction_width : NATURAL := -arg'low; -- length of FP output fraction
- constant in_exponent_width : NATURAL := arg'high; -- length of FP output exponent
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width);
- -- result value
- variable fptype : valid_fpstate;
- variable expon_in : SIGNED (in_exponent_width-1 downto 0);
- variable fract_in : UNSIGNED (in_fraction_width downto 0);
- variable round : BOOLEAN;
- variable expon_out : SIGNED (exponent_width-1 downto 0); -- output fract
- variable fract_out : UNSIGNED (fraction_width downto 0); -- output fract
- variable passguard : NATURAL;
- begin
- fptype := classfp(arg, check_error);
- if ((fptype = pos_denormal or fptype = neg_denormal) and denormalize_in
- and (in_exponent_width < exponent_width
- or in_fraction_width < fraction_width))
- or in_exponent_width > exponent_width
- or in_fraction_width > fraction_width then
- -- size reduction
- classcase : case fptype is
- when isx =>
- result := (others => 'X');
- when nan | quiet_nan =>
- result := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- when pos_inf =>
- result := pos_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- when neg_inf =>
- result := neg_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- when pos_zero | neg_zero =>
- result := zerofp (fraction_width => fraction_width, -- hate -0
- exponent_width => exponent_width);
- when others =>
- break_number (
- arg => arg,
- fptyp => fptype,
- denormalize => denormalize_in,
- fract => fract_in,
- expon => expon_in);
- if fraction_width > in_fraction_width and denormalize_in then
- -- You only get here if you have a denormal input
- fract_out := (others => '0'); -- pad with zeros
- fract_out (fraction_width downto
- fraction_width - in_fraction_width) := fract_in;
- result := normalize (
- fract => fract_out,
- expon => expon_in,
- sign => arg(arg'high),
- fraction_width => fraction_width,
- exponent_width => exponent_width,
- round_style => round_style,
- denormalize => denormalize,
- nguard => 0);
- else
- result := normalize (
- fract => fract_in,
- expon => expon_in,
- sign => arg(arg'high),
- fraction_width => fraction_width,
- exponent_width => exponent_width,
- round_style => round_style,
- denormalize => denormalize,
- nguard => in_fraction_width - fraction_width);
- end if;
- end case classcase;
- else -- size increase or the same size
- if exponent_width > in_exponent_width then
- expon_in := SIGNED(arg (in_exponent_width-1 downto 0));
- if fptype = pos_zero or fptype = neg_zero then
- result (exponent_width-1 downto 0) := (others => '0');
- elsif expon_in = -1 then -- inf or nan (shorts out check_error)
- result (exponent_width-1 downto 0) := (others => '1');
- else
- -- invert top BIT
- expon_in(expon_in'high) := not expon_in(expon_in'high);
- expon_out := resize (expon_in, expon_out'length); -- signed expand
- -- Flip it back.
- expon_out(expon_out'high) := not expon_out(expon_out'high);
- result (exponent_width-1 downto 0) := UNRESOLVED_float(expon_out);
- end if;
- result (exponent_width) := arg (in_exponent_width); -- sign
- else -- exponent_width = in_exponent_width
- result (exponent_width downto 0) := arg (in_exponent_width downto 0);
- end if;
- if fraction_width > in_fraction_width then
- result (-1 downto -fraction_width) := (others => '0'); -- zeros
- result (-1 downto -in_fraction_width) :=
- arg (-1 downto -in_fraction_width);
- else -- fraction_width = in_fraciton_width
- result (-1 downto -fraction_width) :=
- arg (-1 downto -in_fraction_width);
- end if;
- end if;
- return result;
- end function resize;
-
- function resize (
- arg : UNRESOLVED_float; -- floating point input
- size_res : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize_in : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (size_res'left downto size_res'right);
- begin
- if (result'length < 1) then
- return result;
- else
- result := resize (arg => arg,
- exponent_width => size_res'high,
- fraction_width => -size_res'low,
- round_style => round_style,
- check_error => check_error,
- denormalize_in => denormalize_in,
- denormalize => denormalize);
- return result;
- end if;
- end function resize;
-
- function to_float32 (
- arg : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize_in : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float32 is
- begin
- return resize (arg => arg,
- exponent_width => float32'high,
- fraction_width => -float32'low,
- round_style => round_style,
- check_error => check_error,
- denormalize_in => denormalize_in,
- denormalize => denormalize);
- end function to_float32;
-
- function to_float64 (
- arg : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize_in : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float64 is
- begin
- return resize (arg => arg,
- exponent_width => float64'high,
- fraction_width => -float64'low,
- round_style => round_style,
- check_error => check_error,
- denormalize_in => denormalize_in,
- denormalize => denormalize);
- end function to_float64;
-
- function to_float128 (
- arg : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error;
- constant denormalize_in : BOOLEAN := float_denormalize; -- Use IEEE extended FP
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float128 is
- begin
- return resize (arg => arg,
- exponent_width => float128'high,
- fraction_width => -float128'low,
- round_style => round_style,
- check_error => check_error,
- denormalize_in => denormalize_in,
- denormalize => denormalize);
- end function to_float128;
-
- -- to_float (Real)
- -- typically not Synthesizable unless the input is a constant.
- function to_float (
- arg : REAL;
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- length of FP output fraction
- constant round_style : round_type := float_round_style; -- rounding option
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable arg_real : REAL; -- Real version of argument
- variable validfp : boundary_type; -- Check for valid results
- variable exp : INTEGER; -- Integer version of exponent
- variable expon : UNSIGNED (exponent_width - 1 downto 0);
- -- Unsigned version of exp.
- constant expon_base : SIGNED (exponent_width-1 downto 0) :=
- gen_expon_base(exponent_width); -- exponent offset
- variable fract : UNSIGNED (fraction_width-1 downto 0);
- variable frac : REAL; -- Real version of fraction
- constant roundfrac : REAL := 2.0 ** (-2 - fract'high); -- used for rounding
- variable round : BOOLEAN; -- to round or not to round
- begin
- result := (others => '0');
- arg_real := arg;
- if arg_real < 0.0 then
- result (exponent_width) := '1';
- arg_real := - arg_real; -- Make it positive.
- else
- result (exponent_width) := '0';
- end if;
- test_boundary (arg => arg_real,
- fraction_width => fraction_width,
- exponent_width => exponent_width,
- denormalize => denormalize,
- btype => validfp,
- log2i => exp);
- if validfp = zero then
- return result; -- Result initialized to "0".
- elsif validfp = infinity then
- result (exponent_width - 1 downto 0) := (others => '1'); -- Exponent all "1"
- -- return infinity.
- return result;
- else
- if validfp = denormal then -- Exponent will default to "0".
- expon := (others => '0');
- frac := arg_real * (2.0 ** (to_integer(expon_base)-1));
- else -- Number less than 1. "normal" number
- expon := UNSIGNED (to_signed (exp-1, exponent_width));
- expon(exponent_width-1) := not expon(exponent_width-1);
- frac := (arg_real / 2.0 ** exp) - 1.0; -- Number less than 1.
- end if;
- for i in 0 to fract'high loop
- if frac >= 2.0 ** (-1 - i) then
- fract (fract'high - i) := '1';
- frac := frac - 2.0 ** (-1 - i);
- else
- fract (fract'high - i) := '0';
- end if;
- end loop;
- round := false;
- case round_style is
- when round_nearest =>
- if frac > roundfrac or ((frac = roundfrac) and fract(0) = '1') then
- round := true;
- end if;
- when round_inf =>
- if frac /= 0.0 and result(exponent_width) = '0' then
- round := true;
- end if;
- when round_neginf =>
- if frac /= 0.0 and result(exponent_width) = '1' then
- round := true;
- end if;
- when others =>
- null; -- don't round
- end case;
- if (round) then
- if and_reduce (fract) = '1' then -- fraction is all "1"
- expon := expon + 1;
- fract := (others => '0');
- else
- fract := fract + 1;
- end if;
- end if;
- result (exponent_width-1 downto 0) := UNRESOLVED_float(expon);
- result (-1 downto -fraction_width) := UNRESOLVED_float(fract);
- return result;
- end if;
- end function to_float;
-
- -- to_float (Integer)
- function to_float (
- arg : INTEGER;
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- length of FP output fraction
- constant round_style : round_type := float_round_style) -- rounding option
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable arg_int : NATURAL; -- Natural version of argument
- variable expon : SIGNED (exponent_width-1 downto 0);
- variable exptmp : SIGNED (exponent_width-1 downto 0);
- -- Unsigned version of exp.
- constant expon_base : SIGNED (exponent_width-1 downto 0) :=
- gen_expon_base(exponent_width); -- exponent offset
- variable fract : UNSIGNED (fraction_width-1 downto 0) := (others => '0');
- variable fracttmp : UNSIGNED (fraction_width-1 downto 0);
- variable round : BOOLEAN;
- variable shift : NATURAL;
- variable shiftr : NATURAL;
- variable roundfrac : NATURAL; -- used in rounding
- begin
- if arg < 0 then
- result (exponent_width) := '1';
- arg_int := -arg; -- Make it positive.
- else
- result (exponent_width) := '0';
- arg_int := arg;
- end if;
- if arg_int = 0 then
- result := zerofp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- else
- -- If the number is larger than we can represent in this number system
- -- we need to return infinity.
- shift := log2(arg_int);
- if shift > to_integer(expon_base) then
- -- worry about infinity
- if result (exponent_width) = '0' then
- result := pos_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- else
- -- return negative infinity.
- result := neg_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- end if;
- else -- Normal number (can't be denormal)
- -- Compute Exponent
- expon := to_signed (shift-1, expon'length); -- positive fraction.
- -- Compute Fraction
- arg_int := arg_int - 2**shift; -- Subtract off the 1.0
- shiftr := shift;
- for I in fract'high downto maximum (fract'high - shift + 1, 0) loop
- shiftr := shiftr - 1;
- if (arg_int >= 2**shiftr) then
- arg_int := arg_int - 2**shiftr;
- fract(I) := '1';
- else
- fract(I) := '0';
- end if;
- end loop;
- -- Rounding routine
- round := false;
- if arg_int > 0 then
- roundfrac := 2**(shiftr-1);
- case round_style is
- when round_nearest =>
- if arg_int > roundfrac or
- ((arg_int = roundfrac) and fract(0) = '1') then
- round := true;
- end if;
- when round_inf =>
- if arg_int /= 0 and result (exponent_width) = '0' then
- round := true;
- end if;
- when round_neginf =>
- if arg_int /= 0 and result (exponent_width) = '1' then
- round := true;
- end if;
- when others =>
- null;
- end case;
- end if;
- if round then
- fp_round(fract_in => fract,
- expon_in => expon,
- fract_out => fracttmp,
- expon_out => exptmp);
- fract := fracttmp;
- expon := exptmp;
- end if;
- -- Put the number together and return
- expon(exponent_width-1) := not expon(exponent_width-1);
- result (exponent_width-1 downto 0) := UNRESOLVED_float(expon);
- result (-1 downto -fraction_width) := UNRESOLVED_float(fract);
- end if;
- end if;
- return result;
- end function to_float;
-
- -- to_float (unsigned)
- function to_float (
- arg : UNSIGNED;
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- length of FP output fraction
- constant round_style : round_type := float_round_style) -- rounding option
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width);
- constant ARG_LEFT : INTEGER := ARG'length-1;
- alias XARG : UNSIGNED(ARG_LEFT downto 0) is ARG;
- variable sarg : SIGNED (ARG_LEFT+1 downto 0); -- signed version of arg
- begin
- if arg'length < 1 then
- return NAFP;
- end if;
- sarg (XARG'range) := SIGNED (XARG);
- sarg (sarg'high) := '0';
- result := to_float (arg => sarg,
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- round_style => round_style);
- return result;
- end function to_float;
-
- -- to_float (signed)
- function to_float (
- arg : SIGNED;
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- length of FP output fraction
- constant round_style : round_type := float_round_style) -- rounding option
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width);
- constant ARG_LEFT : INTEGER := ARG'length-1;
- alias XARG : SIGNED(ARG_LEFT downto 0) is ARG;
- variable arg_int : UNSIGNED(xarg'range); -- Real version of argument
- variable argb2 : UNSIGNED(xarg'high/2 downto 0); -- log2 of input
- variable rexp : SIGNED (exponent_width - 1 downto 0);
- variable exp : SIGNED (exponent_width - 1 downto 0);
- -- signed version of exp.
- variable expon : UNSIGNED (exponent_width - 1 downto 0);
- -- Unsigned version of exp.
- constant expon_base : SIGNED (exponent_width-1 downto 0) :=
- gen_expon_base(exponent_width); -- exponent offset
- variable round : BOOLEAN;
- variable fract : UNSIGNED (fraction_width-1 downto 0);
- variable rfract : UNSIGNED (fraction_width-1 downto 0);
- variable sign : STD_ULOGIC; -- sign bit
- begin
- if arg'length < 1 then
- return NAFP;
- end if;
- if Is_X (xarg) then
- result := (others => 'X');
- elsif (xarg = 0) then
- result := zerofp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- else -- Normal number (can't be denormal)
- sign := to_X01(xarg (xarg'high));
- arg_int := UNSIGNED(abs (to_01(xarg)));
- -- Compute Exponent
- argb2 := to_unsigned(find_leftmost(arg_int, '1'), argb2'length); -- Log2
- if argb2 > UNSIGNED(expon_base) then
- result := pos_inffp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- result (exponent_width) := sign;
- else
- exp := SIGNED(resize(argb2, exp'length));
- arg_int := shift_left (arg_int, arg_int'high-to_integer(exp));
- if (arg_int'high > fraction_width) then
- fract := arg_int (arg_int'high-1 downto (arg_int'high-fraction_width));
- round := check_round (
- fract_in => fract (0),
- sign => sign,
- remainder => arg_int((arg_int'high-fraction_width-1)
- downto 0),
- round_style => round_style);
- if round then
- fp_round(fract_in => fract,
- expon_in => exp,
- fract_out => rfract,
- expon_out => rexp);
- else
- rfract := fract;
- rexp := exp;
- end if;
- else
- rexp := exp;
- rfract := (others => '0');
- rfract (fraction_width-1 downto fraction_width-1-(arg_int'high-1)) :=
- arg_int (arg_int'high-1 downto 0);
- end if;
- result (exponent_width) := sign;
- expon := UNSIGNED (rexp-1);
- expon(exponent_width-1) := not expon(exponent_width-1);
- result (exponent_width-1 downto 0) := UNRESOLVED_float(expon);
- result (-1 downto -fraction_width) := UNRESOLVED_float(rfract);
- end if;
- end if;
- return result;
- end function to_float;
-
- -- std_logic_vector to float
- function to_float (
- arg : STD_ULOGIC_VECTOR;
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width) -- length of FP output fraction
- return UNRESOLVED_float is
- variable fpvar : UNRESOLVED_float (exponent_width downto -fraction_width);
- begin
- if arg'length < 1 then
- return NAFP;
- end if;
- fpvar := UNRESOLVED_float(arg);
- return fpvar;
- end function to_float;
-
- -- purpose: converts a ufixed to a floating point
- function to_float (
- arg : UNRESOLVED_ufixed; -- unsigned fixed point input
- constant exponent_width : NATURAL := float_exponent_width; -- width of exponent
- constant fraction_width : NATURAL := float_fraction_width; -- width of fraction
- constant round_style : round_type := float_round_style; -- rounding
- constant denormalize : BOOLEAN := float_denormalize) -- use ieee extensions
- return UNRESOLVED_float is
- variable sarg : sfixed (arg'high+1 downto arg'low); -- Signed version of arg
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width);
- begin -- function to_float
- if (arg'length < 1) then
- return NAFP;
- end if;
- sarg (arg'range) := sfixed (arg);
- sarg (sarg'high) := '0';
- result := to_float (arg => sarg,
- exponent_width => exponent_width,
- fraction_width => fraction_width,
- round_style => round_style,
- denormalize => denormalize);
- return result;
- end function to_float;
-
- function to_float (
- arg : UNRESOLVED_sfixed; -- signed fixed point
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width; -- length of FP output fraction
- constant round_style : round_type := float_round_style; -- rounding
- constant denormalize : BOOLEAN := float_denormalize) -- rounding option
- return UNRESOLVED_float is
- constant integer_width : INTEGER := arg'high;
- constant in_fraction_width : INTEGER := arg'low;
- variable xresult : sfixed (integer_width downto in_fraction_width);
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable arg_int : UNSIGNED(integer_width - in_fraction_width
- downto 0); -- unsigned version of argument
- variable argx : SIGNED (integer_width - in_fraction_width downto 0);
- variable exp, exptmp : SIGNED (exponent_width downto 0);
- variable expon : UNSIGNED (exponent_width - 1 downto 0);
- -- Unsigned version of exp.
- constant expon_base : SIGNED (exponent_width-1 downto 0) :=
- gen_expon_base(exponent_width); -- exponent offset
- variable fract, fracttmp : UNSIGNED (fraction_width-1 downto 0) :=
- (others => '0');
- variable round : BOOLEAN := false;
- begin
- if (arg'length < 1) then
- return NAFP;
- end if;
- xresult := to_01(arg, 'X');
- argx := SIGNED(to_slv(xresult));
- if (Is_X (arg)) then
- result := (others => 'X');
- elsif (argx = 0) then
- result := (others => '0');
- else
- result := (others => '0'); -- zero out the result
- if argx(argx'left) = '1' then -- toss the sign bit
- result (exponent_width) := '1'; -- Negative number
- arg_int := UNSIGNED(to_x01(not STD_LOGIC_VECTOR (argx))) + 1; -- Make it positive with two's complement
- else
- result (exponent_width) := '0';
- arg_int := UNSIGNED(to_x01(STD_LOGIC_VECTOR (argx))); -- new line: direct conversion to unsigned
- end if;
- -- Compute Exponent
- exp := to_signed(find_leftmost(arg_int, '1'), exp'length); -- Log2
- if exp + in_fraction_width > expon_base then -- return infinity
- result (-1 downto -fraction_width) := (others => '0');
- result (exponent_width -1 downto 0) := (others => '1');
- return result;
- elsif (denormalize and
- (exp + in_fraction_width <= -resize(expon_base, exp'length))) then
- exp := -resize(expon_base, exp'length);
- -- shift by a constant
- arg_int := shift_left (arg_int,
- (arg_int'high + to_integer(expon_base)
- + in_fraction_width - 1));
- if (arg_int'high > fraction_width) then
- fract := arg_int (arg_int'high-1 downto (arg_int'high-fraction_width));
- round := check_round (
- fract_in => arg_int(arg_int'high-fraction_width),
- sign => result(result'high),
- remainder => arg_int((arg_int'high-fraction_width-1)
- downto 0),
- round_style => round_style);
- if (round) then
- fp_round (fract_in => arg_int (arg_int'high-1 downto
- (arg_int'high-fraction_width)),
- expon_in => exp,
- fract_out => fract,
- expon_out => exptmp);
- exp := exptmp;
- end if;
- else
- fract (fraction_width-1 downto fraction_width-1-(arg_int'high-1)) :=
- arg_int (arg_int'high-1 downto 0);
- end if;
- else
- arg_int := shift_left (arg_int, arg_int'high-to_integer(exp));
- exp := exp + in_fraction_width;
- if (arg_int'high > fraction_width) then
- fract := arg_int (arg_int'high-1 downto (arg_int'high-fraction_width));
- round := check_round (
- fract_in => fract(0),
- sign => result(result'high),
- remainder => arg_int((arg_int'high-fraction_width-1)
- downto 0),
- round_style => round_style);
- if (round) then
- fp_round (fract_in => fract,
- expon_in => exp,
- fract_out => fracttmp,
- expon_out => exptmp);
- fract := fracttmp;
- exp := exptmp;
- end if;
- else
- fract (fraction_width-1 downto fraction_width-1-(arg_int'high-1)) :=
- arg_int (arg_int'high-1 downto 0);
- end if;
- end if;
- expon := UNSIGNED (resize(exp-1, exponent_width));
- expon(exponent_width-1) := not expon(exponent_width-1);
- result (exponent_width-1 downto 0) := UNRESOLVED_float(expon);
- result (-1 downto -fraction_width) := UNRESOLVED_float(fract);
- end if;
- return result;
- end function to_float;
-
- -- size_res functions
- -- Integer to float
- function to_float (
- arg : INTEGER;
- size_res : UNRESOLVED_float;
- constant round_style : round_type := float_round_style) -- rounding option
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (size_res'left downto size_res'right);
- begin
- if (result'length < 1) then
- return result;
- else
- result := to_float (arg => arg,
- exponent_width => size_res'high,
- fraction_width => -size_res'low,
- round_style => round_style);
- return result;
- end if;
- end function to_float;
-
- -- real to float
- function to_float (
- arg : REAL;
- size_res : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding option
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (size_res'left downto size_res'right);
- begin
- if (result'length < 1) then
- return result;
- else
- result := to_float (arg => arg,
- exponent_width => size_res'high,
- fraction_width => -size_res'low,
- round_style => round_style,
- denormalize => denormalize);
- return result;
- end if;
- end function to_float;
-
- -- unsigned to float
- function to_float (
- arg : UNSIGNED;
- size_res : UNRESOLVED_float;
- constant round_style : round_type := float_round_style) -- rounding option
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (size_res'left downto size_res'right);
- begin
- if (result'length < 1) then
- return result;
- else
- result := to_float (arg => arg,
- exponent_width => size_res'high,
- fraction_width => -size_res'low,
- round_style => round_style);
- return result;
- end if;
- end function to_float;
-
- -- signed to float
- function to_float (
- arg : SIGNED;
- size_res : UNRESOLVED_float;
- constant round_style : round_type := float_round_style) -- rounding
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (size_res'left downto size_res'right);
- begin
- if (result'length < 1) then
- return result;
- else
- result := to_float (arg => arg,
- exponent_width => size_res'high,
- fraction_width => -size_res'low,
- round_style => round_style);
- return result;
- end if;
- end function to_float;
-
- -- std_ulogic_vector to float
- function to_float (
- arg : STD_ULOGIC_VECTOR;
- size_res : UNRESOLVED_float)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (size_res'left downto size_res'right);
- begin
- if (result'length < 1) then
- return result;
- else
- result := to_float (arg => arg,
- exponent_width => size_res'high,
- fraction_width => -size_res'low);
- return result;
- end if;
- end function to_float;
-
- -- unsigned fixed point to float
- function to_float (
- arg : UNRESOLVED_ufixed; -- unsigned fixed point input
- size_res : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding
- constant denormalize : BOOLEAN := float_denormalize) -- use ieee extensions
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (size_res'left downto size_res'right);
- begin
- if (result'length < 1) then
- return result;
- else
- result := to_float (arg => arg,
- exponent_width => size_res'high,
- fraction_width => -size_res'low,
- round_style => round_style,
- denormalize => denormalize);
- return result;
- end if;
- end function to_float;
-
- -- signed fixed point to float
- function to_float (
- arg : UNRESOLVED_sfixed;
- size_res : UNRESOLVED_float;
- constant round_style : round_type := float_round_style; -- rounding
- constant denormalize : BOOLEAN := float_denormalize) -- rounding option
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (size_res'left downto size_res'right);
- begin
- if (result'length < 1) then
- return result;
- else
- result := to_float (arg => arg,
- exponent_width => size_res'high,
- fraction_width => -size_res'low,
- round_style => round_style,
- denormalize => denormalize);
- return result;
- end if;
- end function to_float;
-
- -- to_integer (float)
- function to_integer (
- arg : UNRESOLVED_float; -- floating point input
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error) -- check for errors
- return INTEGER is
- variable validfp : valid_fpstate; -- Valid FP state
- variable frac : UNSIGNED (-arg'low downto 0); -- Fraction
- variable fract : UNSIGNED (1-arg'low downto 0); -- Fraction
- variable expon : SIGNED (arg'high-1 downto 0);
- variable isign : STD_ULOGIC; -- internal version of sign
- variable round : STD_ULOGIC; -- is rounding needed?
- variable result : INTEGER;
- variable base : INTEGER; -- Integer exponent
- begin
- validfp := classfp (arg, check_error);
- classcase : case validfp is
- when isx | nan | quiet_nan | pos_zero | neg_zero | pos_denormal | neg_denormal =>
- result := 0; -- return 0
- when pos_inf =>
- result := INTEGER'high;
- when neg_inf =>
- result := INTEGER'low;
- when others =>
- break_number (
- arg => arg,
- fptyp => validfp,
- denormalize => false,
- fract => frac,
- expon => expon);
- fract (fract'high) := '0'; -- Add extra bit for 0.6 case
- fract (fract'high-1 downto 0) := frac;
- isign := to_x01 (arg (arg'high));
- base := to_integer (expon) + 1;
- if base < -1 then
- result := 0;
- elsif base >= frac'high then
- result := to_integer (fract) * 2**(base - frac'high);
- else -- We need to round
- if base = -1 then -- trap for 0.6 case.
- result := 0;
- else
- result := to_integer (fract (frac'high downto frac'high-base));
- end if;
- -- rounding routine
- case round_style is
- when round_nearest =>
- if frac'high - base > 1 then
- round := fract (frac'high - base - 1) and
- (fract (frac'high - base)
- or (or_reduce (fract (frac'high - base - 2 downto 0))));
- else
- round := fract (frac'high - base - 1) and
- fract (frac'high - base);
- end if;
- when round_inf =>
- round := fract(frac'high - base - 1) and not isign;
- when round_neginf =>
- round := fract(frac'high - base - 1) and isign;
- when others =>
- round := '0';
- end case;
- if round = '1' then
- result := result + 1;
- end if;
- end if;
- if isign = '1' then
- result := - result;
- end if;
- end case classcase;
- return result;
- end function to_integer;
-
- -- to_unsigned (float)
- function to_unsigned (
- arg : UNRESOLVED_float; -- floating point input
- constant size : NATURAL; -- length of output
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error) -- check for errors
- return UNSIGNED is
- variable validfp : valid_fpstate; -- Valid FP state
- variable frac : UNSIGNED (size-1 downto 0); -- Fraction
- variable sign : STD_ULOGIC; -- not used
- begin
- validfp := classfp (arg, check_error);
- classcase : case validfp is
- when isx | nan | quiet_nan =>
- frac := (others => 'X');
- when pos_zero | neg_inf | neg_zero | neg_normal | pos_denormal | neg_denormal =>
- frac := (others => '0'); -- return 0
- when pos_inf =>
- frac := (others => '1');
- when others =>
- float_to_unsigned (
- arg => arg,
- frac => frac,
- sign => sign,
- denormalize => false,
- bias => 0,
- round_style => round_style);
- end case classcase;
- return (frac);
- end function to_unsigned;
-
- -- to_signed (float)
- function to_signed (
- arg : UNRESOLVED_float; -- floating point input
- constant size : NATURAL; -- length of output
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error) -- check for errors
- return SIGNED is
- variable sign : STD_ULOGIC; -- true if negative
- variable validfp : valid_fpstate; -- Valid FP state
- variable frac : UNSIGNED (size-1 downto 0); -- Fraction
- variable result : SIGNED (size-1 downto 0);
- begin
- validfp := classfp (arg, check_error);
- classcase : case validfp is
- when isx | nan | quiet_nan =>
- result := (others => 'X');
- when pos_zero | neg_zero | pos_denormal | neg_denormal =>
- result := (others => '0'); -- return 0
- when pos_inf =>
- result := (others => '1');
- result (result'high) := '0';
- when neg_inf =>
- result := (others => '0');
- result (result'high) := '1';
- when others =>
- float_to_unsigned (
- arg => arg,
- sign => sign,
- frac => frac,
- denormalize => false,
- bias => 0,
- round_style => round_style);
- result (size-1) := '0';
- result (size-2 downto 0) := SIGNED(frac (size-2 downto 0));
- if sign = '1' then
- -- Because the most negative signed number is 1 less than the most
- -- positive signed number, we need this code.
- if frac(frac'high) = '1' then -- return most negative number
- result := (others => '0');
- result (result'high) := '1';
- else
- result := -result;
- end if;
- else
- if frac(frac'high) = '1' then -- return most positive number
- result := (others => '1');
- result (result'high) := '0';
- end if;
- end if;
- end case classcase;
- return result;
- end function to_signed;
-
- -- purpose: Converts a float to ufixed
- function to_ufixed (
- arg : UNRESOLVED_float; -- fp input
- constant left_index : INTEGER; -- integer part
- constant right_index : INTEGER; -- fraction part
- constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; -- saturate
- constant round_style : fixed_round_style_type := fixed_round_style; -- rounding
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize)
- return UNRESOLVED_ufixed is
- constant fraction_width : INTEGER := -mine(arg'low, arg'low); -- length of FP output fraction
- constant exponent_width : INTEGER := arg'high; -- length of FP output exponent
- constant size : INTEGER := left_index - right_index + 4; -- unsigned size
- variable expon_base : INTEGER; -- exponent offset
- variable validfp : valid_fpstate; -- Valid FP state
- variable exp : INTEGER; -- Exponent
- variable expon : UNSIGNED (exponent_width-1 downto 0); -- Vectorized exponent
- -- Base to divide fraction by
- variable frac : UNSIGNED (size-1 downto 0) := (others => '0'); -- Fraction
- variable frac_shift : UNSIGNED (size-1 downto 0); -- Fraction shifted
- variable shift : INTEGER;
- variable result_big : UNRESOLVED_ufixed (left_index downto right_index-3);
- variable result : UNRESOLVED_ufixed (left_index downto right_index); -- result
- begin -- function to_ufixed
- validfp := classfp (arg, check_error);
- classcase : case validfp is
- when isx | nan | quiet_nan =>
- frac := (others => 'X');
- when pos_zero | neg_inf | neg_zero | neg_normal | neg_denormal =>
- frac := (others => '0'); -- return 0
- when pos_inf =>
- frac := (others => '1'); -- always saturate
- when others =>
- expon_base := 2**(exponent_width-1) -1; -- exponent offset
- -- Figure out the fraction
- if (validfp = pos_denormal) and denormalize then
- exp := -expon_base +1;
- frac (frac'high) := '0'; -- Remove the "1.0".
- else
- -- exponent /= '0', normal floating point
- expon := UNSIGNED(arg (exponent_width-1 downto 0));
- expon(exponent_width-1) := not expon(exponent_width-1);
- exp := to_integer (SIGNED(expon)) +1;
- frac (frac'high) := '1'; -- Add the "1.0".
- end if;
- shift := (frac'high - 3 + right_index) - exp;
- if fraction_width > frac'high then -- Can only use size-2 bits
- frac (frac'high-1 downto 0) := UNSIGNED (to_slv (arg(-1 downto
- -frac'high)));
- else -- can use all bits
- frac (frac'high-1 downto frac'high-fraction_width) :=
- UNSIGNED (to_slv (arg(-1 downto -fraction_width)));
- end if;
- frac_shift := frac srl shift;
- if shift < 0 then -- Overflow
- frac := (others => '1');
- else
- frac := frac_shift;
- end if;
- end case classcase;
- result_big := to_ufixed (
- arg => STD_ULOGIC_VECTOR(frac),
- left_index => left_index,
- right_index => (right_index-3));
- result := resize (arg => result_big,
- left_index => left_index,
- right_index => right_index,
- round_style => round_style,
- overflow_style => overflow_style);
- return result;
- end function to_ufixed;
-
- -- purpose: Converts a float to sfixed
- function to_sfixed (
- arg : UNRESOLVED_float; -- fp input
- constant left_index : INTEGER; -- integer part
- constant right_index : INTEGER; -- fraction part
- constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; -- saturate
- constant round_style : fixed_round_style_type := fixed_round_style; -- rounding
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize)
- return UNRESOLVED_sfixed is
- constant fraction_width : INTEGER := -mine(arg'low, arg'low); -- length of FP output fraction
- constant exponent_width : INTEGER := arg'high; -- length of FP output exponent
- constant size : INTEGER := left_index - right_index + 4; -- unsigned size
- variable expon_base : INTEGER; -- exponent offset
- variable validfp : valid_fpstate; -- Valid FP state
- variable exp : INTEGER; -- Exponent
- variable sign : BOOLEAN; -- true if negative
- variable expon : UNSIGNED (exponent_width-1 downto 0); -- Vectorized exponent
- -- Base to divide fraction by
- variable frac : UNSIGNED (size-2 downto 0) := (others => '0'); -- Fraction
- variable frac_shift : UNSIGNED (size-2 downto 0); -- Fraction shifted
- variable shift : INTEGER;
- variable rsigned : SIGNED (size-1 downto 0); -- signed version of result
- variable result_big : UNRESOLVED_sfixed (left_index downto right_index-3);
- variable result : UNRESOLVED_sfixed (left_index downto right_index)
- := (others => '0'); -- result
- begin -- function to_sfixed
- validfp := classfp (arg, check_error);
- classcase : case validfp is
- when isx | nan | quiet_nan =>
- result := (others => 'X');
- when pos_zero | neg_zero =>
- result := (others => '0'); -- return 0
- when neg_inf =>
- result (left_index) := '1'; -- return smallest negative number
- when pos_inf =>
- result := (others => '1'); -- return largest number
- result (left_index) := '0';
- when others =>
- expon_base := 2**(exponent_width-1) -1; -- exponent offset
- if arg(exponent_width) = '0' then
- sign := false;
- else
- sign := true;
- end if;
- -- Figure out the fraction
- if (validfp = pos_denormal or validfp = neg_denormal)
- and denormalize then
- exp := -expon_base +1;
- frac (frac'high) := '0'; -- Add the "1.0".
- else
- -- exponent /= '0', normal floating point
- expon := UNSIGNED(arg (exponent_width-1 downto 0));
- expon(exponent_width-1) := not expon(exponent_width-1);
- exp := to_integer (SIGNED(expon)) +1;
- frac (frac'high) := '1'; -- Add the "1.0".
- end if;
- shift := (frac'high - 3 + right_index) - exp;
- if fraction_width > frac'high then -- Can only use size-2 bits
- frac (frac'high-1 downto 0) := UNSIGNED (to_slv (arg(-1 downto
- -frac'high)));
- else -- can use all bits
- frac (frac'high-1 downto frac'high-fraction_width) :=
- UNSIGNED (to_slv (arg(-1 downto -fraction_width)));
- end if;
- frac_shift := frac srl shift;
- if shift < 0 then -- Overflow
- frac := (others => '1');
- else
- frac := frac_shift;
- end if;
- if not sign then
- rsigned := SIGNED("0" & frac);
- else
- rsigned := -(SIGNED("0" & frac));
- end if;
- result_big := to_sfixed (
- arg => STD_LOGIC_VECTOR(rsigned),
- left_index => left_index,
- right_index => (right_index-3));
- result := resize (arg => result_big,
- left_index => left_index,
- right_index => right_index,
- round_style => round_style,
- overflow_style => overflow_style);
- end case classcase;
- return result;
- end function to_sfixed;
-
- -- size_res versions
- -- float to unsigned
- function to_unsigned (
- arg : UNRESOLVED_float; -- floating point input
- size_res : UNSIGNED;
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error) -- check for errors
- return UNSIGNED is
- variable result : UNSIGNED (size_res'range);
- begin
- if (SIZE_RES'length = 0) then
- return result;
- else
- result := to_unsigned (
- arg => arg,
- size => size_res'length,
- round_style => round_style,
- check_error => check_error);
- return result;
- end if;
- end function to_unsigned;
-
- -- float to signed
- function to_signed (
- arg : UNRESOLVED_float; -- floating point input
- size_res : SIGNED;
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error) -- check for errors
- return SIGNED is
- variable result : SIGNED (size_res'range);
- begin
- if (SIZE_RES'length = 0) then
- return result;
- else
- result := to_signed (
- arg => arg,
- size => size_res'length,
- round_style => round_style,
- check_error => check_error);
- return result;
- end if;
- end function to_signed;
-
- -- purpose: Converts a float to unsigned fixed point
- function to_ufixed (
- arg : UNRESOLVED_float; -- fp input
- size_res : UNRESOLVED_ufixed;
- constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; -- saturate
- constant round_style : fixed_round_style_type := fixed_round_style; -- rounding
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize)
- return UNRESOLVED_ufixed is
- variable result : UNRESOLVED_ufixed (size_res'left downto size_res'right);
- begin
- if (result'length < 1) then
- return result;
- else
- result := to_ufixed (
- arg => arg,
- left_index => size_res'high,
- right_index => size_res'low,
- overflow_style => overflow_style,
- round_style => round_style,
- check_error => check_error,
- denormalize => denormalize);
- return result;
- end if;
- end function to_ufixed;
-
- -- float to signed fixed point
- function to_sfixed (
- arg : UNRESOLVED_float; -- fp input
- size_res : UNRESOLVED_sfixed;
- constant overflow_style : fixed_overflow_style_type := fixed_overflow_style; -- saturate
- constant round_style : fixed_round_style_type := fixed_round_style; -- rounding
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize)
- return UNRESOLVED_sfixed is
- variable result : UNRESOLVED_sfixed (size_res'left downto size_res'right);
- begin
- if (result'length < 1) then
- return result;
- else
- result := to_sfixed (
- arg => arg,
- left_index => size_res'high,
- right_index => size_res'low,
- overflow_style => overflow_style,
- round_style => round_style,
- check_error => check_error,
- denormalize => denormalize);
- return result;
- end if;
- end function to_sfixed;
-
- -- to_real (float)
- -- typically not Synthesizable unless the input is a constant.
- function to_real (
- arg : UNRESOLVED_float; -- floating point input
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return REAL is
- constant fraction_width : INTEGER := -mine(arg'low, arg'low); -- length of FP output fraction
- constant exponent_width : INTEGER := arg'high; -- length of FP output exponent
- variable sign : REAL; -- Sign, + or - 1
- variable exp : INTEGER; -- Exponent
- variable expon_base : INTEGER; -- exponent offset
- variable frac : REAL := 0.0; -- Fraction
- variable validfp : valid_fpstate; -- Valid FP state
- variable expon : UNSIGNED (exponent_width - 1 downto 0)
- := (others => '1'); -- Vectorized exponent
- begin
- validfp := classfp (arg, check_error);
- classcase : case validfp is
- when isx | pos_zero | neg_zero | nan | quiet_nan =>
- return 0.0;
- when neg_inf =>
- return REAL'low; -- Negative infinity.
- when pos_inf =>
- return REAL'high; -- Positive infinity
- when others =>
- expon_base := 2**(exponent_width-1) -1;
- if to_X01(arg(exponent_width)) = '0' then
- sign := 1.0;
- else
- sign := -1.0;
- end if;
- -- Figure out the fraction
- for i in 0 to fraction_width-1 loop
- if to_X01(arg (-1 - i)) = '1' then
- frac := frac + (2.0 **(-1 - i));
- end if;
- end loop; -- i
- if validfp = pos_normal or validfp = neg_normal or not denormalize then
- -- exponent /= '0', normal floating point
- expon := UNSIGNED(arg (exponent_width-1 downto 0));
- expon(exponent_width-1) := not expon(exponent_width-1);
- exp := to_integer (SIGNED(expon)) +1;
- sign := sign * (2.0 ** exp) * (1.0 + frac);
- else -- exponent = '0', IEEE extended floating point
- exp := 1 - expon_base;
- sign := sign * (2.0 ** exp) * frac;
- end if;
- return sign;
- end case classcase;
- end function to_real;
-
- -- For Verilog compatability
- function realtobits (arg : REAL) return STD_ULOGIC_VECTOR is
- variable result : float64; -- 64 bit floating point
- begin
- result := to_float (arg => arg,
- exponent_width => float64'high,
- fraction_width => -float64'low);
- return to_sulv (result);
- end function realtobits;
-
- function bitstoreal (arg : STD_ULOGIC_VECTOR) return REAL is
- variable arg64 : float64; -- arg converted to float
- begin
- arg64 := to_float (arg => arg,
- exponent_width => float64'high,
- fraction_width => -float64'low);
- return to_real (arg64);
- end function bitstoreal;
-
- -- purpose: Removes meta-logical values from FP string
- function to_01 (
- arg : UNRESOLVED_float; -- floating point input
- XMAP : STD_LOGIC := '0')
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (arg'range);
- begin -- function to_01
- if (arg'length < 1) then
- assert NO_WARNING
- report "float_pkg:"
- & "TO_01: null detected, returning NULL"
- severity warning;
- return NAFP;
- end if;
- result := UNRESOLVED_float (STD_LOGIC_VECTOR(to_01(UNSIGNED(to_slv(arg)), XMAP)));
- return result;
- end function to_01;
-
- function Is_X
- (arg : UNRESOLVED_float)
- return BOOLEAN is
- begin
- return Is_X (to_slv(arg));
- end function Is_X;
-
- function to_X01 (arg : UNRESOLVED_float) return UNRESOLVED_float is
- variable result : UNRESOLVED_float (arg'range);
- begin
- if (arg'length < 1) then
- assert NO_WARNING
- report "float_pkg:"
- & "TO_X01: null detected, returning NULL"
- severity warning;
- return NAFP;
- else
- result := UNRESOLVED_float (to_X01(to_slv(arg)));
- return result;
- end if;
- end function to_X01;
-
- function to_X01Z (arg : UNRESOLVED_float) return UNRESOLVED_float is
- variable result : UNRESOLVED_float (arg'range);
- begin
- if (arg'length < 1) then
- assert NO_WARNING
- report "float_pkg:"
- & "TO_X01Z: null detected, returning NULL"
- severity warning;
- return NAFP;
- else
- result := UNRESOLVED_float (to_X01Z(to_slv(arg)));
- return result;
- end if;
- end function to_X01Z;
-
- function to_UX01 (arg : UNRESOLVED_float) return UNRESOLVED_float is
- variable result : UNRESOLVED_float (arg'range);
- begin
- if (arg'length < 1) then
- assert NO_WARNING
- report "float_pkg:"
- & "TO_UX01: null detected, returning NULL"
- severity warning;
- return NAFP;
- else
- result := UNRESOLVED_float (to_UX01(to_slv(arg)));
- return result;
- end if;
- end function to_UX01;
-
- -- These allows the base math functions to use the default values
- -- of their parameters. Thus they do full IEEE floating point.
- function "+" (l, r : UNRESOLVED_float) return UNRESOLVED_float is
- begin
- return add (l, r);
- end function "+";
-
- function "-" (l, r : UNRESOLVED_float) return UNRESOLVED_float is
- begin
- return subtract (l, r);
- end function "-";
-
- function "*" (l, r : UNRESOLVED_float) return UNRESOLVED_float is
- begin
- return multiply (l, r);
- end function "*";
-
- function "/" (l, r : UNRESOLVED_float) return UNRESOLVED_float is
- begin
- return divide (l, r);
- end function "/";
-
--- function "rem" (l, r : UNRESOLVED_float) return UNRESOLVED_float is
--- begin
--- return remainder (l, r);
--- end function "rem";
-
--- function "mod" (l, r : UNRESOLVED_float) return UNRESOLVED_float is
--- begin
--- return modulo (l, r);
--- end function "mod";
-
- -- overloaded versions
- function "+" (l : UNRESOLVED_float; r : REAL) return UNRESOLVED_float is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return add (l, r_float);
- end function "+";
-
- function "+" (l : REAL; r : UNRESOLVED_float) return UNRESOLVED_float is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return add (l_float, r);
- end function "+";
-
- function "+" (l : UNRESOLVED_float; r : INTEGER) return UNRESOLVED_float is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return add (l, r_float);
- end function "+";
-
- function "+" (l : INTEGER; r : UNRESOLVED_float) return UNRESOLVED_float is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return add (l_float, r);
- end function "+";
-
- function "-" (l : UNRESOLVED_float; r : REAL) return UNRESOLVED_float is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return subtract (l, r_float);
- end function "-";
-
- function "-" (l : REAL; r : UNRESOLVED_float) return UNRESOLVED_float is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return subtract (l_float, r);
- end function "-";
-
- function "-" (l : UNRESOLVED_float; r : INTEGER) return UNRESOLVED_float is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return subtract (l, r_float);
- end function "-";
-
- function "-" (l : INTEGER; r : UNRESOLVED_float) return UNRESOLVED_float is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return subtract (l_float, r);
- end function "-";
-
- function "*" (l : UNRESOLVED_float; r : REAL) return UNRESOLVED_float is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return multiply (l, r_float);
- end function "*";
-
- function "*" (l : REAL; r : UNRESOLVED_float) return UNRESOLVED_float is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return multiply (l_float, r);
- end function "*";
-
- function "*" (l : UNRESOLVED_float; r : INTEGER) return UNRESOLVED_float is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return multiply (l, r_float);
- end function "*";
-
- function "*" (l : INTEGER; r : UNRESOLVED_float) return UNRESOLVED_float is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return multiply (l_float, r);
- end function "*";
-
- function "/" (l : UNRESOLVED_float; r : REAL) return UNRESOLVED_float is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return divide (l, r_float);
- end function "/";
-
- function "/" (l : REAL; r : UNRESOLVED_float) return UNRESOLVED_float is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return divide (l_float, r);
- end function "/";
-
- function "/" (l : UNRESOLVED_float; r : INTEGER) return UNRESOLVED_float is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return divide (l, r_float);
- end function "/";
-
- function "/" (l : INTEGER; r : UNRESOLVED_float) return UNRESOLVED_float is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return divide (l_float, r);
- end function "/";
-
--- function "rem" (l : UNRESOLVED_float; r : REAL) return UNRESOLVED_float is
--- variable r_float : UNRESOLVED_float (l'range);
--- begin
--- r_float := to_float (r, l'high, -l'low);
--- return remainder (l, r_float);
--- end function "rem";
-
--- function "rem" (l : REAL; r : UNRESOLVED_float) return UNRESOLVED_float is
--- variable l_float : UNRESOLVED_float (r'range);
--- begin
--- l_float := to_float(l, r'high, -r'low);
--- return remainder (l_float, r);
--- end function "rem";
-
--- function "rem" (l : UNRESOLVED_float; r : INTEGER) return UNRESOLVED_float is
--- variable r_float : UNRESOLVED_float (l'range);
--- begin
--- r_float := to_float (r, l'high, -l'low);
--- return remainder (l, r_float);
--- end function "rem";
-
--- function "rem" (l : INTEGER; r : UNRESOLVED_float) return UNRESOLVED_float is
--- variable l_float : UNRESOLVED_float (r'range);
--- begin
--- l_float := to_float(l, r'high, -r'low);
--- return remainder (l_float, r);
--- end function "rem";
-
--- function "mod" (l : UNRESOLVED_float; r : REAL) return UNRESOLVED_float is
--- variable r_float : UNRESOLVED_float (l'range);
--- begin
--- r_float := to_float (r, l'high, -l'low);
--- return modulo (l, r_float);
--- end function "mod";
-
--- function "mod" (l : REAL; r : UNRESOLVED_float) return UNRESOLVED_float is
--- variable l_float : UNRESOLVED_float (r'range);
--- begin
--- l_float := to_float(l, r'high, -r'low);
--- return modulo (l_float, r);
--- end function "mod";
-
--- function "mod" (l : UNRESOLVED_float; r : INTEGER) return UNRESOLVED_float is
--- variable r_float : UNRESOLVED_float (l'range);
--- begin
--- r_float := to_float (r, l'high, -l'low);
--- return modulo (l, r_float);
--- end function "mod";
-
--- function "mod" (l : INTEGER; r : UNRESOLVED_float) return UNRESOLVED_float is
--- variable l_float : UNRESOLVED_float (r'range);
--- begin
--- l_float := to_float(l, r'high, -r'low);
--- return modulo (l_float, r);
--- end function "mod";
-
- function "=" (l : UNRESOLVED_float; r : REAL) return BOOLEAN is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return eq (l, r_float);
- end function "=";
-
- function "/=" (l : UNRESOLVED_float; r : REAL) return BOOLEAN is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return ne (l, r_float);
- end function "/=";
-
- function ">=" (l : UNRESOLVED_float; r : REAL) return BOOLEAN is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return ge (l, r_float);
- end function ">=";
-
- function "<=" (l : UNRESOLVED_float; r : REAL) return BOOLEAN is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return le (l, r_float);
- end function "<=";
-
- function ">" (l : UNRESOLVED_float; r : REAL) return BOOLEAN is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return gt (l, r_float);
- end function ">";
-
- function "<" (l : UNRESOLVED_float; r : REAL) return BOOLEAN is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return lt (l, r_float);
- end function "<";
-
- function "=" (l : REAL; r : UNRESOLVED_float) return BOOLEAN is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return eq (l_float, r);
- end function "=";
-
- function "/=" (l : REAL; r : UNRESOLVED_float) return BOOLEAN is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return ne (l_float, r);
- end function "/=";
-
- function ">=" (l : REAL; r : UNRESOLVED_float) return BOOLEAN is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return ge (l_float, r);
- end function ">=";
-
- function "<=" (l : REAL; r : UNRESOLVED_float) return BOOLEAN is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return le (l_float, r);
- end function "<=";
-
- function ">" (l : REAL; r : UNRESOLVED_float) return BOOLEAN is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return gt (l_float, r);
- end function ">";
-
- function "<" (l : REAL; r : UNRESOLVED_float) return BOOLEAN is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return lt (l_float, r);
- end function "<";
-
- function "=" (l : UNRESOLVED_float; r : INTEGER) return BOOLEAN is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return eq (l, r_float);
- end function "=";
-
- function "/=" (l : UNRESOLVED_float; r : INTEGER) return BOOLEAN is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return ne (l, r_float);
- end function "/=";
-
- function ">=" (l : UNRESOLVED_float; r : INTEGER) return BOOLEAN is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return ge (l, r_float);
- end function ">=";
-
- function "<=" (l : UNRESOLVED_float; r : INTEGER) return BOOLEAN is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return le (l, r_float);
- end function "<=";
-
- function ">" (l : UNRESOLVED_float; r : INTEGER) return BOOLEAN is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return gt (l, r_float);
- end function ">";
-
- function "<" (l : UNRESOLVED_float; r : INTEGER) return BOOLEAN is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return lt (l, r_float);
- end function "<";
-
- function "=" (l : INTEGER; r : UNRESOLVED_float) return BOOLEAN is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return eq (l_float, r);
- end function "=";
-
- function "/=" (l : INTEGER; r : UNRESOLVED_float) return BOOLEAN is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return ne (l_float, r);
- end function "/=";
-
- function ">=" (l : INTEGER; r : UNRESOLVED_float) return BOOLEAN is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return ge (l_float, r);
- end function ">=";
-
- function "<=" (l : INTEGER; r : UNRESOLVED_float) return BOOLEAN is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return le (l_float, r);
- end function "<=";
-
- function ">" (l : INTEGER; r : UNRESOLVED_float) return BOOLEAN is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return gt (l_float, r);
- end function ">";
-
- function "<" (l : INTEGER; r : UNRESOLVED_float) return BOOLEAN is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float(l, r'high, -r'low);
- return lt (l_float, r);
- end function "<";
-
- -- ?= overloads
- function \?=\ (l : UNRESOLVED_float; r : REAL) return STD_ULOGIC is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return \?=\ (l, r_float);
- end function \?=\;
-
- function \?/=\ (l : UNRESOLVED_float; r : REAL) return STD_ULOGIC is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return \?/=\ (l, r_float);
- end function \?/=\;
-
- function \?>\ (l : UNRESOLVED_float; r : REAL) return STD_ULOGIC is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return \?>\ (l, r_float);
- end function \?>\;
-
- function \?>=\ (l : UNRESOLVED_float; r : REAL) return STD_ULOGIC is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return \?>=\ (l, r_float);
- end function \?>=\;
-
- function \?<\ (l : UNRESOLVED_float; r : REAL) return STD_ULOGIC is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return \?<\ (l, r_float);
- end function \?<\;
-
- function \?<=\ (l : UNRESOLVED_float; r : REAL) return STD_ULOGIC is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return \?<=\ (l, r_float);
- end function \?<=\;
-
- -- real and float
- function \?=\ (l : REAL; r : UNRESOLVED_float) return STD_ULOGIC is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return \?=\ (l_float, r);
- end function \?=\;
-
- function \?/=\ (l : REAL; r : UNRESOLVED_float) return STD_ULOGIC is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return \?/=\ (l_float, r);
- end function \?/=\;
-
- function \?>\ (l : REAL; r : UNRESOLVED_float) return STD_ULOGIC is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return \?>\ (l_float, r);
- end function \?>\;
-
- function \?>=\ (l : REAL; r : UNRESOLVED_float) return STD_ULOGIC is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return \?>=\ (l_float, r);
- end function \?>=\;
-
- function \?<\ (l : REAL; r : UNRESOLVED_float) return STD_ULOGIC is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return \?<\ (l_float, r);
- end function \?<\;
-
- function \?<=\ (l : REAL; r : UNRESOLVED_float) return STD_ULOGIC is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return \?<=\ (l_float, r);
- end function \?<=\;
-
- -- ?= overloads
- function \?=\ (l : UNRESOLVED_float; r : INTEGER) return STD_ULOGIC is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return \?=\ (l, r_float);
- end function \?=\;
-
- function \?/=\ (l : UNRESOLVED_float; r : INTEGER) return STD_ULOGIC is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return \?/=\ (l, r_float);
- end function \?/=\;
-
- function \?>\ (l : UNRESOLVED_float; r : INTEGER) return STD_ULOGIC is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return \?>\ (l, r_float);
- end function \?>\;
-
- function \?>=\ (l : UNRESOLVED_float; r : INTEGER) return STD_ULOGIC is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return \?>=\ (l, r_float);
- end function \?>=\;
-
- function \?<\ (l : UNRESOLVED_float; r : INTEGER) return STD_ULOGIC is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return \?<\ (l, r_float);
- end function \?<\;
-
- function \?<=\ (l : UNRESOLVED_float; r : INTEGER) return STD_ULOGIC is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return \?<=\ (l, r_float);
- end function \?<=\;
-
- -- integer and float
- function \?=\ (l : INTEGER; r : UNRESOLVED_float) return STD_ULOGIC is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return \?=\ (l_float, r);
- end function \?=\;
-
- function \?/=\ (l : INTEGER; r : UNRESOLVED_float) return STD_ULOGIC is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return \?/=\ (l_float, r);
- end function \?/=\;
-
- function \?>\ (l : INTEGER; r : UNRESOLVED_float) return STD_ULOGIC is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return \?>\ (l_float, r);
- end function \?>\;
-
- function \?>=\ (l : INTEGER; r : UNRESOLVED_float) return STD_ULOGIC is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return \?>=\ (l_float, r);
- end function \?>=\;
-
- function \?<\ (l : INTEGER; r : UNRESOLVED_float) return STD_ULOGIC is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return \?<\ (l_float, r);
- end function \?<\;
-
- function \?<=\ (l : INTEGER; r : UNRESOLVED_float) return STD_ULOGIC is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return \?<=\ (l_float, r);
- end function \?<=\;
-
- -- minimum and maximum overloads
- function minimum (l : UNRESOLVED_float; r : REAL)
- return UNRESOLVED_float is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return minimum (l, r_float);
- end function minimum;
-
- function maximum (l : UNRESOLVED_float; r : REAL)
- return UNRESOLVED_float is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return maximum (l, r_float);
- end function maximum;
-
- function minimum (l : REAL; r : UNRESOLVED_float)
- return UNRESOLVED_float is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return minimum (l_float, r);
- end function minimum;
-
- function maximum (l : REAL; r : UNRESOLVED_float)
- return UNRESOLVED_float is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return maximum (l_float, r);
- end function maximum;
-
- function minimum (l : UNRESOLVED_float; r : INTEGER)
- return UNRESOLVED_float is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return minimum (l, r_float);
- end function minimum;
-
- function maximum (l : UNRESOLVED_float; r : INTEGER)
- return UNRESOLVED_float is
- variable r_float : UNRESOLVED_float (l'range);
- begin
- r_float := to_float (r, l'high, -l'low);
- return maximum (l, r_float);
- end function maximum;
-
- function minimum (l : INTEGER; r : UNRESOLVED_float)
- return UNRESOLVED_float is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return minimum (l_float, r);
- end function minimum;
-
- function maximum (l : INTEGER; r : UNRESOLVED_float)
- return UNRESOLVED_float is
- variable l_float : UNRESOLVED_float (r'range);
- begin
- l_float := to_float (l, r'high, -r'low);
- return maximum (l_float, r);
- end function maximum;
-
- ----------------------------------------------------------------------------
- -- logical functions
- ----------------------------------------------------------------------------
- function "not" (L : UNRESOLVED_float) return UNRESOLVED_float is
- variable RESULT : STD_ULOGIC_VECTOR(L'length-1 downto 0); -- force downto
- begin
- RESULT := not to_sulv(L);
- return to_float (RESULT, L'high, -L'low);
- end function "not";
-
- function "and" (L, R : UNRESOLVED_float) return UNRESOLVED_float 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 "float_pkg:"
- & """and"": Range error L'RANGE /= R'RANGE"
- severity warning;
- RESULT := (others => 'X');
- end if;
- return to_float (RESULT, L'high, -L'low);
- end function "and";
-
- function "or" (L, R : UNRESOLVED_float) return UNRESOLVED_float 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 "float_pkg:"
- & """or"": Range error L'RANGE /= R'RANGE"
- severity warning;
- RESULT := (others => 'X');
- end if;
- return to_float (RESULT, L'high, -L'low);
- end function "or";
-
- function "nand" (L, R : UNRESOLVED_float) return UNRESOLVED_float 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 "float_pkg:"
- & """nand"": Range error L'RANGE /= R'RANGE"
- severity warning;
- RESULT := (others => 'X');
- end if;
- return to_float (RESULT, L'high, -L'low);
- end function "nand";
-
- function "nor" (L, R : UNRESOLVED_float) return UNRESOLVED_float 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 "float_pkg:"
- & """nor"": Range error L'RANGE /= R'RANGE"
- severity warning;
- RESULT := (others => 'X');
- end if;
- return to_float (RESULT, L'high, -L'low);
- end function "nor";
-
- function "xor" (L, R : UNRESOLVED_float) return UNRESOLVED_float 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 "float_pkg:"
- & """xor"": Range error L'RANGE /= R'RANGE"
- severity warning;
- RESULT := (others => 'X');
- end if;
- return to_float (RESULT, L'high, -L'low);
- end function "xor";
-
- function "xnor" (L, R : UNRESOLVED_float) return UNRESOLVED_float 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 "float_pkg:"
- & """xnor"": Range error L'RANGE /= R'RANGE"
- severity warning;
- RESULT := (others => 'X');
- end if;
- return to_float (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_float)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (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_float; R : STD_ULOGIC)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (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_float)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (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_float; R : STD_ULOGIC)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (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_float)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (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_float; R : STD_ULOGIC)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (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_float)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (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_float; R : STD_ULOGIC)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (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_float)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (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_float; R : STD_ULOGIC)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (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_float)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (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_float; R : STD_ULOGIC)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (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, same as numeric_std functions
-
- function and_reduce (l : UNRESOLVED_float) return STD_ULOGIC is
- begin
- return and_reduce (to_sulv(l));
- end function and_reduce;
-
- function nand_reduce (l : UNRESOLVED_float) return STD_ULOGIC is
- begin
- return nand_reduce (to_sulv(l));
- end function nand_reduce;
-
- function or_reduce (l : UNRESOLVED_float) return STD_ULOGIC is
- begin
- return or_reduce (to_sulv(l));
- end function or_reduce;
-
- function nor_reduce (l : UNRESOLVED_float) return STD_ULOGIC is
- begin
- return nor_reduce (to_sulv(l));
- end function nor_reduce;
-
- function xor_reduce (l : UNRESOLVED_float) return STD_ULOGIC is
- begin
- return xor_reduce (to_sulv(l));
- end function xor_reduce;
-
- function xnor_reduce (l : UNRESOLVED_float) return STD_ULOGIC is
- begin
- return xnor_reduce (to_sulv(l));
- end function xnor_reduce;
-
- -----------------------------------------------------------------------------
- -- Recommended Functions from the IEEE 754 Appendix
- -----------------------------------------------------------------------------
- -- returns x with the sign of y.
- function Copysign (
- x, y : UNRESOLVED_float) -- floating point input
- return UNRESOLVED_float is
- begin
- return y(y'high) & x (x'high-1 downto x'low);
- end function Copysign;
-
- -- Returns y * 2**n for integral values of N without computing 2**n
- function Scalb (
- y : UNRESOLVED_float; -- floating point input
- N : INTEGER; -- exponent to add
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float is
- constant fraction_width : NATURAL := -mine(y'low, y'low); -- length of FP output fraction
- constant exponent_width : NATURAL := y'high; -- length of FP output exponent
- variable arg, result : UNRESOLVED_float (exponent_width downto -fraction_width); -- internal argument
- variable expon : SIGNED (exponent_width-1 downto 0); -- Vectorized exp
- variable exp : SIGNED (exponent_width downto 0);
- variable ufract : UNSIGNED (fraction_width downto 0);
- constant expon_base : SIGNED (exponent_width-1 downto 0)
- := gen_expon_base(exponent_width); -- exponent offset
- variable fptype : valid_fpstate;
- begin
- -- This can be done by simply adding N to the exponent.
- arg := to_01 (y, 'X');
- fptype := classfp(arg, check_error);
- classcase : case fptype is
- when isx =>
- result := (others => 'X');
- when nan | quiet_nan =>
- -- Return quiet NAN, IEEE754-1985-7.1,1
- result := qnanfp (fraction_width => fraction_width,
- exponent_width => exponent_width);
- when others =>
- break_number (
- arg => arg,
- fptyp => fptype,
- denormalize => denormalize,
- fract => ufract,
- expon => expon);
- exp := resize (expon, exp'length) + N;
- result := normalize (
- fract => ufract,
- expon => exp,
- sign => to_x01 (arg (arg'high)),
- fraction_width => fraction_width,
- exponent_width => exponent_width,
- round_style => round_style,
- denormalize => denormalize,
- nguard => 0);
- end case classcase;
- return result;
- end function Scalb;
-
- -- Returns y * 2**n for integral values of N without computing 2**n
- function Scalb (
- y : UNRESOLVED_float; -- floating point input
- N : SIGNED; -- exponent to add
- constant round_style : round_type := float_round_style; -- rounding option
- constant check_error : BOOLEAN := float_check_error; -- check for errors
- constant denormalize : BOOLEAN := float_denormalize) -- Use IEEE extended FP
- return UNRESOLVED_float is
- variable n_int : INTEGER;
- begin
- n_int := to_integer(N);
- return Scalb (y => y,
- N => n_int,
- round_style => round_style,
- check_error => check_error,
- denormalize => denormalize);
- end function Scalb;
-
- -- returns the unbiased exponent of x
- function Logb (
- x : UNRESOLVED_float) -- floating point input
- return INTEGER is
- constant fraction_width : NATURAL := -mine (x'low, x'low); -- length of FP output fraction
- constant exponent_width : NATURAL := x'high; -- length of FP output exponent
- variable result : INTEGER; -- result
- variable arg : UNRESOLVED_float (exponent_width downto -fraction_width); -- internal argument
- variable expon : SIGNED (exponent_width - 1 downto 0);
- variable fract : UNSIGNED (fraction_width downto 0);
- constant expon_base : INTEGER := 2**(exponent_width-1) -1; -- exponent
- -- offset +1
- variable fptype : valid_fpstate;
- begin
- -- Just return the exponent.
- arg := to_01 (x, 'X');
- fptype := classfp(arg);
- classcase : case fptype is
- when isx | nan | quiet_nan =>
- -- Return quiet NAN, IEEE754-1985-7.1,1
- result := 0;
- when pos_denormal | neg_denormal =>
- fract (fraction_width) := '0';
- fract (fraction_width-1 downto 0) :=
- UNSIGNED (to_slv(arg(-1 downto -fraction_width)));
- result := find_leftmost (fract, '1') -- Find the first "1"
- - fraction_width; -- subtract the length we want
- result := -expon_base + 1 + result;
- when others =>
- expon := SIGNED(arg (exponent_width - 1 downto 0));
- expon(exponent_width-1) := not expon(exponent_width-1);
- expon := expon + 1;
- result := to_integer (expon);
- end case classcase;
- return result;
- end function Logb;
-
- -- returns the unbiased exponent of x
- function Logb (
- x : UNRESOLVED_float) -- floating point input
- return SIGNED is
- constant exponent_width : NATURAL := x'high; -- length of FP output exponent
- variable result : SIGNED (exponent_width - 1 downto 0); -- result
- begin
- -- Just return the exponent.
- result := to_signed (Logb (x), exponent_width);
- return result;
- end function Logb;
-
- -- returns the next representable neighbor of x in the direction toward y
--- function Nextafter (
--- x, y : UNRESOLVED_float; -- floating point input
--- constant check_error : BOOLEAN := float_check_error; -- check for errors
--- constant denormalize : BOOLEAN := float_denormalize)
--- return UNRESOLVED_float is
--- constant fraction_width : NATURAL := -mine(x'low, x'low); -- length of FP output fraction
--- constant exponent_width : NATURAL := x'high; -- length of FP output exponent
--- function "=" (
--- l, r : UNRESOLVED_float) -- inputs
--- return BOOLEAN is
--- begin -- function "="
--- return eq (l => l,
--- r => r,
--- check_error => false);
--- end function "=";
--- function ">" (
--- l, r : UNRESOLVED_float) -- inputs
--- return BOOLEAN is
--- begin -- function ">"
--- return gt (l => l,
--- r => r,
--- check_error => false);
--- end function ">";
--- variable fract : UNSIGNED (fraction_width-1 downto 0);
--- variable expon : UNSIGNED (exponent_width-1 downto 0);
--- variable sign : STD_ULOGIC;
--- variable result : UNRESOLVED_float (exponent_width downto -fraction_width);
--- variable validfpx, validfpy : valid_fpstate; -- Valid FP state
--- begin -- fp_Nextafter
--- -- If Y > X, add one to the fraction, otherwise subtract.
--- validfpx := classfp (x, check_error);
--- validfpy := classfp (y, check_error);
--- if validfpx = isx or validfpy = isx then
--- result := (others => 'X');
--- return result;
--- elsif (validfpx = nan or validfpy = nan) then
--- return nanfp (fraction_width => fraction_width,
--- exponent_width => exponent_width);
--- elsif (validfpx = quiet_nan or validfpy = quiet_nan) then
--- return qnanfp (fraction_width => fraction_width,
--- exponent_width => exponent_width);
--- elsif x = y then -- Return X
--- return x;
--- else
--- fract := UNSIGNED (to_slv (x (-1 downto -fraction_width))); -- Fraction
--- expon := UNSIGNED (x (exponent_width - 1 downto 0)); -- exponent
--- sign := x(exponent_width); -- sign bit
--- if (y > x) then
--- -- Increase the number given
--- if validfpx = neg_inf then
--- -- return most negative number
--- expon := (others => '1');
--- expon (0) := '0';
--- fract := (others => '1');
--- elsif validfpx = pos_zero or validfpx = neg_zero then
--- -- return smallest denormal number
--- sign := '0';
--- expon := (others => '0');
--- fract := (others => '0');
--- fract(0) := '1';
--- elsif validfpx = pos_normal then
--- if and_reduce (fract) = '1' then -- fraction is all "1".
--- if and_reduce (expon (exponent_width-1 downto 1)) = '1'
--- and expon (0) = '0' then
--- -- Exponent is one away from infinity.
--- assert NO_WARNING
--- report "float_pkg:"
--- & "FP_NEXTAFTER: NextAfter overflow"
--- severity warning;
--- return pos_inffp (fraction_width => fraction_width,
--- exponent_width => exponent_width);
--- else
--- expon := expon + 1;
--- fract := (others => '0');
--- end if;
--- else
--- fract := fract + 1;
--- end if;
--- elsif validfpx = pos_denormal then
--- if and_reduce (fract) = '1' then -- fraction is all "1".
--- -- return smallest possible normal number
--- expon := (others => '0');
--- expon(0) := '1';
--- fract := (others => '0');
--- else
--- fract := fract + 1;
--- end if;
--- elsif validfpx = neg_normal then
--- if or_reduce (fract) = '0' then -- fraction is all "0".
--- if or_reduce (expon (exponent_width-1 downto 1)) = '0' and
--- expon (0) = '1' then -- Smallest exponent
--- -- return the largest negative denormal number
--- expon := (others => '0');
--- fract := (others => '1');
--- else
--- expon := expon - 1;
--- fract := (others => '1');
--- end if;
--- else
--- fract := fract - 1;
--- end if;
--- elsif validfpx = neg_denormal then
--- if or_reduce (fract(fract'high downto 1)) = '0'
--- and fract (0) = '1' then -- Smallest possible fraction
--- return zerofp (fraction_width => fraction_width,
--- exponent_width => exponent_width);
--- else
--- fract := fract - 1;
--- end if;
--- end if;
--- else
--- -- Decrease the number
--- if validfpx = pos_inf then
--- -- return most positive number
--- expon := (others => '1');
--- expon (0) := '0';
--- fract := (others => '1');
--- elsif validfpx = pos_zero
--- or classfp (x) = neg_zero then
--- -- return smallest negative denormal number
--- sign := '1';
--- expon := (others => '0');
--- fract := (others => '0');
--- fract(0) := '1';
--- elsif validfpx = neg_normal then
--- if and_reduce (fract) = '1' then -- fraction is all "1".
--- if and_reduce (expon (exponent_width-1 downto 1)) = '1'
--- and expon (0) = '0' then
--- -- Exponent is one away from infinity.
--- assert NO_WARNING
--- report "float_pkg:"
--- & "FP_NEXTAFTER: NextAfter overflow"
--- severity warning;
--- return neg_inffp (fraction_width => fraction_width,
--- exponent_width => exponent_width);
--- else
--- expon := expon + 1; -- Fraction overflow
--- fract := (others => '0');
--- end if;
--- else
--- fract := fract + 1;
--- end if;
--- elsif validfpx = neg_denormal then
--- if and_reduce (fract) = '1' then -- fraction is all "1".
--- -- return smallest possible normal number
--- expon := (others => '0');
--- expon(0) := '1';
--- fract := (others => '0');
--- else
--- fract := fract + 1;
--- end if;
--- elsif validfpx = pos_normal then
--- if or_reduce (fract) = '0' then -- fraction is all "0".
--- if or_reduce (expon (exponent_width-1 downto 1)) = '0' and
--- expon (0) = '1' then -- Smallest exponent
--- -- return the largest positive denormal number
--- expon := (others => '0');
--- fract := (others => '1');
--- else
--- expon := expon - 1;
--- fract := (others => '1');
--- end if;
--- else
--- fract := fract - 1;
--- end if;
--- elsif validfpx = pos_denormal then
--- if or_reduce (fract(fract'high downto 1)) = '0'
--- and fract (0) = '1' then -- Smallest possible fraction
--- return zerofp (fraction_width => fraction_width,
--- exponent_width => exponent_width);
--- else
--- fract := fract - 1;
--- end if;
--- end if;
--- end if;
--- result (-1 downto -fraction_width) := UNRESOLVED_float(fract);
--- result (exponent_width -1 downto 0) := UNRESOLVED_float(expon);
--- result (exponent_width) := sign;
--- return result;
--- end if;
--- end function Nextafter;
-
- -- Returns True if X is unordered with Y.
- function Unordered (
- x, y : UNRESOLVED_float) -- floating point input
- return BOOLEAN is
- variable lfptype, rfptype : valid_fpstate;
- begin
- lfptype := classfp (x);
- rfptype := classfp (y);
- if (lfptype = nan or lfptype = quiet_nan or
- rfptype = nan or rfptype = quiet_nan or
- lfptype = isx or rfptype = isx) then
- return true;
- else
- return false;
- end if;
- end function Unordered;
-
- function Finite (
- x : UNRESOLVED_float)
- return BOOLEAN is
- variable fp_state : valid_fpstate; -- fp state
- begin
- fp_state := Classfp (x);
- if (fp_state = pos_inf) or (fp_state = neg_inf) then
- return true;
- else
- return false;
- end if;
- end function Finite;
-
- function Isnan (
- x : UNRESOLVED_float)
- return BOOLEAN is
- variable fp_state : valid_fpstate; -- fp state
- begin
- fp_state := Classfp (x);
- if (fp_state = nan) or (fp_state = quiet_nan) then
- return true;
- else
- return false;
- end if;
- end function Isnan;
-
- -- Function to return constants.
- function zerofp (
- constant exponent_width : NATURAL := float_exponent_width; -- exponent
- constant fraction_width : NATURAL := float_fraction_width) -- fraction
- return UNRESOLVED_float is
- constant result : UNRESOLVED_float (exponent_width downto -fraction_width) :=
- (others => '0'); -- zero
- begin
- return result;
- end function zerofp;
-
- function nanfp (
- constant exponent_width : NATURAL := float_exponent_width; -- exponent
- constant fraction_width : NATURAL := float_fraction_width) -- fraction
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width) :=
- (others => '0'); -- zero
- begin
- result (exponent_width-1 downto 0) := (others => '1');
- -- Exponent all "1"
- result (-1) := '1'; -- MSB of Fraction "1"
- -- Note: From W. Khan "IEEE Standard 754 for Binary Floating Point"
- -- The difference between a signaling NAN and a quiet NAN is that
- -- the MSB of the Fraction is a "1" in a Signaling NAN, and is a
- -- "0" in a quiet NAN.
- return result;
- end function nanfp;
-
- function qnanfp (
- constant exponent_width : NATURAL := float_exponent_width; -- exponent
- constant fraction_width : NATURAL := float_fraction_width) -- fraction
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width) :=
- (others => '0'); -- zero
- begin
- result (exponent_width-1 downto 0) := (others => '1');
- -- Exponent all "1"
- result (-fraction_width) := '1'; -- LSB of Fraction "1"
- -- (Could have been any bit)
- return result;
- end function qnanfp;
-
- function pos_inffp (
- constant exponent_width : NATURAL := float_exponent_width; -- exponent
- constant fraction_width : NATURAL := float_fraction_width) -- fraction
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width) :=
- (others => '0'); -- zero
- begin
- result (exponent_width-1 downto 0) := (others => '1'); -- Exponent all "1"
- return result;
- end function pos_inffp;
-
- function neg_inffp (
- constant exponent_width : NATURAL := float_exponent_width; -- exponent
- constant fraction_width : NATURAL := float_fraction_width) -- fraction
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width) :=
- (others => '0'); -- zero
- begin
- result (exponent_width downto 0) := (others => '1'); -- top bits all "1"
- return result;
- end function neg_inffp;
-
- function neg_zerofp (
- constant exponent_width : NATURAL := float_exponent_width; -- exponent
- constant fraction_width : NATURAL := float_fraction_width) -- fraction
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width) :=
- (others => '0'); -- zero
- begin
- result (exponent_width) := '1';
- return result;
- end function neg_zerofp;
-
- -- size_res versions
- function zerofp (
- size_res : UNRESOLVED_float) -- variable is only use for sizing
- return UNRESOLVED_float is
- begin
- return zerofp (
- exponent_width => size_res'high,
- fraction_width => -size_res'low);
- end function zerofp;
-
- function nanfp (
- size_res : UNRESOLVED_float) -- variable is only use for sizing
- return UNRESOLVED_float is
- begin
- return nanfp (
- exponent_width => size_res'high,
- fraction_width => -size_res'low);
- end function nanfp;
-
- function qnanfp (
- size_res : UNRESOLVED_float) -- variable is only use for sizing
- return UNRESOLVED_float is
- begin
- return qnanfp (
- exponent_width => size_res'high,
- fraction_width => -size_res'low);
- end function qnanfp;
-
- function pos_inffp (
- size_res : UNRESOLVED_float) -- variable is only use for sizing
- return UNRESOLVED_float is
- begin
- return pos_inffp (
- exponent_width => size_res'high,
- fraction_width => -size_res'low);
- end function pos_inffp;
-
- function neg_inffp (
- size_res : UNRESOLVED_float) -- variable is only use for sizing
- return UNRESOLVED_float is
- begin
- return neg_inffp (
- exponent_width => size_res'high,
- fraction_width => -size_res'low);
- end function neg_inffp;
-
- function neg_zerofp (
- size_res : UNRESOLVED_float) -- variable is only use for sizing
- return UNRESOLVED_float is
- begin
- return neg_zerofp (
- exponent_width => size_res'high,
- fraction_width => -size_res'low);
- end function neg_zerofp;
-
--- rtl_synthesis off
--- pragma synthesis_off
-
- --%%% these functions are copied from std_logic_1164 (VHDL-200X edition)
- -- Textio functions
- -- purpose: writes float into a line (NOTE changed basetype)
- 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 NBSP : CHARACTER := CHARACTER'val(160); -- space character
- 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 NUS : STRING(2 to 1) := (others => ' ');
-
- -- 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;
-
--- %%% Replicated textio functions
- function to_ostring (value : STD_LOGIC_VECTOR) return STRING is
- constant ne : INTEGER := (value'length+2)/3;
- variable pad : STD_LOGIC_VECTOR(0 to (ne*3 - value'length) - 1);
- variable ivalue : STD_LOGIC_VECTOR(0 to ne*3 - 1);
- variable result : STRING(1 to ne);
- variable tri : STD_LOGIC_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_LOGIC_VECTOR) return STRING is
- constant ne : INTEGER := (value'length+3)/4;
- variable pad : STD_LOGIC_VECTOR(0 to (ne*4 - value'length) - 1);
- variable ivalue : STD_LOGIC_VECTOR(0 to ne*4 - 1);
- variable result : STRING(1 to ne);
- variable quad : STD_LOGIC_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;
- procedure Char2TriBits (C : CHARACTER;
- RESULT : out STD_LOGIC_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 "float_pkg:"
- & "OREAD Error: Read a '" & c &
- "', expected an Octal character (0-7)."
- severity error;
- result := "UUU";
- good := false;
- end case;
- end procedure Char2TriBits;
-
- procedure OREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR;
- GOOD : out BOOLEAN) is
- variable ok : BOOLEAN;
- variable c : CHARACTER;
- constant ne : INTEGER := (VALUE'length+2)/3;
- constant pad : INTEGER := ne*3 - VALUE'length;
- variable sv : STD_LOGIC_VECTOR(0 to ne*3 - 1);
- variable i : INTEGER;
- variable lastu : BOOLEAN := false; -- last character was an "_"
- begin
- VALUE := (VALUE'range => 'U'); -- initialize to a "U"
- Skip_whitespace (L);
- if VALUE'length > 0 then
- read (l, c, ok);
- i := 0;
- while i < ne loop
- -- Bail out if there was a bad read
- if not ok then
- good := false;
- return;
- elsif c = '_' then
- if i = 0 then
- good := false; -- Begins with an "_"
- return;
- elsif lastu then
- good := false; -- "__" detected
- return;
- else
- lastu := true;
- end if;
- else
- Char2TriBits(c, sv(3*i to 3*i+2), ok, false);
- if not ok then
- good := false;
- return;
- end if;
- i := i + 1;
- lastu := false;
- end if;
- if i < ne then
- read(L, c, ok);
- end if;
- end loop;
- if or_reduce (sv (0 to pad-1)) = '1' then -- %%% replace with "or"
- good := false; -- vector was truncated.
- else
- good := true;
- VALUE := sv (pad to sv'high);
- end if;
- else
- good := true; -- read into a null array
- end if;
- end procedure OREAD;
-
- -- Hex Read and Write procedures for STD_ULOGIC_VECTOR.
- -- Modified from the original to be more forgiving.
-
- procedure Char2QuadBits (C : CHARACTER;
- RESULT : out STD_LOGIC_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 "float_pkg:"
- & "HREAD Error: Read a '" & c &
- "', expected a Hex character (0-F)."
- severity error;
- result := "UUUU";
- good := false;
- end case;
- end procedure Char2QuadBits;
-
- procedure HREAD (L : inout LINE; VALUE : out STD_LOGIC_VECTOR;
- GOOD : out BOOLEAN) is
- variable ok : BOOLEAN;
- variable c : CHARACTER;
- constant ne : INTEGER := (VALUE'length+3)/4;
- constant pad : INTEGER := ne*4 - VALUE'length;
- variable sv : STD_LOGIC_VECTOR(0 to ne*4 - 1);
- variable i : INTEGER;
- variable lastu : BOOLEAN := false; -- last character was an "_"
- begin
- VALUE := (VALUE'range => 'U'); -- initialize to a "U"
- Skip_whitespace (L);
- if VALUE'length > 0 then
- read (l, c, ok);
- i := 0;
- while i < ne loop
- -- Bail out if there was a bad read
- if not ok then
- good := false;
- return;
- elsif c = '_' then
- if i = 0 then
- good := false; -- Begins with an "_"
- return;
- elsif lastu then
- good := false; -- "__" detected
- return;
- else
- lastu := true;
- end if;
- else
- Char2QuadBits(c, sv(4*i to 4*i+3), ok, false);
- if not ok then
- good := false;
- return;
- end if;
- i := i + 1;
- lastu := false;
- end if;
- if i < ne then
- read(L, c, ok);
- end if;
- end loop;
- if or_reduce (sv (0 to pad-1)) = '1' then -- %%% replace with "or"
- good := false; -- vector was truncated.
- else
- good := true;
- VALUE := sv (pad to sv'high);
- end if;
- else
- good := true; -- Null input string, skips whitespace
- end if;
- end procedure HREAD;
-
--- %%% END replicated textio functions
-
- -- purpose: Checks the punctuation in a line
- procedure check_punctuation (
- arg : in STRING;
- colon : out BOOLEAN; -- There was a colon in the line
- dot : out BOOLEAN; -- There was a dot in the line
- good : out BOOLEAN; -- True if enough characters found
- chars : in INTEGER) is
- -- Examples. Legal inputs are "0000000", "0000.000", "0:000:000"
- alias xarg : STRING (1 to arg'length) is arg; -- make it downto range
- variable icolon, idot : BOOLEAN; -- internal
- variable j : INTEGER := 0; -- charters read
- begin
- good := false;
- icolon := false;
- idot := false;
- for i in 1 to arg'length loop
- if xarg(i) = ' ' or xarg(i) = NBSP or xarg(i) = HT or j = chars then
- exit;
- elsif xarg(i) = ':' then
- icolon := true;
- elsif xarg(i) = '.' then
- idot := true;
- elsif xarg (i) /= '_' then
- j := j + 1;
- end if;
- end loop;
- if j = chars then
- good := true; -- There are enough charactes to read
- end if;
- colon := icolon;
- if idot and icolon then
- dot := false;
- else
- dot := idot;
- end if;
- end procedure check_punctuation;
-
- -- purpose: Searches a line for a ":" and replaces it with a ".".
- procedure fix_colon (
- arg : inout STRING;
- chars : in integer) is
- alias xarg : STRING (1 to arg'length) is arg; -- make it downto range
- variable j : INTEGER := 0; -- charters read
- begin
- for i in 1 to arg'length loop
- if xarg(i) = ' ' or xarg(i) = NBSP or xarg(i) = HT or j > chars then
- exit;
- elsif xarg(i) = ':' then
- xarg (i) := '.';
- elsif xarg (i) /= '_' then
- j := j + 1;
- end if;
- end loop;
- end procedure fix_colon;
-
- procedure WRITE (
- L : inout LINE; -- input line
- VALUE : in UNRESOLVED_float; -- floating point input
- JUSTIFIED : in SIDE := right;
- FIELD : in WIDTH := 0) is
- variable s : STRING(1 to value'high - value'low +3);
- variable sindx : INTEGER;
- begin -- function write
- s(1) := MVL9_to_char(STD_ULOGIC(VALUE(VALUE'high)));
- s(2) := ':';
- sindx := 3;
- for i in VALUE'high-1 downto 0 loop
- s(sindx) := MVL9_to_char(STD_ULOGIC(VALUE(i)));
- sindx := sindx + 1;
- end loop;
- s(sindx) := ':';
- sindx := sindx + 1;
- for i in -1 downto VALUE'low loop
- 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_float) is
- -- Possible data: 0:0000:0000000
- -- 000000000000
- variable c : CHARACTER;
- variable mv : UNRESOLVED_float (VALUE'range);
- variable readOk : BOOLEAN;
- variable lastu : BOOLEAN := false; -- last character was an "_"
- variable i : INTEGER; -- index variable
- begin -- READ
- VALUE := (VALUE'range => 'U'); -- initialize to a "U"
- Skip_whitespace (L);
- READ (l, c, readOk);
- if VALUE'length > 0 then
- i := value'high;
- readloop : loop
- if readOk = false then -- Bail out if there was a bad read
- report "float_pkg:"
- & "READ(float): "
- & "Error end of file encountered."
- severity error;
- return;
- elsif c = ' ' or c = CR or c = HT then -- reading done.
- if (i /= value'low) then
- report "float_pkg:"
- & "READ(float): "
- & "Warning: Value truncated."
- severity warning;
- return;
- end if;
- elsif c = '_' then
- if i = value'high then -- Begins with an "_"
- report "float_pkg:"
- & "READ(float): "
- & "String begins with an ""_""" severity error;
- return;
- elsif lastu then -- "__" detected
- report "float_pkg:"
- & "READ(float): "
- & "Two underscores detected in input string ""__"""
- severity error;
- return;
- else
- lastu := true;
- end if;
- elsif c = ':' or c = '.' then -- separator, ignore
- if not (i = -1 or i = value'high-1) then
- report "float_pkg:"
- & "READ(float): "
- & "Warning: Separator point does not match number format: '"
- & c & "' encountered at location " & INTEGER'image(i) & "."
- severity warning;
- end if;
- lastu := false;
- elsif (char_to_MVL9plus(c) = error) then
- report "float_pkg:"
- & "READ(float): "
- & "Error: Character '" & c & "' read, expected STD_ULOGIC literal."
- severity error;
- return;
- else
- mv (i) := char_to_MVL9(c);
- i := i - 1;
- if i < value'low then
- VALUE := mv;
- return;
- end if;
- lastu := false;
- end if;
- READ (l, c, readOk);
- end loop readloop;
- end if;
- end procedure READ;
-
- procedure READ (L : inout LINE; VALUE : out UNRESOLVED_float; GOOD : out BOOLEAN) is
- -- Possible data: 0:0000:0000000
- -- 000000000000
- variable c : CHARACTER;
- variable mv : UNRESOLVED_float (VALUE'range);
- variable lastu : BOOLEAN := false; -- last character was an "_"
- variable i : INTEGER; -- index variable
- variable readOk : BOOLEAN;
- begin -- READ
- VALUE := (VALUE'range => 'U'); -- initialize to a "U"
- Skip_whitespace (L);
- READ (l, c, readOk);
- if VALUE'length > 0 then
- i := value'high;
- good := false;
- readloop : loop
- if readOk = false then -- Bail out if there was a bad read
- return;
- elsif c = ' ' or c = CR or c = HT then -- reading done
- return;
- elsif c = '_' then
- if i = 0 then -- Begins with an "_"
- return;
- elsif lastu then -- "__" detected
- return;
- else
- lastu := true;
- end if;
- elsif c = ':' or c = '.' then -- separator, ignore
- -- good := (i = -1 or i = value'high-1);
- lastu := false;
- elsif (char_to_MVL9plus(c) = error) then
- return;
- else
- mv (i) := char_to_MVL9(c);
- i := i - 1;
- if i < value'low then
- good := true;
- VALUE := mv;
- return;
- end if;
- lastu := false;
- end if;
- READ (l, c, readOk);
- end loop readloop;
- else
- good := true; -- read into a null array
- end if;
- end procedure READ;
-
- procedure OWRITE (
- L : inout LINE; -- access type (pointer)
- VALUE : in UNRESOLVED_float; -- value to write
- JUSTIFIED : in SIDE := right; -- which side to justify text
- FIELD : in WIDTH := 0) is -- width of field
- begin
- WRITE (L => L,
- VALUE => to_ostring(VALUE),
- JUSTIFIED => JUSTIFIED,
- FIELD => FIELD);
- end procedure OWRITE;
-
- procedure OREAD (L : inout LINE; VALUE : out UNRESOLVED_float) is
- constant ne : INTEGER := ((value'length+2)/3) * 3; -- pad
- variable slv : STD_LOGIC_VECTOR (ne-1 downto 0); -- slv
- variable slvu : ufixed (VALUE'range); -- Unsigned fixed point
- variable c : CHARACTER;
- variable ok : BOOLEAN;
- variable nybble : STD_LOGIC_VECTOR (2 downto 0); -- 3 bits
- variable colon, dot : BOOLEAN;
- begin
- VALUE := (VALUE'range => 'U'); -- initialize to a "U"
- Skip_whitespace (L);
- if VALUE'length > 0 then
- check_punctuation (arg => L.all,
- colon => colon,
- dot => dot,
- good => ok,
- chars => ne/3);
- if not ok then
- report "float_pkg:" & "OREAD: "
- & "short string encounted: " & L.all
- & " needs to have " & integer'image (ne/3)
- & " valid octal characters."
- severity error;
- return;
- elsif dot then
- OREAD (L, slvu, ok); -- read it like a UFIXED number
- if not ok then
- report "float_pkg:" & "OREAD: "
- & "error encounted reading STRING " & L.all
- severity error;
- return;
- else
- VALUE := UNRESOLVED_float (slvu);
- end if;
- elsif colon then
- OREAD (L, nybble, ok); -- read the sign bit
- if not ok then
- report "float_pkg:" & "OREAD: "
- & "End of string encountered"
- severity error;
- return;
- elsif nybble (2 downto 1) /= "00" then
- report "float_pkg:" & "OREAD: "
- & "Illegal sign bit STRING encounted "
- severity error;
- return;
- end if;
- read (l, c, ok); -- read the colon
- fix_colon (L.all, ne/3); -- replaces the colon with a ".".
- OREAD (L, slvu (slvu'high-1 downto slvu'low), ok); -- read it like a UFIXED number
- if not ok then
- report "float_pkg:" & "OREAD: "
- & "error encounted reading STRING " & L.all
- severity error;
- return;
- else
- slvu (slvu'high) := nybble (0);
- VALUE := UNRESOLVED_float (slvu);
- end if;
- else
- OREAD (L, slv, ok);
- if not ok then
- report "float_pkg:" & "OREAD: "
- & "Error encounted during read"
- severity error;
- return;
- end if;
- if (or_reduce (slv(ne-1 downto VALUE'high-VALUE'low+1)) = '1') then
- report "float_pkg:" & "OREAD: "
- & "Vector truncated."
- severity error;
- return;
- end if;
- VALUE := to_float (slv(VALUE'high-VALUE'low downto 0),
- VALUE'high, -VALUE'low);
- end if;
- end if;
- end procedure OREAD;
-
- procedure OREAD(L : inout LINE; VALUE : out UNRESOLVED_float; GOOD : out BOOLEAN) is
- constant ne : INTEGER := ((value'length+2)/3) * 3; -- pad
- variable slv : STD_LOGIC_VECTOR (ne-1 downto 0); -- slv
- variable slvu : ufixed (VALUE'range); -- Unsigned fixed point
- variable c : CHARACTER;
- variable ok : BOOLEAN;
- variable nybble : STD_LOGIC_VECTOR (2 downto 0); -- 3 bits
- variable colon, dot : BOOLEAN;
- begin
- VALUE := (VALUE'range => 'U'); -- initialize to a "U"
- GOOD := false;
- Skip_whitespace (L);
- if VALUE'length > 0 then
- check_punctuation (arg => L.all,
- colon => colon,
- dot => dot,
- good => ok,
- chars => ne/3);
- if not ok then
- return;
- elsif dot then
- OREAD (L, slvu, ok); -- read it like a UFIXED number
- if not ok then
- return;
- else
- VALUE := UNRESOLVED_float (slvu);
- end if;
- elsif colon then
- OREAD (L, nybble, ok); -- read the sign bit
- if not ok then
- return;
- elsif nybble (2 downto 1) /= "00" then
- return;
- end if;
- read (l, c, ok); -- read the colon
- fix_colon (L.all, ne/3); -- replaces the colon with a ".".
- OREAD (L, slvu (slvu'high-1 downto slvu'low), ok); -- read it like a UFIXED number
- if not ok then
- return;
- else
- slvu (slvu'high) := nybble (0);
- VALUE := UNRESOLVED_float (slvu);
- end if;
- else
- OREAD (L, slv, ok);
- if not ok then
- return;
- end if;
- if (or_reduce (slv(ne-1 downto VALUE'high-VALUE'low+1)) = '1') then
- return;
- end if;
- VALUE := to_float (slv(VALUE'high-VALUE'low downto 0),
- VALUE'high, -VALUE'low);
- end if;
- GOOD := true;
- end if;
- end procedure OREAD;
-
- procedure HWRITE (
- L : inout LINE; -- access type (pointer)
- VALUE : in UNRESOLVED_float; -- value to write
- JUSTIFIED : in SIDE := right; -- which side to justify text
- FIELD : in WIDTH := 0) is -- width of field
- begin
- WRITE (L => L,
- VALUE => to_hstring(VALUE),
- JUSTIFIED => JUSTIFIED,
- FIELD => FIELD);
- end procedure HWRITE;
-
- procedure HREAD (L : inout LINE; VALUE : out UNRESOLVED_float) is
- constant ne : INTEGER := ((value'length+3)/4) * 4; -- pad
- variable slv : STD_LOGIC_VECTOR (ne-1 downto 0); -- slv
- variable slvu : ufixed (VALUE'range); -- Unsigned fixed point
- variable c : CHARACTER;
- variable ok : BOOLEAN;
- variable nybble : STD_LOGIC_VECTOR (3 downto 0); -- 4 bits
- variable colon, dot : BOOLEAN;
- begin
- VALUE := (VALUE'range => 'U'); -- initialize to a "U"
- Skip_whitespace (L);
- if VALUE'length > 0 then
- check_punctuation (arg => L.all,
- colon => colon,
- dot => dot,
- good => ok,
- chars => ne/4);
- if not ok then
- report "float_pkg:" & "HREAD: "
- & "short string encounted: " & L.all
- & " needs to have " & integer'image (ne/4)
- & " valid hex characters."
- severity error;
- return;
- elsif dot then
- HREAD (L, slvu, ok); -- read it like a UFIXED number
- if not ok then
- report "float_pkg:" & "HREAD: "
- & "error encounted reading STRING " & L.all
- severity error;
- return;
- else
- VALUE := UNRESOLVED_float (slvu);
- end if;
- elsif colon then
- HREAD (L, nybble, ok); -- read the sign bit
- if not ok then
- report "float_pkg:" & "HREAD: "
- & "End of string encountered"
- severity error;
- return;
- elsif nybble (3 downto 1) /= "000" then
- report "float_pkg:" & "HREAD: "
- & "Illegal sign bit STRING encounted "
- severity error;
- return;
- end if;
- read (l, c, ok); -- read the colon
- fix_colon (L.all, ne/4); -- replaces the colon with a ".".
- HREAD (L, slvu (slvu'high-1 downto slvu'low), ok); -- read it like a UFIXED number
- if not ok then
- report "float_pkg:" & "HREAD: "
- & "error encounted reading STRING " & L.all
- severity error;
- return;
- else
- slvu (slvu'high) := nybble (0);
- VALUE := UNRESOLVED_float (slvu);
- end if;
- else
- HREAD (L, slv, ok);
- if not ok then
- report "float_pkg:" & "HREAD: "
- & "Error encounted during read"
- severity error;
- return;
- end if;
- if (or_reduce (slv(ne-1 downto VALUE'high-VALUE'low+1)) = '1') then
- report "float_pkg:" & "HREAD: "
- & "Vector truncated."
- severity error;
- return;
- end if;
- VALUE := to_float (slv(VALUE'high-VALUE'low downto 0),
- VALUE'high, -VALUE'low);
- end if;
- end if;
- end procedure HREAD;
-
- procedure HREAD (L : inout LINE; VALUE : out UNRESOLVED_float; GOOD : out BOOLEAN) is
- constant ne : INTEGER := ((value'length+3)/4) * 4; -- pad
- variable slv : STD_LOGIC_VECTOR (ne-1 downto 0); -- slv
- variable slvu : ufixed (VALUE'range); -- Unsigned fixed point
- variable c : CHARACTER;
- variable ok : BOOLEAN;
- variable nybble : STD_LOGIC_VECTOR (3 downto 0); -- 4 bits
- variable colon, dot : BOOLEAN;
- begin
- VALUE := (VALUE'range => 'U'); -- initialize to a "U"
- GOOD := false;
- Skip_whitespace (L);
- if VALUE'length > 0 then
- check_punctuation (arg => L.all,
- colon => colon,
- dot => dot,
- good => ok,
- chars => ne/4);
- if not ok then
- return;
- elsif dot then
- HREAD (L, slvu, ok); -- read it like a UFIXED number
- if not ok then
- return;
- else
- VALUE := UNRESOLVED_float (slvu);
- end if;
- elsif colon then
- HREAD (L, nybble, ok); -- read the sign bit
- if not ok then
- return;
- elsif nybble (3 downto 1) /= "000" then
- return;
- end if;
- read (l, c, ok); -- read the colon
- fix_colon (L.all, ne/4); -- replaces the colon with a ".".
- HREAD (L, slvu (slvu'high-1 downto slvu'low), ok); -- read it like a UFIXED number
- if not ok then
- return;
- else
- slvu (slvu'high) := nybble (0);
- VALUE := UNRESOLVED_float (slvu);
- end if;
- else
- HREAD (L, slv, ok);
- if not ok then
- return;
- end if;
- if (or_reduce (slv(ne-1 downto VALUE'high-VALUE'low+1)) = '1') then
- return;
- end if;
- VALUE := to_float (slv(VALUE'high-VALUE'low downto 0),
- VALUE'high, -VALUE'low);
- end if;
- GOOD := true;
- end if;
- end procedure HREAD;
-
- function to_string (value : UNRESOLVED_float) return STRING is
- variable s : STRING(1 to value'high - value'low +3);
- variable sindx : INTEGER;
- begin -- function write
- s(1) := MVL9_to_char(STD_ULOGIC(VALUE(VALUE'high)));
- s(2) := ':';
- sindx := 3;
- for i in VALUE'high-1 downto 0 loop
- s(sindx) := MVL9_to_char(STD_ULOGIC(VALUE(i)));
- sindx := sindx + 1;
- end loop;
- s(sindx) := ':';
- sindx := sindx + 1;
- for i in -1 downto VALUE'low loop
- s(sindx) := MVL9_to_char(STD_ULOGIC(VALUE(i)));
- sindx := sindx + 1;
- end loop;
- return s;
- end function to_string;
-
- function to_hstring (value : UNRESOLVED_float) return STRING is
- variable slv : STD_LOGIC_VECTOR (value'length-1 downto 0);
- begin
- floop : for i in slv'range loop
- slv(i) := to_X01Z (value(i + value'low));
- end loop floop;
- return to_hstring (slv);
- end function to_hstring;
-
- function to_ostring (value : UNRESOLVED_float) return STRING is
- variable slv : STD_LOGIC_VECTOR (value'length-1 downto 0);
- begin
- floop : for i in slv'range loop
- slv(i) := to_X01Z (value(i + value'low));
- end loop floop;
- return to_ostring (slv);
- end function to_ostring;
-
- function from_string (
- bstring : STRING; -- binary string
- constant exponent_width : NATURAL := float_exponent_width;
- constant fraction_width : NATURAL := float_fraction_width)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable L : LINE;
- variable good : BOOLEAN;
- begin
- L := new STRING'(bstring);
- READ (L, result, good);
- deallocate (L);
- assert (good)
- report "float_pkg:"
- & "from_string: Bad string " & bstring
- severity error;
- return result;
- end function from_string;
-
- function from_ostring (
- ostring : STRING; -- Octal string
- constant exponent_width : NATURAL := float_exponent_width;
- constant fraction_width : NATURAL := float_fraction_width)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable L : LINE;
- variable good : BOOLEAN;
- begin
- L := new STRING'(ostring);
- OREAD (L, result, good);
- deallocate (L);
- assert (good)
- report "float_pkg:"
- & "from_ostring: Bad string " & ostring
- severity error;
- return result;
- end function from_ostring;
-
- function from_hstring (
- hstring : STRING; -- hex string
- constant exponent_width : NATURAL := float_exponent_width;
- constant fraction_width : NATURAL := float_fraction_width)
- return UNRESOLVED_float is
- variable result : UNRESOLVED_float (exponent_width downto -fraction_width);
- variable L : LINE;
- variable good : BOOLEAN;
- begin
- L := new STRING'(hstring);
- HREAD (L, result, good);
- deallocate (L);
- assert (good)
- report "float_pkg:"
- & "from_hstring: Bad string " & hstring
- severity error;
- return result;
- end function from_hstring;
-
- function from_string (
- bstring : STRING; -- binary string
- size_res : UNRESOLVED_float) -- used for sizing only
- return UNRESOLVED_float is
- begin
- return from_string (bstring => bstring,
- exponent_width => size_res'high,
- fraction_width => -size_res'low);
- end function from_string;
-
- function from_ostring (
- ostring : STRING; -- Octal string
- size_res : UNRESOLVED_float) -- used for sizing only
- return UNRESOLVED_float is
- begin
- return from_ostring (ostring => ostring,
- exponent_width => size_res'high,
- fraction_width => -size_res'low);
- end function from_ostring;
-
- function from_hstring (
- hstring : STRING; -- hex string
- size_res : UNRESOLVED_float) -- used for sizing only
- return UNRESOLVED_float is
- begin
- return from_hstring (hstring => hstring,
- exponent_width => size_res'high,
- fraction_width => -size_res'low);
- end function from_hstring;
--- rtl_synthesis on
--- pragma synthesis_on
- function to_float (
- arg : STD_LOGIC_VECTOR;
- constant exponent_width : NATURAL := float_exponent_width; -- length of FP output exponent
- constant fraction_width : NATURAL := float_fraction_width) -- length of FP output fraction
- return UNRESOLVED_float is
- begin
- return to_float (
- arg => std_ulogic_vector (arg),
- exponent_width => exponent_width,
- fraction_width => fraction_width);
- end function to_float;
-
- function to_float (
- arg : STD_LOGIC_VECTOR;
- size_res : UNRESOLVED_float)
- return UNRESOLVED_float is
- begin
- return to_float (
- arg => std_ulogic_vector (arg),
- size_res => size_res);
- end function to_float;
-
- -- For Verilog compatability
- function realtobits (arg : REAL) return STD_LOGIC_VECTOR is
- variable result : float64; -- 64 bit floating point
- begin
- result := to_float (arg => arg,
- exponent_width => float64'high,
- fraction_width => -float64'low);
- return to_slv (result);
- end function realtobits;
-
- function bitstoreal (arg : STD_LOGIC_VECTOR) return REAL is
- variable arg64 : float64; -- arg converted to float
- begin
- arg64 := to_float (arg => arg,
- exponent_width => float64'high,
- fraction_width => -float64'low);
- return to_real (arg64);
- end function bitstoreal;
-
-end package body float_pkg;
diff --git a/ieee_proposed/rtl/numeric_std_additions.vhd b/ieee_proposed/rtl/numeric_std_additions.vhd
deleted file mode 100644
index 4440d27..0000000
--- a/ieee_proposed/rtl/numeric_std_additions.vhd
+++ /dev/null
@@ -1,2886 +0,0 @@
-------------------------------------------------------------------------------
--- "numeric_std_additions" package contains the additions to the standard
--- "numeric_std" package proposed by the VHDL-200X-ft working group.
--- 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.numeric_std_additions.all;
--- (this package is independant of "std_logic_1164_additions")
--- Last Modified: $Date: 2007/09/27 14:46:32 $
--- RCS ID: $Id: numeric_std_additions.vhdl,v 1.9 2007/09/27 14:46:32 l435385 Exp $
---
--- Created for VHDL-200X par, David Bishop (dbishop@vhdl.org)
-------------------------------------------------------------------------------
-library ieee;
-use ieee.std_logic_1164.all;
-use ieee.numeric_std.all;
-use std.textio.all;
-
-package numeric_std_additions is
- -- Make these a subtype of "signed" and "unsigned" for compatability
--- type UNRESOLVED_UNSIGNED is array (NATURAL range <>) of STD_ULOGIC;
--- type UNRESOLVED_SIGNED is array (NATURAL range <>) of STD_ULOGIC;
-
- subtype UNRESOLVED_UNSIGNED is UNSIGNED;
- subtype UNRESOLVED_SIGNED is SIGNED;
--- alias U_UNSIGNED is UNRESOLVED_UNSIGNED;
--- alias U_SIGNED is UNRESOLVED_SIGNED;
- subtype U_UNSIGNED is UNSIGNED;
- subtype U_SIGNED is SIGNED;
-
- -- Id: A.3R
- function "+"(L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED;
- -- Result subtype: UNSIGNED(L'RANGE)
- -- Result: Similar to A.3 where R is a one bit UNSIGNED
-
- -- Id: A.3L
- function "+"(L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED;
- -- Result subtype: UNSIGNED(R'RANGE)
- -- Result: Similar to A.3 where L is a one bit UNSIGNED
-
- -- Id: A.4R
- function "+"(L : SIGNED; R : STD_ULOGIC) return SIGNED;
- -- Result subtype: SIGNED(L'RANGE)
- -- Result: Similar to A.4 where R is bit 0 of a non-negative
- -- SIGNED
-
- -- Id: A.4L
- function "+"(L : STD_ULOGIC; R : SIGNED) return SIGNED;
- -- Result subtype: UNSIGNED(R'RANGE)
- -- Result: Similar to A.4 where L is bit 0 of a non-negative
- -- SIGNED
- -- Id: A.9R
- function "-"(L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED;
- -- Result subtype: UNSIGNED(L'RANGE)
- -- Result: Similar to A.9 where R is a one bit UNSIGNED
-
- -- Id: A.9L
- function "-"(L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED;
- -- Result subtype: UNSIGNED(R'RANGE)
- -- Result: Similar to A.9 where L is a one bit UNSIGNED
-
- -- Id: A.10R
- function "-"(L : SIGNED; R : STD_ULOGIC) return SIGNED;
- -- Result subtype: SIGNED(L'RANGE)
- -- Result: Similar to A.10 where R is bit 0 of a non-negative
- -- SIGNED
-
- -- Id: A.10L
- function "-"(L : STD_ULOGIC; R : SIGNED) return SIGNED;
- -- Result subtype: UNSIGNED(R'RANGE)
- -- Result: Similar to A.10 where R is bit 0 of a non-negative
- -- SIGNED
-
- -- Id: M.2B
- -- %%% function "?=" (L, R : UNSIGNED) return std_ulogic;
- -- %%% function "?/=" (L, R : UNSIGNED) return std_ulogic;
- -- %%% function "?>" (L, R : UNSIGNED) return std_ulogic;
- -- %%% function "?>=" (L, R : UNSIGNED) return std_ulogic;
- -- %%% function "?<" (L, R : UNSIGNED) return std_ulogic;
- -- %%% function "?<=" (L, R : UNSIGNED) return std_ulogic;
--- function \?=\ (L, R : UNSIGNED) return STD_ULOGIC;
--- function \?/=\ (L, R : UNSIGNED) return STD_ULOGIC;
- function \?>\ (L, R : UNSIGNED) return STD_ULOGIC;
- function \?>=\ (L, R : UNSIGNED) return STD_ULOGIC;
- function \?<\ (L, R : UNSIGNED) return STD_ULOGIC;
- function \?<=\ (L, R : UNSIGNED) return STD_ULOGIC;
--- function \?=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC;
--- function \?/=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC;
- function \?>\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC;
- function \?>=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC;
- function \?<\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC;
- function \?<=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC;
--- function \?=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC;
--- function \?/=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC;
- function \?>\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC;
- function \?>=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC;
- function \?<\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC;
- function \?<=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC;
- -- Result subtype: STD_ULOGIC
- -- Result: terms compared per STD_LOGIC_1164 intent,
- -- returns an 'X' if a metavalue is passed
-
- -- Id: M.3B
- -- %%% function "?=" (L, R : SIGNED) return std_ulogic;
- -- %%% function "?/=" (L, R : SIGNED) return std_ulogic;
- -- %%% function "?>" (L, R : SIGNED) return std_ulogic;
- -- %%% function "?>=" (L, R : SIGNED) return std_ulogic;
- -- %%% function "?<" (L, R : SIGNED) return std_ulogic;
- -- %%% function "?<=" (L, R : SIGNED) return std_ulogic;
--- function \?=\ (L, R : SIGNED) return STD_ULOGIC;
--- function \?/=\ (L, R : SIGNED) return STD_ULOGIC;
- function \?>\ (L, R : SIGNED) return STD_ULOGIC;
- function \?>=\ (L, R : SIGNED) return STD_ULOGIC;
- function \?<\ (L, R : SIGNED) return STD_ULOGIC;
- function \?<=\ (L, R : SIGNED) return STD_ULOGIC;
--- function \?=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC;
--- function \?/=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC;
- function \?>\ (L : SIGNED; R : INTEGER) return STD_ULOGIC;
- function \?>=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC;
- function \?<\ (L : SIGNED; R : INTEGER) return STD_ULOGIC;
- function \?<=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC;
--- function \?=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC;
--- function \?/=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC;
- function \?>\ (L : INTEGER; R : SIGNED) return STD_ULOGIC;
- function \?>=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC;
- function \?<\ (L : INTEGER; R : SIGNED) return STD_ULOGIC;
- function \?<=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC;
- -- Result subtype: std_ulogic
- -- Result: terms compared per STD_LOGIC_1164 intent,
- -- returns an 'X' if a metavalue is passed
-
- -- size_res versions of these functions (Bugzilla 165)
- function TO_UNSIGNED (ARG : NATURAL; SIZE_RES : UNSIGNED) return UNSIGNED;
- -- Result subtype: UNRESOLVED_UNSIGNED(SIZE_RES'length-1 downto 0)
- function TO_SIGNED (ARG : INTEGER; SIZE_RES : SIGNED) return SIGNED;
- -- Result subtype: UNRESOLVED_SIGNED(SIZE_RES'length-1 downto 0)
- function RESIZE (ARG, SIZE_RES : UNSIGNED) return UNSIGNED;
- -- Result subtype: UNRESOLVED_UNSIGNED (SIZE_RES'length-1 downto 0)
- function RESIZE (ARG, SIZE_RES : SIGNED) return SIGNED;
- -- Result subtype: UNRESOLVED_SIGNED (SIZE_RES'length-1 downto 0)
- -----------------------------------------------------------------------------
- -- New/updated funcitons for VHDL-200X fast track
- -----------------------------------------------------------------------------
-
- -- Overloaded functions from "std_logic_1164"
- function To_X01 (s : UNSIGNED) return UNSIGNED;
- function To_X01 (s : SIGNED) return SIGNED;
-
- function To_X01Z (s : UNSIGNED) return UNSIGNED;
- function To_X01Z (s : SIGNED) return SIGNED;
-
- function To_UX01 (s : UNSIGNED) return UNSIGNED;
- function To_UX01 (s : SIGNED) return SIGNED;
-
- function Is_X (s : UNSIGNED) return BOOLEAN;
- function Is_X (s : SIGNED) return BOOLEAN;
-
- function "sla" (ARG : SIGNED; COUNT : INTEGER) return SIGNED;
- function "sla" (ARG : UNSIGNED; COUNT : INTEGER) return UNSIGNED;
-
- function "sra" (ARG : SIGNED; COUNT : INTEGER) return SIGNED;
- function "sra" (ARG : UNSIGNED; COUNT : INTEGER) return UNSIGNED;
-
- -- Returns the maximum (or minimum) of the two numbers provided.
- -- All types (both inputs and the output) must be the same.
- -- These override the implicit funcitons, using the local ">" operator
- function maximum (
- l, r : UNSIGNED) -- inputs
- return UNSIGNED;
-
- function maximum (
- l, r : SIGNED) -- inputs
- return SIGNED;
-
- function minimum (
- l, r : UNSIGNED) -- inputs
- return UNSIGNED;
-
- function minimum (
- l, r : SIGNED) -- inputs
- return SIGNED;
-
- function maximum (
- l : UNSIGNED; r : NATURAL) -- inputs
- return UNSIGNED;
-
- function maximum (
- l : SIGNED; r : INTEGER) -- inputs
- return SIGNED;
-
- function minimum (
- l : UNSIGNED; r : NATURAL) -- inputs
- return UNSIGNED;
-
- function minimum (
- l : SIGNED; r : INTEGER) -- inputs
- return SIGNED;
-
- function maximum (
- l : NATURAL; r : UNSIGNED) -- inputs
- return UNSIGNED;
-
- function maximum (
- l : INTEGER; r : SIGNED) -- inputs
- return SIGNED;
-
- function minimum (
- l : NATURAL; r : UNSIGNED) -- inputs
- return UNSIGNED;
-
- function minimum (
- l : INTEGER; r : SIGNED) -- inputs
- return SIGNED;
- -- Finds the first "Y" in the input string. Returns an integer index
- -- into that string. If "Y" does not exist in the string, then the
- -- "find_rightmost" returns arg'low -1, and "find_leftmost" returns -1
- function find_rightmost (
- arg : UNSIGNED; -- vector argument
- y : STD_ULOGIC) -- look for this bit
- return INTEGER;
-
- function find_rightmost (
- arg : SIGNED; -- vector argument
- y : STD_ULOGIC) -- look for this bit
- return INTEGER;
-
- function find_leftmost (
- arg : UNSIGNED; -- vector argument
- y : STD_ULOGIC) -- look for this bit
- return INTEGER;
-
- function find_leftmost (
- arg : SIGNED; -- vector argument
- y : STD_ULOGIC) -- look for this bit
- return INTEGER;
-
- function TO_UNRESOLVED_UNSIGNED (ARG, SIZE : NATURAL) return UNRESOLVED_UNSIGNED;
- -- Result subtype: UNRESOLVED_UNSIGNED(SIZE-1 downto 0)
- -- Result: Converts a nonnegative INTEGER to an UNRESOLVED_UNSIGNED vector with
- -- the specified SIZE.
-
- alias TO_U_UNSIGNED is
- TO_UNRESOLVED_UNSIGNED[NATURAL, NATURAL return UNRESOLVED_UNSIGNED];
-
- function TO_UNRESOLVED_SIGNED (ARG : INTEGER; SIZE : NATURAL) return UNRESOLVED_SIGNED;
- -- Result subtype: UNRESOLVED_SIGNED(SIZE-1 downto 0)
- -- Result: Converts an INTEGER to an UNRESOLVED_SIGNED vector of the specified SIZE.
-
- alias TO_U_SIGNED is
- TO_UNRESOLVED_SIGNED[NATURAL, NATURAL return UNRESOLVED_SIGNED];
-
- -- L.15
- function "and" (L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED;
-
--- L.16
- function "and" (L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED;
-
--- L.17
- function "or" (L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED;
-
--- L.18
- function "or" (L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED;
-
--- L.19
- function "nand" (L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED;
-
--- L.20
- function "nand" (L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED;
-
--- L.21
- function "nor" (L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED;
-
--- L.22
- function "nor" (L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED;
-
--- L.23
- function "xor" (L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED;
-
--- L.24
- function "xor" (L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED;
-
--- L.25
- function "xnor" (L : STD_ULOGIC; R : UNSIGNED) return UNSIGNED;
-
--- L.26
- function "xnor" (L : UNSIGNED; R : STD_ULOGIC) return UNSIGNED;
-
--- L.27
- function "and" (L : STD_ULOGIC; R : SIGNED) return SIGNED;
-
--- L.28
- function "and" (L : SIGNED; R : STD_ULOGIC) return SIGNED;
-
--- L.29
- function "or" (L : STD_ULOGIC; R : SIGNED) return SIGNED;
-
--- L.30
- function "or" (L : SIGNED; R : STD_ULOGIC) return SIGNED;
-
--- L.31
- function "nand" (L : STD_ULOGIC; R : SIGNED) return SIGNED;
-
--- L.32
- function "nand" (L : SIGNED; R : STD_ULOGIC) return SIGNED;
-
--- L.33
- function "nor" (L : STD_ULOGIC; R : SIGNED) return SIGNED;
-
--- L.34
- function "nor" (L : SIGNED; R : STD_ULOGIC) return SIGNED;
-
--- L.35
- function "xor" (L : STD_ULOGIC; R : SIGNED) return SIGNED;
-
--- L.36
- function "xor" (L : SIGNED; R : STD_ULOGIC) return SIGNED;
-
--- L.37
- function "xnor" (L : STD_ULOGIC; R : SIGNED) return SIGNED;
-
--- L.38
- function "xnor" (L : SIGNED; R : STD_ULOGIC) return SIGNED;
-
- -- %%% remove 12 functions (old syntax)
- function and_reduce(l : SIGNED) return STD_ULOGIC;
- -- Result subtype: STD_LOGIC.
- -- Result: Result of and'ing all of the bits of the vector.
-
- function nand_reduce(l : SIGNED) return STD_ULOGIC;
- -- Result subtype: STD_LOGIC.
- -- Result: Result of nand'ing all of the bits of the vector.
-
- function or_reduce(l : SIGNED) return STD_ULOGIC;
- -- Result subtype: STD_LOGIC.
- -- Result: Result of or'ing all of the bits of the vector.
-
- function nor_reduce(l : SIGNED) return STD_ULOGIC;
- -- Result subtype: STD_LOGIC.
- -- Result: Result of nor'ing all of the bits of the vector.
-
- function xor_reduce(l : SIGNED) return STD_ULOGIC;
- -- Result subtype: STD_LOGIC.
- -- Result: Result of xor'ing all of the bits of the vector.
-
- function xnor_reduce(l : SIGNED) return STD_ULOGIC;
- -- Result subtype: STD_LOGIC.
- -- Result: Result of xnor'ing all of the bits of the vector.
-
- function and_reduce(l : UNSIGNED) return STD_ULOGIC;
- -- Result subtype: STD_LOGIC.
- -- Result: Result of and'ing all of the bits of the vector.
-
- function nand_reduce(l : UNSIGNED) return STD_ULOGIC;
- -- Result subtype: STD_LOGIC.
- -- Result: Result of nand'ing all of the bits of the vector.
-
- function or_reduce(l : UNSIGNED) return STD_ULOGIC;
- -- Result subtype: STD_LOGIC.
- -- Result: Result of or'ing all of the bits of the vector.
-
- function nor_reduce(l : UNSIGNED) return STD_ULOGIC;
- -- Result subtype: STD_LOGIC.
- -- Result: Result of nor'ing all of the bits of the vector.
-
- function xor_reduce(l : UNSIGNED) return STD_ULOGIC;
- -- Result subtype: STD_LOGIC.
- -- Result: Result of xor'ing all of the bits of the vector.
-
- function xnor_reduce(l : UNSIGNED) return STD_ULOGIC;
- -- Result subtype: STD_LOGIC.
- -- Result: Result of xnor'ing all of the bits of the vector.
-
- -- %%% Uncomment the following 12 functions (new syntax)
- -- function "and" ( l : SIGNED ) RETURN std_ulogic;
- -- function "nand" ( l : SIGNED ) RETURN std_ulogic;
- -- function "or" ( l : SIGNED ) RETURN std_ulogic;
- -- function "nor" ( l : SIGNED ) RETURN std_ulogic;
- -- function "xor" ( l : SIGNED ) RETURN std_ulogic;
- -- function "xnor" ( l : SIGNED ) RETURN std_ulogic;
- -- function "and" ( l : UNSIGNED ) RETURN std_ulogic;
- -- function "nand" ( l : UNSIGNED ) RETURN std_ulogic;
- -- function "or" ( l : UNSIGNED ) RETURN std_ulogic;
- -- function "nor" ( l : UNSIGNED ) RETURN std_ulogic;
- -- function "xor" ( l : UNSIGNED ) RETURN std_ulogic;
- -- function "xnor" ( l : UNSIGNED ) RETURN std_ulogic;
-
- -- rtl_synthesis off
--- pragma synthesis_off
- -------------------------------------------------------------------
- -- string functions
- -------------------------------------------------------------------
- function to_string (value : UNSIGNED) return STRING;
- function to_string (value : SIGNED) return STRING;
-
- -- explicitly defined operations
-
- alias to_bstring is to_string [UNSIGNED return STRING];
- alias to_bstring is to_string [SIGNED return STRING];
- alias to_binary_string is to_string [UNSIGNED return STRING];
- alias to_binary_string is to_string [SIGNED return STRING];
-
- function to_ostring (value : UNSIGNED) return STRING;
- function to_ostring (value : SIGNED) return STRING;
- alias to_octal_string is to_ostring [UNSIGNED return STRING];
- alias to_octal_string is to_ostring [SIGNED return STRING];
-
- function to_hstring (value : UNSIGNED) return STRING;
- function to_hstring (value : SIGNED) return STRING;
- alias to_hex_string is to_hstring [UNSIGNED return STRING];
- alias to_hex_string is to_hstring [SIGNED return STRING];
-
- procedure READ(L : inout LINE; VALUE : out UNSIGNED; GOOD : out BOOLEAN);
-
- procedure READ(L : inout LINE; VALUE : out UNSIGNED);
-
- procedure READ(L : inout LINE; VALUE : out SIGNED; GOOD : out BOOLEAN);
-
- procedure READ(L : inout LINE; VALUE : out SIGNED);
-
- procedure WRITE (L : inout LINE; VALUE : in UNSIGNED;
- JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0);
-
- procedure WRITE (L : inout LINE; VALUE : in SIGNED;
- JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0);
-
- alias BREAD is READ [LINE, UNSIGNED, BOOLEAN];
- alias BREAD is READ [LINE, SIGNED, BOOLEAN];
-
- alias BREAD is READ [LINE, UNSIGNED];
- alias BREAD is READ [LINE, SIGNED];
-
- alias BINARY_READ is READ [LINE, UNSIGNED, BOOLEAN];
- alias BINARY_READ is READ [LINE, SIGNED, BOOLEAN];
-
- alias BINARY_READ is READ [LINE, UNSIGNED];
- alias BINARY_READ is READ [LINE, SIGNED];
-
- procedure OREAD (L : inout LINE; VALUE : out UNSIGNED; GOOD : out BOOLEAN);
- procedure OREAD (L : inout LINE; VALUE : out SIGNED; GOOD : out BOOLEAN);
-
- procedure OREAD (L : inout LINE; VALUE : out UNSIGNED);
- procedure OREAD (L : inout LINE; VALUE : out SIGNED);
-
- alias OCTAL_READ is OREAD [LINE, UNSIGNED, BOOLEAN];
- alias OCTAL_READ is OREAD [LINE, SIGNED, BOOLEAN];
-
- alias OCTAL_READ is OREAD [LINE, UNSIGNED];
- alias OCTAL_READ is OREAD [LINE, SIGNED];
-
- procedure HREAD (L : inout LINE; VALUE : out UNSIGNED; GOOD : out BOOLEAN);
- procedure HREAD (L : inout LINE; VALUE : out SIGNED; GOOD : out BOOLEAN);
-
- procedure HREAD (L : inout LINE; VALUE : out UNSIGNED);
- procedure HREAD (L : inout LINE; VALUE : out SIGNED);
-
- alias HEX_READ is HREAD [LINE, UNSIGNED, BOOLEAN];
- alias HEX_READ is HREAD [LINE, SIGNED, BOOLEAN];
-
- alias HEX_READ is HREAD [LINE, UNSIGNED];
- alias HEX_READ is HREAD [LINE, SIGNED];
-
- alias BWRITE is WRITE [LINE, UNSIGNED, SIDE, WIDTH];
- alias BWRITE is WRITE [LINE, SIGNED, SIDE, WIDTH];
-
- alias BINARY_WRITE is WRITE [LINE, UNSIGNED, SIDE, WIDTH];
- alias BINARY_WRITE is WRITE [LINE, SIGNED, SIDE, WIDTH];
-
- procedure OWRITE (L : inout LINE; VALUE : in UNSIGNED;
- JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0);
-
- procedure OWRITE (L : inout LINE; VALUE : in SIGNED;
- JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0);
-
- alias OCTAL_WRITE is OWRITE [LINE, UNSIGNED, SIDE, WIDTH];
- alias OCTAL_WRITE is OWRITE [LINE, SIGNED, SIDE, WIDTH];
-
- procedure HWRITE (L : inout LINE; VALUE : in UNSIGNED;
- JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0);
-
- procedure HWRITE (L : inout LINE; VALUE : in SIGNED;
- JUSTIFIED : in SIDE := right; FIELD : in WIDTH := 0);
-
- alias HEX_WRITE is HWRITE [LINE, UNSIGNED, SIDE, WIDTH];
- alias HEX_WRITE is HWRITE [LINE, SIGNED, SIDE, WIDTH];
-
- -- rtl_synthesis on
--- pragma synthesis_on
-end package numeric_std_additions;
-
-package body numeric_std_additions is
- constant NAU : UNSIGNED(0 downto 1) := (others => '0');
- constant NAS : SIGNED(0 downto 1) := (others => '0');
- constant NO_WARNING : BOOLEAN := false; -- default to emit warnings
- function MAX (left, right : INTEGER) return INTEGER is
- begin
- if left > right then return left;
- else return right;
- end if;
- end function MAX;
-
- -- Id: A.3R
- function "+"(L : UNSIGNED; R: STD_ULOGIC) return UNSIGNED is
- variable XR : UNSIGNED(L'length-1 downto 0) := (others => '0');
- begin
- XR(0) := R;
- return (L + XR);
- end function "+";
-
- -- Id: A.3L
- function "+"(L : STD_ULOGIC; R: UNSIGNED) return UNSIGNED is
- variable XL : UNSIGNED(R'length-1 downto 0) := (others => '0');
- begin
- XL(0) := L;
- return (XL + R);
- end function "+";
-
- -- Id: A.4R
- function "+"(L : SIGNED; R: STD_ULOGIC) return SIGNED is
- variable XR : SIGNED(L'length-1 downto 0) := (others => '0');
- begin
- XR(0) := R;
- return (L + XR);
- end function "+";
-
- -- Id: A.4L
- function "+"(L : STD_ULOGIC; R: SIGNED) return SIGNED is
- variable XL : SIGNED(R'length-1 downto 0) := (others => '0');
- begin
- XL(0) := L;
- return (XL + R);
- end function "+";
-
- -- Id: A.9R
- function "-"(L : UNSIGNED; R: STD_ULOGIC) return UNSIGNED is
- variable XR : UNSIGNED(L'length-1 downto 0) := (others => '0');
- begin
- XR(0) := R;
- return (L - XR);
- end function "-";
-
- -- Id: A.9L
- function "-"(L : STD_ULOGIC; R: UNSIGNED) return UNSIGNED is
- variable XL : UNSIGNED(R'length-1 downto 0) := (others => '0');
- begin
- XL(0) := L;
- return (XL - R);
- end function "-";
-
- -- Id: A.10R
- function "-"(L : SIGNED; R: STD_ULOGIC) return SIGNED is
- variable XR : SIGNED(L'length-1 downto 0) := (others => '0');
- begin
- XR(0) := R;
- return (L - XR);
- end function "-";
-
- -- Id: A.10L
- function "-"(L : STD_ULOGIC; R: SIGNED) return SIGNED is
- variable XL : SIGNED(R'length-1 downto 0) := (others => '0');
- begin
- XL(0) := L;
- return (XL - R);
- end function "-";
-
--- 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') -- | - |
--- );
-
--- %%% FUNCTION "?=" ( l, r : std_ulogic ) RETURN std_ulogic IS
--- function \?=\ ( l, r : STD_ULOGIC ) return STD_ULOGIC is
--- variable value : STD_ULOGIC;
--- begin
--- return match_logic_table (l, r);
--- end function \?=\;
--- function \?/=\ (l, r : STD_ULOGIC) return STD_ULOGIC is
--- begin
--- return no_match_logic_table (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 := MAX(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 \?=\;
-
--- -- %%% Replace with the following function
--- -- function "?=" (L, R: UNSIGNED) return std_ulogic is
--- -- 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 := MAX(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 \?=\;
- -- %%% Replace with the following function
--- function "?=" (L, R: signed) return std_ulogic is
--- end function "?=";
-
- -- Id: C.75
--- function \?=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC is
--- begin
--- return \?=\ (TO_UNSIGNED(L, R'length), R);
--- end function \?=\;
-
--- -- Id: C.76
--- function \?=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC is
--- begin
--- return \?=\ (TO_SIGNED(L, R'length), R);
--- end function \?=\;
-
--- -- Id: C.77
--- function \?=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC is
--- begin
--- return \?=\ (L, TO_UNSIGNED(R, L'length));
--- end function \?=\;
-
--- -- Id: C.78
--- function \?=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC is
--- begin
--- return \?=\ (L, TO_SIGNED(R, L'length));
--- 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 := MAX(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 : UNSIGNED) return std_ulogic is
--- -- %%% 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 := MAX(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 "?/=" (L, R : SIGNED) return std_ulogic is
--- -- %%% end function "?/=";
-
--- -- Id: C.75
--- function \?/=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC is
--- begin
--- return \?/=\ (TO_UNSIGNED(L, R'length), R);
--- end function \?/=\;
-
--- -- Id: C.76
--- function \?/=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC is
--- begin
--- return \?/=\ (TO_SIGNED(L, R'length), R);
--- end function \?/=\;
-
--- -- Id: C.77
--- function \?/=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC is
--- begin
--- return \?/=\ (L, TO_UNSIGNED(R, L'length));
--- end function \?/=\;
-
--- -- Id: C.78
--- function \?/=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC is
--- begin
--- return \?/=\ (L, TO_SIGNED(R, L'length));
--- 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 : SIGNED) return std_ulogic is
- -- %%% end function "?>";
- -- Id: C.57
- function \?>\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC is
- begin
- return \?>\ (TO_UNSIGNED(L, R'length), R);
- end function \?>\;
-
- -- Id: C.58
- function \?>\ (L : INTEGER; R : SIGNED) return STD_ULOGIC is
- begin
- return \?>\ (TO_SIGNED(L, R'length),R);
- end function \?>\;
-
- -- Id: C.59
- function \?>\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC is
- begin
- return \?>\ (L, TO_UNSIGNED(R, L'length));
- end function \?>\;
-
- -- Id: C.60
- function \?>\ (L : SIGNED; R : INTEGER) return STD_ULOGIC is
- begin
- return \?>\ (L, TO_SIGNED(R, L'length));
- 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 : SIGNED) return std_ulogic is
- -- %%% end function "?>=";
-
- function \?>=\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC is
- begin
- return \?>=\ (TO_UNSIGNED(L, R'length), R);
- end function \?>=\;
-
- -- Id: C.64
- function \?>=\ (L : INTEGER; R : SIGNED) return STD_ULOGIC is
- begin
- return \?>=\ (TO_SIGNED(L, R'length),R);
- end function \?>=\;
-
- -- Id: C.65
- function \?>=\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC is
- begin
- return \?>=\ (L, TO_UNSIGNED(R, L'length));
- end function \?>=\;
-
- -- Id: C.66
- function \?>=\ (L : SIGNED; R : INTEGER) return STD_ULOGIC is
- begin
- return \?>=\ (L, TO_SIGNED(R, L'length));
- 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 : SIGNED) return std_ulogic is
- -- %%% end function "?<";
-
- -- Id: C.57
- function \?<\ (L : NATURAL; R : UNSIGNED) return STD_ULOGIC is
- begin
- return \?<\ (TO_UNSIGNED(L, R'length), R);
- end function \?<\;
-
- -- Id: C.58
- function \?<\ (L : INTEGER; R : SIGNED) return STD_ULOGIC is
- begin
- return \?<\ (TO_SIGNED(L, R'length),R);
- end function \?<\;
-
- -- Id: C.59
- function \?<\ (L : UNSIGNED; R : NATURAL) return STD_ULOGIC is
- begin
- return \?<\ (L, TO_UNSIGNED(R, L'length));
- end function \?<\;
-
- -- Id: C.60
- function \?<\ (L : SIGNED; R : INTEGER) return STD_ULOGIC is
- begin
- return \?<\ (L, TO_SIGNED(R, L'length));
- end function \?<\;
-
-