/* match: search for regexp anywhere in text */

	int match(char *regexp, char *text)

	{

	    if (regexp[0] == '^')

	        return matchhere(regexp+1, text);

	    do {    /* must look even if string is empty */

	        if (matchhere(regexp, text))

	            return 1;

	    } while (*text++ != '\0');

	    return 0;

	}



	/* matchhere: search for regexp at beginning of text */

	int matchhere(char *regexp, char *text)

	{

	   if (regexp[0] == '\0')

	       return 1;

	   if (regexp[1] == '*')

	       return matchstar(regexp[0], regexp+2, text);



	   if (regexp[0] == '$' && regexp[1] == '\0')

	       return *text == '\0';

	   if (*text!='\0' && (regexp[0]=='.' || regexp[0]==*text))

	       returnmatchhere(regexp+1, text+1);

	   return 0;

	}



	/* matchstar: search for c*regexp at beginning of text */

	int matchstar(int c, char *regexp, char *text)

	{

	   do {   /* a * matches zero or more instances */

	       if (matchhere(regexp, text))

	           return 1;

	   } while (*text != '\0' && (*text++ == c || c == '.'));

	   return 0;

	}

	} while (*text != '\0' && (*text++ == c || c == '.'));

	if (regexp[0] == '$' && regexp[1] == '\0')

	    return *text == '\0';

	/* matchstar: leftmost longest search for c*regexp */

	int matchstar(int c, char *regexp, char *text)

	{



	    char *t;



	    for (t = text; *t != '\0' && (*t == c || c == '.'); t++)

	        ;

	    do { /* * matches zero or more */

	        if (matchhere(regexp, t))

	            return 1;

	    } while (t-- > text);

	    return 0;

	}

	for (t = text; *t != '\0' && (*t == c || c == '.'); t++)

	grep 'a.*a.*a.*a.a'

	c80-216-32-218.cm-upc.chello.se - - [08/Oct/2006:06:37:48 -0700] "GET /ongoing/When/

	200x/2006/10/08/Grief-Lessons HTTP/1.1" 200 5945 "http://www.tbray.org/ongoing/"

	"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322)

	crawl-66-249-72-77.googlebot.com 1166406026 2003/04/08/Riffs

	egspd42470.ask.com 1166406027 2006/05/03/MARS-T-Shirt

	84.7.249.205 1166406040 2003/03/27/Scanner

1 class BigHash

2

3   def initialize(file)

4     @hash = {} 

5     lines = 0   

6     File.open(file).each_line do |line| 

7       s = line.split 

8       article = s[2].intern

9       if @hash[s[0]]

10        @hash[s[0]] << [ s[1], article ]  

11      else

12        @hash[s[0]] = [ s[1], article ] 

13      end

14      lines += 1

15      STDERR.puts "Line: #{lines}" if (lines % 100000) == 0

16    end

17  end

18

19  def find(key)

20    @hash[key]

21  end

22

23 end

	package javax.mail;

	

	public final class Session

	{

	   ...

	   public static Session getDefaultInstance(Properties props);

	   ...

	   public Store getStore( ) throws NoSuchProviderException;

	   ...

	}

	public void doTable(Parse table) {

	    doRows(table.parts.more);

	}

	public voiddoRows(Parse rows) {

	    while (rows != null) {

	        doRow(rows);

	        rows = rows.more;

	    }

	}

	public void doRow(Parse row) {doCells(row.parts);

	}

	public void doCell(Parse cell, int columnNumber) {ignore(cell);

	}

	public static void ignore (Parse cell) {

	    cell.addToTag(" bgcolor=\"#efefef\"");

	    ignores++;

	}

	String input = read(new File(argv[0]);Parse parse = new Parse(input);

	public String leader;

	public String tag;

	public String body;

	public String end;

	public String trailer;



	public Parse more;

	public Parse parts;

	static String tags[] = {"table", "tr", "td"};



	public Parse (String text) throws ParseException {

	    this (text, tags, 0, 0);

	}



	public Parse (String text, String tags[]) throws ParseException {

	    this (text, tags, 0, 0);

	}



	public Parse (String text, String tags[], int level, int offset) throws ParseException

	{

	    String lc = text.toLowerCase( );

	    int startTag = lc.indexOf("<"+tags[level]);

	    int endTag = lc.indexOf(">", startTag) + 1;

	    int startEnd = lc.indexOf("</"+tags[level], endTag);

	    int endEnd = lc.indexOf(">", startEnd) + 1;

	    int startMore = lc.indexOf("<"+tags[level], endEnd);

	    if (startTag<0 || endTag<0 || startEnd<0 || endEnd<0) {

	        throw new ParseException ("Can't find tag: "+tags[level], offset);

	    }

	    

	    leader = text.substring(0,startTag);

	    tag = text.substring(startTag, endTag);

	    body = text.substring(endTag, startEnd);

	    end = text.substring(startEnd,endEnd);

	    trailer = text.substring(endEnd);

	    

	    if (level+1 < tags.length) {

	        parts = newParse (body, tags, level+1, offset+endTag);

	        body = null;

	    }

	    

	    if (startMore>=0) {

	        more = new Parse (trailer, tags, level, offset+endEnd);

	        trailer = null;

	    }

	}

Binary search solves the problem by keeping track of the range within the array that holds t (if t is anywhere in the array). Initially, the range is the entire array. The range is shrunk by comparing its middle element to t and discarding half the range. The process continues until t is discovered in the array or until the range in which it must lie is known to be empty.

Most programmers think that with the above description in hand, writing the code is easy. They are wrong. The only way to believe this is by putting down this column right now and writing the code yourself. Try it.

So, the number one goal is to write a framework within which we have some glimmer of hope that developers will actually write tests. The framework has to use familiar tools, so that there is little new to learn. It has to require no more work than absolutely necessary to write a new test. It has to eliminate duplicate effort.

	var symbol_table = {};

	var original_symbol = {

	    nud: function ( ) {

	        this.error("Undefined.");

	    },

	    led: function (left) {

	        this.error("Missingoperator.");

	    }

	};

	var symbol = function (id, bp) {

	    var s = symbol_table[id];

	    bp = bp || 0;

	    if (s) {

	        if (bp >= s.lbp) {

	            s.lbp = bp;

	        }

	    } else {

	        s = object(original_symbol);

	        s.id = s.value = id;

	        s.lbp = bp;

	        symbol_table[id] = s;

	    }

	    return s;

	};

	symbol(":");

	symbol(";");

	symbol(",");

	symbol(")");

	symbol("]");

	symbol("}");

	symbol("else");

	symbol("(end)");

	symbol("(name)");

	var itself = function ( ) {

	    return this;

	};

	symbol("(literal)").nud = itself;

	symbol("this").nud = function ( ) {

	    scope.reserve(this);

	    this.arity = "this";

	    return this;

	};

	var token;

	var advance = function (id) {

	    var a, o, t, v;

	    if (id && token.id !== id) {

	        token.error("Expected '" + id + "'.");

	    }

	    if (token_nr >= tokens.length) {

	        token = symbol_table["(end)"];

	        return;

	    }

	    t = tokens[token_nr];

	    token_nr += 1;

	    v = t.value;

	    a = t.type;

	    if (a === "name") {

	        o = scope.find(v);

	    } else if (a === "operator") {

	        o = symbol_table[v];

	        if (!o) {

	            t.error("Unknown operator.");

	        }

	    } else if (a === "string" || a === number") {

	        a = "literal";

	        o = symbol_table["(literal)"];

	    } else {

	        t.error("Unexpected token.");

	    }

	    token = object(o);

	    token.value = v;

	    token.arity = a;

	    return token;

	};

	dA e B f

	(dA e) B f

	dA (e B f)

	var expression = function (rbp) {

	    var left;

	    var t = token;

	    advance( );

	    left = t.nud( );

	    while (rbp < token.lbp) {

	        t = token;

	        advance( );

	        left = t.led(left);

	    }

	    return left;

	}

	symbol("+", 60).led = function (left) {

	    this.first = left;

	    this.second = expression(60);

	    this.arity = "binary";

	    return this;

	};

	symbol("*", 70).led = function (left) {

	    this.first = left;

	    this.second = expression(70);

	    this.arity = "binary";

	    return this;

	};

	var infix = function (id, bp, led) {

	    var s = symbol(id, bp);

	    s.led = led || function (left) {

	        this.first = left;

	        this.second = expression(bp);

	        this.arity = "binary";

	        return this;

	    };

	    return s;

	}

	infix("+", 60);

	infix("-", 60);

	infix("*", 70);

	infix("/", 70);

	infix("===", 50);

	infix("!==", 50);

	infix("<", 50);

	infix("<=", 50);

	infix(">", 50);

	infix(">=", 50);

	var prefix = function (id, nud) {

	    var s = symbol(id);

	    s.nud = nud || function ( ) {

	        scope.reserve(this);

	        this.first = expression(80);

	        this.arity = "unary";

	        return this;

	    };

	    return s;

	}

	prefix("-");

	prefix("!");

	prefix("typeof");

	prefix("(", function ( ) {

	    var e = expression(0);

	    advance(")");

	    return e;

	});

	var assignment = function (id) {

	    return infixr(id, 10, function (left) {

	        if (left.id !== "." && left.id !== "[" &&

	                left.arity !== "name") {

	            left.error("Bad lvalue.");

	        }

	        this.first = left;

	        this.second = expression(9);

	        this.assignment = true;

	        this.arity = "binary";

	        return this;

	    });

	};

	assignment("=");

	assignment("+=");

	assignment("-=");

	var constant = function (s, v) {

	    var x = symbol(s);

	    x.nud = function ( ) {scope.reserve(this);

	        this.value = symbol_table[this.id].value;

	        this.arity = "literal";

	        return this;

	    };

	    x.value = v;

	    return x;

	};

	constant("true", true);

	constant("false", false);

	constant("null", null);

	constant("pi", 3.141592653589793);

	var scope;

	var original_scope = {

	    define: function (n) {

	        var t = this.def[n.value];

	        if (typeof t === "object") {

	            n.error(t.reserved ?

	                "Already reserved." :

	                "Already defined.");

	        }

	        this.def[n.value] = n;

	        n.reserved = false;

	        n.nud      = itself;

	        n.led      = null;

	        n.std      = null;

	        n.lbp      = 0;

	        n.scope    = scope;

	        return n;

	    },

	find: function (n) {

	    var e = this;

	    while (true) {

	        var o = e.def[n];

	        if (o) {

	            return o;

	        }

	        e = e.parent;

	        if (!e) {

	            return symbol_table[

	                symbol_table.hasOwnProperty(n) ?

	                n : "(name)"];

	        }

	    }

	},

	var statement = function ( ) {

	    var n = token, v;

	    if (n.std) {

	        advance( );

	        scope.reserve(n);

	        return n.std( );

	    }

	    v = expression(0);

	    if (!v.assignment && v.id !== "(") {

	        v.error("Bad expression statement.");

	    }

	    advance(";");

	    return v;

	};

	var statements = function ( ) {var a = [], s;

	    while (true) {

	        if (token.id === "}" || token.id === "(end)") {

	            break;

	        }

	        s = statement( );

	        if (s) {

	            a.push(s);

	        }

	    }

	    return a.length === 0 ? null : a.length === 1 ? a[0] : a;

	};

	var stmt = function (s, f) {

	    var x = symbol(s);

	    x.std = f;

	    return x;

	};

	stmt("{", function ( ) {

	    new_scope( );

	    var a =statements( );

	    advance("}");

	    scope.pop( );

	    return a;

	});

	var block = function ( ) {

	    var t = token;

	    advance("{");

	    return t.std( );

	};

	prefix("function", function ( ) {

	    var a = [];

	    scope = new_scope( );

	    if (token.arity === "name") {

	        scope.define(token);

	        this.name = token.value;

	        advance( );

	    }

	    advance("(");

	    if (token.id !== ")") {

	        while (true) {

	            if (token.arity !== "name") {

	                token.error("Expected a parameter name.");

	            }

	            scope.define(token);

	            a.push(token);

	            advance( );

	            if (token.id !== ",") {

	                break;

	            }

	            advance(",");

	        }

	    }

	    this.first = a;

	    advance(")");

	    advance("{");

	    this.second =statements( );

	    advance("}");

	    this.arity = "function";

	    scope.pop( );

	    return this;

	});

	infix("(", 90, function (left) {

	    var a = [];

	    this.first = left;

	    this.second = a;

	    this.arity = "binary";

	    if ((left.arity !== "unary" ||

	            left.id !== "function") &&

	        left.arity !== "name" &&

	        (left.arity !== "binary" ||

	            (left.id !== "." &&

	            left.id !== "(" &&

	            left.id !== "["))) {

	        left.error("Expected a variable name.");

	    }

	    if (token.id !== ")") {

	        while (true) {

	            a.push(expression(0));

	            if (token.id !== ",") {

	                break;

	            }

	            advance(",");

	         }

	    }

	    advance(")");

	    return this;

	});

	prefix("[", function ( ) {

	    var a = [];

	    if (token.id !== "]") {

	        while (true) {

	            a.push(expression(0));

	            if (token.id !== ",") {

	                break;

	            }

	            advance(",");

	         }

	    }

	    advance("]");

	    this.first = a;

	    this.arity = "unary";

	    return this;

	});

	prefix("{", function ( ) {

	    var a = [];

	    if (token.id !== "}") {

	        while (true) {

	            var n = token;

	            if (n.arity !== "name" && n.arity !== "literal") {

	                token.error("Bad key.");

	            }

	            advance( );

	            advance(":");

	            var v = expression(0);

	            v.key = n.value;

	            a.push(v);

	            if (token.id !== ",") {

	                break;

	            }

	            advance(",");

	         }

	    }

	    advance("}");

	    this.first = a;

	    this.arity = "unary";

	    return this;

	});

	pop = 0;

	for (i = 0; i < 32; i++){

	   if (x & 1) pop = pop + 1;

	   x = x >> 1;

	}

	pop = 0;

	while (x) {

	   pop = pop + (x & 1);

	   x = x >> 1;

	}

	pop = 0;

	while (x) {

	   pop = pop + 1;

	   x = x & (x - 1);

	}

	int pop(unsigned x) {

	   unsigned n;



	   n = (x >> 1) & 033333333333;            // Count bits in

	   x = x - n;                              // each three-bit

	   n = (n >> 1) & 033333333333;            // field.

	   x = x - n;

	   x = (x + (x >> 3)) & 030707070707;      // Six-bit sums.

	   return x%63;                            // Add six-bit sums.

	}

	pop(x) – pop(y) = pop(x) – (32 – pop(y))

	                = pop(x) + pop(y) – 32

int popDiff(unsigned x, unsigned y) {

   x = x - ((x >> 1) & 0x55555555);

   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);

   y = ~y;

   y = y - ((y >> 1) & 0x55555555);

   y = (y & 0x33333333) + ((y >> 2) & 0x33333333);

   x = x + y;

   x = (x & 0x0F0F0F0F) + ((x >> 4) & 0x0F0F0F0F);

   x = x + (x >> 8);

   x = x + (x >> 16);

   return (x & 0x0000007F) - 32;

}

	h ← ab + ac + bc = ab + (a + b)c = ab + (a ⊕ b)c

	l ← (a ⊕ b) ⊕ c

Figure 10-3: A circuit for the total population count of seven words

	dist(x, y) = pop(x ⊕ y)

	ntz(x) = pop(¬x & (x – 1)) = 32 – pop(x | –x)

	use strict;

	use Test;



	BEGIN { plan tests => 392, todo => [] }



	useCryptonite::Mail::HTML qw (&cmdopen &cmdsend &cmdayt);



	$Test::Harness::Verbose = 1;



	my ($cmailclient, $select, $sessionkey);

	my ($USER, $CMAILID, $PASSWORD) = 'test';

	my $a = $Cryptonite::Mail::Config::CONFIG{ADMINPW};



	ok(sub {               # 1: cmdopen

	     my $status;

	     ($status, $cmailclient, $select) = cmdopen;

	     return $status unless $cmailclient;

	     1;

	  }, 1);



	ok(sub {               # 2: newuser

	     my $status = cmdsend('test.pl', $a, $cmailclient, $select,

	                          'newuser', $USER);

	     return $status unless $status =~ /^\+OK.*with password (.*)$/;

	     $PASSWORD = $1;

	     1;

	   }, 1);



	...

	sub _getuser { # Get a user object from the database.

	  my $self = shift; my $username = shift;

	  $self->db->table('users'); $self->db->template($usertmpl);

	  my ($user) = $self->db->select("WHERE USERNAME = '$username'");

	  return $user;

	}

	                   Rate IMAPClientSearch    CclientSearch

	IMAPClientSearch 39.8/s               --             -73%

	CclientSearch     145/s             264%               --



	                 Rate IMAPClientSort CclientSort

	IMAPClientSort 21.3/s             --        -99%

	CclientSort    2000/s          9280%          --

Ax = b

A = LU

P

        T

        A = LU

x = A

        -1

        Pb

	||r||/||A|| ≤ ||e|| ≤ ||A-1|| ||r||

	struct device {

	        struct list_head node;           /* node in sibling list */

	        struct list_head children;

	        struct device *parent;

	        char   name[DEVICE_NAME_SIZE];   /* descriptive ascii string */

	        char   bus_id[BUS_ID_SIZE];      /* position on parent bus */



	        spinlock_t       lock;           /* lock for the device to ensure two

	                                            different layers don't access it at

	                                            the same time. */

	        atomic_t         refcount;       /* refcount to make sure the device

	                                          * persists for the right amount of time */



	        struct driver_dir_entry * dir;



	        struct device_driver *driver;    /* which driver has allocated this

	                                            device */

	        void            *driver_data;    /* data private to the driver */

	        void            *platform_data;  /* Platform-specific data (e.g. ACPI,

	                                            BIOS data relevant to device */



	       u32             current_state;    /* Current operating state. In

	                                            ACPI-speak, this is D0-D3, D0

	                                            being fully functional,and D3

	                                            being off. */



	      unsigned char *saved_state;        /* saved device state */

	};

	atomic_t          refcount;

	static inline void get_device(struct device * dev)

	{

	        BUG_ON(!atomic_read(&dev->refcount));

	        atomic_inc(&dev->refcount);

	}

	void put_device(struct device * dev)

	{

	        if (!atomic_dec_and_lock(&dev->refcount,&device_lock))

	                return;



	    ...



	        /* Tell the driver to clean up after itself.

	         * Note that we likely didn't allocate the device,

	         *so this is the driver's chance to free that up...

	         */

	        if (dev->driver && dev->driver->remove)

	                 dev->driver->remove(dev,REMOVE_FREE_RESOURCES);

	}

	int VOP_READ(

	        struct vnode *vp,          /* File to read from */

	        struct uio *uio,           /* Buffer specification */

	        int ioflag,                /* I/O-specific flags */

	        struct ucred *cred)        /* User's credentials */

	{

	    /* Hypothetical implementation */

	       switch (vp->filesystem) {

	       case FS_NTFS:               /* NTFS-specific code */

	       case FS_ISO9660:            /* ISO-9660-specific code */

	       case FS_FAT32:              /* FAT-32-specific code */

	    /* [...] */

	    }

	}

	/*

	 * A generic structure.

	 * This can be used by bypass routines to identify generic arguments.

	 */

	struct vop_generic_args {

	       structvnodeop_desc *a_desc;

	       /* other random data follows, presumably */

	};



	/*

	 * This structure describes the vnode operation taking place.

	 */

	struct vnodeop_desc {

	       char    *vdesc_name;            /* a readable name for debugging */

	       int      vdesc_flags;           /* VDESC_* flags */

	       vop_bypass_t    *vdesc_call;    /* Function to call */



	       /*

	        * These ops are used by bypass routines to map and locate arguments.

	        * Creds and procs are not needed in bypass routines, but sometimes

	        * they are useful to (for example) transport layers.

	        * Nameidata is useful because it has a cred in it.

	        */

	       int     *vdesc_vp_offsets;     /* list ended by VDESC_NO_OFFSET */

	       int      vdesc_vpp_offset      /* return vpp location */

	       int      vdesc_cred_offset;    /* cred location, if any */

	       int      vdesc_thread_offset   /* thread location, if any *

	       int      vdesc_componentname_offset; /* if any */ 

	};

	int ma_fill         13

	int ma_used         13

	int ma_mask         31



	PyDictEntry ma_table[]:

	[0]: aa, 1                  hash(aa) == -1549758592, -1549758592 & 31 = 0

	[1]: ii, 9                  hash(ii) == -1500461680, -1500461680 & 31 = 16	

	[2]: null, null

	[3]: null, null 

	[4]: null, null

	[5]: jj, 10                 hash(jj) == 653184214, 653184214 & 31 = 22

	[6]: bb, 2                  hash(bb) == 603887302, 603887302 & 31 = 6

	[7]: null, null 

	[8]: cc, 3                  hash(cc) == -1537434360, -1537434360 & 31 = 8

	[9]: null, null

	[10]: dd, 4                 hash(dd) == 616211530, 616211530 & 31 = 10

	[11]: null, null

	[12]: null, null

	[13]: null, null

	[14]: null, null 

	[15]: null, null

	[16]: gg, 7                 hash(gg) == -1512785904, -1512785904 & 31 = 16

	[17]: ee, 5                 hash(ee) == -1525110136, -1525110136 & 31 = 8

	[18]: hh, 8                 hash(hh) == 640859986, 640859986 & 31 = 18

	[19]: null, null

	[20]: null, null

	[21]: kk, 11                hash(kk) == -1488137240, -1488137240 & 31 = 8

	[22]: ff, 6                 hash(ff) == 628535766, 628535766 & 31 = 22

	[23]: null, null

	[24]: null, null

	[25]: null, null

	[26]: null, null

	[27]: null, null

	[28]: null, null

	[29]: ll, 12                hash(ll) == 665508394, 665508394 & 31 = 10

	[30]: mm, 13                hash(mm) == -1475813016, -1475813016 & 31 = 8 

	[31]: null, null

	/* Starting slot */

	slot = hash;



	/* Initial perturbation value */

	perturb = hash;

	while (<slot is full> && <item in slot doesn't equal the key>) {

	    slot = (5*slot) + 1 + perturb;

	    perturb >>= 5;

	}

	for k, v in d.iteritems():

	    d[k] = d[k] + 1

	if (N==0)

	    copy memory from b to a

	    return

	set up ptr_to_a and ptr_to_b

	for n=0 to size of first dimension of a and b

	    copy_ND(ptr_to_a, ptr_to_b, N-1)

	    add stride_a[0] to ptr_to_a and stride_b[0] to ptr_b

	set up iterator

	  (including pointing the current value to the first value in the array)

	while iterator not done:process the current value

	point the current value to the next value

	#include <float.h>

	double *currval, maxval=-DBL_MAX;

	PyObject *it;

	it = PyArray_IterNew(ao);

	while (PyArray_ITER_NOTDONE(it)) {

	    currval = (double *)PyArray_ITER_DATA(it);

	    if (*currval < maxval) maxval = *currval;

	    PyArray_ITER_NEXT(it);

	}

	# Add a task in task_module. Context represents the currentproject object.

	context_obj = context.getObject()

	# newContent is an ERP5 API method that creates a new content.

	task = context.task_module.newContent(portal_type = 'Task')

	# Set the source_project reference to the task.

	task.setSourceProjectValue(context_obj)

	# Redirect the user to Task GUI, so that the user can edit its properties.

	return context.REQUEST.RESPONSE.redirect(task.absolute_url() + '?portal_status_

	message=Created+Task.')

    #include "mapreduce/mapreduce.h"



    // User's map function

    class WordCounter : public Mapper {

     public:

      virtual void Map(const MapInput& input) {

        const string& text = input.value();

        const int n = text.size();

        for (int i = 0; i < n; ) {

          // Skip past leading whitespace

          while ((i < n) && isspace(text[i]))

            i++;



          // Find word end

          int start = i;

          while ((i < n) && !isspace(text[i]))

            i++;

          if (start < i)

            EmitIntermediate(text.substr(start,i-start),"1");

        }

      }

    };

    REGISTER_MAPPER(WordCounter);



    // User's reduce function

    class Adder : public Reducer {

      virtual void Reduce(ReduceInput* input) {

        // Iterate over all entries with the

        // same key and add the values

        int64 value = 0;

        while (!input->done()) {

          value += StringToInt(input->value());

          input->NextValue();

        }



        // Emit sum for input->key()

        Emit(IntToString(value));

      }

    };

    REGISTER_REDUCER(Adder);



    int main(int argc, char** argv) {

      ParseCommandLineFlags(argc, argv);MapReduceSpecification spec;



      // Store list of input files into "spec"

      for (int i = 1; i < argc; i++) {

        MapReduceInput* input = spec.add_input();

        input->set_format("text");

        input->set_filepattern(argv[i]);

        input->set_mapper_class("WordCounter");

      }



      // Specify the output files:

      //    /gfs/test/freq-00000-of-00100

      //    /gfs/test/freq-00001-of-00100

      //    ...

      MapReduceOutput* out = spec.output();

      out->set_filebase("/gfs/test/freq");

      out->set_num_tasks(100);

      out->set_format("text");

      out->set_reducer_class("Adder");



      // Optional: do partial sums within map

      // tasks to save network bandwidth

      out->set_combiner_class("Adder");



      // Tuning parameters: use at most 2,000

      // machines and 100 MB of memory per task

      spec.set_machines(2000);

      spec.set_map_megabytes(100);

      spec.set_reduce_megabytes(100);

      // Now run it

      MapReduceResult result;

      if (!MapReduce(spec, &result)) abort( );



      // Done: 'result' structure contains info

      // about counters, time taken, number of

      // machines used, etc.



      return 0;

    }

Write a procedure to transfer money from one bank account to another. To keep things simple, both accounts are held in memory: no interaction with databases is required. The procedure must operate correctly in a concurrent program, in which many threads may call transfer simultaneously. No thread should be able to observe a state in which the money has left one account, but not arrived in the other (or vice versa).

	class Account {

	  Int balance;

	  synchronized void withdraw( Int n ) {

	    balance = balance - n; }

	  void deposit( Int n ) {

	    withdraw( -n ); }

	}

	void transfer( Account from, Account to, Int amount ) {

	  from.withdraw( amount );

	  to.deposit( amount ); }

Santa repeatedly sleeps until wakened by either all of his nine reindeer, back from their holidays, or by a group of three of his ten elves. If awakened by the reindeer, he harnesses each of them to his sleigh, delivers toys with them and finally unharnesses them (allowing them to go off on holiday). If awakened by a group of elves, he shows each of the group into his study, consults with them on toy R&D and finally shows them each out (allowing them to go back to work). Santa should give priority to the reindeer in the case that there is both a group of elves and a group of reindeer waiting.

	atomically (do { limitedWithdraw a1 10

	               ; limitedWithdraw2 a2 a3 20 })

	(define-syntax or

	  (lambda (x)

	    (syntax-case x ()

	      [(_ e1 e2)

	       (syntax (let ([t e1]) (if t t e2)))])))

	(define-syntax or

	   (lambda (x)

	      (syntax-case x ()

	        [(_ e1 e2)

	         (syntax (let ([t e1]) (if t t e2))])))

	(letrec-syntax ([or (lambda (x)

	                      (syntax-case x ()

	                        [(_ e1 e2)

	                         #'(let ([t e1]) (if t t e2))]))])

	 (or a b))

	(let ([t #t]) (or #f t))

	(define-syntax or

	  (lambda (x)

	    (syntax-case x ()

	      [(_ e1 e2) #'(let ([t e1]) (if t t e2))])))

	<(let ((t #t)) (or #f t))>

	<(or #f t) [t x () → l1]>

	l1 → lexical(t.1)

public interfaceHotkeyAdaptor {public void setXML(String _xml);

	    public boolean parseXML();

	    public boolean executeQuery();

	    public String getResponseXML();



	}

	HotkeyAdaptor hotkey =null;



	if (sb.toString().indexOf("Pip3A2PriceAndAvailabilityRequest") > 0) {

	    // Price and Availability Request

	    hotkey = HotkeyAdaptorFactory.getAdaptor(

	        HotkeyAdaptorFactory.ROSETTANET,

	        HotkeyAdaptorFactory.PRODUCTAVAILABILITY);

	}

	else if (sb.toString().indexOf("Pip3A5PurchaseOrderStatusQuery ") > 0) {

	    // Order Status

	    hotkey = HotkeyAdaptorFactory.getAdaptor(

	        HotkeyAdaptorFactory.ROSETTANET,

	        HotkeyAdaptorFactory.ORDERSTATUS);

	}

public class TestHotKeyService {public static void main (String[] args) throws Exception {



	        String strURL = "http://xxxxxxxxxxx/HotKey/HotKeyService";

	        String strXMLFilename = "SampleXMLRequest.xml";

	        File input = new File(strXMLFilename);



	        PostMethod post = new PostMethod(strURL);

	        post.setRequestBody(new FileInputStream(input));

	        if (input.length( ) < Integer.MAX_VALUE) {

	            post.setRequestContentLength((int)input.length());

	        } else {

	              post.setRequestContentLength(

	                  EntityEnclosingMethod.CONTENT_LENGTH_CHUNKED);

	        }



	        post.setRequestHeader("Content-type", "text/xml; charset=ISO-8859-1");



	        HttpClient httpclient = new HttpClient();

	        System.out.println("[Response status code]: " +

	               httpclient.executeMethod(post));

	        System.out.println("\n[Response body]: ");

	        System.out.println("\n" + post.getResponseBodyAsString( ));



	        post.releaseConnection();

	    }

	}

When using DDD with GDB 4.16, the run command correctly uses any prior command-line arguments, or the value of set args. However, when I switched to GDB 4.17, this no longer worked: If I entered a run command in the console window, the prior command-line options would be lost.

	proc tts_say {text} {puts -nonewline $tts(write) "$text"}

	proc say {text} {_say "$text"}

	while( d.diffs == DD_CONF && ( bf->end != bf->Lines( ) ||

	                               lf1->end != lf1->Lines( ) ||

	                               lf2->end != lf2->Lines( ) ) )

	case MS_BASE:               /* dumping the original */



	    if( selbits = selbitTab[ DL_BASE ][ diffDiff ] )

	    {

	        readFile = bf;

	        readFile->SeekLine( bf->start );

	        state = MS_LEG1;

	        break;

	    }



	case MS_LEG1:               /* dumping leg1 */



	    if( selbits = selbitTab[ DL_LEG1 ][ diffDiff ] )

	    {

	        readFile = lf1;

	        readFile->SeekLine( lf1->start );

	        state = MS_LEG2;

	        break;

	    }



	case MS_LEG2:               /* dumping leg2 */



	    if( selbits = selbitTab[ DL_LEG2 ][ diffDiff ] )

	    {

	        readFile = lf2;

	        readFile->SeekLine( lf2->start );

	    }



	    state = MS_DIFFDIFF;

	    break;

	Breakpoint 3, DiffMerge::DiffDiff (this=0x80e10c0) at diff/diffmerge.cc:510

	510             Mode initialMode = d.mode;

	(gdb)list 505,515

	505             DiffGrid d = diffGrid

	506                     [ df1->StartLeg() == 0 ][ df1->StartBase( ) == 0 ]

	507                     [ df2->StartLeg() == 0 ][ df2->StartBase( ) == 0 ]

	508                     [ df3->StartL1() == 0 ][ df3->StartL2( ) == 0 ];

	509

	510             Mode initialMode = d.mode;

	511

	512             // Pre-process rules, typically the outer snake information

	513             // contradicts the inner snake, its not perfect, but we use

	514             // the length of the snake to determine the best outcome.

	515

	(gdb) print d

	$1 = {mode = CONF, diffs = DD_CONF}

	(gdb)

Figure 33-2: Three noncollinear points

	(defun naive-collinear (px py qx qy rx ry)

	  (let ((m (slope px py qx qy))

	        (b (y-intercept px py qx qy)))

	    (= ry (+ (* m rx) b))))

Instead of drawing a line through two points and seeing whether the third point is on the line, suppose I drew all three lines and checked to see whether they are really the same line. Actually, I would need to draw only two of the lines, because if line is identical to line , it must also be equal to . Furthermore, it turns out I need to compare only the slopes, not the y-intercepts. (Do you see why?) Judging by eye whether two lines are really coincident or form a narrow scissors angle might not be the most reliable procedure, but in the computational world, it comes down to a simple comparison of two numbers, the m values (see ).

Figure 33-3: Testing collinearity by comparing slopes

	(defun mm-collinear (px py qx qy rx ry)

	  (equalp (slope px py qx qy)

	          (slope qx qy rx ry)))

	(defun typed-mm-collinear (px py qx qy rx ry)

	  (let ((pq-slope (slope px py qx qy))

	        (qr-slope (slope qx qy rx ry)))

	    (or (and (numberp pq-slope)

	             (numberp qr-slope)

	             (= pq-slope qr-slope))

	        (and (not pq-slope)

	             (not qr-slope)))))

Figure 33-4: Testing collinearity by the triangle inequality

	(defuntriangle-collinear (px py qx qy rx ry)

	  (let ((pq (distance px py qx qy))

	        (pr (distance px py rx ry))

	        (qr (distance qx qy rx ry)))

	    (let ((sidelist (sort (list pq pr qr) #'>)))

	      (= (first sidelist)

	         (+ (second sidelist) (third sidelist))))))

For the ease of exposition, we shall assume that no two endpoints have the same x-or y-coordinates. This, in particular, applies to the two endpoints of the same segment, and thus rules out the presence of vertical or horizontal segments…Our rationale is that the key ideas of the algorithm are best explained without having to worry about special cases every step of the way. Relaxing the assumptions is very easy (no new ideas are required) but tedious. That's for the theory. Implementing the algorithm so that the program works in all cases, however, is a daunting task. There are also numerical problems that alone would justify writing another paper. Following a venerable tradition, however, we shall try not to worry too much about it.