06 August 2010

OED: Star Wars Collector's Edition

As a logophile, I occasionally browse both my copy of the Shorter Oxford English Dictionary and the OED Online. For one reason or another, I was reading the updated draft entry of remember, v.1 sense 5a, and I found the most startlingly nerdy quotation displayed:

G. LUCAS Star Wars Episode I: Phantom Menace 91, I made this for you. So you'd remember me. I carved it out of a japor snippet... It will bring you good fortune.

There you have it. It seems that some lexicographer out there chose to sacrifice literary integrity to make a nerdy allusion. I suppose I should also check the entries for "father," "force," "droid," …

26 July 2010

The Case-book of Linear Transport Theory

There are very few people who, upon glancing at the section titles in their neutron transport theory books, would chuckle because "The Case of Anisotropic Scattering," "The Albedo Problem," and "The X-Function Identities" all read like titles from a collection of mysteries.

22 June 2010

Alcohol isn't allowed at the sailing club

I might suggest a slogan for "designated sailor" awareness out on the lake: don't imbibe and jibe?

18 June 2010

Kids these days

Curse you, the internet, for your abhorrent mangling of the words "epic" and "fail." The Iliad is epic. Typical residents of the internet fail to appreciate the beauty of literate conversation.

11 June 2010

Time-dependent discrete ordinates transport

The discrete ordinates approximation for transport lumps "particles" into certain directions. In a 1-D time-dependent transport problem, the effect is the same as having several waves propagating at different speeds from the source region.

04 May 2010

Regression

A study titled The largest Last Supper: depictions of food portions and plate size increased over the millennium has attempted to extrapolate nominal meal portion sizes from paintings of The Last Supper created over an 800-year span. Now, tell me if this is not the worst regression analysis you've ever seen:

Really, a parabolic fit? One that extends 300 years beyond the range of the data? I'm no expert in regression analysis, but even an r-value of 0.5 does not seem worthy of the strong conclusions which the article draws.

Aside from the poor correlation coefficient, and assuming the very method of linking plate-to-head ratio to portion size is valid, it looks like their extrapolation hinges entirely on one outlier (the most recent painting) and a century of plenty (in the 1500's, where there were not only small portions but large portions). This is a crock.

12 March 2010

It's science, ok

Today I had a little fun with my code. As I've mentioned too often, it's written with a Python front end. That means I can very easily interact with the hundreds of Python modules out there. Well, this being a Friday afternoon, I decided to tie it into an image processing library, which will let me turn an image into a series of values, which I can then define as a field on my mesh (e.g., the total cross section). So I did that with a test image, and ran it through my transport code.

The code to load an image as grayscale, create the mesh, and set the cross sections:

    im = Image.open(fname).convert("L").transpose(Image.FLIP_TOP_BOTTOM )
    values = ( (255.0 - x) / 255.0 for x in im.getdata() )
    args = list(im.size) + list( 10.0 * float(i) / max(im.size)
                                  for i in im.size )
    mesh = meshlib.Mesh(*args)
    sigma_t = meshlib.CellFieldFloat(mesh, meshlib.VectorFloat(values) )

I also did this with a picture of my advisor.

26 February 2010

Vim: strip trailing whitespace on write

Git is picky about leave trailing whitespace (spaces at the end of a line) in your code. To keep it from being a problem, I modified some helpful scripts to my exacting specifications: it will notify you if it replaces trailing whitespace, it won't change your cursor position, and it won't affect innocent bystander files. Add it to your $HOME/.vim/ftplugin/cpp.vim ftplugin file.

" automatically remove trailing whitespace before write
function! StripTrailingWhitespace()
  normal mZ
  %s/\s\+$//e
  if line("'Z") != line(".")
    echo "Stripped whitespace\n"
  endif
  normal `Z
endfunction
autocmd BufWritePre *.cpp,*.hpp,*.i :call StripTrailingWhitespace()

I like Vim, but I despise Vimscript. Trying to get it to do exactly what I want takes so much guessing and consequently far too much time.

17 February 2010

SWIG iterators and generators, continued

This is a continuation of my previous post on Python generators with SWIG. I've improved the code, added an iterator class so that the same generator method can be called multiple times concurrently, and added a couple of macros to allow easy instantiation of the SWIG code.

A SWIG file (use with the %include directive) is available for download, and further updates will be posted on my projects page.

As an example of how this would be used, see an excerpt of a 2D diffusion input file that uses my mesh library:

for c in mesh.cells():
    source[c] = max(  math.cos( c.getCenter()[0] / 2 * math.pi )
                    + math.cos( c.getCenter()[1] / 2 * math.pi ),
                  0)

UPDATE 4/25/2011: my project that uses this file is now posted on github.

15 February 2010

Easy Python generators using SWIG

In my research code, I have a number of classes that act as wrappers for containers, and they provide begin and end functions. I want an easy way to provide a generator for looping over these embedded containers. Because of the way SWIG's STL wrappers work, it's not (easily?) possible to wrap a vector of pointers, and we'd like to avoid all the extra overhead those wrappers have anyway: all we need is a way to increment a pointer and to tell if it's at the end.

So, my solution is to create a thin wrapper for only the increment operator ++, and extend the class with a function to return the "beginning" iterator and to check whether the iterator is at the end position.

For this particular instance, I have a class Mesh that has methods for beginLeftBoundaryFaces and endLeftBoundaryFaces—which return STL vector iterators that point to a Face *.

%inline %{
//! Thin wrapper for ONLY the increment operator
void _bfiter_incr( std::vector<Face *>::const_iterator* iter )
{
    // increment the iterator
    ++(*iter);
}
%}

%extend Mesh {
%insert("python") %{
    def left_boundary_faces(self):
        "A generator to iterate through boundary faces."
        faceIter = self._beginLeftBoundaryFaces()
        keepLooping = True
        while keepLooping == True:
            face = self._bfiter_dereference_Left( faceIter )
            if face:
                _bfiter_incr( faceIter )
                yield face
            else:
                keepLooping = False
%}

//! get the first element in the vector
std::vector<Face *>::const_iterator* _beginLeftBoundaryFaces()
{
    return new std::vector<Face *>::const_iterator(
            ($self->beginLeftBoundaryFaces()) );
}

//! dereference the iterator; return NULL if at the end
const Face* _bfiter_dereference_Left(
        const std::vector<Face *>::const_iterator* iter )
{
    // if at the end, return NULL
    if (*iter == ($self)->endLeftBoundaryFaces() ) {
        return NULL;
    }
    // otherwise, return the face to which this iterator points
    return **iter;
}
}

So now I can do:

for f in mesh.left_boundary_faces():
    print f.area()

or, of course, anything else now that I'm using Python.

See further updates on the thin Python wrappers for C++ iterators.