A

p

e

r

s

o

n

a

l

B

l

o

g

List operations

Apply a function to each member of a list:

Ruby:       [1,2,3].map { |x| x * 2 }
Python:     map(lambda x: x * 2, [1,2,3])
Haskell:    map (*2) [1,2,3]
Javascript: [1,2,3,4].map(x => x * 2)

Flatten a list of multiple sublists:

Ruby;       [[1,2,3],[4,5,6],[7,8,9]].flatten
Python:     [item for list in [[1,2,3],[4,5,6],[7,8,9]] for item in list]
Haskell:    concat [[1,2,3],[4,5,6],[7,8,9]]
Javascript: [].concat(...[[1,2,3],[4,5,6],[7,8,9]])

Multiply all members of a list:

Ruby:       [1,2,3,4].reduce(1,:*)
Python:     reduce((lambda x, y: x * y), [1,2,3,4], 1)
Haskell:    foldl (*) 1 [1,2,3,4]
Javascript: [1,2,3,4].reduce((accu, item) => accu * item, 1)

Filter all even members from a list:

Ruby:       [0,1,2,3,4,5,6,7,8,9].select &:even?
Python:     filter(lambda x: not x % 2, [0,1,2,3,4,5,6,7,8,9])
Haskell:    filter (even) [0,1,2,3,4,5,6,7,8,9]
Javascript: [0,1,2,3,4,5,6,7,8,9].filter(x => x % 2 == 0)

Sort a list ascending:

Ruby:       [5,9,0,1,3,2,4,8,6,7].sort
Python:     sorted([5,9,0,1,3,2,4,8,6,7])
Haskell:    Data.List.sort [5,9,0,1,3,2,4,8,6,7]
Javascript: [5,9,0,1,3,2,4,8,6,7].sort()

Element is member of the list

Ruby:       [0,1,2,3,4,5,6,7,8,9].include? 5
Python:     5 in [0,1,2,3,4,5,6,7,8,9]
Haskell:    5 `elem` [0,1,2,3,4,5,6,7,8,9]
Javascript: [0,1,2,3,4,5,6,7,8,9].includes(5)

List of numbers between 100 and 200

Ruby:       (100..200).to_a
Python:     range(100,200 + 1)
Haskell:    [100..200]
Javascript: Array(100 + 1).fill(100).map((e,i) => e + i)

Two lists and return a list of corresponding pairs:

Ruby:       [1,2,3,4,5].zip([5,4,3,2,1])
Python:     zip([1,2,3,4,5], [5,4,3,2,1])
Haskell:    zip [1,2,3,4,5] [5,4,3,2,1]
Javascript: No suitable oneliner

Minimum and Maximum of a list:

Ruby:       [:min, :max].map { |m| [5,2,6,2,1,7,3].method(m).call }
Python:     [m([5,2,6,2,1,7,3]) for m in [min, max]]
Haskell:    [m [5,2,6,2,1,7,3] | m <- [minimum, maximum]]
Javascript: [Math.min, Math.max].map(m => m.apply(null, [5,2,6,2,1,7,3]))

Print each member of a list

Ruby:       [1,2,3,4,5].each { |v| puts v }
Python:     print '\n'.join(str(p) for p in [1,2,3,4,5])
Haskell:    mapM_ (putStrLn . show) [1,2,3,4,5]
Javascript: [1,2,3,4,5].forEach(x => console.log(x))

Multiple lines to one single line string:

Ruby:       "Hello\nprograming\n world".lines.map(&:strip).join ' '
Python:     ' '.join([line.strip() for line in "Hello\nprograming\n world".splitlines()])
Haskell:    Data.Text.unpack $ Data.Text.unwords $ map(Data.Text.strip) $ Data.Text.lines $ Data.Text.pack "Hello\nprograming\n world"
Javascript: "Hello\nprograming\n world".split('\n').map(x => x.replace(' ', '')).join(' ')

Dürüm (vegan)

Transferzeit

Hohmann-Transfer

Dieser Eintrag beschreibt die Zeit auf einem Hohmann-Transfer zwischen zwei Kreisbahnen um einen Zentralkörper und ist im Weiteren auch für einen Bi-elliptischen-Transfer interessant. Die Bahn für den Transfer ist dabei immer eine Ellipse mit der großen Halbachse $a = \frac{r_1 + r_2}{2}$ Dabei ist $r_1$ Radius der inneren Kreisbahn und $r_2$ Radius der äußeren Bahn.

Die Frage nach der Transferzeit $T$ auf einer Ellipse kann durch das 3. Keplersche Gesetz beantwortet werden. Nachdem gilt: Die Periode der quadratischen Umlaufzeit auf einer Ellipsenbahn ist proportional zu der dritten Potenz der Halbachse $a$:

\begin{equation}\label{eq:test} T^2\sim a^3\quad\Leftrightarrow\quad T^2 = c\cdot a^3,\quad c\in\mathbb{R}\end{equation}

Da die Halbachse bereits bestimmt wurde, muss hier noch der Proportionalitätsfaktor $c$ bestimmt werden.

Dieser wird hier durch eine möglichst einfache Ellipse bestimmt. Die Ausgangskreisbahn umkreist den gleichen Zentralkörper mit der Masse $M$ wie auch die Transfer-Ellipse somit ergibt sich die gleiche Konstante. Für die gilt:

\begin{equation}\label{eq:kreisbahn} T^2\sim r^3\quad\Leftrightarrow\quad T^2 = c\cdot r^3,\quad c\in\mathbb{R}\end{equation}

Damit sich ein Körper auf einer Kreisbahn befindet müssen sich Zentripetalkraft und Gravitationskraft ausgleichen. Da die Vektoren stets in entgegengesetzte Richtung zeigen, sind hier nur die Beträge wichtig:

\begin{equation}F_z = F_g\quad\Leftrightarrow\quad m\frac{v^2}{r} = \gamma\frac{M\cdot m}{r^2},\quad\gamma\in\mathbb{R}\end{equation}

$\gamma$ ist die Gravitationskonstante. Damit ergibt sich die Kreisbahngeschwindigkeit:

\begin{equation}\Rightarrow\quad v = \sqrt{\frac{\gamma\cdot M}{r}}\end{equation}

Mit dem Kreisumfang $2\cdot r\cdot\pi$ für die gesamte Strecke einer Periode ergibt sich dann die Zeit $T$ nach $v = \frac{2\cdot r\cdot\pi}{T}$ mit dem gewöhnlichen Weg-Zeit-Gesetz. Die Konstante $c$ kann resultierend in $\eqref{eq:kreisbahn}$ aufgelöst werden:

\begin{equation}T^2 = \frac{4\cdot\pi^2\cdot r^3}{\gamma\cdot M}\quad\Rightarrow\qquad c = \frac{4\cdot\pi^2}{\gamma\cdot M}\end{equation}

Damit ist für die ursprüngliche Transfer-Ellipse $\eqref{eq:test}$, mit der großen Halbachse $a = \frac{r_2 + r_1}{2}$ und dem Wert für $c$, die Periode gegeben:

\begin{equation}T^2 = c\cdot a^3\quad\Leftrightarrow\quad T^2 = \frac{4\cdot\pi^2}{\gamma\cdot M}\cdot \frac{(r_2 + r_1)^3}{8}\end{equation}

Da die Transfer-Ellipse nur aus einer halben Ellipse besteht, wird hier auch nur die Hälfte der Periode genommen:

\begin{equation}T = \pi\sqrt{\frac{(r_2 + r_1)^3}{2\cdot\gamma\cdot M}} ,\quad T_{1/2} = \pi\sqrt{\frac{(r_2 + r_1)^3}{8\cdot\gamma\cdot M}}\end{equation}

Damit ist die Transferzeit $ T_{½} $ gegeben.

Hintergrund ist, dass diese Transferzeit auch für den Bi-elliptischen Transfer erweitert werden kann und dass die ESA in einem Video „Soyuz rendezvous and docking explained“ den Flug zur ISS mit jenem Manöver beschreibt.

Vegane Pizza Woche

Die vegane Kitchen ist gerade das einzige Project für das ich Zeit finde. Na klar für Kochen muss doch immer Zeit bleiben und als Veganer hat man in meiner Wohngegend auch gar keine andere Chance.

Ich kann Fortschritte bezüglich meiner Rezepte-Datenbank berichten. Es ist jetzt möglich ein Rezept auch mit Verbindungen zu anderen Rezepten zu veröffentlichen und auf einer Seite anzuzeigen. Problematisch wird es wenn ein Rezept mit einem Rezept verbunden ist, dass wiederum mit einem Rezept verbunden ist. Diese Kette kann man beliebig weiter spinnen. Die Software erlaubt das Prinzip.

Gute Beispiele, die jetzt gelöst sind, sind die Pizza Rezepte. Pizza Funghi, Pizza Hawaii und Lahmacun. Zwei Pizzen haben z.B. den gleichen Teig und die gleiche Sauce. Da bietet es sich einfach an ein Rezept für den Pizzateig und eines für die Pizzasauce anzulegen um dann die Pizzen mit Teig und Sauce zu verbinden.