function bpad ($instr) {
  return substr("000000", 0, 8 - strlen($instr)) . $instr;
}

function dpad ($instr) {
  return substr("      ", 0, 3 - strlen($instr)) . $instr;
}

function show($instr) {
  for ($i = 0; $i < strlen($instr); $i++) {
    $let = $instr[$i];                                                          
    $no = ord($let);
    echo $i . " : " . $let . " / " . dpad($no) . " / " . bpad(decbin($no)) . " / " . dechex($no).  "\n";
  }
}

Here is an example of use

php > $var = "T" . pack("cc", 195, 171) . "st";
php > show($var);
0 : T /  84 / 01010100 / 54
1 : � / 195 / 11000011 / c3
2 : � / 171 / 10101011 / ab
3 : s / 115 / 01110011 / 73
4 : t / 116 / 01110100 / 74
php > show (utf8_decode($var));
0 : T /  84 / 01010100 / 54
1 : � / 235 / 11101011 / eb
2 : s / 115 / 01110011 / 73
3 : t / 116 / 01110100 / 74

import Tkinter as Tk
import tkFont
import random
import sys

def genstr (j):
    rno = random.randint(4,50)
    ret_val = str(j) + ":"
    for i in range (0, rno):
        ret_val += "hello" + str(i)
    return ret_val

def gendata (lh):
    ret_val = []
    for i in range(0,lh):
        ret_val.append (genstr (i))
    return ret_val

data = gendata (100)

root = Tk.Tk()
font = tkFont.Font(family='times', size=13)

class lines:
    def __init__ (self):
        self.lastct = 1   # remember where the cutoff was last work from there

    def count (self, text, cutoff = 400):
        global font
        no_lines = 1
        start_idx = 0
        idx = self.lastct

        while True:
            if idx > len (text):
                idx = len (text)

            # shrink from guessed value
            while font.measure (text[start_idx:idx - 1]) > cutoff:
                if idx <= start_idx:
                    print "error"
                    sys.exit ()
                else:
                    idx -= 1
                    self.lastct = idx - start_idx # adjust since was too big

            # increase from guessed value (note: if first shrunk then done)
            while (idx < len (text)
                   and font.measure (text[start_idx:idx]) < cutoff):
                idx += 1
                self.lastct = idx - start_idx     # adjust since was too small

            # next line has been determined
            print "*" + text[start_idx:idx-1] + "*"
            if idx == len(text) and font.measure (text[start_idx:]) < cutoff:
                return no_lines
            elif idx == len(text):
                return no_lines + 1
            else:
                no_lines += 1
                start_idx = idx - 1
                idx = start_idx + self.lastct

lin = lines()

for i in range(0,len(data)):
    lin.count(data[i], 450)

for i in range(0,min(len(data),10)):
    l = Tk.Label(root)
    l.pack()
    l['text'] = data[i]
    print i
    no = lin.count (data[i], 450)
    print "computed lines", no
    l['width'] = 50
    l['justify'] = Tk.LEFT
    l['anchor'] = 'w'
    l['wraplength'] = 450
    l['padx']=10
    l['pady'] = 5
    l['height'] = no
    l['font'] = font
    if i % 2 == 0:
        l['background'] = 'grey80'
    else:
        l['background'] = 'grey70'

root.mainloop()

import time
import copy

data = map (lambda x: x.strip(), open('sgb-words.txt').readlines())
print len (data)

def d (w1, w2):
    count = 0
    for idx in range(0,5):
        if w1[idx] != w2[idx]:
            count += 1
    return count

print "creating graph"
t0 = time.clock ()
graph = [[a,b] for a in data for b in data if d(a,b) ==1 and a < b]
t1 = time.clock ()
print "took " + str (t1 - t0) + " seconds."

#t0 = time.clock ()
#graph2 = []
#for i in range (0, len(data)):
#    for j in range(0,len(data)):
#        if d(data[i],data[j]) == 1 and i < j:
#            graph2.append ([i,j])
#t1 = time.clock ()
#print "took " + str (t1 - t0) + " seconds."

def deg ():
    maxd = 0
    maxw = ""
    for idx in range (0,len(data)):
        count = 0
        if idx % 100 == 0:
            print idx, maxd, maxw
        for idx2 in range (0,len(data)):
            if d(data[idx],data[idx2]) == 1:
                count += 1
        if count > maxd:
            maxd = count
            maxw = [data[idx]]
        elif count == maxd:
            maxw.append (data[idx])
    return maxd, maxw

def nbd (w):
    nbdv = []
    for idx in range(0,len(data)):
        if d(w,data[idx]) == 1:
            nbdv.append(data[idx])
    return nbdv

def gnbd (w, graph):
    N = [x[1] for x in graph if x[0] == w]
    N.extend ([ x[0] for x in graph if x[1] == w])
    return N

def union (x,y):
    ret_val = copy.copy(x)
    ret_val.extend (y)
    return ret_val

def unique (x):
    ret_val = []
    for idx in range(0,len(x)):
        if not x[idx] in x[0:idx]:
            ret_val.append (x[idx])
    return ret_val

def collect (f, x, remlist):
    if remlist == []:
        return x
    else:
        return collect (f, f(x, remlist[0]), remlist [1:])

def collect2 (f, x, remlist):
    ret_val = copy.copy(x)
    for idx in range (0, len (remlist)):
        ret_val.extend (remlist[idx])
    return ret_val

def next (reached, graph):
    N = unique (collect2 (union, [], map (lambda x: gnbd(x, graph), reached)))
    return N

#print deg()
# (25, ['cores', 'bares'])
#print "Nbd of cores is:"
#print nbd('cores')
#print "Nbd of bares is:"
#print nbd('bares')

def sub (l1, l2):
    ret_val = []
    for idx in range(0,len(l1)):
        if l1[idx] not in l2:
            ret_val.append (l1[idx])
    return ret_val

def component (graph, start):
    reached = [start]  # start with just the first node
    new = [start]
    t0 = time.clock ()
    while True:
        next_bd = next (new, graph)
        new = sub (next_bd,reached)
        reached = unique (union (reached, new))
        if new == []:
            print "DONE:", len (reached)
            return reached
        else:
            print len (reached), time.clock() - t0

def components (graph, vertices):
    rem = vertices
    components = []
    while rem != []:
        print rem [0]
        new_component = component (graph, rem[0])
        rem = sub (rem, new_component)
        components.append (new_component)
        print "still to do: " + str (len(rem))
        print "components: ", map (len, components)
    return components

print components (graph, data)

UPDATE: when running aide my system became rather slow, so I would recommend running it with nice: sudo nice -n 20 aide –init –config=aide.kasterma.conf

Total LIE!

The location is in fact C:\Users\bart\Documents\

Then adding more and more threads leads to significant slowdown.

The linear slowdown as shown in the graph continues at least up to 750 threads. I was expecting an additional slowdown (an increase in slope of the line) when there were so many threads their pages of memory would get swapped out in between them being active (4 KB per page, 8192 KB cache size, at least 5 pages per thread [for the 3 different parts of the array it is sorting, code, and stack], means this would happen before 410 threads). I am not quite sure yet why that does not happen.

Code is again available in my github repository.

Note that I used to next to last value measured since the last value is a bit of an outlier (I was watching the system monitor, and for some reason the process switched to another core). All code is available in the github repository.

• download plink.
• add the location of plink to the windows path (on the page how to set the windows path there is a description, that didn’t quite work for me but got me close enough).

After doing this I now have a local emacs editing a remote file. It remains to be seen if it is quick enough (although I am connected over a very fast network, so I do not expect problems). The big advantage is that the local emacs has much better default color scheme than the default of emacs over putty.

The code for getting the string ‘Swaziland|Liberia|RepublicCongo|Lesotho|Tajikistan|Mauritania|EastTimor|Togo|T\
onga|FrenchGuiana|Libya|Panama|CentralAfricanRepublic|EquatorialGuinea|GuineaBi\
ssau|Belize|SaintVincentGrenadines|Namibia|Micronesia|PapuaNewGuinea|Djibouti|S\
aoTomePrincipe|Reunion|Nicaragua|SolomonIslands|Vanuatu|Israel|Jordan|Gambia|Er\
itrea|WesternSahara|Honduras|Botswana|Paraguay|Comoros’ consisting of all countries where the 0-4 age group is the biggest is mostly given below. I am not giving all of it b/c I think I need to keep my key private, and I don’t want to be the cause of tops of queries to their API (if you want you can come up with your own complete list of countrys; hint Wolfram|Alpha).

First the script that queries Wolfram|Alpha and saves the info to a file.

""" wa.py

Setting up some basic code to get queries answered by Wolfram|Alpha.

Bart Kastermans, www.bartk.nl
"""

import time
import pickle
import urllib
import BeautifulSoup

APPID="GET-YOUR-OWN"
URL="http://api.wolframalpha.com/v2/query?input=%(query)s&appid=" + \
    APPID  + \
    "&podstate=AgeDistributionGrid:AgeDistributionData__Show details"

ALL_COUNTRIES = ["China", "India", "United States", "Indonesia", "Brazil", "Pakistan", "Bangladesh", "Nigeria", "Russia", "Japan", "Mexico", "Philippines", "Vietnam", "Ethiopia", "Germany", "Egypt", "Turkey", "Iran", "Thailand", "France", "Democratic Republic of the Congo", "United Kingdom", "Italy", "Myanmar", "South Africa"]

for country in ALL_COUNTRIES:
    query = urllib.quote ("age distribution " + country)
    url_query = URL % {'query':query}

    print "current query:", url_query

    page = urllib.urlopen (url_query)
    cont = page.readlines ()

    # extract the info we want (apologies for magic constants)
    cont_parsed = BeautifulSoup.BeautifulStoneSoup (''.join (cont))
    data = cont_parsed.findAll (scanner='Data')
    if len (data) > 1:
        result = cont_parsed.findAll (scanner='Data')[1].plaintext
    else:
        result = None

    countryinfo [country] = result

    print "current result:"  # give some feedback something is happening
    print result
    print "Just got information for country:", country

    time.sleep (5)   # spread the queries over time

# save the information to file
COUNTRY_FILE = open ("country_info.txt", "w")
PICKLER = pickle.Pickler (COUNTRY_FILE)
PICKLER.dump (countryinfo)
COUNTRY_FILE.close ()

Then the script that does the parsing

import pickle

def convert (x):
    """ anything that does not convert is set to 0 """
    try:
        return int (x)
    except:
        return 0

def parse_info (inp):
    """ certainly presumes the input is of right form """
    example2 = str(inp).split ("\n")
    example3 = example2 [1:-2]
    example4 = map (lambda x: x.split ("|"), example3)
    example5 = map (lambda x: [x[0], x[3].split (" ")[1]], example4)
    example6 = map (lambda x: [x[0], convert (x[1])], example5)
    return example6

COUNTRY_FILE = open ("country_info.txt")
UNPICKLER = pickle.Unpickler (COUNTRY_FILE)
country_info = UNPICKLER.load ()
COUNTRY_FILE.close ()

# remove coutries with no info, "parse" the ones with
for country in country_info.keys ():
    if country_info [country] == None:
        del country_info [country]
    else:
        country_info [country] = parse_info (country_info [country])

def country_color (country):
    """ green means the 0-4 group is largest, red otherwise """
    val_least_key = country [0][1]
    color = "green"

    for item in country:
        if item [1] > val_least_key:
            color = "red"

    return color

# assign colors
colors = {}
for country in country_info.keys ():
    colors [country] = country_color (country_info [country])

# create the strings to paste into google staticmap
red = []
green = []
for country in colors.keys ():
    if colors [country] == 'red':
        red.append (country)
    else:
        green.append (country)

red_str = "|".join (red)
green_str = "|".join (green)