lomereiter

import cv
import commands
import time
from PIL import Image
from collections import deque

camera = cv.CreateCameraCapture(-1)

prev_brightness_values = deque([], 5)
prev_brighness = None

lomereiter

// building suffix trees in linear time using the Ukkonen's algorithm
//
// with -debug flag, LOTS of output is printed during construction
// so that each step of the algorithm can be studied

import std.stdio;
import std.array, std.range, std.algorithm;

class SuffixTree {
  static struct Node {

lomereiter

import std.stdio, std.range, std.algorithm, std.conv, std.string, std.file;

immutable letters = "abcdefghijklmnopqrstuvwxyz"d;

auto replaces(S)(S word) {
  return word.length.iota.map!(i =>
           letters.length.iota.map!(j =>
             word[0 .. i].chain(letters[j .. j+1], word[i+1 .. $])))
         .joiner;
}

lomereiter

import bio.bam.reader;
import bio.bam.pileup;

import bio.core.base;
import bio.core.tinymap;

import std.stdio, std.parallelism, std.algorithm, std.array, std.range;

void main(string[] args) {
    defaultPoolThreads = 4;

lomereiter

# -*- coding: utf-8 -*-
Rule = Struct.new :from, :to, :exit

def parseSingleRule(rule_src)
  rule_src =~ /^\s*([^\s]*)\s*=>\s*([\.]?)([^\s]*)\s*$/
  r = Rule.new($1, $3)
  r.exit = $2 == '.'
  r
end

lomereiter

unittest {
import std.conv;
import bio.gff3.reader;
import bio.gtf.reader;
import bio.gff3.writer;
import bio.gff3.validator;
  
void main() {
  // Keeps all comments and pragmas -- this is cheap.
  // If user doesn't need them -- std.algorithm.filter to the rescue!

lomereiter

extern mod gmp;
extern mod std;

use std::getopts::*;
use gmp::Mpz;
use num::Num::from_int;
use std::time::precise_time_s;

fn factorial(n: uint) -> Mpz
{

lomereiter

...
movl  $239, %edi
movq	%r14, %rsi
movl	$1, %edx
callq	_arrayExpSliceAddass_k

...

LBB0_14:
    xorl	%eax, %eax

lomereiter

jb.statistic <- function(x) {
    x.mean <- mean(x)
    deltas <- x - x.mean
    len <- length(x)

    cm2 <- sum(deltas ** 2) / len 
    cm3 <- sum(deltas ** 3) / len 
    cm4 <- sum(deltas ** 4) / len 

    skew <- cm3 / cm2 ** 1.5 

lomereiter

require 'benchmark'

require 'zlib'
require 'msgpack'

Genotype = Struct.new :location, :ref, :alleles, :prob
class Genotype
  def to_msgpack(buf='')
    [location, ref, alleles, prob].to_msgpack(buf)
  end