The post on applying GPU to finding Eulerian path mentioned a stumbling block: partitioning a very specific kind of graph. In general, partitioning is a hard problem, NP-hard actually. The graphs we are dealing with are very specific, though, and may be partitioned in $latex O(|E|)$ time (E - the set of graph edges). Our … Continue reading HashSet, Graph, Cognac

# Category: bioinformatics

# Zooming Through Euler Path: Supercharging with GPU

So, continuing where we left off: Walking the Euler Path: Intro Visualizing Graphs Walking the Euler Path: GPU for the Road Walking the Euler Path: PIN Cracking and DNA Sequencing For the Win And finally I ran the GPU-enabled algorithm for finding the Euler path. And the results: Generating euler graph: vertices = 10,485,760; avg … Continue reading Zooming Through Euler Path: Supercharging with GPU

# Walking the Euler Path: PIN Cracking and DNA Sequencing

Continuing on to some cool applications of Eulerian paths. Intro Visualization GPU/CUDA Injection The goal of this little graph experiment remains exploration of accelerating Eulerian path finding on the GPU. This is the final introductory post. Eulerian Path Hierholzer algorithm works great. It's linear in the number of edges, so as fast as we can … Continue reading Walking the Euler Path: PIN Cracking and DNA Sequencing

# Walking the Euler Path: GPU for the Road

Continuation of the previous posts: Intro Visualization GPU Digression I was going to talk about something else this week but figured I'd take advantage of the free-hand format and digress a bit. Continuing the travel metaphor and remembering Julius Cesar's "alea iacta", we'll talk about GPU algorithms, for which I invariably use my favorite Aela.CUDA … Continue reading Walking the Euler Path: GPU for the Road

# Walking the Euler Path: Intro

Source Code I'm thinking about a few posts in these series going very fast through the project. The source is on my GitHub, check out the tags since the master branch is still work in progress. Experimenting with Graph Algorithms with F# and GPU Graphs play their role in bioinformatics which is my favorite area … Continue reading Walking the Euler Path: Intro

# Non-linear Thinking with CUDA.

I love GPU programming for precisely this: it forces and enables you to think about a solution in a non-linear fashion in more than one sense of the word. The Problem Given a set $latex A = \{a_1, a_2 \ldots a_n\}$, output a set $latex S_A = \{0,\ \sum\limits_{k=1}^{n} a_k,\ \sum\limits_{k=i}^{i + j \mod n} … Continue reading Non-linear Thinking with CUDA.

# Turnpike Problem (F#)

The Problem This is a problem for which no polynomial time solution exists, although a pseudo-polynomial (polynomial in the degree of the maximum element) does exist. In this paper, the algorithm proposed for the sum-function with full information is simple enough. For the original problem with the difference funcition, the algorithm is simple as well: … Continue reading Turnpike Problem (F#)

# Decomposition Problem with F#, Dynamic Programming

As my former boss and mentor used to say, in order to understand recursion one must first understand recursion. This is funny, ha-ha, but if we tweak it slightly we get a really useful statement: in order to understand dynamic programming, one must first understand recursion. Here is an example. Sources Github: http://github.com/fierval/BioInfo Decomposition Problem … Continue reading Decomposition Problem with F#, Dynamic Programming

# Motif Finding with Gibbs Sampling (F#)

The Problem "Motif finding is a problem of finding common substrings of specified length in a set of strings. In bioinformatics, this is useful for finding transcription binding sites" (recap here). The problem is succinctly stated on Rosalind. Given a set of strings DNA of size t, find "most common" substrings of length k. "Most common" means, that substrings … Continue reading Motif Finding with Gibbs Sampling (F#)