steinelu

def wasserstein_distance_gaussian_analytical(G1, G2):
    mu1, sigma1 = G1
    mu2, sigma2 = G2
    
    diff_mean = mu1 - mu2
    squared_diff_mean = np.dot(diff_mean, diff_mean) # euclidean norm
    
    sigma1_sqrt = linalg.sqrtm(sigma1)
    sigma_product = np.dot(sigma1_sqrt, np.dot(sigma2, sigma1_sqrt))
    sigma_product_sqrt = scipy.linalg.sqrtm(sigma_product)

steinelu

const std = @import("std");
const builtin = @import("builtin");

pub fn main() !void {
    const n = 20;
    var idx : [n]u8 = undefined;
    
    for (&idx, 0..) |*id, i| {
        id.* = @intCast(i);
    }

steinelu

#include <stdio.h>
#include <stdlib.h>

struct Node{
    struct Node *parent;
    struct Node *left;
    struct Node *right;
    int index;
    int value;
};

steinelu

import math 
class SegmentTree:
    def __init__(self, arr, function, neutral_element):
        self.m = len(arr)
        k = math.ceil(math.log2(self.m)) + 1
        self.n = 2**k
        self.arr = arr
        self.tree = [neutral_element for _ in range(self.n)]
        self.foo = function
        self.neutral_element = neutral_element

steinelu

# strongly inspired from https://hkeylocalmachine.com/?p=518

$listener = New-Object System.Net.HttpListener
$listener.Prefixes.Add('http://+:8000/')
$listener.Start()


while ($true){
    $context = $listener.GetContext()

steinelu

function foo(n::UInt)
    if n == 1 || n == 0
        return n
    end
    if n%2 == 0
        return 4 * foo(UInt(n/2))
    else
        return 4 * foo(UInt(floor(n/2))) + 1
    end
end

steinelu

\documentclass[12pt,a4paper]{scrartcl}

\usepackage[utf8]{inputenc}
\usepackage[ngerman]{babel}
\usepackage{listings}
\usepackage{amsmath,amssymb,amstext,amsthm}
\usepackage{tikz}
\usepackage{hyperref}
\usepackage{url}
\usepackage[headsepline]{scrpage2}

steinelu

"Hallo Welt!" | Select-String ".* (.*)" | ForEach-Object {$_.Matches.Groups[1]}

steinelu

func consoleSize() (int, int) {
	cmd := exec.Command("stty", "size")
	cmd.Stdin = os.Stdin
	out, err := cmd.Output()
	if err != nil {
		log.Fatal(err)
	}

	s := string(out)

steinelu

package main

import (
	"fmt"
	"encoding/json"
)

func main() {
	dict := make(map[int]string)
	dict[12] = "Lukas"