numeric_std Package

VHDL Reference GuideChapter 10: Foundation Express Packages

numeric_std Package

Foundation Express supports nearly all of numeric_std, the IEEE Standard VHDL Synthesis Package, which defines numeric types and arithmetic functions.

Warning: The numeric_std package and the std_logic_arith package have overlapping operations. Using these two packages simultaneously during analysis could cause type mismatches.

Understanding the Limitations of numeric_std package

The 1999.05 version of Foundation Express does not support the following numeric_std package components:

divide, rem, or mod operators

If your design contains these operators, use the std_logic_arith package.
TO_01 function as a simulation construct

Using the Package

Access numeric_std package with the following statement in your VHDL code.

library IEEE;

use IEEE.numeric_std.all;

These VHDL packages are pre-analyzed and do not require further analyzing. To list the packages currently in memory, use the following command.

report_design_lib

Data Types

The numeric_std package defines the following two data types in the same way that the std_logic_arith package does.

UNSIGNED
```
type UNSIGNED is array (NATURAL range <>) of STD_LOGIC;
```
See the “UNSIGNED” section of this chapter for more information.
SIGNED
```
type SIGNED is array (NATURAL range <>) of STD_LOGIC;
```
See the “SIGNED” section of this chapter for more information.

Conversion Functions

The numeric_std package provides functions to convert values between its UNSIGNED and SIGNED types. The following example shows the declarations of these conversion functions.

function TO_INTEGER (ARG: UNSIGNED) return NATURAL;

function TO_INTEGER (ARG: SIGNED) return INTEGER;

function TO_UNSIGNED (ARG, SIZE: NATURAL) return UNSIGNED;

function TO_SIGNED (ARG: INTEGER; SIZE: NATURAL) return SIGNED;

TO_INTEGER, TO_SIGNED, and TO_UNSIGNED are similar to CONV_INTEGER, CONV_SIGNED, and CONV_UNSIGNED in std_logic_arith (see the “Conversion Functions” section of this chapter).

Resize Function

The resize function numeric_std supports is shown in the declarations in the following example.

function RESIZE (ARG: SIGNED; NEW_SIZE: NATURAL) return SIGNED;

function RESIZE (ARG: UNSIGNED; NEW_SIZE: NATURAL) return UNSIGNED;

Arithmetic Functions

The numeric_std package provides arithmetic functions for use with combinations of UNSIGNED and SIGNED data types and the predefined types STD_ULOGIC and INTEGER. These functions produce adders and subtracters.

There are two sets of arithmetic functions, which the numeric_std package defines in the same way that the std_logic_arith package does.

Binary functions having two arguments, such as the following.

A+B

A*B
Unary functions having one argument, such as the following.

-A

abs A

The following example shows the declarations for binary functions having two arguments.

function "+" (L, R: UNSIGNED) return UNSIGNED;

function "+" (L, R: SIGNED) return SIGNED;

function "+" (L: UNSIGNED; R: NATURAL) return UNSIGNED;

function "+" (L: NATURAL; R: UNSIGNED) return UNSIGNED;

function "+" (L: INTEGER; R: SIGNED) return SIGNED;

function "+" (L: SIGNED; R: INTEGER) return SIGNED;

function "-" (L, R: UNSIGNED) return UNSIGNED;

function "-" (L, R: SIGNED) return SIGNED;

function "-" (L: UNSIGNED;R: NATURAL) return UNSIGNED;

function "-" (L: NATURAL; R: UNSIGNED) return UNSIGNED;

function "-" (L: SIGNED; R: INTEGER) return SIGNED;

function "-" (L: INTEGER; R: SIGNED) return SIGNED;

function "*" (L, R: UNSIGNED) return UNSIGNED;

function "*" (L, R: SIGNED) return SIGNED;

function "*" (L: UNSIGNED; R: NATURAL) return UNSIGNED;

function "*" (L: NATURAL; R: UNSIGNED) return UNSIGNED;

function "*" (L: SIGNED; R: INTEGER) return SIGNED;

function "*" (L: INTEGER; R: SIGNED) return SIGNED;

The following example shows the declarations for unary functions having one argument.

function "abs" (ARG: SIGNED) return SIGNED;

function "-" (ARG: SIGNED) return SIGNED;

Comparison Functions

The numeric_std package provides functions to compare UNSIGNED and SIGNED data types to each other and to the predefined type INTEGER. Foundation Express compares the numeric values of the arguments and returns a BOOLEAN value.

These functions produce comparators. The function declarations are listed in two groups.

Ordering functions ("<", "<=", ">", ">="), shown in the following example

Equality functions ("=", "/="), shown in the second example

function ">" (L, R: UNSIGNED) return BOOLEAN;

function ">" (L, R: SIGNED) return BOOLEAN;

function ">" (L: NATURAL; R: UNSIGNED) return BOOLEAN;

function ">" (L: INTEGER; R: SIGNED) return BOOLEAN;

function ">" (L: UNSIGNED; R: NATURAL) return BOOLEAN;

function ">" (L: SIGNED; R: INTEGER) return BOOLEAN;

function "<" (L, R: UNSIGNED) return BOOLEAN;

function "<" (L, R: SIGNED) return BOOLEAN;

function "<" (L: NATURAL; R: UNSIGNED) return BOOLEAN;

function "<" (L: INTEGER; R: SIGNED) return BOOLEAN;

function "<" (L: UNSIGNED; R: NATURAL) return BOOLEAN;

function "<" (L: SIGNED; R: INTEGER) return BOOLEAN;

function "<=" (L, R: UNSIGNED) return BOOLEAN;

function "<=" (L, R: SIGNED) return BOOLEAN;

function "<=" (L: NATURAL; R: UNSIGNED) return BOOLEAN;

function "<=" (L: INTEGER; R: SIGNED) return BOOLEAN;

function "<=" (L: UNSIGNED; R: NATURAL) return BOOLEAN;

function "<=" (L: SIGNED; R: INTEGER) return BOOLEAN;

function ">=" (L, R: UNSIGNED) return BOOLEAN;

function ">=" (L, R: SIGNED) return BOOLEAN;

function ">=" (L: NATURAL; R: UNSIGNED) return BOOLEAN;

function ">=" (L: INTEGER; R: SIGNED) return BOOLEAN;

function ">=" (L: UNSIGNED; R: NATURAL) return BOOLEAN;

function ">=" (L: SIGNED; R: INTEGER) return BOOLEAN;

The following example shows numeric_std equality functions.

function "=" (L, R: UNSIGNED) return BOOLEAN;

function "=" (L, R: SIGNED) return BOOLEAN;

function "=" (L: NATURAL; R: UNSIGNED) return BOOLEAN;

function "=" (L: INTEGER; R: SIGNED) return BOOLEAN;

function "=" (L: UNSIGNED; R: NATURAL) return BOOLEAN;

function "=" (L: SIGNED; R: INTEGER) return BOOLEAN;

function "/=" (L, R: UNSIGNED) return BOOLEAN;

function "/=" (L, R: SIGNED) return BOOLEAN;

function "/=" (L: NATURAL; R: UNSIGNED) return BOOLEAN;

function "/=" (L: INTEGER; R: SIGNED) return BOOLEAN;

function "/=" (L: UNSIGNED; R: NATURAL) return BOOLEAN;

function "/=" (L: SIGNED; R: INTEGER) return BOOLEAN;

Defining Logical Operators Functions

The numeric_std package provides functions that define all of the logical operators: NOT, AND, OR, NAND, NOR, XOR, and XNOR. These functions work just like similar functions in std_logic_1164, except that they operate on SIGNED and UNSIGNED values rather than on STD_LOGIC_VECTOR values. The following example shows these function declarations.

function "not" (L: UNSIGNED) return UNSIGNED;

function "and" (L, R: UNSIGNED) return UNSIGNED;

function "or" (L, R: UNSIGNED) return UNSIGNED;

function "nand" (L, R: UNSIGNED) return UNSIGNED;

function "nor" (L, R: UNSIGNED) return UNSIGNED;

function "xor" (L, R: UNSIGNED) return UNSIGNED;

function "xnor" (L, R: UNSIGNED) return UNSIGNED;

function "not" (L: SIGNED) return SIGNED;

function "and" (L, R: SIGNED) return SIGNED;

function "or" (L, R: SIGNED) return SIGNED;

function "nand" (L, R: SIGNED) return SIGNED;

function "nor" (L, R: SIGNED) return SIGNED;

function "xor" (L, R: SIGNED) return SIGNED;

function "xnor" (L, R: SIGNED) return SIGNED;

Shift Functions

The numeric_std package provides functions for shifting the bits in UNSIGNED and SIGNED numbers. These functions produce shifters. The following example shows the shift function declarations.

function SHIFT_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED;

function SHIFT_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED;

function SHIFT_LEFT (ARG: SIGNED; COUNT: NATURAL) return SIGNED;

function SHIFT_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED;

function ROTATE_LEFT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED;

function ROTATE_RIGHT (ARG: UNSIGNED; COUNT: NATURAL) return UNSIGNED;

function ROTATE_LEFT (ARG: SIGNED; COUNT: NATURAL) return SIGNED;

function ROTATE_RIGHT (ARG: SIGNED; COUNT: NATURAL) return SIGNED;

The SHIFT_LEFT function shifts the bits of its argument ARG left by COUNT bits. SHIFT_RIGHT shifts the bits of its argument ARG right by COUNT bits.

The SHIFT_LEFT functions work the same for both UNSIGNED and SIGNED values of ARG, shifting in zero bits as necessary. The SHIFT_RIGHT functions treat UNSIGNED and SIGNED values differently.

If ARG is an UNSIGNED number, vacated bits are filled with zeros
If ARG is a SIGNED number, the vacated bits are copied from the ARG sign bit

The example in the “Shift and Rotate Operators” section of this chapter shows some shift functions calls and their return values.

Rotate Functions

ROTATE_LEFT and ROTATE_RIGHT are similar to the shift functions.

The following example shows rotate function declarations.

ROTATE_LEFT (U1, COUNT) = "01011011"

ROTATE_LEFT (S1, COUNT) = "01011011"

ROTATE_LEFT (U2, COUNT) = "01011111"

ROTATE_LEFT (S2, COUNT) = "01011111"

ROTATE_RIGHT (U1, COUNT) = "01101101"

ROTATE_RIGHT (S1, COUNT) = "01101101"

ROTATE_RIGHT (U2, COUNT) = "01111101"

ROTATE_RIGHT (S2, COUNT) = "01111101"

Shift and Rotate Operators

The numeric_std package provides shift operators and rotate operators, which work in the same way that shift functions and rotate functions do. The shift operators are sll, srl, sla, and sra.

The following example shows some shift and rotate operator declarations.

function "sll" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED;

function "sll" (ARG: SIGNED; COUNT: INTEGER) return SIGNED;

function "srl" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED;

function "srl" (ARG: SIGNED; COUNT: INTEGER) return SIGNED;

function "rol" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED;

function "rol" (ARG: SIGNED; COUNT: INTEGER) return SIGNED;

function "ror" (ARG: UNSIGNED; COUNT: INTEGER) return UNSIGNED;

function "ror" (ARG: SIGNED; COUNT: INTEGER) return SIGNED;

The following example includes some shift and rotate operators.

Variable U1, U2: UNSIGNED (7 downto 0);

Variable S1, S2: SIGNED (7 downto 0);

Variable COUNT: NATURAL;

...

U1 <= "01101011";

U2 <= "11101011";

S1 <= "01101011";

S2 <= "11101011";

COUNT <= 3;

...

SHIFT_LEFT (U1, COUNT) = "01011000"

SHIFT_LEFT (S1, COUNT) = "01011000"  

SHIFT_LEFT (U2, COUNT) = "01011000"

SHIFT_LEFT (S2, COUNT) = "01011000"

SHIFT_RIGHT (U1, COUNT) = "00001101"

SHIFT_RIGHT (S1, COUNT) = "00001101"

SHIFT_RIGHT (U2, COUNT) = "00011101"

SHIFT_RIGHT (S2, COUNT) = "11111101"

U1 sll COUNT = "01011000"

S1 sll COUNT = "01011000"

U2 sll COUNT = "01011000"

S2 sll COUNT = "01011000"

U1 srl COUNT = "00001101"

S1 srl COUNT = "00001101"

U2 srl COUNT = "00011101"

S2 srl COUNT = "11111101"

U1 rol COUNT = "01011011"

S1 rol COUNT = "01011011"

U2 rol COUNT = "01011111"

S2 rol COUNT = "01011111"

U1 ror COUNT = "01101101"

S1 ror COUNT = "01101101"

U2 ror COUNT = "01111101"

S2 ror COUNT = "01111101"