Using auto-icon to streamline the setup process, we, led by Dr. Rumeng Li, ran 1-day global ICON-ART simulations, obviously focussing on aerosol-related stuff, like dust concentration: The spike in dust concentration above the Saharian desert is clearly visible.

Later, we evaluated the model prediction by comparing it to MODIS satellite data: However, since we just ran the model for a single day, its spin-up period wasn’t over yet, so there’re still some visible artefacts, such as the columns south of strong emission zones in North Africa.

import random
import timeit
from tqdm import tqdm
import seaborn as sns
import matplotlib.pyplot as plt

sns.set_theme(style="ticks", rc={"font.sans-serif": "Inter"})

random.seed(42)

Searching algorithms

# linear search | O(n)

def linear_search(unordered_list, search_value):
    for index in range(len(unordered_list)):
        if unordered_list[index] == search_value:
            return True
    return False

# binary search (only applies to ordered lists) | O(logn)

def binary_search(ordered_list, search_value):
    first = 0
    last = len(ordered_list) - 1

    while first <= last:
        middle = (first + last)//2
        if search_value == ordered_list[middle]:
            return True
        elif search_value < ordered_list[middle]:
            last = middle - 1
        else: 
            first = middle + 1

Actually, I like the recursive implementation even more:

def binary_search_recursive(ordered_list, search_value):
  # define the base case
  if len(ordered_list) == 0:
    return False
  else:
    middle = len(ordered_list)//2
    # check whether the search value equals the value in the middle
    if search_value == ordered_list[middle]:
        return True
    elif search_value < ordered_list[middle]:
        # call recursively with the left half of the list
        return binary_search_recursive(ordered_list[:middle], search_value)
    else:
        # call recursively with the right half of the list
        return binary_search_recursive(ordered_list[middle+1:], search_value)

Sorting algorithms

# bubble sort | O(n²)

def bubble_sort(my_list):
    list_length = len(my_list)
    is_sorted = False
    while not is_sorted:
        is_sorted = True
        for i in range(list_length-1):
            if my_list[i] > my_list[i+1]:
                my_list[i], my_list[i+1] = my_list[i+1], my_list[i]
                is_sorted = False
        list_length -= 1
    return my_list

# selection sort | O(n²)

def selection_sort(my_list):
    list_length = len(my_list)
    for i in range(list_length-1):
        lowest = my_list[i]
        index = i
        for j in range(i+1, list_length):
            if my_list[j] < lowest:
                lowest = my_list[j]
                index = j
        my_list[i], my_list[index] = my_list[index], my_list[i]
    return my_list

# insertion sort | O(n²)

def insertion_sort(my_list):
    for i in range(1, len(my_list)):
        number_to_order = my_list[i]
        j = i - 1
        while j >= 0 and number_to_order < my_list[j]:
            my_list[j+1] = my_list[j]
            j -= 1
        my_list[j+1] = number_to_order
    return my_list

# merge sort | O(n logn)

def merge_sort(my_list):
    if len(my_list) > 1:
        mid = len(my_list)//2
        left_half = my_list[:mid]
        right_half = my_list[mid:]
        merge_sort(left_half)
        merge_sort(right_half)

        i = j = k = 0
        while i < len(left_half) and j < len(right_half):
            if left_half[i] < right_half[j]:
                my_list[k] = left_half[i]
                i += 1
            else:
                my_list[k] = right_half[j]
                j += 1
            k += 1

        while i < len(left_half):
            my_list[k] = left_half[i]
            i += 1
            k += 1

        while j < len(right_half):
            my_list[k] = right_half[j]
            j += 1
            k += 1

# quicksort (Hoare's partition) | O(n²)

def partition(my_list, first_index, last_index):
  pivot = my_list[first_index]
  left_pointer = first_index + 1
  right_pointer = last_index
 
  while True:
    while my_list[left_pointer] < pivot and left_pointer < last_index:
      left_pointer += 1
    while my_list[right_pointer] > pivot and right_pointer >= first_index:
      right_pointer -= 1 
    if left_pointer >= right_pointer:
        break
    my_list[left_pointer], my_list[right_pointer] = my_list[right_pointer], my_list[left_pointer]
  
  my_list[first_index], my_list[right_pointer] = my_list[right_pointer], my_list[first_index]
  return right_pointer

def quicksort(my_list, first_index=0, last_index=None):
  if last_index == None:
    last_index = len(my_list) - 1
  if first_index < last_index:
    partition_index = partition(my_list, first_index, last_index)
    quicksort(my_list, first_index, partition_index - 1)
    quicksort(my_list, partition_index + 1, last_index)

Compare runtime

def evaluate_search_algorithm(algorithm):
    sizes = [100, 500, 1000, 2000, 5000, 10000]
    times = []
    for size in sizes:
        # generate data
        data = list(range(size))
        times.append(
            timeit.timeit(  # output in seconds
                stmt=lambda: algorithm(data, random.randrange(size)),  # always search for different integer
                number=1
            )
        )
    return times


def evaluate_sort_algorithms(algorithm):
    sizes = [5, 10, 20, 50, 75, 100]
    times = []
    for size in sizes:
        # generate data
        data = [random.randint(1,1000) for _ in range(size)]
        times.append(
            timeit.timeit(
                stmt=lambda: algorithm(data),
                number=1
            )
        )
    return times

runtime_search, runtime_sort = {}, {}

for algorithm in [linear_search, binary_search_recursive]:
    runtime_search[algorithm.__name__] = evaluate_search_algorithm(algorithm)

for algorithm in [bubble_sort, selection_sort, insertion_sort, merge_sort, quicksort]:
    runtime_sort[algorithm.__name__] = evaluate_sort_algorithms(algorithm)

fig, axs = plt.subplots(1, 2, figsize=(7,4), layout="constrained")
for alg, time in runtime_search.items():
    axs[0].plot([100, 500, 1000, 2000, 5000, 10000], [t*1e3 for t in time], marker='.', label=alg)
for alg, time in runtime_sort.items():
    axs[1].plot([5, 10, 20, 50, 75, 100], [t*1e3 for t in time], marker='.', label=alg)

titles = ["search", "sort"]
for ax, title in zip(axs, titles):
    ax.legend()
    ax.set_xlabel("list length")
    ax.set_ylabel("runtime [ms]")
    ax.set_title(title)
    ax.set_ylim(bottom=0)
    ax.set_xlim(left=0)

To display this jupyter notebook here, I used nbconvert to export it directly as markdown.

Among other things, one can clearly see the data gap in the spring of 2025 during which the FU suffered an electricity blackout lasting several (!) weeks. Another way to visualize such a time series is to aggregate the data and plot the average yearly cycle of the distribution. A really nice example for such a plot can be found on the FU’s meteorological institute’s website.

Late-July of 2022 marks one of the time periods with the highest recorded temperatures in Berlin. To understand just how severe a large city’s buildings and sealed surfaces can amplify a heat wave, we look at different weather stations in Berlin:

While the weather tower with its station inside the botanical garden measured “only” 36.9°C, Berlin’s city centre (Hackescher Markt) reported up to 40.5°C – an increase of almost 4°C! On top, especially in the early morning of 21st July, we see that the inner city stays warm and cannot cool as much as more greeny areas like the botanical garden.

(The temperature data for Botanischer Garten (FU) can be found on the DWD’s open data server, Schöneberg is part of the Urban Climate Observatory Berlin, and a MESSI weather station is situated at Hackescher Markt. Also note the differing measurement intervals of the raw displayed data, hence some curves look “smoother” than others.)

Kriging is an advanced spatial interpolation method that does not just “smooth” values between stations. It uses the spatial structure in the data (captured by the variogram) to weight nearby observations based on how similar points are expected to be at a given distance.

An advantage of kriging is that it also provides a prediction uncertainty, the kriging variance \(\sigma^2\) (right figure). This does not measure the actual error, but shows where the interpolation is more or less reliable.

1. Die Linke ist stärkste Kraft bei den Jungwähler:innen ✊, dafür leider die AfD bei den etwas Älteren.
2. Junge Menschen sind stark politisiert und wählen eher die sogenannten “Ränder”, die traditionelle “Mitte” verschwindet.

After trying geopandas and streamlit to get interactive plots and web apps, I now gave bokeh a shot. However, to get any kind of calculations done, you’d need to run a bokeh server, which is not possible in my current static hugo & github pages setup. So I reverted to plotly and wrote the update functions to re-calculate the probabilities in JavaScript, which can be run client-side in the browser.

Außerdem nimmt zum Beispiel die Türkei seit 2013 auf unbestimmte Zeit nicht mehr am ESC teil und hat den Auftritt Conchita Wursts im darauffolgenden Jahr auch noch nicht verkraftet (😂). Da jedoch nur die Punktevergabe bei erfolgreicher Finalteilnahme berücksichtigt wird, wirkt sich dies nicht negativ auf das Ergebnis aus. Zudem lässt sich beobachten, dass vor allem europäische Länder mit einer großen Diaspora in Deutschland besonders viele Zuschauer:innen-Punkte erhalten.

Der zugrundeliegende Datensatz wurde von Janne Spijkervet zusammengestellt.

Weihnachten, die Zeit des Friedens,
Zeit zu vergeben und zu verzeihen.
Ich liebe dich und du liebst mich, jeder liebt jeden,
lass uns zusammen fröhlich sein.
Nichts ist heut unmöglich, auch ein Wunder kann geschehen.
Jeder Traum geht in Erfüllung, wenn du es wirklich willst.

Hey, was für ein frohes Fest!
Keine Angst, es wird vorübergehen.
Hey, was für ein frohes Fest!
Nur Mut, wir werden es durchstehen.

— Die Roten Rosen // Frohes Fest

Impressionen

Ein Boxplot liefert die sogenannte Fünf-Punkte-Zusammenfassung. Die Box entspricht dem Interquartilsabstand (IQR) und enthält somit die mittleren 50 % der Daten; der Median wird als durchgehender Strich in der Box dargestellt. Die Whisker enden am letzten Datenpunkt, der sich noch im Bereich von 1,5×IQR befindet. Alles darüber bzw. darunter wird als Ausreißer gekennzeichnet.

In dieser Darstellung ist zu erkennen, dass die Grippewelle im Herbst kontinuierlich eintritt, während eine zweite Welle im neuen Jahr eine deutlich breitere Streuung aufweist, der Median jedoch größer ist. Während letztere Welle in einigen Jahren anscheinend ausbleibt bzw. keine nennenswerte Zahl an Krankheitsfällen verursacht, kann in anderen Jahren die erste Welle sogar überlagert werden!

Diese Abbildung wurde durch eine Übung des Moduls Interdisziplinäre Naturrisikoforschung inspiriert.

Allerdings wird bei Änderung der Projektion² deutlich, dass diese sogenannten Loxodromen nicht die kürzeste Verbindung zweier Punkte auf einer Kugeloberfläche sind. Reist ein Flugzeug beispielsweise von Berlin nach Chicago auf einer Orthodromen, also entlang eines Großkreises bzw. auf wirklich kürzestem Weg, wird dies in der Mercator-Projektion als Kurve dargestellt. Während Flugreisen ist diese auf den ersten Blick widersprüchliche Routenführung manchmal auf der on-board Karte (in Mercator-Projektion) zu erkennen. Die frühneuzeitliche Seefahrt nahm also für eine vereinfachte Navigation eine längere Strecke in Kauf.

As outlined by Schöley & Willekens (2017), the labelled patterns in the Lexis diagram below are predominantly linked to:

1. The pronounced impact of the Spanish Civil War (and before possibly of World War I).
2. The persistently higher risk of accidents among young men.
3. Smoking-related deaths in men before women began to adopt similar smoking habits.

Inspiriert durch whattowatchon.tv.

Eine Inszenierung als Opfer einer angeblichen Hetzkampagne der “etablierten” Medien verhalf den Freien Wählern augenscheinlich zu einem verbesserten Abschneiden in der anschließenden Landtagswahl.² Sie wurden zweitstärkste Kraft mit 15,8 %. Anscheinend kann 78 Jahre nach dem Ende des Zweiten Weltkriegs in Bayern wieder politisches Kapital aus einer antisemitischen Vergangenheit geschlagen werden.

Auch ein Faschist¹ in der Rolle des Vorsitzenden kann den Höhenflug der Partei anscheinend nicht beeinträchtigen.