ademar

// Based on the article 'Combinators for logic programming' by Michael Spivey and Silvija Seres.

let rec inf_seq n =  seq { yield n; yield! inf_seq (n+1) }

let rec lzw f l1 l2 =
    LazyList.delayed ( fun () -> 
    match l1,l2 with
    |LazyList.Nil, _ -> l2
    |_, LazyList.Nil -> l1
    |LazyList.Cons(p1,tail1),LazyList.Cons(p2,tail2)

endolith

Grr this took hours to figure out. I was trying to install MJPG-streamer and running VLC command lines and all this crap but nothing worked.

First install motion:

~> sudo apt-get install motion

Then create a config file:

~> mkdir ~/.motion

~> nano ~/.motion/motion.conf

melpomene

import numpy as np
import matplotlib.pyplot as plt
import sys

def main():
	if len(sys.argv) == 1 or "-h" in sys.argv or "--help" in sys.argv:
		print "python lagrange.py <x1.y1> .. <x_k.y_k>"
		print "Example:"
		print "python lagrange.py 0.1 2.4 4.5 3.2"

stevenworthington

# ipak function: install and load multiple R packages.
# check to see if packages are installed. Install them if they are not, then load them into the R session.

ipak <- function(pkg){
    new.pkg <- pkg[!(pkg %in% installed.packages()[, "Package"])]
    if (length(new.pkg)) 
        install.packages(new.pkg, dependencies = TRUE)
    sapply(pkg, require, character.only = TRUE)
}

yihui

See http://animation.r-forge.r-project.org/knitr/ for a preview of all knitr themes in HTML, and http://rclickhandbuch.files.wordpress.com/2014/09/knitrthemesoverview.pdf for a preview in LaTeX (credit to Berry Boessenkool).

The knitr themes manual can be found at (Rnw source).

gist:f72e5c4a432492abce59

typedef char C;

typedef long I;

typedef struct a {
  I t,r,d[3],p[2];
}* A;

#define P printf

psayre23

Below are the Big O performance of common functions of different Java Collections.


List                 | Add  | Remove | Get  | Contains | Next | Data Structure
---------------------|------|--------|------|----------|------|---------------
ArrayList            | O(1) |  O(n)  | O(1) |   O(n)   | O(1) | Array
LinkedList           | O(1) |  O(1)  | O(n) |   O(n)   | O(1) | Linked List
CopyOnWriteArrayList | O(n) |  O(n)  | O(1) |   O(n)   | O(1) | Array

pezy

Here is a solution that is more efficient than the sieve of Eratosthenes. It is derived from similar algorithms for counting primes. The advantage is that there is no need to find all the primes to find their sum.

The main idea is as follows: Let S(v,m) be the sum of integers in the range 2..v that remain after sieving with all primes smaller or equal than m. That is S(v,m) is the sum of integers up to v that are either prime or the product of primes larger than m. 

S(v, p) is equal to S(v, p-1) if p is not prime or v is smaller than p*p. Otherwise (p prime, p*p<=v) S(v,p) can be computed from S(v,p-1) by finding the sum of integers that are removed while sieving with p. An integer is removed in this step if it is the product of p with another integer that has no divisor smaller than p. This can be expressed as

S(v,p)=S(v,p−1)−p(S(v/p,p−1)−S(p−1,p−1)).

Dynamic programming can be used to implement this. It is sufficient to compute S(v,p) for all positive integers v that are representable as floor(n/k) for 

karenyyng

Table Of Content

Skip to the relevant sections if needed.

• 2-min tutorial to do it the quick-and-dirty-way
• Concepts for resolving Git conflicts
• Setting up different editors / tool for using git mergetool
  • Finding out what mergetool editors are supported
• mergetool simple code example for vimdiff
  • Resolving conflict from a Git pull
• Other great references and tutorials

NeoTheFox

#!/usr/bin/bash

xconfig="/etc/X11/xorg.conf"
if [ -e "$xconfig" ]
then
	echo "Nvidia xconfig detected"
	echo "Switching to mesa..."
	sudo pacman -S lib32-mesa-libgl mesa-libgl
	sudo rm $xconfig
else