Wurzel ziehen - VHDL

Im package math_real gibt es eine Wurzelfunktion.

USE ieee.math_real.all;

function sqrt(x:in real) return real;

logik, also ich gebrauchs in einem process

das nächste wär ja, das mein input integer und nicht real ist

Kannst du mal deine benötigten Formeln hier hinschreiben? Oft kann die 
die Benutzung einer Wurzelfunktion durch Umformen der Formel ungehen.

> Mein Problem dabei ist das ausrechnen der Wurzel.
Dein vorrangiges Problem ist das Ausrechnen der Wurzel.
Auch das 1/(...) ist für die Synthese nicht ohne.

Wie wäre es, eine Tabelle mit der Funktion abzulegen und zwischen den 
Stützpunkten zu interpolieren?

die formel ist:

1/sqrt(1+2^(-2*i))

Ich habe auch schriftlich Wurzelziehen inner schule gelernt, und bin 
erst 1997 eingeschult worden. lernte man also nicht nur "Früher" ;)

Wie wäre es mit modified Dijkstra's square root?
 Ich habe auch keine Erfahrung damit.


http://lib.tkk.fi/Diss/2005/isbn9512275279/article3.pdf

Wofür braucht man bei einem Dynamikkompressor noch den RMS?

Da haben wir doch den richtigen in der Runde >>Vladimir Baykov

Ich habe mich mit Cordic auch schon intensiv beschäftigt, allerdings zur 
Sinussignalerzeugung.
http://www.dossmatik.de/vhdl.html

Die Wurzel lässt sich im hyperbolischen Modi berechnen. Wenn ich mich 
richtig erinnere, müssen bestimmte Interationsschritte doppelt 
durchgeführt werden.

Die Formel-Sprache der Mathematiker ist international.
Leider fehlen ein paar Diagramme oder ein Strukturgramm für den 
Algorithmus, um einen Einstieg zu haben. Das ist das eigentliche Problem 
Vladimir's.

Es handelt sich bei allen Problemen um Kegelschnitte. Auf diesen 
Schnittebenen gibt es mit jedem Schritt eine Bewegung, die sich dem 
Ergebnis nähert. Die Schrittweite wird mit jedem Schritt auch kleiner. 
Diese Schritte muss man sich mal in ein Diagramm eintragen, dann 
versteht man es.



Ander blöde Frage was ist RMS?
RMS ist bei mir root mean square, der Quadratische Mittelwert

> der Quadratische Mittelwert
Richtig, nachdem man die Quadrate gebildet und bearbeitet hat, sollte 
man die Wurzel ziehen...

Ich habe mich mit Cordic nochmal beschäftigt.
Es lässt sich die Wurzel nur indirekt berechnen.
Mit der hyperbolische Variante lässt sich folgende Funktion annähern.

Nimmt man für

 und

So berechnet man:

So die Theorie. Es könnte sein, dass es noch eine einfachere Cordic 
Variante gibt. Das ist meine eigene Herleitung.

>>Jürgen

ich habe leider in deinem Link nicht gefunden, wie man eine Wurzel 
berechnet.

>> Melanie

>>die formel ist:

>>1/sqrt(1+2^(-2*i))

Wenn mich nicht alles täucht, ist das der der reziproke Cordic gain? Bei 
Cordic ist das eine Konstante! Also wenn du Cordic vor hast, dann ist 
dieser Wert nicht ständig zu berechnen.

ralf schrieb:
> "df" , "f"?
df    = Hex-Zahl (beginnt in C mit 0x)
0.5f  = Null Komma Fünf als float
Das ist jetzt aber eigentlich keine Frage wert, weil Urschleim^3 ... :-/

>>Quake 3
> ?
Das ist/war ein Computer-Spiel.

BTW: warum mußt du hier so alte Threads wieder ausgraben?

ralf schrieb:
>> Mir fällt dazu nur wieder der Quake 3 Source Code ein:

1

 float InvSqrt (float x) {

2

     float xhalf = 0.5f*x;

3

     int i = *(int*)&x;

4

     i = 0x5f3759df - (i>>1);  // hier muß man sich mal den Aufbau einer IEEE float-Zahl genauer anschauen

5

     x = *(float*)&i;

6

     x = x*(1.5f - xhalf*x*x);

7

     return x;

8

 }

> Kann mir das bitte mal jemand entschlüsseln?
Spiel doch mal selber Prozessor und sieh dir dazu vorab den Aufbau von 
IEEE 754 float-Zahlen mal sehr genau an. Da wird nämlich auf Bit-Ebene 
in einer solchen Zahl herumgemantscht...
Als Tipp:
es kommt (mit hinreichender Genauigkeit) der Kehrwert der Wurzel raus
InvSqrt(36.000000) = 0.166477 --> 6.006850
InvSqrt(49.000000) = 0.142762 --> 7.004646
InvSqrt(64.000000) = 0.124788 --> 8.013566
InvSqrt(81.000000) = 0.111086 --> 9.002046

> Ist das rekursiv?
Nein, weil InvSqrt() nicht innerhalb von InvSqrt() aufgerufen wird.

Das ist das Newton'schen Näherungsverfahren, bei der einfach die erste 
Division des 1/k-Wertes weggelassen wurde, wodurch man folglich 1/sqrt() 
erhält. Keine Hexerei. Der wirklich kluge Kunstgriff dieses Ansatzes 
besteht im trickreichen Ermitteln des Startwertes, damit die Folge schon 
nach der ersten Korrektur gut konvergiert.

Im Grunde wäre es auch für FPGAs gut nutzbar, allerdings liegen im FPGA 
die Werte so selten im float vor :-)

Um zu einem guten Startwert zu gelangen, muss man anders vorgehen. Ich 
habe da selber schon einiges probiert, allerdings kosten die meisten 
Überlegungen zuviel Zeit, um noch effizient zu sein. Ein VHDL-Wurzel 
Core auf binärer Basis braucht mitunter deutlich weniger Takte, als die 
Eingangsbitbreite.

Morten schrieb:
> Ist bekannt, worum hier das "INT I=1" sein soll? Das wird weder
> fortgeschrieben, noch verwendet. Ist das überhaupt von Nöten?

Offenbar nicht. Könnte sein, dass es ein Überbleibsel des original Algos 
von Dijkstra ist, wobei ich nicht genau weiß, wie der aussieht. Ich sehe 
auch nicht, was daran jetzt so Schlaues sein soll, bzw. worin wiederum 
die Modifikation der Autoren besteht.

Die vorgestellte Methodik ist ein iteratives Näherungsverfahren, welches 
weitgehend dem schriftlichen Wurzelziehen aus der Schule entspricht, das 
seinerseits wiederum auf selbiges von Heron zurückgeht, wie ich weiter 
oben schon angemerkt hatte.


Morten schrieb:
> Welche Möglichkeit gibt es für die Lösung des Problems?
Welches Problem besteht? Der Algo als solcher funktioniert ja.
Ich denke, "I" ist ein Zähler, der die Anzahl der Iterationen und damit 
Rechentiefe mitprotokolliert. Diese ist allerdings durch die Wahl der 
Breite des Eingangsvektors bereits implizit determiniert. Redundante 
Info.

Entwickler schrieb:
> Wenn es den gäbe, müsste man nicht einen Core dafür entwickeln:

Ob man pauschal von der Existenz eines Cores in der Bib eines 
Herstellers darauf schließen kann, dass dieser das nun plus ultra ist 
und es nicht Besseres gibt, sei mal dahin gestellt. Ich verweise an 
dieser Stelle auf die anderweitig gepostete Gegenüberstellung meiner DDS 
und der von Xilinx :-)


Nochmals zu dem Dokument hier:

Mir ist beim nochmaligen Überfliegen nicht so ganz klar, worin jetzt 
genau die Errungenschaft besteht. Irgendwie liest es sich, als hatten 
die Autoren nur Probleme, die in C formulierte "Rotation" des 
Zwischenvektors in VHDL abzubilden, weil es keinen Befehl dafür gab und 
das irgendwie klug gelöst.

Ich nehme an, dass das (nicht publizierte) VHDL den links in der Box 
dargestellten Algorithmus tatsächlich sequenziell abbildet und dort 
wirklich Zwischenwerte rotiert werden.

Dass man aber in VHDL eine Rotation durch ein Verschieben bzw Umgreifen 
realisiert, muss hier eigentlich nicht erwähnt werden und sicher auch 
nicht, dass man nicht nur auf das Hineinpassen des Probevektors mit 
Faktor 2 auf Ja und Nein testen kann, um zu entscheiden, ob man eine 1 
oder 0 in den Ergebnisvektor setzt.

Ich habe das z.B. in "meiner" VHDL-Wurzel mit 4 Fragezweigen realisiert 
und kann folglich in einem Takt 2 Ergebnisbits bilden. Damit kriegt man 
aus den 32 Eingangsbits die 16 Ausgangsbits in 8 Takten raus.

Daraus mache ich jetzt aber kein paper :-)

... sondern verweise auf den einfachen Algo hier:
Beitrag "Re: Wurzel ziehen - VHDL"

Edi M. schrieb:
> Darf man das irgendwo bestaunen?

Ist in einigen designs verbaut, z.B. wo es um Abstandsberechnungen mit X 
und Y geht, um Radien zu ermitteln, oder komplexe Zahlen zu berechnen.

Als Core erhältlich :-)