moosechips

pathmunge () {
        if ! echo $PATH | /bin/egrep -q "(^|:)$1($|:)" ; then
           if [ "$2" = "after" ] ; then
              PATH=$PATH:$1
           else
              PATH=$1:$PATH
           fi
        fi
}
 
pathmunge /usr/local/blah/bin
pathmunge ~/bin
export PATH
# now PATH is ~/bin:/usr/local/blah/bin:<old path>

import csv
class CommentedFileReader:
    """
    Helper class for file reading.
    Skips lines starting with '#'
 
    tsv_file = csv.reader(CommentedFileReader("inputfile.txt"),
                      delimiter='\t')
    for row in tsv_file:
        print row[2] # prints column 3 of each line
    """
    def __init__(self, f, commentstring="#"):
        self.f = open(f, 'rU')
        self.commentstring = commentstring
    def next(self):
        line = self.f.next()
        while line.startswith(self.commentstring):
            line = self.f.next()
        return line
    def __iter__(self):
        return self
 
csv.register_dialect('bed', delimiter = '\t', 
                     quoting = csv.QUOTE_NONE,
                     skipinitialspace = True)
 
class BEDReader(csv.DictReader):
    """
    Read BED files into a DictReader.
    See BEDReader.FIELDS for field names
 
    Example:
        bed = BEDReader("file.bed")
        for line in bed:
            # print the chromStart
            print(line['chromStart'])
    """
    FIELDS = ('chrom', 'chromStart', 'chromEnd', 
              'name', 'score', 'strand',
              'thickStart', 'thickEnd',
              'itemRgb', 
              'blockCount', 'blockSizes', 'blockStarts')
 
    def __init__(self, filename):
        csv.DictReader.__init__(self, CommentedFileReader(filename), dialect='bed', 
                                fieldnames=self.FIELDS)
 
if __name__ == "__main__":
    bed = BEDReader("data.txt")
    for line in bed:
        print(line['chromStart'])

import matplotlib.pyplot as plt
import numpy as np
 
fig = plt.figure(facecolor='white')
x = np.linspace(0,2*np.pi,100)
y = 2*np.sin(x)
 
ax = fig.add_subplot(1,1,1, aspect='equal')
ax.set_title(r'$y=\sin(t)$')
ax.plot(x,y)
ax.spines['left'].set_position('zero')
ax.spines['right'].set_color('none')
ax.spines['bottom'].set_position('zero')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
ax.autoscale_view(tight=True)
ax.set_ylim(-2.5,2.5)
ax.set_xlim((0,2*np.pi))
ax.set_xticks([0,np.pi,2*np.pi])
ax.set_xticklabels(['', r'$\pi$', r'$2\pi$'])
ax.text(2*np.pi + .1, -.2, r'$t$') # Manually adjusted
 
plt.savefig('plot.pdf')
plt.show()

#! /usr/bin/env python
import subprocess
# Use a sequence of args
return_code = subprocess.call(["echo", "hello sequence"])
 
# Set shell=true so we can use a simple string for the command
return_code = subprocess.call("echo hello string", shell=True)
 
# subprocess.call() is equivalent to using subprocess.Popen() and wait()
proc = subprocess.Popen("echo hello popen", shell=True)
return_code = proc.wait() # wait for process to finish so we can get the return code

#! /usr/bin/env python
import subprocess
# Put stderr and stdout into pipes
proc = subprocess.Popen("echo hello stdout; echo hello stderr >&2", \
        shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
return_code = proc.wait()
# Read from pipes
for line in proc.stdout:
    print("stdout: " + line.rstrip())
for line in proc.stderr:
    print("stderr: " + line.rstrip())

ssh-copy-id moose@moosechips.com

ssh-keygen -t rsa

Host moosechips.com
  User moose

ssh moosechips.com

ssh -Y user@host
mathematica
xset: bad font path element (#23), possible causes are:
   Directory does not exist or has wrong permissions
   Directory missing fonts.dir
   Incorrect font server address or syntax

Xft.dpi: 108

Device Drivers --->
 
Input device support --->
 
--- Input device support
[*]     Event interface

flagedit --alpha-order +hal +X

euse -E hal X

INPUT_DEVICES="evdev"
# Change the video driver to match your video card
# or install a bunch and let hal choose
VIDEO_DRIVER="nv nvidia radeon radeonhd intel sis via vesa fbdev"

emerge -av xorg-server

cp /usr/share/hal/fdi/policy/10osvendor/* /etc/hal/fdi/policy

rc-config add hald default
/etc/init.d/hald start

mv /etc/X11/xorg.conf /etc/X11/xorg.conf.bak

startx

lspci | grep -i wireless
03:00.0 Network Controller: Intel Corporation PRO/Wireless 4965 AG or AGN Network Connection (rev 61)

Device Drivers  --->
  [*] Network device support  --->
    Wireless LAN  --->
      {*} Intel Wireless Wifi Core
      <M> Intel Wireless WiFi Next Gen AGN
        [*]   Intel Wireless WiFi 4965AGN

emerge -av wpa_supplicant wireless-tools

cd /etc/init.d
ln -s net.lo net.wlan0

modules=( "wpa_supplicant" )
iwconfig_wlan0="mode managed"
wpa_supplicant_wlan0="-Dwext"

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=wheel
 
network={
  ssid="MySSID"
  scan_ssid=1
  key_mgmt=WPA-PSK
  psk="password"
  priority=5
}

emerge -av iwl4965-ucode

/etc/init.d/net.wlan0 restart

sudo aptitude install gparted unetbootin

wget http://superb-west.dl.sourceforge.net/sourceforge/gparted/gparted-live-0.4.4-1.iso
wget http://www.kernel.org/pub/linux/utils/boot/syslinux/syslinux-3.80.tar.bz2

sudo gparted

unetbootin

tar xjvf syslinux-3.80.tar.bz2

cd syslinux-3.80/linux
sudo ./syslinux -s /dev/sdc1

alias grep='grep --color=always'
export LESS='-R'

// libgen_example.c
// Demonstrate libgen.h usage and pitfalls
// Compile:  gcc -g -o libgen_example libgen_example.c
#include
<libgen.h> //basename and dirname
#include <string.h> //strlen and strcpy
#include <stdio.h> //printf
#include <stdlib.h> //malloc
 
int main(int argc, char* argv[]) {
    // Demonstrate how dirname changes the path you input to it
    char path[] = "default/path/to/nowhere.txt";
    printf("path='%s'\n", path);
    char * dir = dirname(path);
    printf("path='%s'  dir='%s'\n", path, dir);
    char * base = basename(path);
    printf("path='%s'  dir='%s'  base='%s'\n\n",
           path, dir, base);
    // Since dirname changed path, base is now "to"
    // instead of "nowhere.txt" as we might have expected.
    // Output:
    // path='default/path/to/nowhere.txt'
    // path='default/path/to'  dir='default/path/to'
    // path='default/path/to'  dir='default/path/to'  base='to'
 
    //========
    // Demonstrate c string copying
    const char * another_path = "another/path";
    char * modifiable_copy = (char *)malloc(strlen(another_path) + 1);
    strcpy(modifiable_copy, another_path);
    char * another_dir = dirname(modifiable_copy);
    printf("another_path='%s'\n", another_path);
    printf("modifiable_copy='%s'\n", modifiable_copy);
    printf("another_dir='%s'\n\n", another_dir);
    // note that after this free, another_dir is now also
    // invalid since it pointed to the modifiable_copy's memory
    free(modifiable_copy);
    // Output:
    // another_path='another/path'
    // modifiable_copy='another'
    // another_dir='another'
 
    //========
    // const strings declared as char * can cause segfaults
    char * char_pointer_path = "char/pointer/path";
    printf("char_pointer_path='%s'\n", char_pointer_path);
 
    char * char_pointer_dir = dirname(char_pointer_path);
    printf("char_pointer_path='%s' char_pointer_dir='%s'\n",
           char_pointer_path, char_pointer_dir);
    // Output:
    // char_pointer_path='char/pointer/path'
    // Segmentation fault
}

// filesystem_example.cpp
// Demonstrate using boost::filesystem
// Compile:  g++ -I /usr/local/include/boost-1_38/ -L /usr/local/lib -lboost_filesystem-gcc41-mt-1_38 -o filesystem_example filesystem_example.cpp
#include <boost/filesystem.hpp>
#include <iostream>
namespace fs = boost::filesystem;
 
int main(int argc, char* argv[])
{
    fs::path pathname("default/path/to/nowhere.txt");
    std::string dirname  = pathname.parent_path().string();
    std::string basename = pathname.filename();
 
    std::cout << "pathname = " << pathname << std::endl;
    std::cout << "dirname = " << dirname << std::endl;
    std::cout << "basename = " << basename << std::endl;
    // Output:
    // pathname = default/path/to/nowhere.txt
    // dirname = default/path/to
    // basename = nowhere.txt
 
    std::cout << std::endl;
    std::cout << "extension = " << pathname.extension() << std::endl;
    std::cout << "complete = " << fs::complete(pathname) << std::endl;
    std::cout << "exists = " << ((fs::exists(pathname)) ? "true" : "false") << std::endl;
    // Output:
    // extension = .txt
    // complete = /home/moose/default/path/to/nowhere.txt
    // exists = false
}