1440 lines
65 KiB
VHDL
1440 lines
65 KiB
VHDL
-- -----------------------------------------------------------------
|
|
--
|
|
-- Copyright 2019 IEEE P1076 WG Authors
|
|
--
|
|
-- See the LICENSE file distributed with this work for copyright and
|
|
-- licensing information and the AUTHORS file.
|
|
--
|
|
-- This file to you under the Apache License, Version 2.0 (the "License").
|
|
-- You may obtain a copy of the License at
|
|
--
|
|
-- http://www.apache.org/licenses/LICENSE-2.0
|
|
--
|
|
-- Unless required by applicable law or agreed to in writing, software
|
|
-- distributed under the License is distributed on an "AS IS" BASIS,
|
|
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
-- implied. See the License for the specific language governing
|
|
-- permissions and limitations under the License.
|
|
--
|
|
-- Title : Fixed-point package (Generic package declaration)
|
|
-- :
|
|
-- Library : This package shall be compiled into a library
|
|
-- : symbolically named IEEE.
|
|
-- :
|
|
-- Developers: Accellera VHDL-TC and IEEE P1076 Working Group
|
|
-- :
|
|
-- Purpose : This packages defines basic binary fixed point
|
|
-- : arithmetic functions
|
|
-- :
|
|
-- Note : This package may be modified to include additional data
|
|
-- : required by tools, but it must in no way change the
|
|
-- : external interfaces or simulation behavior of the
|
|
-- : description. It is permissible to add comments and/or
|
|
-- : attributes to the package declarations, but not to change
|
|
-- : or delete any original lines of the package declaration.
|
|
-- : The package body may be changed only in accordance with
|
|
-- : the terms of Clause 16 of this standard.
|
|
-- :
|
|
-- --------------------------------------------------------------------
|
|
-- $Revision: 1220 $
|
|
-- $Date: 2008-04-10 17:16:09 +0930 (Thu, 10 Apr 2008) $
|
|
-- --------------------------------------------------------------------
|
|
|
|
use STD.TEXTIO.all;
|
|
library IEEE;
|
|
use IEEE.STD_LOGIC_1164.all;
|
|
use IEEE.NUMERIC_STD.all;
|
|
use IEEE.fixed_float_types.all;
|
|
|
|
package fixed_generic_pkg is
|
|
generic (
|
|
-- Rounding routine to use in fixed point, fixed_round or fixed_truncate
|
|
fixed_round_style : fixed_round_style_type := fixed_round;
|
|
-- Overflow routine to use in fixed point, fixed_saturate or fixed_wrap
|
|
fixed_overflow_style : fixed_overflow_style_type := fixed_saturate;
|
|
-- Extra bits used in divide routines
|
|
fixed_guard_bits : NATURAL := 3;
|
|
-- If TRUE, then turn off warnings on "X" propagation
|
|
no_warning : BOOLEAN := false
|
|
);
|
|
|
|
-- Author David Bishop (dbishop@vhdl.org)
|
|
constant CopyRightNotice : STRING :=
|
|
"Copyright IEEE P1076 WG. Licensed Apache 2.0";
|
|
|
|
-- 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;
|
|
|
|
alias U_ufixed is UNRESOLVED_ufixed;
|
|
alias U_sfixed is UNRESOLVED_sfixed;
|
|
|
|
subtype ufixed is (resolved) UNRESOLVED_ufixed;
|
|
subtype sfixed is (resolved) 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 : UNRESOLVED_SIGNED) return UNRESOLVED_ufixed;
|
|
function scalb (y : UNRESOLVED_sfixed; N : INTEGER) return UNRESOLVED_sfixed;
|
|
function scalb (y : UNRESOLVED_sfixed; N : UNRESOLVED_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" (l : UNRESOLVED_ufixed) return STD_ULOGIC;
|
|
function "nand" (l : UNRESOLVED_ufixed) return STD_ULOGIC;
|
|
function "or" (l : UNRESOLVED_ufixed) return STD_ULOGIC;
|
|
function "nor" (l : UNRESOLVED_ufixed) return STD_ULOGIC;
|
|
function "xor" (l : UNRESOLVED_ufixed) return STD_ULOGIC;
|
|
function "xnor" (l : UNRESOLVED_ufixed) return STD_ULOGIC;
|
|
function "and" (l : UNRESOLVED_sfixed) return STD_ULOGIC;
|
|
function "nand" (l : UNRESOLVED_sfixed) return STD_ULOGIC;
|
|
function "or" (l : UNRESOLVED_sfixed) return STD_ULOGIC;
|
|
function "nor" (l : UNRESOLVED_sfixed) return STD_ULOGIC;
|
|
function "xor" (l : UNRESOLVED_sfixed) return STD_ULOGIC;
|
|
function "xnor" (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 : UNRESOLVED_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 : UNRESOLVED_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 : UNRESOLVED_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 UNRESOLVED_UNSIGNED;
|
|
|
|
-- unsigned fixed point to unsigned
|
|
function to_unsigned (
|
|
arg : UNRESOLVED_ufixed; -- fixed point input
|
|
size_res : UNRESOLVED_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 UNRESOLVED_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 : UNRESOLVED_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 : UNRESOLVED_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 : UNRESOLVED_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 UNRESOLVED_SIGNED;
|
|
|
|
-- signed fixed point to signed
|
|
function to_signed (
|
|
arg : UNRESOLVED_sfixed; -- fixed point input
|
|
size_res : UNRESOLVED_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 UNRESOLVED_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;
|
|
|
|
--===========================================================================
|
|
-- 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];
|
|
|
|
end package fixed_generic_pkg;
|