Mathematik

arabische Ziffern (//werden von den Europäern verwendet//): 1234567890
indische Ziffern (//werden von den Arabern verwendet//): ١٢٣٤٥٦٧٨٩٠

Eine gute Näherung für "Wurzel aus 2" ist der Bruch 1055 / 746.

• studyflix
• allgemeines Dreieck
• 73 ist die beste Zahl der Welt
• Die magische Zahl 1089
• 2+2=5
• Mysterium der Mathematik
• Internet hat entschieden: Das sind die elegantesten Gleichungen des Universums - 07. April 2016
  1. Dirac-Gleichung
  2. Eulersche Identität
  3. Pi ~ 3,1416 ~ 22/7 ~ 355/113
• ausgewählte Bezeichnungen
  • irrationale Zahlen kann man nicht als Bruch darstellen
  • transzendente Zahlen kann man nicht als Gleichung darstellen

• elektronische Rechenmaschine mit mechanischem Schallspeicher
  • Retro Computer / Tischrechner: ISKRA 111 (der Shibari Computer)
  • Retro Tischrechner: Soemtron ETR220 (ohne IC, nur mit Transistoren, Dioden und Kernspeicher) / Soemtron ETR220

Zu welchem Zinssatz "Z" muß man sein Kapital, für eine Verdopplung nach 9 Jahren, anlegen?
Z = 2^(1/9) = 1,08006 = 8,006 %

Auf welchen Betrag "B" vergrößert sich das Kapital (von 1000 €), wenn man es mit 8,006% für 9 Jahre anlegt?
B = 1000 * 1,08006^9 = 2000 €

Nach wieviel Jahren "J" hat sich das Kapital Verdopplung, wenn es mit 8,006% angelegt wird?
J = log(2) / log(1,08006) = 9 Jahre
J = ln(2)  / ln(1,08006)  = 9 Jahre

dezimaler Logarithmus (und rückwärts):

10^4       = 10000
log(10000) = 4

wenn ein Programm nur den natürlichen Logarithmus "ln(x)" berechnen kann (wie z.B. das Komandozeilenwerkzeug "bc"), man aber den dezimaler Logarithmus "log(x)" berechnen möchte, dann kann man das wie folgt tun:

ln(10000)/ln(10) = 4

> echo "l(10000)/l(10)" | bc -l
4.00000000000000000000

• https://de.wikipedia.org/wiki/Skalarprodukt
• Ein Skalar ist ein einfacher Zahlenwert: https://de.wikipedia.org/wiki/Skalar_(Mathematik)

• https://de.wikipedia.org/wiki/Kreuzprodukt

math-product.js

const a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
const b = ["a", "b", "c", "d", "e", "f"];
 
console.info(`%c A = ${a}`, "color: blue");
console.info(a);
console.info(`%c B = ${b}`, "color: blue");
console.info(b);
 
let result;
 
// skalarprodukt
result = a.length * b.length;
console.info("%c Skalarprodukt: Anzahl der Elemente von A mal Anzahl der Elemente von B", "color: red");
console.info(`%c |A| * |B| = ${result}`, "color: blue");
 
// kreuzprodukt/vektorprodukt
result = new Array();
for (const i of a) {
    for (const j of b) {
        result.push(`${i}${j}`)
    }
}
console.info("%c Kreuzprodukt/Vektorprodukt: Jedes Element von A kombiniert mit jedem Element von B", "color: red");
console.info(`%c A x B = ${result}`, "color: blue");
console.info(result);
console.info(`%c |A x B| = ${result.length}`, "color: blue");

Den Code in die DevTools Konsole einfügen oder mit Deno (oder einer anderen JS runtime z.B. NodeJS) ausführen

$ deno run math-product.js

a  =  Kathete      =  c * sin Alpha  =  c * cos Beta
b  =  Kathete      =  c * sin Beta   =  c * cos Alpha
c  =  Hypothenuse  =  a / sin Alpha  =  b / sin Beta   =  a / cos Beta  =  b / cos Alpha

Primzahlen_bc.sh

#!/bin/sh
 
#==============================================================================#
# Primzahlen ausgeben
#==============================================================================#
 
if [ x = "x${2}" ] ; then
	VON="1"
	BIS="120"
else
	VON="${1}"
	BIS="${2}"
fi
 
#------------------------------------------------------------------------------#
 
echo "
bc << 'EOF'
define is_prime(n) {
	if (n <= 1) return 0
	if (n <= 3) return 1
	if (n % 2 == 0 || n % 3 == 0) return 0
 
	i = 5
	while (i * i <= n) {
		if (n % i == 0 || n % (i + 2) == 0) return 0
		i += 6
	}
	return 1
}
 
define print_primes(min,max) {
	print \"Primzahlen von 1 bis \", max, \" in verschiedenen Basen:\n\"
	print \"========================================================\n\"
	print \"  Basis 12 | Basis 10 | Basis 7  | Basis 5  | Basis 3  | Basis 2  |\n\"
	print \"|----------|----------|----------|----------|----------|----------|\n\"
	for (n = min; n <= max; n++) {
		if (is_prime(n)) {
			print \"   \";
 
			obase=12;
			print n, \"       \";
 
			obase=10;
			print n, \"       \";
 
			obase=7;
			print n, \"       \";
 
			obase=5;
			print n, \"       \";
 
			obase=3;
			print n, \"       \";
 
			obase=2;
			print n, \"       \";
 
			print \"\n\"
		}
	}
}
 
print_primes(${VON},${BIS})
quit
EOF
" | bash
 
#------------------------------------------------------------------------------#

> /cifs/bin/Primzahlen_bc.sh 
Primzahlen von 1 bis 120 in verschiedenen Basen:
========================================================
  Basis 12 | Basis 10 | Basis 7  | Basis 5  | Basis 3  | Basis 2  |
|----------|----------|----------|----------|----------|----------|
   2       2       2       2       2       10       
   3       3       3       3       10       11       
   5       5       5       10       12       101       
   7       7       10       12       21       111       
   B       11       14       21       102       1011       
   11       13       16       23       111       1101       
   15       17       23       32       122       10001       
   17       19       25       34       201       10011       
   1B       23       32       43       212       10111       
   25       29       41       104       1002       11101       
   27       31       43       111       1011       11111       
   31       37       52       122       1101       100101       
   35       41       56       131       1112       101001       
   37       43       61       133       1121       101011       
   3B       47       65       142       1202       101111       
   45       53       104       203       1222       110101       
   4B       59       113       214       2012       111011       
   51       61       115       221       2021       111101       
   57       67       124       232       2111       1000011       
   5B       71       131       241       2122       1000111       
   61       73       133       243       2201       1001001       
   67       79       142       304       2221       1001111       
   6B       83       146       313       10002       1010011       
   75       89       155       324       10022       1011001       
   81       97       166       342       10121       1100001       
   85       101       203       401       10202       1100101       
   87       103       205       403       10211       1100111       
   8B       107       212       412       10222       1101011       
   91       109       214       414       11001       1101101       
   95       113       221       423       11012       1110001       
0

Primzahlenausgabe.bc

#
# nur wann es eine Primzahl ist, wird die Zahl ausgegeben
#
# echo "11" | bc -q ${0}
define is_prime(n) {
	if (n <= 1) return 0
	if (n <= 3) return 1
	if (n % 2 == 0 || n % 3 == 0) return 0
 
	i = 5
	while (i * i <= n) {
		if (n % i == 0 || n % (i + 2) == 0) return 0
		i += 6
	}
	return 1
}
 
# Lese die Eingabe und teste sie
n = read()
if (is_prime(n)) {
	print n, "\n"
}

Zahlenbasis.bc

obase = read();
n = read();
print n;
print "\n"

Primzahlen_bc+bash.sh

#!/bin/sh
 
#==============================================================================#
# Primzahlen n verschiedenen Basen ausgeben
#==============================================================================#
 
if [ x = "x${2}" ] ; then
	VON="1"
	BIS="120"
else
	VON="${1}"
	shift
	BIS="${1}"
	shift
	BASIS_LISTE="${@}"
fi
 
if [ x = "x${BASIS_LISTE}" ] ; then
	BASIS_LISTE="12 10 7 5 3 2"
fi
 
VERZ="$(dirname "${0}")"
 
#------------------------------------------------------------------------------#
BREIT_1="$(echo "Basis $(echo "${BASIS_LISTE}" | tr -s ' ' '\n' | sort -nr | head -n1)" | wc -m | awk '{print $1 + 2}')"
BREIT_2="$(echo "$(echo "${BASIS_LISTE}" | tr -s ' ' '\n' | sort -n | head -n1) ${BIS}" | tr ' ' '\n' | bc -lq ${VERZ}/Zahlenbasis.bc | wc -m | awk '{print $1 + 2}')"
BREIT_3="$(echo "${BREIT_1} ${BREIT_2}" | tr -s ' ' '\n' | sort -nr | head -n1 | awk '{print $1}')"
BREIT_4="$(echo "${BREIT_3}" | awk '{print $1 - 1}')"
#echo "BREIT_1='${BREIT_1}'"
#echo "BREIT_2='${BREIT_2}'"
#echo "BREIT_3='${BREIT_3}'"
#echo "BREIT_4='${BREIT_4}'"
#------------------------------------------------------------------------------#
KOPF_1="$(for A in ${BASIS_LISTE}
do
	for B in $(seq -w 1 ${BREIT_4})
	do
		echo "-"
	done
	echo "+"
done | tr -d '\n' | sed 's/.*/+&/'
echo)"
#------------------------------------------------------------------------------#
KOPF_2="$(for C in ${BASIS_LISTE}
do
	echo " Basis ${C}                "
done | cut -b-${BREIT_4} | tr -s '\n' '|' | sed 's/.*/|&/'
echo)"
#------------------------------------------------------------------------------#
echo "Primzahlen ${VON} bis ${BIS} in verschiedenen Basen:"
echo "${KOPF_1}"
echo "${KOPF_2}"
echo "${KOPF_1}"
#------------------------------------------------------------------------------#
 
for NZ in $(seq -w ${VON} ${BIS})
do
	echo "${NZ}" | bc -q ${VERZ}/Primzahlenausgabe.bc
done | while read PZ
do
	for DIE_BASIS in ${BASIS_LISTE}
	do
		echo "${DIE_BASIS} ${PZ}" | tr ' ' '\n' | bc -lq ${VERZ}/Zahlenbasis.bc
	done | sed 's/.*/        & /' | rev | cut -b-${BREIT_4} | rev | tr -s '\n' '|' | sed 's/.*/|&/'
	echo
done
 
echo "${KOPF_1}"
 
#------------------------------------------------------------------------------#

> ./Primzahlen_bc+bash.sh 100 120
Primzahlen 100 bis 120
Primzahl in verschiedenen Basen:
+----------+----------+----------+----------+----------+----------+
| Basis 12 | Basis 10 | Basis 7  | Basis 5  | Basis 3  | Basis 2  |
+----------+----------+----------+----------+----------+----------+
|       85 |      101 |      203 |      401 |    10202 |  1100101 |
|       87 |      103 |      205 |      403 |    10211 |  1100111 |
|       8B |      107 |      212 |      412 |    10222 |  1101011 |
|       91 |      109 |      214 |      414 |    11001 |  1101101 |
|       95 |      113 |      221 |      423 |    11012 |  1110001 |
+----------+----------+----------+----------+----------+----------+

sehr gute Näherungen für Pi:

• 22 / 7 ~ Pi
• 355 / 113 ~ Pi

• Was hat Pi mit den Primzahlen zu tun?

Der englische Mathematiker William Jones verwendete in seiner Synopsis Palmariorum Matheseos (1706) als erster den griechischen Kleinbuchstaben "Pi", um das Verhältnis von Umfang zu Durchmesser auszudrücken.

Leonhard Euler verwendete erstmals 1737 den griechischen Kleinbuchstaben "Pi" für die Kreiszahl, nachdem er zuvor p verwendet hatte. Seitdem ist aufgrund der Bedeutung Eulers diese Bezeichnung allgemein üblich.

Pi auf 51 Stellen hinter dem Komma genau:

Pi = 3.14159265358979323846264338327950288419716939937510…

Im Gegensatz zur Eulerschen Zahl e konnten aber bislang bei der (regulären) Kettenbruchdarstellung von "Pi" keinerlei Regelmäßigkeiten festgestellt werden.

Die Genauigkeit von 200 dezimalen Nachkommastellen erhält man mit 194 Teilnennern:

"Pi" = [3; 7, 15, 1, 292, 1, 1, 1, 2, 1, 3, 1, 14, 2, 1, 1, 2, 2, 2, 2, 1, 84, 2, 1, 1, 15, 3, 13, 1, 4, 2, 6, 6, 99, 1, 2, 2, 6, 3, 5, 1, 1, 6, 8, 1, 7, 1, 2, 3, 7, 1, 2, 1, 1, 12, 1, 1, 1, 3, 1, 1, 8, 1, 1, 2, 1, 6, 1, 1, 5, 2, 2, 3, 1, 2, 4, 4, 16, 1, 161, 45, 1, 22, 1, 2, 2, 1, 4, 1, 2, 24, 1, 2, 1, 3, 1, 2, 1, 1, 10, 2, 5, 4, 1, 2, 2, 8, 1, 5, 2, 2, 26, 1, 4, 1, 1, 8, 2, 42, 2, 1, 7, 3, 3, 1, 1, 7, 2, 4, 9, 7, 2, 3, 1, 57, 1, 18, 1, 9, 19, 1, 2, 18, 1, 3, 7, 30, 1, 1, 1, 3, 3, 3, 1, 2, 8, 1, 1, 2, 1, 15, 1, 2, 13, 1, 2, 1, 4, 1, 12, 1, 1, 3, 3, 28, 1, 10, 3, 2, 20, 1, 1, 1, 1, 4, 1, 1, 1, 5, 3, 2, 1, 6, 1, 4, …]

Pi per Skript berechnen

Durch den Goldenen Schnitt, Goldene Zahl, Phi oder auch göttliche Teilung wird ein Zahlenwert bezeichnet, den man in der Natur vielerorts wieder findet.

Die Phi ist eine irrationale Zahl, das heißt sie lässt sich nicht als Bruch zweier ganzer Zahlen darstellen. Sie ist jedoch algebraisch vom Grad 2, insbesondere kann sie mit Zirkel und Lineal konstruiert werden.

• Goldene Zahl = φ = 1,6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374847540880753868917521266338622235369317931800607667263544333890865959395829056383226613199282902678806752...
  • Phi = 987 / 610 = 1,618032787 (auf 5 Nachstellen genau)
  • Phi = 6765 / 4181 = 1,618033963 (auf 7 Nachstellen genau)
  • Phi = (1 + sqrt(5)) / 2 = (1 + (5^(1/2))) / 2 = 1,618033989 (auf 8 Nachstellen genau)

Es ist aber auch möglich, die Phi aus zwei aufeinander folgenden Zahlen der Fibonacci-Folge zu errechnen. Je größer die gewählten Zahlen aus der Fibonacci-Folge sind, desto genauer ist das Ergebnis.

1/Phi = Phi - 1
Phi²  = Phi + 1

Phi per Skript berechnen

Die Ägypter hatten (außer für 2/3) nur Zeichen für Stammbrüchen und haben demnach nur in Stammbrüchen gerechnet:

• Ägyptische Brüche (und zwei ungelöste mathematische Probleme)

⇒ 20/21 = 1/2 + 1/3 + 1/9 + 1/126
oder
⇒ 20/21 = 1/2 + 1/3 + 1/14 + 1/21

zerlegen_in_stammbrueche.py

#!/usr/bin/python3
 
from fractions import Fraction
 
def greedy (x, forceOdd = False):
        L = []
        print(str(x) + " = ", end = "")
        while x > 0:
                inv = Fraction(1) / x
                u = int(inv)
                if u < inv:
                        u += 1
                if forceOdd and u % 2 == 0:
                        u += 1
                f = Fraction(1, u)
                L.append(f)
                x -= f
        print(" + ".join(map(str, L)))
 
print (greedy(Fraction(20, 21)))
print (greedy(Fraction(20, 21), True))

20/21 = 1/2 + 1/3 + 1/9 + 1/126
20/21 = 1/3 + 1/3 + 1/5 + 1/13 + 1/115 + 1/10465

Mit Hilfe der Farey-Folge kann man sympatischere Stammbrüche als Lösung finden.

Die Fibonacci-Folge ist eine unendliche Folge von Zahlen (den Fibonacci-Zahlen), bei der sich die jeweils folgende Zahl durch Addition der beiden vorherigen Zahlen ergibt: 0, 1, 1, 2, 3, 5, 8, 13, … Benannt ist sie nach Leonardo Fibonacci, der damit 1202 das Wachstum einer Kaninchenpopulation beschrieb. Die Reihe war aber schon in der indischen und westlichen Antike bekannt.

C# Programm (sehr ähnlich in Java)

using System;
using System.Collections.Generic;
 
Test(7);
 
static void Test(int n)
{
    var passed = 0;
    var failed = new List<int>();
    for (var i = -1; i <= n; i++)
    {
        var (a, b, c) = (Fibonacci1(i), Fibonacci2(i), Fibonacci3(i));
        if (a == b && a == c) passed++;
        else failed.Add(i);
 
        Console.WriteLine($"Fibonacci1({i}) = {c}");
        Console.WriteLine($"Fibonacci2({i}) = {b}");
        Console.WriteLine($"Fibonacci3({i}) = {c}");
    }
    Console.WriteLine($"\nTest passed: {passed}/{n + 2}");
    Console.WriteLine($"Test failed: {(failed.Count != 0 ? failed.ToArray() : 0)}\n");
}
 
static int Fibonacci1(int n)
{
    if (n < 0) return -1;
    var (x, y, z) = (0, 1, 0);
    for (var i = 0; i < n; i++)
    {
        z = x;
        x += y;
        y = z;
    }
    return x;
}
 
static int Fibonacci2(int n)
{
    if (n < 0) return -1;
    return (n <= 1) ? n : Fibonacci2(n - 2) + Fibonacci2(n - 1);
}
 
static int Fibonacci3(int n)
{
    var sqrt5 = Math.Sqrt(5);
    if (n < 0) return -1;
    return Convert.ToInt32(Math.Round((Math.Pow(((1 + sqrt5) / 2), n) - (Math.Pow(((1 - sqrt5) / 2), n))) / sqrt5));
}

Fibonacci-Folge per Skript berechnen

siehe auch: Der goldene Schnitt und die Fibonacci-Folge

In dem Video Die Pyramiden Lüge habe ich erfahren, dass das Quadrat von Phi = 5/6 von Pi ist und da ich ja bereits weiß, wie man Phi aus der Fibonacci-Folge berechnet, kann ich den genauen Zusammenhang hier demonstrieren.

Als erstes benötigen wir zwei sehr große aufeinander folgende Zahlen aus der Fibonacci-Reihe, ich nenne sie hier "f" und "g". In diesem Beispiel soll "f" die 49. und "g" die 50. Zahl aus der Fibonacci-Folge sein.

f =  7778742049
g = 12586269025

daraus kann man Phi berechnen:

Phi = 12586269025 / 7778742049
Phi = 1,61803398875

jetzt brauchen wir das Quadrat von Phi:

Phi * Phi = 1,61803398875² = 2,61803398875

und daraus können wir jetzt Pi berechnen:

Pi = Phi * Phi * 6 / 5 = 3,1416407865

Die Genauigkeit ist natürlich höher, je größer die verwendeten Zahlen aus der Fibonacci-Folge sind.

Weil es Mathematik ist, geht es auch rückwärts:

Pi = 3.14159265358979323846264338327950...

leider rechnet mein Taschenrechner aber nur mit dieser Genauigkeit:

Pi = 3,141592654

und so sieht die Berechnung dann in einem Stück aus:

Phi² = Pi * 5 / 6
Phi² = 3,141592654 * 5 / 6
Phi² = 15,707963268 / 6
Phi² = 2,617993878
Phi  = Wurzel(2,617993878)
Phi  = 1,618021594

Also, ich finde es sehr bemerkenswert, dass man aus einer sehr einfach zu erstellenden Fibonacci-Folge, mit einer sehr einfachen Formel, sowohl Phi als auch Pi berechnen kann. Ebenso bemerkenswert finde ich, dass es zwischen Pi und Phi einen so einfachen mathematischen Zusammenhang gibt.

eulersche Zahl: e = 2,718281828459…

Die Kettenbruchentwicklung von e weist folgendes Muster auf, welches sich bis ins Unendliche fortsetzt:

e = [2;1,2,1,1,4,1,1,6,1,1,8,1,1,10,1,…]

#!/bin/bash
 
GENAUIGKEIT="64"
 
if [ "$(uname -s)" = "FreeBSD" ] ; then
        B="tail -r"
elif [ "$(uname -s)" = "Linux" ] ; then
        B="tac"
else
        echo "Dieses System wird nicht unterstützt"
        exit 1
fi
 
echo "2;1,2,1,1,4,1,1,6,1,1,8,1,1,10,1,2;1,2,1,1,4,1,1,6,1,1,8,1,1,10,1,2;1,2,1,1,4,1,1,6,1,1,8,1,1,10,1" \
  | tr -s '[;,]' '\n' \
  | ${B} \
  | while read ZAHL
do
        if [ -z "${FORMEL}" ] ; then
                FORMEL="${ZAHL}"
        else
                FORMEL="(${ZAHL}+1/${FORMEL})"
        fi
        echo "${FORMEL}"
done | tail -n1 | sed -e "s/.*/scale=${GENAUIGKEIT};&/" | bc -l

2.7182818284642508923782694452544440585600629510636232896063239753

Die von Geoffrey Miller beschriebene Regel besagt nun: Man untersuche 37 % der Elemente der gegebenen Menge und finde darin das optimale Element. Dann untersucht man weiter einzelne Elemente, bis man ein Element findet, das besser ist als das bisher gefundene Optimum. Dieses Element wählt man.

Bekannt wurde die 37-%-Regel vor allem durch Geoffrey Miller, der sie in seinem Buch The Mating Mind als mögliches Verfahren für die Partnerauswahl beschreibt. Zurück geht die Regel auf das sogenannte Sekretärinnenproblem, für das Eugene Dynkin in einer Arbeit aus dem Jahr 1963 (also zwei Jahre vor der Geburt von Miller) die 1/e-Regel bewies: E. Dynkin, Optimal choice of the stopping time of a Markov process, DAN150, 2 (1963), 238-240 (Original in russisch). Es ist gerundet 1/e = 37 %.

Eine alternative Möglichkeit, reelle Zahlen darzustellen, ist die Kettenbruchentwicklung. Da "Pi" irrational ist, ist auch diese Darstellung unendlich lang.

Euler fand heraus, dass periodische Kettenbrüche (so wie bei der Quadratwurzel von 2 oder bei der goldenen Zahl) quadratischen Irrationalzahlen entsprechen, und Lagrange zeigte später, dass alle diese Zahlen periodische Kettenbrüche haben.

Man kann beweisen, dass jeder unendliche Kettenbruch konvergiert. Ganz ähnlich, wie man reelle Zahlen durch Dezimalzahlen darstellt, kann man weiter zeigen, dass

• die Zuordnung Kettenbruch ←→ reelle Zahl bijektiv ist (d.h. zu jeder reellen Zahl es genau einen Kettenbruch gibt, der sie darstellt und umgekehrt)
• und die endlichen Kettenbrüche gerade zu den rationalen Zahlen gehören.

Aus den oben genannten Kettenbruch-Zahlenwerten für "Pi", baut dieses Script den entsprechenden Kettenbruch zusammen:

#!/bin/bash
 
if [ "$(uname -s)" = "FreeBSD" ] ; then
        B="tail -r"
elif [ "$(uname -s)" = "Linux" ] ; then
        B="tac"
else
        echo "Dieses System wird nicht unterstützt"
        exit 1
fi
 
echo "3; 7, 15, 1, 292, 1, 1, 1, 2, 1, 3, 1, 14, 2, 1, 1, 2, 2, 2, 2, 1, 84, 2, 1, 1, 15, 3, 13, 1, 4, 2, 6, 6, 99, 1, 2, 2, 6, 3, 5, 1, 1, 6, 8, 1, 7, 1, 2, 3, 7, 1, 2, 1, 1, 12, 1, 1, 1, 3, 1, 1, 8, 1, 1, 2, 1, 6, 1, 1, 5, 2, 2, 3, 1, 2, 4, 4, 16, 1, 161, 45, 1, 22, 1, 2, 2, 1, 4, 1, 2, 24, 1, 2, 1, 3, 1, 2, 1, 1, 10, 2, 5, 4, 1, 2, 2, 8, 1, 5, 2, 2, 26, 1, 4, 1, 1, 8, 2, 42, 2, 1, 7, 3, 3, 1, 1, 7, 2, 4, 9, 7, 2, 3, 1, 57, 1, 18, 1, 9, 19, 1, 2, 18, 1, 3, 7, 30, 1, 1, 1, 3, 3, 3, 1, 2, 8, 1, 1, 2, 1, 15, 1, 2, 13, 1, 2, 1, 4, 1, 12, 1, 1, 3, 3, 28, 1, 10, 3, 2, 20, 1, 1, 1, 1, 4, 1, 1, 1, 5, 3, 2, 1, 6, 1, 4" \
  | tr -s '[;,]' '\n' \
  | ${B} \
  | while read ZAHL
do
        if [ -z "${FORMEL}" ] ; then
                FORMEL="${ZAHL}"
        else
                FORMEL="(${ZAHL}+1/${FORMEL})"
        fi
        echo "${FORMEL}"
done | tail -n1

(3+1/(7+1/(15+1/(1+1/(292+1/(1+1/(1+1/(1+1/(2+1/(1+1/(3+1/(1+1/(14+1/(2+1/(1+1/(1+1/(2+1/(2+1/(2+1/(2+1/(1+1/(84+1/(2+1/(1+1/(1+1/(15+1/(3+1/(13+1/(1+1/(4+1/(2+1/(6+1/(6+1/(99+1/(1+1/(2+1/(2+1/(6+1/(3+1/(5+1/(1+1/(1+1/(6+1/(8+1/(1+1/(7+1/(1+1/(2+1/(3+1/(7+1/(1+1/(2+1/(1+1/(1+1/(12+1/(1+1/(1+1/(1+1/(3+1/(1+1/(1+1/(8+1/(1+1/(1+1/(2+1/(1+1/(6+1/(1+1/(1+1/(5+1/(2+1/(2+1/(3+1/(1+1/(2+1/(4+1/(4+1/(16+1/(1+1/(161+1/(45+1/(1+1/(22+1/(1+1/(2+1/(2+1/(1+1/(4+1/(1+1/(2+1/(24+1/(1+1/(2+1/(1+1/(3+1/(1+1/(2+1/(1+1/(1+1/(10+1/(2+1/(5+1/(4+1/(1+1/(2+1/(2+1/(8+1/(1+1/(5+1/(2+1/(2+1/(26+1/(1+1/(4+1/(1+1/(1+1/(8+1/(2+1/(42+1/(2+1/(1+1/(7+1/(3+1/(3+1/(1+1/(1+1/(7+1/(2+1/(4+1/(9+1/(7+1/(2+1/(3+1/(1+1/(57+1/(1+1/(18+1/(1+1/(9+1/(19+1/(1+1/(2+1/(18+1/(1+1/(3+1/(7+1/(30+1/(1+1/(1+1/(1+1/(3+1/(3+1/(3+1/(1+1/(2+1/(8+1/(1+1/(1+1/(2+1/(1+1/(15+1/(1+1/(2+1/(13+1/(1+1/(2+1/(1+1/(4+1/(1+1/(12+1/(1+1/(1+1/(3+1/(3+1/(28+1/(1+1/(10+1/(3+1/(2+1/(20+1/(1+1/(1+1/(1+1/(1+1/(4+1/(1+1/(1+1/(1+1/(5+1/(3+1/(2+1/(1+1/(6+1/(1+1/4))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

Das Pentagonhexakontaeder ist ein konvexes Polyeder, das sich aus 60 Fünfecken zusammensetzt und zu den Catalanischen Körpern zählt. Es ist dual zum abgeschrägten Dodekaeder und hat 92 Ecken sowie 150 Kanten. Die folgenden Bilder zeigen zwei zueinander spiegelbildliche Pentagonhexakontaeder.

Durch Verbinden der Mittelpunkte von jeweils fünf Kanten, die in jeder Raumecke des abgeschrägten Dodekaeders zusammenstoßen, entsteht ein Sehnenfünfeck, dessen Umkreis gleichzeitig Inkreis des Tangentenfünfecks, der Begrenzungsfläche des Pentagonhexakontaeders, ist. Bei diesem speziellen Typ sind alle Flächenwinkel gleich groß (≈ 153°), und es existiert ein einheitlicher Kantenkugelradius.

Ich finde diesen geometrischen Körper deshalb so interessant, weil hier ein kugelähnlicher 3D-Körper aus nur einer einzigen 2D-Geometrie besteht.

Normalerweise ist es üblich mindestens zwei verschiedene 2D-Geometrie zum erstellen eines kugelähnlicher Gebildes zu verwenden. Ein Fußball zum Beispiel besteht aus gleichseitigen 5-Ecken und 6-Ecken, auch ist es üblich 5-Ecke zusammen mit gleichseitigen 3-Ecken zu verwenden.

Hier wird aber nur eine einzige Geometrie verwendet.

kgV.sh

#!/bin/bash
 
#------------------------------------------------------------------------------#
#
# Kleinstes gemeinsames Vielfaches
#
#------------------------------------------------------------------------------#
 
LANG=C
STOP=nein
V=1
#set -x
while [ "${STOP}" = "nein" ]
do
        V="$(echo "${V}" | awk '{print $1 + 1}')"
        R0=""
        TEST=ja
 
        for i in ${@}
        do
                R1="$(echo "${V} ${i}" | awk '{print $1/$2}')"
                R2="$(echo "${R1}" | egrep -v '[.].*[^0]')"
 
                if [ "x${R2}" = x ] ; then
                        TEST=nein
                else
                        R0="${R0} ${i}*${R2}=${V},"
                fi
        done
 
        if [ "${TEST}" = "ja" ] ; then
                STOP=ja
                echo "# ${R0}"
        fi
done

> ./kgV.sh 5 6 7
#  5*42=210, 6*35=210, 7*30=210,

• Riemannsche Vermutung
• Die Riemann-Hypotese