CORDIC-Algorithmus zur Auswertung elementarer Funktionen in Hardware

(1)

CORDIC-Algorithmus zur Auswertung

elementarer Funktionen in Hardware

• Verfahren

• Implementierung in VHDL

FH-Report

(2)

Dipl.-Ing.(FH) Marcel Beuler

Fachhochschule Gießen-Friedberg FB Elektro- und Informationstechnik Wiesenstraße 14

35390 Gießen

CORDIC-Algorithmus zur Auswertung

elementarer Funktionen in Hardware

Version 1.2

(3)

Inhaltsverzeichnis

1 Einführung...1

2 Der CORDIC-Algorithmus...2

2.1 Herleitung...2

2.2 Betriebsarten des CORDIC-Algorithmus...5

2.3 Verallgemeinerung des CORDIC-Algorithmus...7

2.3.1 Hyperbolischer Modus (m=-1)...10

2.3.2 Linearer Modus (m=0)...13

2.3.3 Berechnung der Exponentialfunktion...14

2.3.4 Erweiterung des zulässigen Argument-Bereiches

für artanh(), ln() und sqrt()...15

2.3.5 Zusammenfassung CORDIC-Algorithmus...18

3 Prinzipielle Möglichkeiten der Implementierung...19

3.1 Bitparallele iterative CORDIC-Struktur...19

3.2 Bitserielle iterative CORDIC-Struktur...19

3.3 Bitparallele CORDIC-Struktur, rein kombinatorisch...20

3.4 Bitparallele CORDIC-Struktur mit Pipeline-Registern...21

4 Implementierung in VHDL...22

4.1 Funktionaler Überblick...22

4.2 Vorstufe...23

4.3 Erweiterung des Argument-Bereiches der exp-Funktion...25

4.4 CORDIC-Iterationen...27

4.5 Skalierung – Konstantenmultiplizierer...30

4.6 Zusätzliche Operationen für ln-Berechnung...34

4.7 Zusätzliche Operationen für sqrt-Berechnung...35

4.8 Endstufe...35

4.9 Simulation...37

A Anhang...40

A1 C-Quellcode zur Berechnung von sin() und cos()...40

A2 C-Quellcode zur Berechnung von arctan()...40

A3 C-Quellcode zur Berechnung von arcsin()...41

A4 C-Quellcode zur Berechnung von sinh() und cosh()...41

A5 C-Quellcode zur Berechnung von sinh() und cosh()...42

A6 C-Quellcode zur Berechnung von artanh()...42

A7 C-Quellcode zur Multiplikation im linearen Modus...43

A8 C-Quellcode zur Division im linearen Modus...43

A9 C-Quellcode zur Berechnung von exp()...44

A10 VHDL-Quellcode für CORDIC-Algorithmus...45

(4)

1 Einführung

Taylor-Polynome werden traditionell als die erste und häufig auch alleinige Möglichkeit dargestellt, elementare Funktionen auszuwerten [Riss04]. Dabei zeigen schon einfachste, ältere Taschenrechner, dass eine Potenzreihen-Entwicklung eher nicht die Methode dieser Berechnung sein kann. Eigenschaften von Intel x86 (Co-) Prozessoren deuten in dieselbe Richtung.

Zunächst sei an die Taylor-Reihe einer Exponentialfunktion erinnert. Nach [Papu01] gilt hierfür:

1 2 3 4 0

1 1!

2!

3!

4!

!

n x n

x

e

n

∞ =

= +

+

+ =

…

∑

(1.1)

Um zu zeigen, dass die Konvergenz-Geschwindigkeit dieser Reihe vom Argument abhängig ist, betrachten wir folgendes Zahlenbeispiel (die Taylor-Reihe wird bei n=8 abgebrochen):

0.5 5.7

1.6487212707 (Taschenrechner)

e

298.8674009671 (Taschenrechner)

e

=

8 0.5 0

0.5 1.6487212650

!

n n

e

n

=

≈

∑

=

8 5.7 0

5.7 261.9926451175

!

n n

e

n

=

≈

∑

=

Bei einer Hardware-Realisierung könnten die Nenner-Fakultäten als Konstanten in einem Speicher (Look-Up Table) abgelegt werden. Dann hat man immer noch das Problem, dass mit größer werdendem x immer mehr Glieder zur Erzielung einer vorgegebenen Genauigkeit erforderlich sind. Um die Berechnungszeit in Grenzen zu halten, müssten die Potenzen durch den Einsatz vieler Multiplizierer parallel ermittelt werden, und deren Umsetzung ist in digitalen Schaltungen bekanntlich aufwändig.

Es wird deutlich, dass die Berechnung elementarer Funktionen mittels Taylor-Reihe für eine Hardware-Realisierung aus Aufwandsgründen und schlechter Abschätzung des Konvergenzverhaltens (Berechnungszeit der Exponentialfunktion würde mit dem Argument schwanken) nicht in Frage kommt. Abhilfe schaffen iterative Verfahren wie CORDIC- und Bitalgorithmus, die auf einem Tripel (x,y,z) bzw. einem Tupel (x,y) operieren. Diese Algorithmen werden üblicherweise in der ingenieurwissenschaftlichen Ausbildung nicht behandelt, obwohl sie in vielen Anwendungen wie beispielsweise Signal- oder Bildverarbeitung eine wichtige Rolle spielen. Grund genug, sich mit diesen Verfahren auseinanderzusetzen!

Eine ganz besondere Bedeutung hat der hier behandelte CORDIC-Algorithmus erlangt. Er ist zwar nach [WEB01] nicht der schnellste Algorithmus, wird aber aufgrund des Bestrebens nach einer regulär und einfach strukturierten Hardware oft eingesetzt. Durch Änderung eines Parameters können hier trigonometrische und hyperbolische Funktionen sowie die Exponential-, Logarithmus- und die Wurzelfunktion berechnet werden.

(5)

β

(

x

_n

,

y

_n

)

0 0

(

x y

,

)

ϕ

y

x

r

β

(

x

_n

,

y

_n

)

0 0

(

x y

,

)

ϕ

y

x

r

2 Der CORDIC-Algorithmus

Der CORDIC-Algorithmus wurde 1959 von J. E. Volder entwickelt und 1971 von J. S. Walther auf die heute übliche Form erweitert. CORDIC ist die Abkürzung für Coordinate Rotation Digital Computer [Pirs96]. Dieser Algorithmus ermöglicht es, elementare trigonometrische und hyperbolische Funktionen unter fast ausschließlicher Verwendung von schnellen Operationen effizient zu berechnen. Mit schnellen Operationen sind hier Additionen (adds) und Multiplikationen mit Zweier-Potenzen (shifts) gemeint.

2.1 Herleitung

Ausgangspunkt für die Herleitung des CORDIC-Algorithmus ist die Drehung eines Vektors [x0,y0] T

um den Winkel φ in einem kartesischen Koordinatensystem, siehe Bild 2.1. Durch die Drehung wird der Betrag des Vektors nicht verändert.

Bild 2.1: Vektordrehung im kartesischen Koordinatensystem

0 0 0 0

cos( )

sin( )

x

r

y

r

β

=

⇒

_{= ⋅}

=

⇒

_{= ⋅}

Unter Anwendung der Additionstheoreme nach [Papu01] ergibt sich:

0 0

cos(

)

cos( ) cos( )

sin( ) sin( )

n

x y

x

= ⋅

r

β ϕ

+

= ⋅

r

β

⋅

ϕ

− ⋅

r

β

⋅

ϕ

x

_n

= ⋅

x

₀

cos( )

ϕ

−

y

₀

⋅

sin( )

ϕ

(2.1a)

0 0

sin(

)

sin( ) cos( )

cos( ) sin( )

n

y x

y

= ⋅

r

β ϕ

+

= ⋅

r

β

⋅

ϕ

+ ⋅

r

β

⋅

ϕ

y

_n

= ⋅

x

₀

sin( )

ϕ

+

y

₀

⋅

cos( )

ϕ

(2.1b)

Die Gln. (2.1a) und (2.1b) lassen sich zur sog. Drehmatrix zusammenfassen. Der Ergebnisvektor [xn,yn]

T

berechnet sich demnach wie folgt:

0 0

cos( )

sin( )

cos( )

n n

x

y

ϕ

−













=

⋅

























(2.2)

(6)

2

1 cos( )

1 tan ( )

ϕ

=

+

(2.3)

Durch Ausklammern von cos(φ) lässt sich die Beziehung nach Gl. (2.2) derart modifizieren, dass innerhalb der Drehmatrix nur noch eine Abhängigkeit von einer Winkelfunktion besteht:

0 0

2

0 0

1 tan( )

1

1 tan( )

cos( )

tan( )

1 _{1 tan ( )}

tan( )

1

n n

x

y

ϕ

_ϕ

ϕ

−





















=

⋅

=

⋅





































₊





(2.4)

Bei dem CORDIC-Algorithmus wird die Drehung um den Winkel φ durch mehrere Rotationen mit bekanntem Teilwinkel αi realisiert [Pirs96]:

1 0

{ 1,1}

n i i i i

ϕ

−

σ α

σ

=

∑

⋅

∈ −

(2.5)

Durch festzulegende Vorzeichen σi wird die Summe der n Teilwinkel αi den gegebenen Winkel φ

annähern. Um n für eine vorgegebene Genauigkeit möglichst gering zu halten, wird der Betrag der Teilwinkel αi mit größerem Index abnehmen. Sollen nur einfachste Bauelemente zum Einsatz

kommen, dann kann dies durch eine Folge von Zweierpotenzen erreicht werden:

tan(

α

_i

)

=

2

−i (2.6)

Weiterhin wird nach [Pirs96] eine Hilfsvariable zi eingeführt, die die aufakkumulierten Teilwinkel enthält

und sich zur Steuerung der Vorzeichen der Teilwinkel verwenden lässt (Rotating-Mode):

z

i+₁

= − ⋅

z

i

σ

i

arctan(2 )

−i

= −

z

i

sgn( ) arctan(2 )

z

i

⋅

−i (2.7) mit:

sgn( )

1

0

1

0

i i i i

z

σ

=





+

≥

−

<



(2.8)

CORDIC-Algorithmen operieren somit auf Tripeln (xi,yi,zi). Für das Matrixprodukt nach Gl. (2.4) ergibt

sich nun: 1 1 0 0 0 0 0 0

1

2

1

2 cos(

)

2

1

2

1

i i n n n i i i _i _i n i i i i

x

K

y

σ

α

σ

− − − − − − = =



_{− ⋅}





_{− ⋅}















=

⋅





⋅

= ⋅





⋅













⋅













∏

_

_





∏

_

_





(2.9) mit: 1 1 1 2 2 0 0 0

1

1 cos(

)

1 tan (

)

1 2

n n n i i i i _i i

K

α

− − − − = = =

=

+

∏

(2.10)

K ist der sog. Skalierungsfaktor. Da der Kosinus eine gerade Funktion ist, spielt das Vorzeichen bei der Skalierung keine Rolle [WEB01]. Für n→∞ liefert K folgenden Wert:

1 2 0

1 lim

0.607253

1 2

n i n i

K

− − →∞ =

=

≈

+

∏

(2.11)

Ist n groß genug (n≥10), dann wird dieser Wert gut approximiert. Bei dem CORDIC-Algorithmus ist also am Ende des Iterationsablaufes zur Skalierung auf den korrekten Amplitudenwert noch eine abschließende Multiplikation mit dem in Gl. (2.11) angegebenen Faktor durchzuführen.

Die einzelnen Teilschritte des Matrixproduktes nach Gl. (2.9) lassen sich (ohne Skalierung) durch Gl. (2.12) beschreiben. Eine solche CORDIC-Rotation besteht nach [Riss04] aus zwei SHIFTs und zwei ADDs und lässt sich daher mit minimalem Hardware-Aufwand durchführen.

(7)

( )

1 1 1 0

1

2

1

2

0 sgn( ) arctan 2

i i i i i i i i i i i _i i _i _i _i i i i i

x

y

_y

_x

z

σ

ϕ

− − + − − + − +



_{− ⋅}





_{− ⋅}

_⋅







 

=





⋅

=









 

⋅

+ ⋅

⋅













_

_

 

_

_

←

= −

⋅

=

(2.12)

Die in [Riss04] angegebenen SHIFT- und ADD-Operationen berücksichtigen jedoch noch nicht den zu bestimmenden Arkustangens der Hilfsvariablen zi. Hierzu wird nach [WEB01] vor der eigentlichen

Berechnung eine Tabelle T fester Länge L angelegt, wobei gilt: ₁

arctan( )

₁

mit:

₁

1

4 T

=

δ

=

π

δ

=

(2.13a)

T

j

=

arctan(

δ

j

) mit:

δ

j

=

δ

j−₁

2 ; 2

≤ ≤

j

L

(2.13b)

Die Länge L der Tabelle bestimmt die erreichbare Genauigkeit. Führt man alle CORDIC-Rotationen mit den so berechneten Tabellenwerten hintereinander im gleichen Drehsinn aus, so erzielt man nach Gl. (2.14) eine Gesamtdrehung von etwas mehr als ±π/2. Der Konvergenzbereich des Verfahrens erstreckt sich somit über mehr als den vierten und ersten Quadranten.

( )

1 0

arctan 2

1.74

n i i

ϕ

− − =

= ±

∑

≈ ±

(2.14) Beispiel 2.1: Der Vektor [x0,y0] T

=[4,1]T soll um φ=52°=0,907571 gedreht werden (vgl. mit Bild 2.1). M ittels CORDIC-Algorithmus ist der skalierte Ergebnisvektor [x8,y8]

T

mit K nach Gl. (2.11) zu bestimmen und mit der exakten Lösung zu vergleichen. Da φ>0 ist, ist das Start-Vorzeichen σ0 positiv. Mit Gl. (2.12) ergeben

sich folgende Iterationsschritte:

( )

0 1 0 0 0 0 1 0 0 0 0 1 0 0 1 2 3 2 5 arctan 2 0.122173 0 1 x x y y y x z z σ σ σ σ − − − = − ⋅ ⋅ = = + ⋅ ⋅ = = − ⋅ = > ⇒ =

( )

1 2 1 1 1 1 2 1 1 1 1 2 1 1 2 2 0.5 2 6.5 arctan 2 0.341475 0 1 x x y y y x z z σ σ σ σ − − − = − ⋅ ⋅ = = + ⋅ ⋅ = = − ⋅ = − < ⇒ _{= −}

( )

3 4 3 3 3 3 4 3 3 3 3 4 3 3 4 2 2.92188 2 6.10938 arctan 2 0.027859 0 1 x x y y y x z z σ σ σ σ − − − = − ⋅ ⋅ = = + ⋅ ⋅ = = − ⋅ = > ⇒ ₌

( )

6 7 6 6 6 6 7 6 6 6 6 7 6 6 7 2 2.83374 2 6.16986 arctan 2 0.012304 0 1 x x y y y x z z σ σ σ σ − − − = − ⋅ ⋅ = = + ⋅ ⋅ = = − ⋅ = > ⇒ ₌

( )

7 8 7 7 7 7 8 7 7 7 7 8 7 7 8 2 2.78554 2 6.192 arctan 2 0.004492 0 1 x x y y y x z z σ σ σ σ − − − = − ⋅ ⋅ = = + ⋅ ⋅ = = − ⋅ = > ⇒ ₌ Skalierungsfaktor nach Gl. (2.11): 8

0.607259

n

K

₌

=

⇒

8 8 8 8

K

1.69154

3.76015

x

K y

y

⋅ →

=

⋅

→

=

Für den exakten Ergebnisvektor [xn,yn]T gilt nach Gl. (2.2):

1.67464

3.7677

n n

x

y









=

















(8)

Beispiel 2.2:

Mit dem CORDIC-Algorithmus sollen die trigonometrischen Funktionen sin(φ) und cos(φ) für φ im Bogenmaß mit |φ|<π/2 approximiert werden. Nach Gl. (2.2) lautet der Ausgangsvektor [x0,y0]

T

:

0 0

1 cos( )

sin( )

1 cos( )

0 sin( )

cos( )

0 sin( )

n n

x

y

ϕ

−





 







  





=

⇒

₌

_⋅

₌





 







  





 



  













Der im Anhang A1 angegebene C-Quellcode führt n=15 Rotationen mit φ=0.6 durch und gibt anschließend den skalierten Ergebnisvektor aus. Man erhält folgende Werte:

x = 0.82530795 // cos(0.6) y = 0.56468291 // sin(0.6)

In Anlehnung an [WEB02] wird die Skalierung über g=K-1 (gain) vorgenommen (Genauigkeit: 11 Stellen nach dem Komma). Mit dem unter dieser Adresse angegebenen Dokument kann der CORDIC-Algorithmus interaktiv untersucht werden. Die von JavaScript zur Verfügung gestellten Bibliotheksfunktionen Math.sin und Math.cos dienen als Referenz (in grün). Zunächst wird im Feld “symbolic φ“ der Wert des Winkels eingegeben (hier 0.6). Anschließend wird dieser Wert durch Drücken der Schaltfläche “get φ and evaluate library functions“ übernommen. Mittels “step“ werden nun die einzelnen Iterationsschritte ausgeführt. Bild 2.2 zeigt die Ergebnisse für n=15.

Bild 2.2: Berechnung von cos(0.6) und sin(0.6) mittels interaktiven Dokuments [WEB02] Die Ergebnisse nach Bild 2.2 stimmen mit denen des C-Quellcodes (gerundet) überein.

2.2 Betriebsarten des CORDIC-Algorithmus

Der bisherige Iterationsablauf des CORDIC-Algorithmus bezeichnet man als “Rotating“, da ein Vektor [x0,y0]

T

um einen definierten Winkel φ gedreht wird [Pirs96]. Für die mit z0=φ initialisierte Hilfsvariable

gilt hierbei z→0. In diesem Rotating-Mode lassen sich mit x0=1 und y0=0 die trigonometrischen

Funktionen sin(φ) und cos(φ) berechnen, siehe Beispiel 2.2. Arkustangensfunktion:

Die zweite Betriebsart des Verfahrens ist das sog. “Vectoring“. Hier wird der Ausgangsvektor derartig gedreht, dass der Vektor nach Abschluss der Iteration auf der positiven x-Achse liegt (y→0). Dann repräsentieren die aufakkumulierten Teilwinkel den Winkel arctan(y0/x0) und die x-Koordinate den

noch zu skalierenden Betrag des Vektors. Die einzelnen Teilschritte berechnen sich bis auf die Initialisierung von z0 und der Vorzeichenbestimmung σi gemäß [Andr98] analog zum Rotating-Mode

(9)

x

K e

⋅

x

_n

e

x

=

1

1 r

=

_arg

n

y

=

x

K e

⋅

x

_n

e

x

=

1

1 r

=

_arg

n

y

=

( )

1 1 1

2

2 arctan 2

i i i i i i i i i i i i i i

x

y

x

z

σ

− + − + − +

= − ⋅

⋅

= + ⋅

⋅

= − ⋅

mit: ₀

0 ;

1

0

1

0

i i i

y

z

y

σ



+

<

=



−

>



(2.15) Daraus ergibt sich schließlich:

1 2 2 0 0 0 0 0 0 0 0

0 arctan

arctan

n n n

x

K

x

y

z

x

−

=

⋅

+

=









=

+

_

_

=

_

_









(2.16)

Die Drehrichtung des Vektors hängt vom Quadranten ab. Mit der in Gl. (2.15) angegebenen Vorzeichensteuerung lässt sich arctan(y0/x0) für den 1. und 4. Quadranten bestimmen. Der

C-Quellcode im Anhang A2 berechnet wieder n=15 Iterationen mit den Initialwerten x=1.8 und y=0.7. Gemäß Taschenrechner gilt hierfür arctan(0.7/1.8)=0.370891. Die mittels Programm berechneten Ergebnisse lauten:

x = 1.93132079 // Betrag des Vektors z = 0.37086993 // arctan(0.7/1.8)

Arkussinusfunktion:

Der Vectoring-Mode eignet sich nach [WEB02] und [Andr98] auch zur Berechnung der inversen trigonometrischen Funktion φ=arcsin(arg). Hierzu muss der skalierte Einheitsvektor K·ex einer Folge

von Rotationen unterzogen werden, bis die y-Komponente des gedrehten Vektors mit arg übereinstimmt. Durch die anfängliche Skalierung wird erreicht, dass nach der Rotation der Betrag des Vektors gleich Eins ist, siehe Bild 2.3:

r

= =

1 x

_n2

+

y

_n2

=

x

_n2

+

arg

2

⇒

x

_n

=

1 arg

−

2 (2.17)

Bild 2.3: Berechnung von arcsin(arg)

Mit der Hilfsvariablen zi werden nach Bild 2.3 alle Teilwinkel zum Winkel arctan(yn/xn) aufakkumuliert.

Nach Gl. (2.17) kann man hierfür auch schreiben:

2

arg

arctan

1 arg

n n

y

x









=







_



_





_

₋

_

Nach [Papu01] gilt zwischen dem Arkussinus und dem Arkustangens folgender Zusammenhang:

2 2

arg

arcsin( )

arctan

arcsin(arg)

arctan

1 1 arg

x









=

_

_

⇒

₌

_

_





−





_

_

(2.18)

Somit entsprechen die aufakkumulierten Teilwinkel der inversen trigonometrischen Funktion φ=arcsin(arg). Es ergeben sich folgende Iterationsgleichungen:

(10)

( )

1 1 1

2

2 arctan 2

x

y

x

z

σ

− + − + − +

= − ⋅

⋅

= + ⋅

⋅

= + ⋅

mit: ₀

;

₀ ₀

0 ;

1 (arg

)

0 1 (arg

)

0

i

y

x

K

y

z

y

σ



+

−

>

=



−

<



(2.19)

Die Vorzeichensteuerung berücksichtigt für (arg-y)>0 ein Anwachsen von yi+1, d.h. es gilt hier yi+1>yi.

Der im Anhang A3 dargestellte C-Quellcode berechnet wieder n=15 Iterationen mit dem Initialwert arg=0.7. Hierfür gilt gemäß Taschenrechner arcsin(0.7)=0.775397. Das Programm liefert folgende Ergebnisse:

x = 0.71415968

y = 0.69998283 // arg = 0.7 z = 0.77537345 // arcsin(0.7)

Das Dokument [WEB02] ermöglicht auch hier wieder eine interaktive Untersuchung. Die Ergebnisse für arg=0.7 nach n=15 Iterationen zeigt Bild 2.4, sie stimmen erwartungsgemäß mit denen des C-Quellcodes (gerundet) überein. [WEB02] berechnet zusätzlich noch die arccos-Funktion, für die folgender Zusammenhang gilt:

arccos(arg)

arcsin(arg)

2 π

= −

(2.20)

Bild 2.4: Berechnung von arcsin(0.7) und arccos(0.7) mittels interaktiven Dokuments [WEB02]

2.3 Verallgemeinerung des CORDIC-Algorithmus

Der CORDIC-Algorithmus in seiner bisher definierten Form erlaubt mit den beiden Betriebsarten Rotating und Vectoring die Bestimmung der trigonometrischen Funktionen sin und cos (damit auch tan) sowie der Arkusfunktionen arctan und arcsin (damit auch arccos). Durch die von J. S. Walther formulierte Verallgemeinerung des Verfahrens können zusätzliche Elementarfunktionen wie beispielsweise die hyperbolischen Funktionen und die Exponentialfunktion ermittelt werden [Walt71]. Um die Verallgemeinerung des CORDIC-Algorithmus zu verstehen, betrachten wir die hyperbolischen Additionstheoreme:

0 0

cosh(

)

cosh( ) cosh( )

sinh( ) sinh( )

sinh(

)

sinh( ) cosh( )

cosh( ) sinh( )

x y y x

β ϕ

β

ϕ

β

ϕ

β ϕ

β

ϕ

β

ϕ

±

=

⋅

±

⋅

±

=

⋅

±

⋅

(2.21)

(11)

0 0

cosh(

)

cosh( )

sinh( )

1 tanh( )

cosh( )

sinh(

)

sinh( )

cosh( )

tanh( )

1 x

x

y

β ϕ

ϕ

_ϕ

ϕ

β ϕ

ϕ

±





±

















=

⋅





=

⋅







_±





_±





_±























(2.22)

Diese Drehmatrix nach [WEB02] legt es nahe, die Funktionen cosh(φ) und sinh(φ) für ein gegebenes Argument φ

durch eine Folge von hyperbolischen Rotationen zeitgleich zu berechnen. Hierzu muss

φ nach [WEB02] wieder als Summe geeigneter Dreh- bzw. Teilwinkel αi und Drehrichtungen σi

dargestellt werden:

tanh(

α

i

)

=

2 bzw.

−i

α

i

=

artanh 2

( )

−i (2.23)

( )

1 1

artanh 2

{ 1,1}

n n i i i i i i i

ϕ

σ α

σ

−

σ

= =

=

∑

⋅ =

∑

⋅

∈ −

(2.24)

Die Summation beginnt mit i=1, da artanh(0) nicht definiert ist. Somit lassen sich auch hier die einzelnen Rotationen – bis auf die Skalierung am Ende – ausschließlich mit SHIFT- und ADD-Operationen ausführen. Da der Kosinus hyperbolicus eine gerade Funktion ist, spielt das Vorzeichen σi bei der Bestimmung des Skalierungsfaktors keine Rolle:

( )

1 1

cosh(

)

cosh artanh 2

n n i i i i

K

α

− = =





=

∏

=

∏





(2.25)

Über den hyperbolischen Pythagoras kann nach [WEB02] folgende allgemeine Beziehung angegeben werden: 2 2 2 2

1 cosh ( ) sinh ( )

1 tanh ( )

cosh( )

cosh ( )

x

−

=

−

Für den Skalierungsfaktor ergibt sich jetzt:

x

=

artanh 2

( )

−i

⇒

tanh( )

x

=

tanh artanh 2





( )

−i





=

2

−i

2 1

1 1 2

n i i

K

− ⋅ =

⇒

₌

−

∏

(2.26)

Für n→ ∞ liefert K folgenden Wert:

2 1

1 lim

1.20514

1 2

n i n i

K

− ⋅ →∞ =

=

≈

−

∏

(2.27)

Mit β=0 erhält man:

x

₀

=

cosh( )

β

_β₌₀

=

1 ;

y

₀

=

sinh( )

β

_β₌₀

=

0

Die Hilfsvariable zi enthält wieder die aufakkumulierten Teilwinkel und steuert (im Rotating-Mode) das

Vorzeichen σi=sgn(zi). Damit gilt für die Folge von hyperbolischen Rotationen zur Berechnung von

cosh(φ) und sinh(φ):

( )

2 1 1 1 0

1

2

1

2 cosh( )

1

1 sinh( )

_{1 2}

₂

₁

0 ₂

₁

0

0 sgn( ) artanh 2

i i n n i i i i i i _i i _i i i i i

K

z

σ

ϕ

_σ

− − − − − ⋅ = = − +



_⋅





_⋅







 

=

⋅





⋅

= ⋅





⋅





 

⋅





₋



_



_

 



_



_

 

←

= −

⋅

∏

ϕ

=

(2.28)

(12)

Gl. (2.28) zeigt, dass sich auf Grundlage der hyperbolischen Additionstheoreme die hyperbolischen Funktionen cosh(φ) und sinh(φ) mittels CORDIC-Verfahren ermitteln lassen. Nun sollen die Berechnungsvorschriften auf Basis der trigonometrischen und hyperbolischen Additionstheoreme gemeinsam durch eine allgemeine Iterationsgleichung beschrieben werden. Betrachten wird zunächst die Iterationsgleichungen für beide Fälle getrennt.

trigonometrisch (Gl. (2.12)):

( )

1 1 1

2

2 arctan 2

x

y

x

z

σ

− + − + − +

= − ⋅

⋅

= + ⋅

⋅

= − ⋅

hyperbolisch (Gl. (2.28)):

( )

1 1 1

2

2 artanh 2

x

y

x

z

σ

− + − + − +

= + ⋅

⋅

= + ⋅

⋅

= − ⋅

Wir führen nun nach [Pirs96] folgende Größen ein:

m

∈

{1,0, 1}

−

Parameter für den Modus zirkular (m=1), linear (m=0) und hyperbolisch (m=-1)

δ

m i_,

=

2

−i Schrittweite des i-ten Iterationsschrittes (0<δm,i≤1)

K

_m−1 Skalierungsfaktor

α

_{m i}_, Dreh- bzw. Teilwinkel im i-ten Iterationsschritt

Der lineare Modus (m=0) ermöglicht die Multiplikation und Division und wird in Abschnitt 2.3.2 ausführlich erläutert. Es lässt sich nun folgende allgemeine Form des CORDIC-Algorithmus angeben:

1 , 1 , 1 ,

1

0

1

0

1

i i i m i i i i m i i i i m i

x

m

y

z

σ δ

σ α

+ + +

 

−







_{  }





₌



_{  }

_⋅







_{  }







₋



_{ }









 

(2.29)

Die sich für die verschiedenen Werte von m ergebenden Skalierungsfaktoren (in Gl. (2.29) nicht berücksichtigt) und Drehwinkel der einzelnen Iterationsschritte (auch Mikrorotationen genannt) sind in Tabelle 2.1 zusammengefasst. m α_{m i}_, 1 m K− i 1 arctan(δ_1,_i) 1 2 1, 0 1 n i i δ − = +

∏

{0,1,…,n−1} 0 δ_0,i 1 {0,1,…,n−1} 1 − artanh(δ−1,i) 2 1, 1 1 n i i δ− = −

∏

(Ko nve { rgenzp 1, 2 rob , , m } le ) n …

Tabelle 2.1: Teilwinkel und Skalierungsfaktoren in Abhängigkeit von m

Der zirkulare Modus ist bereits in Abschnitt 2.1 und 2.2 für die beiden Betriebsarten Rotating und Vectoring ausführlich behandelt worden. Daher wird nachfolgend nur noch auf die durch die Verallgemeinerung hinzugekommenen Moden “hyperbolisch“ und “linear“ eingegangen, jeweils in beiden Betriebsarten.

(13)

2.3.1 Hyperbolischer Modus (m

=

-1)

Rotating:

Im letzten Abschnitt wurde durch Gl. (2.28) bereits gezeigt, dass mit dem Ausgangsvektor [x0,y0]

T

=[1,0]T die hyperbolischen Funktionen cosh(φ) und sinh(φ) approximiert werden können. Der im Anhang A4 angegebene C-Quellcode führt dies mit dem Argument φ=0.8 für n=15 Iterationen aus. Gemäß Taschenrechner erhält man folgende Werte:

cosh(0.8) 1.3374349463 ; sinh(0.8)

=

0.8881059822

Die berechneten Ergebnisse nach Anhang A4 lauten:

x = 1.33741188 // cosh(0.8) y = 0.88807125 // sinh(0.8)

Gemäß [Papu01] weisen die hyperbolischen Funktionen cosh und sinh einen Definitionsbereich von

−∞ bis +∞ auf. Werden alle Mikrorotationen artanh(δ-1,i) nach Tabelle 2.1 mit dem gleichen Drehsinn

aufaddiert, dann erhält man allerdings folgenden Konvergenzbereich des C-Quellcode nach A4 für φ:

( )

1

artanh 2

1.05547

n i i

ϕ

− =

= ±

∑

≈ ±

(2.30)

Das bedeutet, dass der in Gl. (2.30) angegebene Wert das maximal zulässige Argument für den Quellcode nach A4 darstellt. Im Zusammenhang mit der Exponentialfunktion wird in Abschnitt 2.3.3 gezeigt, wie mit unzulässigen Argumenten zu verfahren ist.

Konvergenzproblem:

Zur einfachen Realisierung des CORDIC-Verfahrens wurden bisher für die Iterationsschrittweiten δm,i

Zweierpotenzen eingesetzt, wodurch sich die Matrixmultiplikation durch eine Shiftoperation implementieren lässt (siehe Tabelle 2.1):

δ

_{m i}_,

=

2

−S m i( , )

S m i

( , ) {0,1,

=

…

,

n

−

1} mit:

m

∈

{1, 0}

(2.31a)

δ

_{m i}_,

=

2

−S m i( , )

( , ) {1, 2,

S m i

=

…

, } mit:

n

m

∈ −

{ 1}

(2.31b) Die ganzzahlige Folge S(m,i) wird nach [Pirs96] als Shiftfolge des CORDIC-Algorithmus bezeichnet. Sie beeinflusst die Konvergenz, den Konvergenzbereich und den Skalierungsfaktor. Die aus ihr resultierenden Teilwinkel αm,i sollen zunächst einmal eine monoton fallende Folge bilden. Darüber

hinaus muss jeder Teilwinkel einer Iteration durch eine nachfolgende Richtungsumkehr durch alle folgenden Teilwinkel bis auf einen Restfehler kompensiert werden können. Dieser ist durch den Teilwinkel der letzten Iteration definiert. Somit muss für die Winkel gelten:

1 , , , 1 1

{0,1,

,

2} mit:

{1,0}

n m i m j m n j i

i

n

m

α

−

α

− = +

−

∑

<

∈

…

−

∈

(2.32a) _, _, _, 1

{1, 2,

,

1} mit:

{ 1}

n m i m j m n j i

i

n

m

α

= +

−

∑

<

∈

…

−

∈ −

(2.32b)

Für eine Folge, in der der Nachfolgewinkel mindestens die Hälfte des vorhergehenden beträgt, ist Gl. (2.32) erfüllt:

α

_i₊₁

≥ ⋅

1₂

α

_i (2.33)

(14)

arctan 2

( )

−4

=

0.062419

> ⋅

1₂

arctan 2

( )

−3

=

0.062177

Die Verhältnisse im linearen Fall werden in Abschnitt 2.3.2 behandelt. Im hyperbolischen Modus wird Gl. (2.33) für eine ganzzahlige Shiftfolge nach Gl. (2.31b) nicht erfüllt. Mit dem C-Quellcode nach A4 soll nun gezeigt werden, wie sich diese Verletzung der Konvergenzbedingung auf die Bestimmung der Funktionen cosh(0.01) und sinh(0.01) auswirkt. Tabelle 2.2 zeigt die exakten Werte sowie die Ergebnisse für eine steigende Anzahl von Iterationsschritten (10 Stellen nach dem Komma). Man sieht, dass das Verfahren mit der gewählten Shiftfolge bei einem kleinen Argument völlig versagt.

n x (cosh(0.01)) y (sinh(0.01)) 8 1.0011095622 0.0470666476 16 1.0009314586 0.0431715729 24 1.0009308025 0.0431563596 32 1.0009307999 0.0431563001 40 1.0009307999 0.0431562999 exakt: 1.0000500004 0.0100001667

Tabelle 2.2: Ergebnisse für ϕ=0.01 bei Nichteinhaltung der Konvergenzbedingung

Um die Konvergenzbedingung im hyperbolischen Fall zu erfüllen, muss eine Winkeldrehung an bestimmten Stellen wieder vollständig rückgängig gemacht werden können. Dies wird durch die Wiederholung der Iterationen i=4,13,40,k,3k+1 erreicht, siehe auch [Andr98, Pirs96, WEB01]. Man erhält somit die komplexere Shiftfolge nach Gl. (2.34).

S

( 1, ) {1, 2,3, 4, 4,5,6,

−

i

=

…

,13,13,14,15,

…

, 40, 40, 41,

…

, }

n

(2.34) Da die Iterationen i=4,13,40,k,3k+1 doppelt ausgeführt werden, ändert sich auch der Skalierungsfaktor. Für ihn gilt jetzt:

4 13 40 121 2 2 2 2 1 4 13 40

1

1 1.207497

1 2

i

1 2

i

1 2

i

1 2

i i i i i

K

− ⋅ − ⋅ − ⋅ − ⋅ = = = =



 



=



 

⋅

 

⋅

 

⋅



⋅ ≈



₋

 

₋

 

₋

 

₋





∏

 

∏

 

∏

 

∏



…

(2.35)

Der C-Quellcode im Anhang A5 berücksichtigt die Shiftfolge nach Gl. (2.34) und den neuen Skalierungsfaktor g=K-1 nach Gl. (2.35). Tabelle 2.3 zeigt die berechneten Ergebnisse für das Argument φ=0.01. Das CORDIC-Verfahren konvergiert jetzt gegen die exakten Werte.

n x (cosh(0.01)) y (sinh(0.01)) 8 1.0000337989 0.0079055564 16 1.0000499596 0.0099960772 24 1.0000500007 0.0100001902 32 1.0000500004 0.0100001667 exakt: 1.0000500004 0.0100001667

Tabelle 2.3: Ergebnisse für ϕ=0.01 bei Einhaltung der Konvergenzbedingung

Der Konvergenzbereich für φ erhöht sich nun gegenüber Gl. (2.30) etwas:

( )

4

(

13

)

(

40

)

1

artanh 2

1.118173

n i i

ϕ

− − − − =





= ±



+



≈ ±



∑

…



(2.36)

Ist φ vom Betrag her größer als der in Gl. (2.36) angegebene Wert, so liefert der Quellcode nach A5 ebenfalls falsche Ergebnisse. Wie bereits erwähnt, wird in Abschnitt 2.3.3 gezeigt, wie mit solchen unzulässigen Argumenten im Zusammenhang mit der Exponentialfunktion zu verfahren ist.

(15)

Vectoring:

Nach Abschluss der Iteration liegt der Ausgangsvektor wieder auf der positiven x-Achse (y→0). Die aufakkumulierten Teilwinkel repräsentieren jetzt den Winkel artanh(y0/x0) und die x-Koordinate den

noch zu skalierenden hyperbolischen Betrag des Vektors. Die einzelnen Teilschritte entsprechen bis auf die Initialisierung von z0 und der Vorzeichenbestimmung σi gemäß [Andr98] dem Rotating-Mode

nach Gl. (2.28):

( )

1 1 1

2

2 artanh 2

x

y

x

z

σ

− + − + − +

= + ⋅

⋅

= + ⋅

⋅

= − ⋅

mit: ₀

0 ;

1

0

1

0

i i i

y

z

y

σ



+

<

=



−

>



(2.37)

Daraus ergibt sich:

1 2 2 1 2 2 0 0 0 0 0 0 0 0 0 0

0 artanh

artanh

n n n

x

K

x

m y

K

x

y

z

x

− −

=

⋅

+ ⋅

=

⋅

−

=









=

+

_

_

=

_

_









(2.38)

Die Vorzeichensteuerung nach Gl. (2.37) ermöglicht es, artanh(y0/x0) für den 1. und 4. Quadranten zu

bestimmen. Gemäß [Papu01] hat die Funktion artanh einen Definitionsbereich von −1 bis +1 und einen Wertebereich von −∞ bis +∞. Beim CORDIC-Algorithmus ist dieser Wertebereich für φ auf den Konvergenzbereich nach Gl. (2.36) beschränkt. Der im Anhang A6 angegebene C-Quellcode berechnet n=15 Iterationen für die Werte x=3.9 und y=2.5. Der Taschenrechner liefert hierfür artanh(2.5/3.9)=0.759913. Die Ergebnisse nach A6 lauten:

x = 2.99332591 // hyperbolischer Betrag z = 0.75993257 // artanh(2.5/3.9)

Der maximal mögliche Quotient der Werte x0 und y0 für den Quellcode A6 beträgt:

0 0 0 0

artanh

y

1.118173

y

tanh( 1.118173)

0.806932

x

ϕ

=



_



_

= ±

⇒

₌

_±

_{= ±}





(2.39) Logarithmus naturalis:

Über den Areatangens hyperbolicus lässt sich auch der natürliche Logarithmus mittels CORDIC-Verfahren berechnen:

(

)

12 ln ln 1 2 ln ln

1

1 tanh ln

; ln

ln

1

x x x x

e

x

e

− −

−

=

= ⋅

+

ln

2 artanh

1

1 x

x

−





⇒

= ⋅





+





(2.40) Quadratwurzel:

Für r kann man auch schreiben:

(

r

+

₄1

) ( )

2

− −

r

₄1 2

=

r

2

+

1₂

r

+

₁₆1

r

−

r

2

+

1₂

r

−

₁₆1

r

=

₂1

r

+

₂1

r

=

r

(2.41) mit:

x

₀

= +

r

1₄

;

y

₀

= −

r

1₄

(16)

2.3.2 Linearer Modus (m

=

0)

Der CORDIC-Algorithmus im linearen Modus multipliziert (Rotating) oder dividiert (Vectoring). Auch wenn diese Implementierung den “herkömmlichen“ Implementierungen für Multiplizierer bzw. Dividierer nicht ebenbürtig ist, so bietet sich hier doch eine attraktive Variante an, beispielsweise wenn es um die Einsparung zusätzlicher funktionaler Baugruppen geht. Im linearen Fall entspricht die Schrittweite δ0,i dem Teilwinkel α0,i im i-ten Iterationsschritt:

α

_0,_i

=

δ

_0,_i

=

2

−i

i

∈

{0,1,

…

,

n

−

1}

(2.42) Der Skalierungsfaktor K0 ist 1. Aus Gl. (2.42) ist ersichtlich, dass sich im linearen Fall das System am

Rande des Konvergenzbereiches befindet, da die Gleichheitsbeziehung in Gl. (2.33) gilt. Für Gl. (2.29) erhält man jetzt:

1 1 0, 1 0,

1

0

0 1 0

0

1

i i i i i i i i i i

x

y

z

σ δ

+ + +

 







_{  }





₌



_{  }

_⋅







_{  }







₋



_{ }









 

(2.43) Rotating:

In dieser Betriebsart gilt für die einzelnen Iterationsschritte:

1 1 1

2

0

2

i i i i i i i i i i i

x

y

x

z

σ

+ − + − +

=

= + ⋅

⋅

←

= − ⋅

mit: ₀

0 ;

1 z

0 1 z

0

i i i

y

=

σ

=





+

>

−

<



(2.44) Mit Gl. (2.5): 1 1 0, 0 0 0

2

n n i i i i i i

z

ϕ

−

σ δ

−

σ

− = =

=

∑

⋅

=

∑

⋅

=

Daraus resultiert schließlich unter Beachtung des Konvergenzbereiches:

0 0 0 0 0 0 0

0

n n n

x

y

x

z

x

z

=

+ ⋅ = ⋅

=

für: 1 0 0

lim

2

n i n i

z

− − →∞ =

∑

= >

(2.45)

Der Betrag von z0 muss somit <2 sein. Im Anhang A7 ist der zugehörige C-Quellcode für die

Initialwerte x=3.5 und z=1.9 angegeben. Nach n=24 Iterationen ergibt sich für das Produkt x·z:

y = 6.64999992 // x*z

Vectoring:

Die einzelnen Iterationsschritte lauten:

1 1 1

0

2

i i i i i i i i i i i

x

y

x

z

σ

+ − + − +

=

←

= + ⋅

⋅

= − ⋅

mit: ₀

0 ;

1

0

1

0

i i i

y

z

y

σ



+

<

=



−

>



(2.46)

Wegen α0,i=δ0,i gilt für die aufakkumulierten Teilwinkel:

1 1 0 0, 0 0 0

2

n n i i i i i i

y

x

σ δ

σ

− − − =

⋅

=

⋅

=

∑

(17)

Daraus ergibt sich:

0 0 0 0 0 0 0

0

n n n

x

y

z

x

=

+

=

für: 1 0 0 0

lim

2

n i n i

y

x

− − →∞ =

∑

= >

(2.47)

Die Vorzeichensteuerung in Gl. (2.46) ermöglicht es, den Quotienten y0/x0 für den 1. und 4.

Quadranten zu bestimmen. Der C-Quellcode im Anhang A8 führt die Division für die Initialwerte x=4.1 und y=-5.8 aus. Das Ergebnis nach n=24 Iterationen lautet:

z = -1.41463411 // y/x

2.3.3 Berechnung der Exponentialfunktion

Nach [Papu01] gilt für cosh(x) und sinh(x):

cosh( )

; sinh( )

2

x x x x

e

x

− −

+

−

=

Durch Addition dieser beiden hyperbolischen Funktionen erhält man die Exponentialfunktion:

cosh( )

sinh( )

2

x x x x x x

e

x

− −

+

₊

−

₌

_⇒

₌

₊

(2.48) Die Berechnung dieser hyperbolischen Funktionen mittels CORDIC-Algorithmus wurde in Abschnitt 2.3.1 behandelt. Als maximal zulässiges Argument für φ gilt nach Gl. (2.36):

ϕ

= ±

1.118173

Hierfür wollen wir nachfolgend ein beliebiges Argument x∈ℝ einsetzen, das sich als Summe eines zulässigen Argumentes z mit |z|<ln2≈0.693147 und einem Vielfachen von ln2 darstellen lässt:

x

= + ⋅

z

m

ln 2

(2.49)

Unter Anwendung der hyperbolischen Additionstheoreme gilt dann [WEB02]:

* **

cosh( )

x

=

cosh(

z

+ ⋅

m

ln 2)

=

cosh( ) cosh(

z

⋅

m

⋅

ln 2)

+

sinh( ) sinh(

z

⋅

m

⋅

ln 2)

(2.50a)

e

m⋅ln 2

=

(

e

ln 2

)

m

=

2

m

⇒

(

)

(

)

(

)

(

)

1 1 2 1 1 2

cosh(

ln 2)

2

2 sinh(

ln 2)

2

m m m m m m m m

m

− − − − − −

⋅

= ⋅

+

=

⋅

+

⋅

= ⋅

−

=

⋅

−

(

)

(

)

1 1 1 1 1 1

cosh( ) 2

2

2 cosh( )

sinh( ) 2

2

2 sinh( )

2 *

sinh

**

( )

m m m m m m m m

z

− − − − − − − − − −

⋅

+

=

⋅

+

⋅

−

=

⋅

−

⋅

(18)

* **

sinh( )

x

=

sinh(

z

+ ⋅

m

ln 2)

=

sinh( ) cosh(

z

⋅

m

⋅

ln 2)

+

cosh( ) sinh(

z

⋅

m

⋅

ln 2)

(2.51a)

(

)

(

)

1 1 1

sinh( ) 2

2

2 sinh( )

cosh( ) 2

2

2 cosh( )

2 *

cosh

**

( )

m m m m m m m m

z

− − − − − − − − − −

⋅

+

=

⋅

+

⋅

−

=

⋅

−

⋅

⇒

sinh(

z

+ ⋅

m

ln 2)

=

2

m−1

⋅



_

cosh( )

z

+

sinh( )

z

−

2

−2m

⋅

(

cosh( ) sinh( )

z

−

z

)



_

(2.51b) Die Gln. (2.50b) und (2.51b) ermöglichen es, die hyperbolischen Funktionen cosh(x) und sinh(x) für ein beliebiges Argument x∈ℝ zu berechnen. Nach Gl. (2.48) erhält man daher für exp(x):

exp( )

x

=

exp(

z

+ ⋅

m

ln 2)

= ⋅

2 2

m−1

⋅

[

cosh( )

z

+

sinh( )

z

]

=

2

m

⋅

[

cosh( )

z

+

sinh( )

z

]

(2.52) Der im Anhang A9 angegebene C-Quellcode berechnet die Exponentialfunktion exp(arg) mit arg∈ℝ

nach Gl. (2.52). Zunächst wird die Variable arg mittels Cast-Operator (int) durch ln_2 dividiert, um den ganzzahligen Faktor m für die spätere Stellenverschiebung zu erhalten. Das Argument z, für welches die hyperbolischen Funktionen direkt bestimmt werden, geht aus Gl. (2.49) hervor:

m = (int)(arg / ln_2); z = arg – m * ln_2;

Bei einer Hardware-Realisierung ist z der echt-gebrochenrationale Divisionsrest von arg/ln_2. Für die Initialwerte arg=0.5, arg=5.7 und arg=-5.7 berechnet A9 nach jeweils n=32 Iterationen folgende Funktionswerte:

exp_fkt = 1.6487212710 // für arg = 0.5 exp_fkt = 298.8674009805 // für arg = 5.7 exp_fkt = 0.0033459655 // für arg = -5.7

Vergleicht man die Ergebnisse für arg=0.5 und arg=5.7 mit denen des Zahlenbeispiels aus Abschnitt 1, dann erkennt man, dass das Konvergenzverhalten der Exponentialfunktion hier nicht vom Argument abhängig ist!

2.3.4 Erweiterung des zulässigen Argument-Bereiches für

artanh(), ln() und sqrt()

artanh():

Das betragsmäßig größte Argument für den Areatangens hyperbolicus innerhalb des Konvergenz-Bereiches beträgt nach Gl. (2.39) ≈0.81, die Funktion weist aber einen Definitionsbereich von -1 bis +1 auf. Um auch den unzulässigen Bereich abzufangen, führen wir eine Beschreibung mittels Mantisse M und Exponent E ein, wobei gelten soll:

arg

= −

1 M

⋅

2

−E

bzw.

M

⋅

2

−E

= −

1 arg

(2.53) mit:

0.5 ≤

M

<

1.0 ;

E

≥

0

Die Normalisierung der Mantisse entspricht nicht der Norm ANSI/IEEE 754, sondern ist der Original-Veröffentlichung von J. S. Walther entnommen [Walt71]. Da der ganzzahlige Exponent E nicht <0 werden kann, liegt der Definitionsbereich des Argumentes jetzt bei 0<arg<1. Für die Berechnung stellt dies kein Problem dar, weil zwischen einem positiven und einem negativen Argument folgende Beziehung besteht:

(19)

Gesucht ist somit folgende Lösung:

artanh 1

(

−

M

⋅

2

−E

)

=

?

Diese Funktion wird nun so umgeformt, dass ein Term artanh() entsteht, dessen Argument sich im Konvergenzbereich befindet. Nach [Papu01] gilt für artanh(x):

artanh( )

1₂

ln

1

1 x

x

+





= ⋅





−





artanh 1

(

2 )

1₂

ln

1 1

2

₂1

ln

2

2 2 2

1 1

2

2 2 2

E E E E E E E

M

− − − − −



_{+ −}

_⋅





₋

_⋅



_⋅

⇒

−

⋅

= ⋅





= ⋅





− +

⋅









artanh 1

(

2 )

1₂

ln

4 2

2

₂1

ln

(

4

2

2 )

2

E E E E

M

− −



⋅

−





−

⋅



⇒

−

⋅

= ⋅





= ⋅













(

)

(

)

(

)

( )

1 2 1 1 2 2

2

2 artanh 1

2 ln

2

2 ln

l

2

2 n 2

2

E E E E E E E E E E E

M

− − − − − − − − −



₊

₋

_⋅

₋

_⋅



−

⋅

= ⋅





+







₊

₋

_⋅

_{+ −}

₋

_⋅



= ⋅





+ ⋅

+

−

⋅

− −

+

−

+ − +

⋅



⋅



−

⋅

(

)

1 2 2

2

1

2

2 artanh 1

2 ln

ln 2

2

1

2

E E E E E E

M

− − − − −



₋

_⋅



+





+

−

⋅





−

⋅

= ⋅

+ ⋅



₋

_⋅



−



₊

₋

_⋅







⇒

artanh 1

(

−

M

⋅

2

−E

)

=

artanh( )

T

+ ⋅

E₂

ln 2

(2.55) mit:

2

2 ; 0.5

1.0 ;

0

2

E E

M

T

M

E

M

− −

−

⋅

=

≤

<

≥

+

−

⋅

Um den Wertebereich von T zu ermitteln, betrachten wir folgende Zahlenkombinationen von M und E:

M _→ 1; E = 0 => T = 0 M = 0.5; E = 0 => T = 0.5

M _→ 1; E = 1 => T = 0.2 M = 0.5; E = 1 => T = 0.555556

M _→ 1; E = 100 => T = 0.3 M = 0.5; E = 100 => T = 0.6

⇒

0 < ≤

T

0.6

(2.56)

Der Wertebereich von T liegt somit im Konvergenzbereich der artanh-Funktion nach Gl. (2.39). Beispiel 2.3:

Es ist der Areatangens hyperbolicus für die folgenden Argumente mittels Gl. (2.55) zu bestimmen:

a) artanh(0.99609375) = 3.11818480 (Taschenrechner) b) artanh(0.00390625) = 0.00390627 “ c) artanh(0.50390625) = 0.55452812 “ a) 7 7 2 arg 1 2 0.99609375 0.11111111 2 0.00390625 0.00000001 0.1 2 0.5 ; 7 0.59937402 artanh(0.59937402) ln 2 3.11818479 E E M b M b b M E T − − − = − ⋅ = = ⋅ = = = ⋅ = = ⇒ ₌ ⇒ _{+ ⋅} ₌