thomasjungblut

const _ = require('underscore');
const { Client } = require('pg');

const all_query = `SELECT id FROM "filter-test"."filter-test";`;
const some_query = `SELECT id, blob FROM "filter-test"."filter-test" WHERE id IN ('$(WHERE_IN_FILTER)');`;

async function query(q) {
    const client = new Client({
        user: 'postgres',
        database: 'postgres'

thomasjungblut

#!/usr/bin/python3

import random as r


def random_doors():
    doors = [False] * 3
    doors[r.randint(0, 2)] = True
    return doors

thomasjungblut

#!/usr/bin/python3
from time import sleep

import requests
from twilio.rest import Client

TWILIO_ACCOUNT_SID = "ACXXX"
TWILIO_AUTH_TOKEN = "XXX"
FROM = "+1XXXXX"
RECIPIENT = "+491XXXX"

thomasjungblut

from bayes_opt import BayesianOptimization
from sklearn.cross_validation import KFold
import xgboost as xgb

def xgbCv(train, features, numRounds, eta, gamma, maxDepth, minChildWeight, subsample, colSample):   
   # prepare xgb parameters 
   params = {
            "objective": "reg:linear",
            "booster" : "gbtree",
            "eval_metric": "mae",            

thomasjungblut

public class FlatMapTest {

     public FlatMapTest() { // <init> //()V
         <localVar:index=0 , name=this , desc=LFlatMapTest;, sig=null, start=L1, end=L2>

         L1 {
             aload0 // reference to self
             invokespecial java/lang/Object <init>(()V);
             return
         }

thomasjungblut

train <- read.csv("train.csv")
bound <- floor(nrow(train) * 0.9)         
train <- train[sample(nrow(train)), ]       
df.train <- train[1:bound, ]                
df.validation <- train[(bound+1):nrow(train), ]

train.y <- df.train$TARGET
validation.y <- df.validation$TARGET

dtrain <- xgb.DMatrix(data=df.train, label=train.y)

thomasjungblut

import de.jungblut.math.DoubleVector;
import de.jungblut.math.MathUtils;
import de.jungblut.math.dense.DenseDoubleVector;
import de.jungblut.math.minimize.CostFunction;
import de.jungblut.math.minimize.CostGradientTuple;
import de.jungblut.math.minimize.Fmincg;

public class FminCGNumericalGradient {

  static class RealCostFunction implements CostFunction {

thomasjungblut

package de.jungblut.nlp;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import com.google.common.base.Stopwatch;

thomasjungblut

import java.util.concurrent.Executors
import scala.util.Random
import java.util.concurrent.ExecutorService
import java.util.concurrent.Callable
import java.util.concurrent.FutureTask
import java.util.concurrent.ExecutorCompletionService
import scala.collection.mutable.MutableList

object PiEstimator extends App {

thomasjungblut

package de.jungblut.interviews;

import java.util.Stack;

import com.google.common.base.Preconditions;

public class BinaryTree {

	class TreeNode {
		TreeNode left;