Verilog: Signed Division durch Zweierpotenz

[Martin O. (ossi-2)]

Ich will in Verilog einen "Signed" Wert durch 2 (oder eine andere 
Zweierpotenz) teilen. Wenn ich das mit einem einfachen Rechts-Shift 
mache, ist die Arithmetik nicht symmetrisch.

Beispiel:
 11>>1 ergibt 5  ,
-11>>1 ergibt aber -6.

x=  11 = 0000001011     x>>1=   5 = 0000000101
x= -11 = 1111110101     x>>1=  -6 = 1111111010

Ich möchte eine Funktion, die symmetrisch arbeitet, bzw. der üblichen 
Divsion
entspricht. Gibt es eine etablierte Lösung in Verlog?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Martin O. schrieb:
> Beispiel:
>  11>>1 ergibt 5
Das ist mathematisch falsch. Denn eigentlich wird bei einer Zahl, die 
genau auf ",5000000..." endet, zur nächsten geraden Zahl hin gerundet.
Siehe http://de.wikipedia.org/wiki/Rundung unter "Mathematisches Runden"

> -11>>1 ergibt aber -6.
Was eigentlich korrekt ist...

Wenn du aber unbedingt zwangsweise in Richtung Null runden willst, dann 
addiere einfach bei einer negativen Zahl eins drauf und schiebe sie dann 
nach rechts...

[(prx) A. K. (prx)]

Lothar Miller schrieb:
>>  11>>1 ergibt 5
> Das ist mathematisch falsch.

Bei Schiebeoperation im Zweierkomplement ist das korrekt.

> Siehe http://de.wikipedia.org/wiki/Rundung unter "Mathematisches Runden"

Schon mal eine Schiebeoperation mit Rundung gesehen?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

A. K. schrieb:
> Schon mal eine Schiebeoperation mit Rundung gesehen?
Nein, aber die Frage war ja nach der Rundung einer negativen Zahl zur 
Null hin...

Der Synthesizer selber wird jede Division, die einfach mit "/2" dasteht 
durch eine "Schiebeoperation" ersetzen (in der Realität durch einfaches 
Ignorieren des LSB).

[(prx) A. K. (prx)]

Lothar Miller schrieb:
> Der Synthesizer selber wird jede Division, die einfach mit "/2" dasteht
> durch eine "Schiebeoperation" ersetzen (in der Realität durch einfaches
> Ignorieren des LSB).

Gibts in Verilog überhaupt negative Zahlen im Zweierkomplement, oder ist 
das Sache des Anwenders und das Ergebnis folgt der alten Regel "Schrott 
rein Schrott raus"?

Aber die Lösung ist einfach: Für Zahlen mit Vorzeichen das 
Einerkomplement an Stelle des Zweierkomplements verwenden. ;-)

[Frank F. (frank_f49)]

Bei signed shift nimmt  man

>>>

und nicht

>>

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Frank Fahrenheit schrieb:
> Bei signed shift nimmt  man

>>>

Und was wird dann tatsächlich daraus gemacht?

In VHDL ist es jedenfalls so, dass bei einem negativen "integer" oder 
"signed" die Division und auch der Shift nicht symmetrisch ist: es wird 
einfach das LSB weggelassen.

[Marcus H. (mharnisch)]

Lothar Miller schrieb:
> Der Synthesizer selber wird jede Division, die einfach mit "/2" dasteht
> durch eine "Schiebeoperation" ersetzen (in der Realität durch einfaches
> Ignorieren des LSB).

"The integer division shall truncate any fractional part toward 0" (IEEE 
1800-2012)

Daraus folgt, dass ein Synthesewerkzeug, sofern es den Operator 
unterstützt, ihn auch entsprechend implementieren muss.

Erst schieben wollen, um vermeintlich "unnütze" Logik zu vermeiden und 
dann meckern, dass es nicht so funktioniert wie man es sich vorstellt. 
Wer Division meint, soll auch Division sagen und den Rest dem Tool 
überlassen.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Marcus Harnisch schrieb:
> Daraus folgt, dass ein Synthesewerkzeug, sofern es den Operator
> unterstützt, ihn auch entsprechend implementieren muss.
Ich nehme alles zurück und behaupte das Gegenteil!
Natürlich macht der Synthesizer die Signed Division so, dass er erst das 
Zweierkomplement bildet, dann abschneidet und dann wieder das 
Zweierkomplement bildet. Dementsprechend braucht er für die 
signed-Division 2 Addierer:
Macro Statistics
# Adders/Subtractors   : 2
 8-bit adder           : 2

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity DivVsShift is
    port ( slv       : in  std_logic_vector (7 downto 0);

           uns_shift : out std_logic_vector (7 downto 0);
           uns_div   : out std_logic_vector (7 downto 0);
           sig_shift : out std_logic_vector (7 downto 0);
           sig_div   : out std_logic_vector (7 downto 0)
       );
end DivVsShift;

architecture Behavioral of DivVsShift is
begin
    uns_div   <= std_logic_vector( unsigned(slv) / 8);
    uns_shift <= std_logic_vector( shift_right( unsigned(slv), 3));
    sig_div   <= std_logic_vector(   signed(slv) / 8);
    sig_shift <= std_logic_vector( shift_right(   signed(slv), 3));
end Behavioral;

[Peter B. (funkheld)]

Für Datentypen mit Vorzeichen:
>>> oder <<<

Wird in Verilog einfacher geregelt, nicht so kompliziert wie in VHDL.

http://www.asic-world.com/verilog/verilog2k1.html
(bis zur Mitte scollen)

---------------------------
Und was wird dann tatsächlich daraus gemacht?
---------------------------

Natürlich bleibt es eine Signed.....

Natürlich muss sie vorher  so deklariert werden :
reg signed [7:0] a;

so ist es immer eine unsigned:
reg signed [7:0] a;

Gruss

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Peter Bierbach schrieb:
> Wird in Verilog einfacher geregelt, nicht so kompliziert wie in VHDL.
Was ist an einen /2 kompliziert? Natürlich muss man auch dort den 
richtigen Datentypen verwenden.
Der erwähnte Dreizack als arithmetischer Shift ist zwar tricky, aber 
nicht unbedingt intuitiv...

[Peter B. (funkheld)]

-----------------------------------
Der erwähnte Dreizack als arithmetischer Shift ist zwar tricky, aber
nicht unbedingt intuitiv...
-----------------------------------
Es geht auch ohne Textromane.... um etwas auszuführen.

Damals hat man in "C" so gedacht als es erfunden wurde.
Und einige Befehle von  "C" sind danach in vielen anderen Sprachen
übernommen worden...,...

Gruss

[berndl (Gast)]

Peter Bierbach schrieb:
> Natürlich muss sie vorher  so deklariert werden :
> reg signed [7:0] a;
>
> so ist es immer eine unsigned:
> reg signed [7:0] a;

Super Erklaerung! Peter, ich danke dir! Du hast mich technisch und 
menschlich richtig weit nach vorn' gebracht...

Au Mann...

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Peter Bierbach schrieb:
> -----------------------------------
> Der erwähnte Dreizack als arithmetischer Shift ist zwar tricky, aber
> nicht unbedingt intuitiv...
> -----------------------------------
> Es geht auch ohne Textromane.... um etwas auszuführen.
Und was genau ist an "/2" wesentlich länger oder gar unverständlicher 
als an ">>>"?

[Marcus H. (mharnisch)]

Lothar Miller schrieb:
> Und was genau ist an "/2" wesentlich länger oder gar /unverständlicher/
> als an ">>>"?

Der Unterschied ist, dass /2 für den gegebenen Fall das richtige 
Ergebnis erzeugt ;)

[foo (Gast)]

Martin O. schrieb:
> Beispiel:
>  11>>1 ergibt 5  ,
> -11>>1 ergibt aber -6.

Dieses Abrunden ist Programmierern auch unter dem Namen FLOOR bekannt: 
http://de.wikipedia.org/wiki/Abrundungsfunktion_und_Aufrundungsfunktion

[peter (Gast)]

------------------------
berndl (Gast)
-----------------------

So ist es nun, einige Veriloger nehmen an , das sie einfach :
reg [7:] test=-23 ; setzen können.

Natürlich geht das , es wird eine -23 draus wenn ich die Bits 
arithmetisch betrachte. Wird aber bei jeder Benutzung als unsigned 
genommen.

[peter (Gast)]

---------------------------------------
Der Unterschied ist, dass /2 für den gegebenen Fall das richtige
Ergebnis erzeugt ;)
---------------------------------------
Hier wird mehr Platz verschwendet im FPGA , beim VERILOG  weniger.

Nur probieren....dann sieht man das Ergebnis.

Gruss

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

peter schrieb:
> Hier wird mehr Platz verschwendet im FPGA , beim VERILOG  weniger.
Vermutlich, weil etwas Anderes gemacht wird. Einfach ausprobieren...
Eine Signed-Division brauch nun mal das Zweierkomplement weil sie etwas 
Anderes ist als ein Rechtsshift...

[Martin O. (ossi-2)]

Besten Dank für die (größtenteils) hilfreichen Anregungen.
Problemlösung bei mir war die Verwendung von /4096
zusammend mit der konsequenzen Verwendung von "signed".
Im nachhinein naheliegend, aber für mich als Verilog/FPGA Anfänger
gibt's halt doch viel zu lernen.

[peter (Gast)]

--------------------------------------
Vermutlich, weil etwas Anderes gemacht wird.
--------------------------------------

Wahrscheinlich wird da ein anderer Weg genommen, vermute ich auch.

Gruss

[Christian R. (supachris)]

peter schrieb:
> Wahrscheinlich wird da ein anderer Weg genommen, vermute ich auch.

Kommt denn bei der vereinfachten Verilog Beschreibung auch das richtige 
Ergebnis raus?

[peter (Gast)]

------------------------------
Kommt denn bei der vereinfachten Verilog Beschreibung auch das richtige
Ergebnis raus?
-------------------------------


Wenn ich den weg :
reg signed [7:0] a;
einhalte ja.

bei :
reg  [7:0] a;
werden alle Bits normal berechnet ala "unsigned"

Gruss

[peter (Gast)]

Hmmm...

Bei >>> oder <<< wird das 7.Bit nicht mit genommen.
Bie >> oder << wird es mit genommen:

Gruss