1001 lines
51 KiB
VHDL
1001 lines
51 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 : Floating-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 floating 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 float_generic_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)
|
|
float_exponent_width : NATURAL := 8;
|
|
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)
|
|
float_round_style : round_type := round_nearest;
|
|
-- Denormal numbers (very small numbers near zero) true or false
|
|
float_denormalize : BOOLEAN := true;
|
|
-- Turns on NAN processing (invalid numbers and overflow) true of false
|
|
float_check_error : BOOLEAN := true;
|
|
-- Guard bits are added to the bottom of every operation for rounding.
|
|
-- any natural number (including 0) are valid.
|
|
float_guard_bits : NATURAL := 3;
|
|
-- If TRUE, then turn off warnings on "X" propagation
|
|
no_warning : BOOLEAN := false;
|
|
package fixed_pkg is new IEEE.fixed_generic_pkg
|
|
generic map (<>) );
|
|
|
|
-- Author David Bishop (dbishop@vhdl.org)
|
|
constant CopyRightNotice : STRING :=
|
|
"Copyright IEEE P1076 WG. Licensed Apache 2.0";
|
|
|
|
use fixed_pkg.all;
|
|
|
|
-- Note that this is "INTEGER range <>", thus if you use a literal, then the
|
|
-- default range will be (INTEGER'low to INTEGER'low + X)
|
|
type UNRESOLVED_float is array (INTEGER range <>) of STD_ULOGIC; -- main type
|
|
alias U_float is UNRESOLVED_float;
|
|
|
|
subtype float is (resolved) 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 : UNRESOLVED_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 : UNRESOLVED_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 : UNRESOLVED_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 : UNRESOLVED_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 UNRESOLVED_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 UNRESOLVED_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 : UNRESOLVED_UNSIGNED;
|
|
constant round_style : round_type := float_round_style; -- rounding option
|
|
constant check_error : BOOLEAN := float_check_error) -- check for errors
|
|
return UNRESOLVED_UNSIGNED;
|
|
|
|
-- float to signed
|
|
function to_signed (
|
|
arg : UNRESOLVED_float; -- floating point input
|
|
size_res : UNRESOLVED_SIGNED;
|
|
constant round_style : round_type := float_round_style; -- rounding option
|
|
constant check_error : BOOLEAN := float_check_error) -- check for errors
|
|
return UNRESOLVED_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 UNRESOLVED_UNSIGNED;
|
|
expon : out UNRESOLVED_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 UNRESOLVED_ufixed; -- a number between 1.0 and 2.0
|
|
expon : out UNRESOLVED_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 : UNRESOLVED_UNSIGNED; -- fraction, unnormalized
|
|
expon : UNRESOLVED_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 : UNRESOLVED_ufixed; -- unsigned fixed point
|
|
expon : UNRESOLVED_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 : UNRESOLVED_UNSIGNED; -- unsigned
|
|
expon : UNRESOLVED_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 : UNRESOLVED_ufixed; -- unsigned fixed point
|
|
expon : UNRESOLVED_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" (l : UNRESOLVED_float) return STD_ULOGIC;
|
|
function "nand" (l : UNRESOLVED_float) return STD_ULOGIC;
|
|
function "or" (l : UNRESOLVED_float) return STD_ULOGIC;
|
|
function "nor" (l : UNRESOLVED_float) return STD_ULOGIC;
|
|
function "xor" (l : UNRESOLVED_float) return STD_ULOGIC;
|
|
function "xnor" (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 : UNRESOLVED_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 UNRESOLVED_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
|
|
--===========================================================================
|
|
|
|
-- 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];
|
|
|
|
end package float_generic_pkg;
|