Code for this entry: here. In this first part, we started shamelessly plagiarizing creatively reproducing a Clojure monad that does a great job describing stochastically independent processes. After a few trials I became convinced, that the approach in the blog post mentioned above was indeed optimal: a "natural" approach of modelling an event as a … Continue reading Modelling Stochastically Independent Processes with F# Computation Expressions: Part 2

# Modelling Stochastically Independent Processes with F# Computation Expressions: Part 1

The idea for doing this is not new. There is an excellent series of posts closely tracing an article on applications of functional programming to probability. A colleague of mine has recently called my attention to his own post of two years ago, where he describes a monad that models stochastically independent events in Clojure. … Continue reading Modelling Stochastically Independent Processes with F# Computation Expressions: Part 1

# Generating Permutations: Clojure or F#: Part 2

Marching on from the last post. Lazy Sequences This is my favorite feature ever. If I want to generate just a few of 10! (nobody even knows how much that is) permutations, I could: provided, the function is defined (as described in the first post): Here I am not sure which language I like more. … Continue reading Generating Permutations: Clojure or F#: Part 2

# Generating Permutations: Clojure or F#: Part 1

The Alogirthm Recently, I have entered a brave (new?) world of Clojure and was looking for a small project to take it for a ride. I stopped on a popular/interesting enough little problem, that subsumed a certain interview question which I was once unfortunate enough to stumble through with half my brain tied behind my … Continue reading Generating Permutations: Clojure or F#: Part 1

# Supercharging SQL Join with GTX Titan, CUDA C++, and Thrust: Part 2

Note: All this code is now on GitHub. Compute the mathces Here is a simple, purely brute-force algorithm for computing the join mentioned in Part 1. Here is the entirely "CPU" implementation of the algorithm: Loop over both datasets, compare them one-by-one, if there is a match - flag it. The only thing to note … Continue reading Supercharging SQL Join with GTX Titan, CUDA C++, and Thrust: Part 2

# Supercharging SQL Join with GTX Titan, CUDA C++, and Thrust: Part 1

This is a post in two parts: Part 1 - The problem, solution setup, the algorithm. Part 2 - (The juicy) Implementation details, discussion. Suppose at the heart of the data layer of a web application there is a join like this: This join filters patents belonging to a set of classes from the Patents … Continue reading Supercharging SQL Join with GTX Titan, CUDA C++, and Thrust: Part 1

# Compiling CUDA Projects with Dynamic Parallelism (VS 2012/13)

Just a quick note. If you are starting from a template C++ CUDA project in VS 2012/2013, calling a kernel from a kernel (dynamic parallelism) would not compile: error : kernel launch from __device__ or __global__ functions requires separate compilation mode To fix this, first make sure your hardware supports it (cc 3.5 or higher) … Continue reading Compiling CUDA Projects with Dynamic Parallelism (VS 2012/13)

# D3 Fisheye Distortion for Bar Charts

Intro Focus + context visualizations are quite useful when we want to zoom into some part of a visualization, but are unwilling to give up the "bird's eye" view of the entire picture. In this case, we distort the part of the visual on which we want to focus, while preserving the entire view. In … Continue reading D3 Fisheye Distortion for Bar Charts

# Computing Self-Organizing Maps in a Massively Parallel Way with CUDA. Part 2: Algorithms

In the previous post I spoke briefly about motivations for implementing self-organizing maps in F# using GPU with CUDA. I have finally been able to outperform a single threaded C++ implementation by a factor of about 1.5. This is quite modest, but on the other hand rather impressive since we started out by being 60 … Continue reading Computing Self-Organizing Maps in a Massively Parallel Way with CUDA. Part 2: Algorithms

# Computing Self-Organizing Maps in a Massively Parallel Way with CUDA. Part 1: F#

By 2017, it is expected that GPUs will no longer be an external accelerator to a CPU; instead, CPUs and GPUs will be integrated on the same die with a unified memory architecture. Such a system eliminates some of accelerator architecturesâ€™ historical challenges, including requiring the programmer to manage multiple memory spaces, suffering from bandwidth … Continue reading Computing Self-Organizing Maps in a Massively Parallel Way with CUDA. Part 1: F#