synthesizeable_vhdl-model-library:array-divider

Array-Divider

A short interface specification:

  • The input widths of the model are parameterizable (@BITBR).
  • The inputs and outputs will have the same bit width.
  • The algorithm is implemented asynchronous without flipflops.

Array-Divider block diagram

dvd : Input port for the dividend
dvs : Input port for the divisor
quot : Output port for the quotient
rest : Output port for the remainder (2's complement)
array_divider.vhd
-- ############################################################################
-- # Project    :    VHDL-Modellbibliothek				      #
-- #                                                                          #
-- # Filename   :    array_divider.vhd                                        #
-- #                                                                          #
-- # Schaltung  :    Array-Dividierer                                         #
-- #                                                                          #
-- # Modell	:    array_divider                                            #
-- #                                                                          #
-- # Designer   : Wolfgang Sehr                                               #
-- # Abteilung  : Lehrstuhl fuer Rechnergestuetzten Schaltungsentwurf         #
-- # Datum      : 20.01.1995                                                  #
-- ############################################################################
 
-- ############################################################################
-- #                        IEEE PACKAGES                                     #
-- ############################################################################
   Library IEEE;
   use IEEE.std_logic_1164.all;
   use IEEE.std_logic_arith.all;
-- ############################################################################
 
 
ENTITY array_divider IS
	GENERIC(X :INTEGER := @BITBR);  -- X := Operandenbreite 
				   	  -- symmetrisches Array X * X
	PORT(dvd	: IN  UNSIGNED ((X-1)   DOWNTO 0);
	     dvs	: IN  UNSIGNED ((X-1)   DOWNTO 0);
	     quot	: OUT UNSIGNED ((X-1)	DOWNTO 0);
	     rest	: OUT UNSIGNED ((X-1)	DOWNTO 0));
 
	-- dvd     	: Eingangsport fuer Dividenden 
	--
	-- dvs		: Eingangsport fuer Divisor
	-- 
	-- quot		: Ausgangsport fuer Quotienten
	--
	-- rest		: Ausgangsport fuer Rest
	--
	-- -> Darstellung im 2'er Komplement
 
END array_divider;
 
 
ARCHITECTURE verhalten OF array_divider IS
 
BEGIN
 
   PROCESS(dvd, dvs)
	CONSTANT eins : STD_LOGIC := '1';
 
	VARIABLE dvd_sgn		: SIGNED ((X-1)   DOWNTO 0);
	VARIABLE dvs_sgn		: SIGNED ((X-1)   DOWNTO 0);
	VARIABLE ztld 			: SIGNED ((2*X-2) DOWNTO 0);
	VARIABLE tlr			: SIGNED ((X-1)   DOWNTO 0);
	VARIABLE k_ztld			: UNSIGNED ((ztld'LENGTH-1) DOWNTO 0);
	VARIABLE k_tlr			: UNSIGNED ((tlr'LENGTH-1)  DOWNTO 0);
	VARIABLE vz			: UNSIGNED ( 1              DOWNTO 0);	
	VARIABLE a   			: UNSIGNED ((ztld'LENGTH-1) DOWNTO 0);
	VARIABLE a_ein			: UNSIGNED ((ztld'LENGTH-1) DOWNTO 0);
	VARIABLE b   			: UNSIGNED ((tlr'LENGTH-1)  DOWNTO 0);
	VARIABLE k_b 			: UNSIGNED ((tlr'LENGTH-1)  DOWNTO 0);
	VARIABLE q   			: UNSIGNED ((tlr'LENGTH-1)  DOWNTO 0);
	VARIABLE k_q			: UNSIGNED ((tlr'LENGTH-1)  DOWNTO 0);
	VARIABLE r			: UNSIGNED ((tlr'LENGTH-1)  DOWNTO 0);
	VARIABLE k_r			: UNSIGNED ((tlr'LENGTH-1)  DOWNTO 0);
	VARIABLE sum 			: UNSIGNED ( tlr'LENGTH     DOWNTO 0);
	VARIABLE n_divisable		: UNSIGNED ((tlr'LENGTH-1)  DOWNTO 0);
	VARIABLE n_div_detect		: STD_LOGIC;
	VARIABLE b_add			: UNSIGNED ((tlr'LENGTH)    DOWNTO 0);
 
	VARIABLE zwischenrest		: UNSIGNED ((X*X-1)	    DOWNTO 0);
 
	-- k_ztld		: komplementierter Dividend aufbereitet fuer den
	--			: Divisionsalgorithmus
	-- 
	-- k_tlr		: komplementierter Divisor
	--
	-- vz			: 0 -> positives Vorzeichen
	--			: 1 -> negatives Vorzeichen
	--			: vz(1) Vorzeichen des Dividenden
	--			: vz(0) Vorzeichen des Divisors
	--
	-- a			: Variable fuer den aktuellen Dividenden
	-- 			: waehrend der Ausfuehrumg des Divisions-
	--			: algorithmus
	--
	-- a_ein		: Variable fuer den Dividenden, der anfangs in
	--			: Divisionsalgorithmus uebernommen wird
	--
	-- b			: Variable fuer den Divisor (immer positiv)
	--
	-- k_b			: komplemtierter Divisor (immer negativ)
	--
	-- q			: Variable fuer den Quotienten
	--
	-- k_q			: komplementierter Quotient
	--		
	-- r			: ganzzahliger Rest der Division
	--
	-- k_r			: komplementierter ganzzahliger Rest der
	--			: Division
	--
	-- sum			: Ergebnis der Addition/Subtraktion in den
	--			: einzelnen Stufen
	--	
	-- n_divisable		: ist in der Stufe i Null, ab der der Dividend
	--			: nicht mehr weiter durch den Divisor 
	--			: teilbar ist
	--			 
	-- n_div_detect		: ist 1, wenn der Dividend vor der letzten Zeile
	--			: nicht mehr durch den Divisor teilbar ist
	-- 
	-- b_add		: Zwischenspeichervariable fuer Addition
	--
	-- zwischenrest		: Stellt den aktuellen Zwischenrest dar, der
 	--			: sich aus dem Ergebnis der Addition/Subtraktion
	--			: und den noch nicht behandelten Stellen des
	--			: Dividenden zusammensetzt.
 
   BEGIN
	-- ####################################################################
	-- Eingangssignale bzw. komplementierte Eingangssignale werden den
	-- internen Variablen des PROCESS zugewiesen
	-- ####################################################################
	dvd_sgn := CONV_SIGNED(dvd, dvd_sgn'LENGTH);
	dvs_sgn := CONV_SIGNED(dvs, dvs_sgn'LENGTH);
 
	ztld := CONV_SIGNED(dvd_sgn, ztld'LENGTH);
   	tlr  := CONV_SIGNED(dvs_sgn, tlr'LENGTH);
 
	FOR i IN 0 TO (ztld'LENGTH-1) LOOP
	  k_ztld(i) := NOT(ztld(i));
	END LOOP;
	k_ztld := k_ztld + eins;
 
	FOR i IN 0 TO (tlr'LENGTH-1) LOOP
	   k_tlr(i) := NOT(tlr(i));
	END LOOP;
	k_tlr := k_tlr + eins;
 
	IF (dvd(dvd'LENGTH-1) = '1') THEN
	   vz(1) := '1';
	ELSE 
	   vz(1) := '0';
	END IF;
 
	IF (dvs(dvs'LENGTH-1) = '1') THEN
	   vz(0) := '1';
	ELSE
	   vz(0) := '0';
	END IF;
 
 
	CASE vz IS
	   WHEN "00" =>  	a 	:= CONV_UNSIGNED(ztld,a'LENGTH);
				a_ein 	:= CONV_UNSIGNED(ztld,a'LENGTH);
				b 	:= CONV_UNSIGNED(tlr, b'LENGTH);
 
	   WHEN "01" => 	a 	:= CONV_UNSIGNED(ztld,  a'LENGTH);
				a_ein	:= CONV_UNSIGNED(ztld,  a'LENGTH);
				b 	:= CONV_UNSIGNED(k_tlr, b'LENGTH);
 
	   WHEN "10" => 	a 	:= CONV_UNSIGNED(k_ztld,a'LENGTH);
				a_ein	:= CONV_UNSIGNED(k_ztld,a'LENGTH);
				b 	:= CONV_UNSIGNED(tlr,   b'LENGTH);
 
	   WHEN "11" => 	a 	:= CONV_UNSIGNED(k_ztld,a'LENGTH);
				a_ein 	:= CONV_UNSIGNED(k_ztld,a'LENGTH);
				b 	:= CONV_UNSIGNED(k_tlr, b'LENGTH);
 
	   WHEN OTHERS =>	a 	:= CONV_UNSIGNED(0, a'LENGTH);
				a_ein 	:= CONV_UNSIGNED(0, a'LENGTH);
				b 	:= CONV_UNSIGNED(0, b'LENGTH);
	END CASE;
	-- ####################################################################
 
 
 
	-- ####################################################################
	-- Divisionsalgorithmus
	-- ####################################################################
	sum(tlr'LENGTH) := '1';
	zwischenrest := CONV_UNSIGNED(0, zwischenrest'LENGTH);
 
   	FOR n IN 0 TO (tlr'LENGTH-1) LOOP
	   k_b(n) := NOT(b(n));
	END LOOP;
	k_b := k_b + eins;
 
	FOR i IN 0 TO (tlr'LENGTH-1) LOOP
	   --------------------------------------------------------------------
      	   -- Addition oder Subtraktion des Divisors in Abhaengigkeit des
	   -- Uebertrags der zuvor erfolgten Rechenoperation
	   --------------------------------------------------------------------
	   IF sum(tlr'LENGTH) = '1' THEN
		b_add := CONV_UNSIGNED(k_b, tlr'LENGTH+1); 
	   ELSIF sum(tlr'LENGTH) ='0' THEN 
		b_add := CONV_UNSIGNED(b, tlr'LENGTH+1);
	   END IF;
 
		sum := CONV_UNSIGNED(a(ztld'LENGTH-1-i DOWNTO
		       ztld'LENGTH-tlr'LENGTH-i), tlr'LENGTH+1) 
		       + b_add;
	   -------------------------------------------------------------------
 
 
 
	   -------------------------------------------------------------------
	   -- sichern des Zwischenrestes mit angehaengtem Dividendenrest
	   -------------------------------------------------------------------
 
	   FOR k IN 0 TO (X-1-1-i) LOOP
		zwischenrest(i*X+k) := a_ein(k);
	   END LOOP;
 
	   FOR l IN 0 TO i LOOP 
		zwischenrest(i*X+(X-1-i+l)) := sum(l);
	   END LOOP;
 
	   -------------------------------------------------------------------
 
 
 
	   -------------------------------------------------------------------
	   -- Umlagern der Ergebnisse
	   -------------------------------------------------------------------
	   FOR m IN 1 TO (tlr'LENGTH-1) LOOP
	      a(ztld'LENGTH-m-1-i) := sum(tlr'LENGTH-m-1);
	   END LOOP;
	   q(tlr'LENGTH-1-i)	 := sum(tlr'LENGTH);  -- XOR b(tlr'LENGTH-1); 
				  -- Uebertrag bei der Addition stellt
				  -- Quotientenstelle dar
	   -------------------------------------------------------------------
	END LOOP;
 
 
	-- ####################################################################
	-- Restkorrektur
	-- ####################################################################
	r := CONV_UNSIGNED('0', tlr'LENGTH);
	n_div_detect := '0';
 
	-- --------------------------------------------------------------------
	-- Ueberpruefung der Teilbarkeit
	-- --------------------------------------------------------------------
	FOR i IN 0 TO (tlr'LENGTH-1) LOOP
	   IF (i < tlr'LENGTH-1) THEN
	      IF (q(tlr'LENGTH-1-i) = '1') THEN
		 n_divisable(i) := '0';
	         FOR l IN i+1 TO (tlr'LENGTH-1) LOOP
	             n_divisable(i) := n_divisable(i) OR (q(tlr'LENGTH-1-l));
	         END LOOP;
	      ELSE
	       	 n_divisable(i) := '1';		 
	      END IF;
	   END IF;
	END LOOP;
	-- --------------------------------------------------------------------
 
	-- --------------------------------------------------------------------
	-- Zuweisung des entsprechenden Restes
	-- --------------------------------------------------------------------
	IF (q = CONV_UNSIGNED(0, tlr'LENGTH)) THEN
	   r := CONV_UNSIGNED(a_ein((tlr'LENGTH-1) DOWNTO 0), tlr'LENGTH);
	ELSE
	   FOR i IN 1 TO (tlr'LENGTH-1) LOOP
	      IF (i < tlr'LENGTH-1) THEN
	         IF (n_divisable(i) = '0') THEN
		     r := CONV_UNSIGNED(zwischenrest(i*X+X-1 DOWNTO i*X), 
		  		        tlr'LENGTH);
		     n_div_detect := '1';
	         END IF;
	      ELSE
		 IF (n_div_detect = '0') THEN
		     r := CONV_UNSIGNED(zwischenrest(i*X+X-1 DOWNTO i*X), 
		  		        tlr'LENGTH);
		 END IF;
	      END IF;
 
	   END LOOP;
	END IF; 
	-- ####################################################################
 
 
 
	-- ####################################################################
	-- interne Variablen werden Ausgangssignalen zugewiesen
	-- ####################################################################
	FOR i IN 0 TO (q'LENGTH-1) LOOP
	   k_q(i) := NOT(q(i));
	END LOOP;
	k_q := k_q + CONV_UNSIGNED(1, q'LENGTH);
 
	FOR i IN 0 TO (r'LENGTH-1) LOOP
	   k_r(i) := NOT(r(i));
	END LOOP;
	k_r := k_r + eins;
 
	CASE vz IS
	   WHEN "00" 	=>  quot <= q;
			    rest <= r;
 
	   WHEN "01" 	=>  quot <= k_q;
			    rest <= r;
 
	   WHEN "10" 	=>  quot <= k_q;
			    rest <= k_r;
 
	   WHEN "11" 	=>  quot <= q;
			    rest <= k_r;
 
	   WHEN OTHERS 	=>  quot <= CONV_UNSIGNED(0, quot'LENGTH);
			    rest <= CONV_UNSIGNED(0, rest'LENGTH);
 
	END CASE;
	-- ####################################################################
 
   END PROCESS;
END verhalten;
 
CONFIGURATION CFG_array_divider OF array_divider IS
   FOR verhalten
   END FOR;
END CFG_array_divider;
tb_array_divider.vhd
-- ############################################################################
-- # Project    :    VHDL-Modellbibliothek				      #
-- #                                                                          #
-- # Filename   :    tb_array_divider.vhd                                     #
-- #                                                                          #
-- # Schaltung  :    Array-Dividierer Testbench                               #
-- #                                                                          #
-- # Modell	:    tb_array_divider                                         #
-- #                                                                          #
-- # Designer   : Wolfgang Sehr; ueberarbeitet von Stefan Schmechtig          #
-- # Abteilung  : Lehrstul fuer rechnergestuetzten Schaltungsentwurf          #
-- # Datum      : 20.01.1995                                                  #
-- ############################################################################
 
-- ############################################################################
-- #                           IEEE PACKAGES                                  #
-- ############################################################################
   Library IEEE;
   use IEEE.std_logic_1164.all;
   use IEEE.std_logic_arith.all;
 
   USE IEEE.math_real.all; 	-- wird fuer die Erzeugung von Zufallszahlen
				-- benoetigt 
-- ############################################################################
 
ENTITY TB_array_divider IS
	GENERIC(X :INTEGER := @BITBR);  -- symmetrisches Array X * X
END TB_array_divider;
 
 
ARCHITECTURE verhalten OF TB_array_divider IS
	SIGNAL tb_dvd		: UNSIGNED ((X-1)   	DOWNTO 0);
	SIGNAL tb_dvs		: UNSIGNED ((X-1)   	DOWNTO 0);
	SIGNAL tb_quot		: UNSIGNED ((X-1)   	DOWNTO 0);
	SIGNAL tb_rest		: UNSIGNED ((X-1)   	DOWNTO 0);
	SIGNAL fehler_num 	: STD_LOGIC;
	SIGNAL fehler_bereich	: STD_LOGIC;
	SIGNAL fehler_insg	: STD_LOGIC;
 
	-- tb_dvd	  : Dividend, der von der Testbench stimuliert wird
	--		  :
	-- tb_dvs	  : Divisor, der von der Testbench stimuliert wird
	--                :
	-- tb_quot	  : Quotient, den die Testbench vom UUT empfaengt
	--                :
	-- tb_rest	  : Rest den die Testbench vom UUT empfaengt
	--                :
	-- fehler_num	  : ist nur '1', wenn Division durch Null auftritt
	--                :
	-- fehler_bereich : ist nur '1', wenn ein von der Testbench
	--		  : ausgegebener Stimuli den Darstellungsbereich
	-- 		  : der Zahl in der gewawehlten Bitbreite uebersteigt
	--                :
	-- fehler_insg    : ist '1', wenn ein Fehler auftritt der auf 
	--		  : UUT zurueckzufuehren ist
 
 
	COMPONENT array_divider
	PORT(dvd	: IN  UNSIGNED ((X-1) 	DOWNTO 0);
	     dvs	: IN  UNSIGNED ((X-1)   DOWNTO 0);
	     quot	: OUT UNSIGNED ((X-1)	DOWNTO 0);
	     rest	: OUT UNSIGNED ((X-1)	DOWNTO 0));
	END COMPONENT;
 
BEGIN
 
   UUT: array_divider               -- einzige Schaltung
	PORT MAP(tb_dvd,
		 tb_dvs,
		 tb_quot,
		 tb_rest);
 
  stim: PROCESS
	VARIABLE	dividend_int 	: INTEGER;
	VARIABLE	divisor_int	: INTEGER;
	VARIABLE	tb_dividend_var	: SIGNED((X-1) DOWNTO 0);
	VARIABLE	tb_divisor_var	: SIGNED((X-1) DOWNTO 0);
 
	-- dividend_int		: Dividend als Integerzahl dargestellt
	-- divisor_int		: Divisor als Integerzahl dargestellt
	-- tb_dividend_var	: Dividend im SIGNED-Format dargestellt
	-- tb_divisor_var	: Divisor im SIGNED-Format dargestellt
 
 
	BEGIN
		    dividend_int := RAND;
		    divisor_int	 := RAND;
 
		    tb_dividend_var := CONV_SIGNED(dividend_int,
 						   tb_dividend_var'LENGTH);
	    	    tb_divisor_var  := CONV_SIGNED(divisor_int,
						   tb_divisor_var'LENGTH);
 
	  	    tb_dvd  <= CONV_UNSIGNED(tb_dividend_var, tb_dvd'LENGTH);
		    tb_dvs  <= CONV_UNSIGNED(tb_divisor_var,  tb_dvs'LENGTH);
 
		    WAIT FOR 0.1 ns;
 
		    tb_dividend_var := CONV_SIGNED(tb_dvd,
						   tb_dividend_var'LENGTH);
		    tb_divisor_var  := CONV_SIGNED(tb_dvs,
						   tb_divisor_var'LENGTH);
 
		    dividend_int := CONV_INTEGER(tb_dividend_var);
		    divisor_int  := CONV_INTEGER(tb_divisor_var);
 
		    WAIT FOR 10 ns;
 
	    LOOP
		-- ------------------------------------------------------------
		-- Bestimmmung des Dividenden		
		-- ------------------------------------------------------------
		dividend_int 	:= RAND;
	    	tb_dividend_var := CONV_SIGNED(dividend_int,
					        tb_dividend_var'LENGTH);
		tb_dvd <= CONV_UNSIGNED(tb_dividend_var, tb_dvd'LENGTH);
		WAIT FOR 0.1 ns;
 
		tb_dividend_var := CONV_SIGNED(tb_dvd, tb_dividend_var'LENGTH);
		dividend_int 	:= CONV_INTEGER(tb_dividend_var);
 
		WAIT FOR 7.5 ns;
		-- ------------------------------------------------------------
 
		-- ------------------------------------------------------------
		-- Bestimmung des Divisors	
		-- ------------------------------------------------------------
		divisor_int  	:= RAND;
		tb_divisor_var	:= CONV_SIGNED(divisor_int,
 					       tb_divisor_var'LENGTH);
	    	tb_dvs  <= CONV_UNSIGNED(tb_divisor_var, tb_dvs'LENGTH);
		WAIT FOR 0.1 ns;
 
		tb_divisor_var 	:= CONV_SIGNED(tb_dvs, tb_divisor_var'LENGTH);
		divisor_int	:= CONV_INTEGER(tb_divisor_var);		
 
		WAIT FOR 12.3 ns;
		-- ------------------------------------------------------------ 
	   END LOOP;
	END PROCESS;
 
 contr: Process(tb_quot, tb_rest)
	VARIABLE quot_sgn : SIGNED(tb_quot'LENGTH-1 DOWNTO 0);
	VARIABLE rest_sgn : SIGNED(tb_rest'LENGTH-1 DOWNTO 0);
 
	VARIABLE quot_int 	: INTEGER;
	VARIABLE rest_int 	: INTEGER;
 
	VARIABLE quot_chk		: INTEGER;
	VARIABLE rest_chk		: INTEGER;
 
	VARIABLE dividend_chk 		: INTEGER;
	VARIABLE divisor_chk		: INTEGER;
 
	VARIABLE dividend_chk_sgn 	: SIGNED((X-1) DOWNTO 0);
	VARIABLE divisor_chk_sgn 	: SIGNED((X-1) DOWNTO 0);		
 
	VARIABLE unzul_bitkomb		: UNSIGNED   ((X-1)   	DOWNTO 0);
 
 
	-- quot_sgn		: Quotient vom UUT empfangen im SIGNED-Format
	--			:
	-- rest_sgn		: Rest vom UUT empfangen im SIGNED-Format
	--			:
	-- quot_int		: Quotient vom UUT empfangen im Integer-Format
	--			:
	-- rest_sgn		: Rest vom UUT empfangen im Integer-Format
	--			:
	-- quot_chk		: Quotient innerhalb der Testbench berechnet
	--			: im Integer-Format	
	--			:
	-- rest_chk		: Rest innerhalb der Testbench berechnet
	--			: im Integer-Format
	--			:
	-- dividend_chk		: Dividend wie er als Stimuli vorliegt,
	--			: aber im Integer-Format
	--			:
	-- divisor_chk		: Divisor wie er als Stimuli vorliegt,
	--			: aber im Integer-Format
	--			:
	-- divisor_chk_sgn	: Divisor sie er als Stimuli vorliegt,
	--			: aber im SIGNED-Format
	--			:
	-- dividend_chk_sgn	: Dividend wie er als Stimuli vorliegt,
	--			: aber im SIGNED-Format
	-- unzul_bitkomb	: In dieser Variable wird die entsprechende
	--			: unzulaessige Bitkombination abgelegt die
	--			: eine Bereichsueberschreitung im jeweiligen
	--			: Zahlenformat darstellt.
	--			: (naemlich: 100.....000)
 
 
 
 
 
	BEGIN
	   -- -----------------------------------------------------------------
	   -- Abfragen der am UUT anliegenden Signale
	   -- -----------------------------------------------------------------
	   dividend_chk_sgn := CONV_SIGNED(tb_dvd, dividend_chk_sgn'LENGTH);
	   divisor_chk_sgn  := CONV_SIGNED(tb_dvs, divisor_chk_sgn'LENGTH);	
 
	   dividend_chk := CONV_INTEGER(dividend_chk_sgn);
	   divisor_chk	:= CONV_INTEGER(divisor_chk_sgn);
 
	   FOR i IN 0 TO (tb_quot'LENGTH-1) LOOP
	       quot_sgn(i) := tb_quot(i);
	   END LOOP;
	   quot_int := CONV_INTEGER(quot_sgn);
 
	   FOR i IN 0 TO (tb_rest'LENGTH-1) LOOP
	       rest_sgn(i) := tb_rest(i);
	   END LOOP;
	   rest_int := CONV_INTEGER(rest_sgn);
	   -- -----------------------------------------------------------------
 
	   -- -----------------------------------------------------------------
	   -- Berechnung der Ausgangssignale, die am UUT anliegen muessen,
	   -- lediglich aufgrund der Eingangssignale
	   -- "Vergleichsmodell"
	   -- -----------------------------------------------------------------
	   IF ( divisor_chk /= 0) THEN
	      quot_chk := dividend_chk / divisor_chk;
	      rest_chk := dividend_chk - (divisor_chk*quot_chk);
	   END IF;
	   -- -----------------------------------------------------------------
 
	   -- -----------------------------------------------------------------
	   -- Ueberpruefung, ob die Zahlenwerte, die im UUT berechnet wurden,
	   -- mit denen die hier in der Testbench berechnet wurden ueberein-
	   -- stimmen bzw., ob andere Fehler auftreten
	   -- ----------------------------------------------------------------- 
	   unzul_bitkomb := CONV_UNSIGNED(0, tb_dvd'LENGTH);
	   unzul_bitkomb(tb_dvd'LENGTH-1) := '1';
 
	   IF (tb_dvd = unzul_bitkomb) THEN
		fehler_num 	<= '0';
		fehler_bereich 	<= '1';
		fehler_insg 	<= '0';
	   ELSIF (divisor_chk = 0) THEN
		fehler_num 	<= '1';
		fehler_bereich 	<= '0';
		fehler_insg 	<= '0';
 
	   ELSE 
	   	IF (quot_chk /= quot_int) OR (rest_chk /= rest_int) THEN
		   fehler_num 		<= '0';
		   fehler_bereich 	<= '0';
		   fehler_insg 		<= '1';
	        ELSE
		   fehler_num 		<= '0';
		   fehler_bereich 	<= '0';
		   fehler_insg 		<= '0';
		END IF;
	   END IF;
	   -- -----------------------------------------------------------------
 
	END PROCESS;
 
 
END verhalten;
 
 
CONFIGURATION CFG_TB_array_divider OF TB_array_divider IS
   FOR verhalten
	FOR UUT: array_divider
	  	USE CONFIGURATION WORK.CFG_array_divider;
	END FOR;
   END FOR;
END CFG_TB_array_divider;
trace_array_divider.vhd
tr tb_dvd
tr tb_dvs
tr tb_quot
tr tb_rest
tr fehler_num
tr fehler_bereich
tr fehler_insg
 
cd stim
tr dividend_int
tr divisor_int
 
cd contr
tr quot_int
tr rest_int