cpdean

james@archx1c6g ➜  write-test git:(master) ✗ cat ./src/main.rs
use std::io::Write;

fn main() {
    for _ in 0..10 {
        writeln!(
            ::std::io::stdout().lock(),
            "Hello, world!"
        ).unwrap_or_else(|_| {
            eprintln!("stderr: Hello, stderr!");

cpdean

Part of a series of examples. See:

1. mousewheel-zoom + click-to-center via projection
2. click-to-center via projection
3. click-to-center via transform
4. click-to-zoom via transform

cpdean

This is a fork of mike bostock's vector tiles example.

I've just re-centered it around Minneapolis to see how it looks.

Looking for an easy way to do map visualizations, geo data is too fickle to learn without leveraging tons of examples

Adapting d3.geo.tile to show OpenStreetMap vector tiles. See also the static example.

cpdean

#!/bin/bash

# node.js using PPA (for statsd)
sudo apt-get install python-software-properties
sudo apt-add-repository ppa:chris-lea/node.js
sudo apt-get update
sudo apt-get install nodejs npm

# Install git to get statsd
sudo apt-get install git

cpdean

import concurrent.futures
import multiprocessing
import random

import time
from functools import partial


def fn2(fn, chunk):
    return [fn(*args) for args in zip(*chunk)]

cpdean

This is how mock.patch should be used, but I'm having some problems on my own codebase.

It's weird, but in this tiny example everything works just fine...

cpdean

# nope

cpdean

from math import sqrt
import random,time
import profile

random.seed(1)

def bellman_ford(edges):

        numRows = len(edges)
	numCols = len(edges[0])

cpdean

from time import time
from math import sqrt
def disproves(n):
        i=2
        while i*i*2<n:
                diff = n-i*i*2
                if not any(diff%j==0 for j in xrange(3,int(sqrt(diff))+1,2)) :return False
                i+=1
        return True
n=3

cpdean

import time
bound,mem = 1000000,{}

def collatz(n): 
    if n==1: return [1]
    else: return [n] + collatz(n/2 if (n%2==0) else 3*n+1) if (n>1) else [1] 

def collatzCount_recursive_memoized(n):
    if n not in mem: mem[n]= 1 + collatzCount_recursive_memoized(n/2 if (n%2==0) else 3*n+1) if (n>1) else 1
    return mem[n]