Joachim Mohr   Mathematik Musik Delphi
Suche
Siehe auch Einführung zum Zweierlogarithmus

Definition des Logarithmus ohne gebrochene Hochzahlen

Zunächst ein Beispiel:

Wir haben gesehen: die Quint ist der lb(1.5)-fache Teil der Oktave:

           3
  Qui = lb(-)Ok
           2

     3                                                    3
  lb(-) ist die Zahl y mit der ich 2 potenzieren muss, um - zu erhalten:
     2                                                    2

       3            y   3
  y=lb(-) <=>      2  = -     (*)
       2                2

      0         1
  Da 2 = 1 und 2 = 2 folgt 0 < y < 1

                                        3
  Also ist y in der Nähe von vielleicht -.
                                        4       
                      3
                      -
                      4
  Was bedeutet aber 2   ?  
                                  3                  3
                                  -                  -
                                  4  4 -             4
  Für den Mathematiker ist klar: 2 = \/8 . Also ist 2  die

  die positive Zahl, die vier Mal mit sich selbst  multipliziert 8 ergibt.

Um den Logarithmus definierten zu können, muss ich also die Potenzen von gebrochenen Hochzahlen beherrschen.


Ich habe mich gefragt: Kann man das Intervall der Quinte nicht elementarer annähern?

Das ist möglich!

Und das Erstaunliche dabei ist: Ich lande wieder bei den pythagoreischen Abschätzungen!

                                        m
Diesmal mache ich den Ansatz: Der Bruch - (m, n natürliche Zahlen) soll
                                        n
                   3
den Logarithmus lb(-) annähern. Dann wird aus der Äquivalenz (*)
                   2
                               m
                               -
                m      3       n   3
die Äquivalenz  - = lb(-) <=> 2  = - . Und diese kann ich umformen zu:
                n      2           2


     m      3       m    3 n
     - = lb(-) <=> 2  = (-)
     n      2            2   

Musikalisch gesprochen: Ich betrachte Vielfache der Quinte mit Vielfachen der Oktave.

Dass das mit ganzen Zahlen nicht lösbar ist, führte im vergleichbaren Fall der Geometrie zum depressiven Zustand der Pythagoreer: Ihr göttliches Dogma "Alles ist Zahl" zerbrach.

Die Näherungszahlen kennen Sie schon: siehe Lektion 3.


                       3       1  3  7   24  31  179  389
Näherungszahlen für lb(-) sind -, -, ——, ——, ——, ———, ———, ...
                       2       2  5  12  41  53  306  665

Das fett gedruckte Verhältnis bedeutet musikalisch: 12 Quinten sind ungefähr 7 Oktaven.
Wählen wir als zweites Intervall die große Terz mit dem Frequenzverhältnis 5:4. Diesmal türmen wir große Terzen aufeinander und vergleichen es mit Oktaven:

Erste Näherung: 3 große Terzen ergeben ungefähr eine (etwas zu tiefe) Oktav .


                 5           1       5 3
Mathematisch: lb(-) ungefähr - , da (-) =1,953 ungefähr 2
                 4           3       4

Einen besseren Vergleich ergibt: Drei Terzen hoch und eine Oktav zurück:

  5 3
 (-) : 2 = 0,977 (Fehler: 2,3%)
  4

Gehen wir weitere Terzen nach oben und passend Oktaven nach unten, dann erhalten wir die nächst bessere Näherung erst nach 28 Terzen (28 Terzen hoch und 9 Oktaven abwärts).

                 5            9       5 28    9
Mathematisch: lb(-) ungefähr  ——, da (-)   : 2  = 1,00974 (Fehler: 0,974%)
                 4            28      4
                                                            5
Als Tabelle  für die Näherungswerte (mit dem Fehler) von lb(-) erhalten als
                                                            4

1         9            19          47            207
- (2,3%), —— (0,974%), —— (0,43%), ——— (0,104%), ——— (0,016%), ...
3         28           59          146           643

                                                  5
Ganz ohne Taschenrechner ist es so uns möglich lb(-) zu berechnen.
                                                  4

Anhang a    Hörpsychologischer Algorithmus zur Berechnung des lb(x)

Für Informatiker wird im folgenden ein Algorithmus zur Berechnung des lb(x) angeführt:

Aufgabe:

       n
    1,5
y = ———  soll möglichst genau 1 annähern (siehe Anhang 2)
     m
    2


Hörpsychologischer Algorithmus:

Setze zu Anfang m=0 und n=0:
Gehe Quinten nach oben, erhöhe n jeweils um 1.
Wenn du eine Oktave übertriffst, dann
  gehe eine Oktave nach unten, erhöhe m um eins und
  notiere (m;n) für den Näherungswert m/n von lb(1,5).

Die Tonfolge und zugehörige Wertepaare wäre folgende:

c g d' d (2;1) a e' e (4;2) h fis' fis (6,3) cis' cis (7;4)

gis dis' dis (9;5) ais eis' eis (11;6) his =?= c (12;7)

Ich erhalte so die Näherungswerte m/n für lb(1.5) = 0,584 962 ...

 m         n        m/n
 1         2        0,5
 2         4        0,5
 3         6        0,5
 4         7        0,571 429
 5         9        0,555 556
 6         11       0,545 455
 7         12       0,583 333
 ...

                                                 7
Bemerkung: Gut bekannt ist die Näherung lb(1,5)=——
                                                12

Mit dem Quintenzirkel von 12 Quinten erhalte ich 7 Oktaven. (Nicht genau: Der Unterschied ist das pythagoreische Komma.)

Mathematische Beschreibung zur Berechnung von lb(x):
(Eps ist die Schranke für die gewünschte Genauigkeit,
 zum Beispiel eps=0,0001)

Setzte Anfangswerte: m=0, n=0 und y=1.

Wiederhole die folgenden Zeilen bis |y - 1| < eps
  Multipliziere y mit x und erhöhe n um 1 solange bis y > 2.
  Dividiere y durch 2 und erhöhe m um 1.

Der Näherungswert von lb(x) ist dann m/n.

In der "Delphi-Ecke" natürlich noch als Pascal-Programm:

function lb(const x: extended): extended;
  const eps = 1E-4;
  var m,n,y,y0: extended;
   {y = x^n/2^m soll möglichst nahe 1 approximieren}
begin
  if x < 0 then raise EMathError.Create('Negativer lb existiert nicht!');
  if x < 1 then Begin
    result := - lb(1/x); //da lb(x) = - lb(1/x);
    exit;     //lb rekursiv
  End;
  if x > 2 then Begin
    result := 1 + lb(x/2); //da lb(x) = lb(2*x/2) = 1 + lb(x/2) )
    exit;    //lb rekursiv
  End;
  //Jetzt 1 < x < 2  m := 0;
  n := 0;
  y := 1;
  y0 := 100; //Schlechter als der erste y-Wert
  repeat
    repeat
      y := y*x;
      inc(n);
    until y > 2;
    y := y/2;
    inc(m);
    if abs(y - 1) < abs(y0 - 1) then Begin
       y0 := y;
       //Gib zu Testzwecken m und n passend aus
    End;
  until abs(y - 1) < eps;
  result := m/n;
end;

Die Ausgabe sieht dann folgendermaßen aus:
 m         n        m/n
 1         2        0,5
 4         7        0,571 429
 7         12       0,583 333
 31        53       0,584 906
 210       359      0,584 958
 389       665      0,584 962
 ...

Anhang b   

Mathematischer Algorithmus zur Berechnung
des lb(x) hörpsychologisch interpretiert



Der folgende Algorithmus ist die einfachste Form des üblichen mathematischen Verfahrens, um den lb(x) zu berechnen.

Ich erläutere ihn mit Qui = lb(3/2)·Ok. Analog geht dies auch mit jedem Intervall der Oktave.


                            1
Da 2Qui  > 1Ok, folgt Qui = -Ok + r  (r : "kleiner" Rest)
                            2      1   1

Wir betrachten nun das Intervall i = 2Qui - Ok = 2r .
                                  1                1

Nun verdoppeln wir das Intervall i  und vergleichen es mit der Oktav.
                                  1

Hier ist i der Ganzton und i = 2i die (pythagoreische) große Terz.
          1                 2    1

Wäre i > Ok gewesen, hätten wir i = 4Qui - 2Ok = Ok + "kleiner" Rest.
      2                          2

                                 1     1
Wir könnten also schreiben Qui = -Ok + -Ok + ("kleiner" Rest):4 (Konjunktiv!).
                                 2     4

                                                   1       1
Da aber i  kleiner als die Oktave ist folgt: Qui = -Ok + 0·-Ok + "kleiner" Rest.
         2                                         2       4

                         1
Wobei ("kleiner" Rest) < -Ok ist.
                         4

Durch Verdoppeln der Intervalle können wir in ähnlicher Weise feststellen,

            1     1     1
ob wir noch -Ok, ——Ok  ——Ok zur Quinte hinzurechnen können.
            8    16  , 32

Auf diese Weise erhalten wir:

       1    1     1    1     1     1
Qui = (-  + —— + —— + ——— + ——— + ———— + ...)Ok = 0,58496Ok + kleiner "Rest"
       2    16   64   256   512   1024

                                           3
Mit dem Taschenrechner gerechnet: Qui = lb(-)Ok = 0,5849625Ok.
                                           2

Diesen Algorithmus beschreibe ich im folgenden mathematisch:

Wir rechnen mit dem Frequenzverhältnis x (Bei der Quinte x=3/2).

Der Näherungswert a für lb(x) wird laufend verbessert.

Setzte Anfangswert a=0 und y = x.
                            0

     2                      2                1
Ist y  > 2, dann setze y = y - 2 und addiere - zu a,
     0                  1   0                2
                                   2
            andernfalls setze y = y  und addiere nichts zu a.
                               1   0

     2                      2                1
Ist y  > 2, dann setze y = y - 2 und addiere - zu a,
     1                  2   1                4
                                   2
            andernfalls setze y = y  und addiere nichts zu a.
                               2   1

                                         1   1   1
Fahre so fort und addiere gegebenenfalls -, ——, ——, ...
                                         8  16  32

Als Delphi-Programm:

function lb(const x: real): real;
  var y, potenzvon2, a: real; //oder statt "a" gleich "result"
      k: integer;
  //Iteration lb(x) = 0,y1y2y3y4y5... (dual)
  //lb(x*x)=2*lb(x) = y1,y2y3y4y5 ...
  //Durch Quadrieren von x erhält man die Dualdarstellung
begin
  if x < 0 then raise EMathError.Create('Negativer lb existiert nicht!');
  if x < 1 then Begin
    result := - lb(1/x); //da lb(x) = - lb(1/x);
    exit;      //rekursiv
  End;
  if x > 2 then Begin
    result := 1 + lb(x/2); //da lb(x) = lb(2*x/2) = 1 + lb(x/2) )
    exit;       //rekursiv
  End;
  //Nun der eigentliche Algorithmus für 1 < x <= 2
  potenzvon2 :=1;
  y := x;
  a := 0;
  for k := 1 to 64 {Je nach Genauigkeit des Zahlentyps} do Begin
    potenzvon2 := potenzvon2/2; //1/2 1/4 1/8 1/16 ...
    y:= y*y;
    if y > 2 then Begin
      y := y/2;                    1     1     1
      a := a + potenzvon2; //a = ?·- + ?·- + ?·- + ... ? = 0 oder 1
    End;                           2     4     8
  End;
  result := a;
end;

Kommentieren  ↑nach oben