The Return of Agent Zlerich

Tidbits from the World

2026-04-13T16:51:00.005+00:00

Just quotes, etc. where I frequently want the original source…

“Legacy” is not a pejorative.
“Invert, always, invert”

Jacobi originally but popularized by Munger : “...it is in the nature of things that many hard problems are best solved when they are addressed backward”
Algorithm for inversion:
Define the problem - what is it that you're trying to achieve?
Invert it - what would guarantee the failure to achieve this outcome?
Finally, consider solutions to avoid this failure

“[Not naming software tools] is actually a lesson that originates from the early days of Call of Duty at IW. From what I’m told, IW never named their engine, because any time you name something it becomes a bit more of a thing, and you start working for it. And they were a studio making games, the game is the thing. Nothing else.” [source]
“You have to do basic science on your libraries to see how they work…” [Sussman as reported by Wingo]
“A pointer is an integer with a shiv” [source]
Optimal stopping problems are solved with the odds algorithm, e.g. the classical secretary problem.
“The Statistics of Sharpe Ratios” by Andrew Lo [paper]
“You are in a drawdown. When should you start worrying?” [paper]
NIST has several excellent references:

Dictionary of Algorithms and Data Structures (DADS), a dictionary of algorithms, algorithmic techniques, data structures, archetypal problems, etc
Engineering Statistics Handbook with chapters Explore, Measure, Characterize, Model, Improve, Monitor, Compare, and Reliability

“If you have a procedure with 10 parameters, you probably missed some.” [source]
Driscoll Kraay Standard Errors are robust to both cross-sectional and temporal dependence.
The Python Graph Gallery is a visual reference over many graphs along with the source code to produce them.
Total least squares minimizes errors on both dependent and independent variables.
Bottom Line Up Front (BLUF) writing [HBR, Wikipedia]
Dennis Ritchie: “Our habit of trying to document bugs and limitations visibly was enormously useful to the system. As we put out each edition, the presence of these sections shamed us into fixing innumerable things rather than exhibiting them in public. I remember clearly adding or editing many of these sections, then saying to myself 'I can't write this,' and fixing the code instead.” [source]
A bestiary of regression variants , including:

Linear Regression
Polynomial Regression
Logistic Regression
Quantile Regression
Ridge Regression
Lasso Regression
Elastic Net Regression
Principal Components Regression (PCR)
Partial Least Squares (PLS) Regression
Support Vector Regression
Ordinal Regression
Poisson Regression
Negative Binomial Regression
Quasi Poisson Regression
Cox Regression
Tobit Regression

A Bestiary of Functions for Systems Designers is a nice visual guide
Karpathy blogged A Recipe for Training Neural Networks :

Become one with the data
Set up the end-to-end training/evaluation skeleton + get dumb baselines
Overfit, recalling deep double descent
Regularize
Tune
Squeeze out the juice

Agustin Lebron’s The Laws of Trading :

Know why you are doing a trade before you trade.
You're never happy with the amount you traded.
Take only the risks you're being paid to take. Hedge the others.
Put on a risk using the most liquid instrument for that risk.
If you can't explain your edge in five minutes, you don't have a very good one.
The long-term profitability of an edge is inversely proportional to how long it takes to explain it.
The model expresses the edge.
If you think your costs are negligible relative to your edge, you're wrong about at least one of them.
Just because something has never happened doesn't mean it can't.

Corollary: Enough people relying on something being true makes it false.
Working to align everyone's interests is time well spent.
If you don't master technology and data, you're losing to someone who does.
If you're not getting better, you're getting worse.

Shellhaters.org has a great POSIX Shell and Utilities Quick Reference
Practical SQL for Data Analysis: What you can do without Pandas [source]
Taguchi methods are statistical methods, sometimes called robust design methods, developed by Genichi Taguchi to improve the quality of manufactured goods, and more recently also applied to engineering…. See also orthogonal arrays , optimal experimental link, and notice Sandia’s Dakota implements many of these ideas.
Prefer to change the code rather than write a workaround [source]
By nature, bugs are found in places that you didn’t think to look [source]

A cold path is a path through the code or situation that rarely happens.
By contrast, hot paths happen frequently. You don’t find bugs in hot paths.
Bugs are always in cold paths — every bug is found in a path colder than all the paths you tested.
Don’t have cold paths and avoid fallbacks

Your Makefiles are wrong is an opinionated approach to GNU Make:

Don’t use tabs with .RECIPEPREFIX
Always use (a recent) bash in strict mode
Change some Make defaults, with a nice TLDR pre-amble

Mike Acton’s Expectations of Professional Software Engineers [summary]
Scalability! But at what COST? says “Big data systems may scale well, but this can often be just because they introduce a lot of overhead” and is often referred to as “The COST Paper”
strace Wow Much Syscall by Brendan Gregg includes useful strace one-liners
Richard Sutton’s The Bitter Lesson starts “The biggest lesson that can be read from 70 years of AI research is that general methods that leverage computation are ultimately the most effective, and by a large margin….” and begins to conclude “One thing that should be learned from the bitter lesson is the great power of general purpose methods, of methods that continue to scale with increased computation even as the available computation becomes very great. The two methods that seem to scale arbitrarily in this way are search and learning.”
Syntax across languages is a gigantic survey of language design, e.g. operators/functions/etc. The survey can often inform what some collection of users will find natural or unnatural based on their existing skills.
Nick Higham’s “What Is” article series gives brief descriptions of concepts in numerical analysis for upper-level undergraduates with mathematical inclinations
Long names are long observes “identifiers that are too damn long.”

Omit words that are obvious given a variable’s or parameter’s type
Omit words that don’t disambiguate the name
Omit words that are known from the surrounding context
Omit words that don’t mean much of anything

(e.g. data, state, amount, value, manager, engine, object, entity, and instance)
Ends with a humorous application to waffles.

How to help someone use a computer : “Computer people are fine human beings, but they do a lot of harm in the ways they "help" other people with their computer problems….”
Common statistical tests are linear models:

Hoeffding’s test for dependence was proposed by Wassily Hoeffding (1948) as a test of correlation for two variables with continuous distribution functions (wikipedia, random blog, post). Hoeffding’s D is a nonparametric measure of the distance between the joint distribution F(x, y) and the product of marginal distributions F1(x)F2(y). The advantage of this statistic lies in the fact that it has more power to detect non-monotonic dependency structures compared to other more common measures (Pearson, Kendall, Spearman)
Data systems often fall into one of schema-on-write or schema-on-read:

Traditional databases are schema-on-write: “we can't upload data until the table is created and we can't create tables until we understand the schema of the data that will be in this table.”
Newer systems, e.g. “Big Data” is often schema-on-read, requiring all code that handles the data to understand it’s implicit schema. Still “some level of schema design is inevitable”.
Martin Kleppmann’s book Designing Data-Intensive Applications often comes up.

Simple sabotage for software , taking CIA sabotage manuals for inspiration, enumerates many horrid, insidious ways to sabotage a software organization. To do better as an organization, work to prevent even accidental sabotage.
The Internet Was Designed With a Narrow Waist:

A narrow waist is concept, interface, or protocol that solves an interoperability problem.
Picture an hourglass with M things on one side, N on the other, and an important concept in the middle.
It avoids O(M × N) code explosions, letting us write O(M + N) amounts of code instead.
Byte streams and text are essential narrow waists in software, particularly in distributed-systems like the Internet.

On achieving high-level goals [source pp 138-9]:

Write down your five biggest goals for the year.
Pick the one that will make the biggest difference in your life. Tackle that one first.
Write your chosen goal in the past tense as though it's already happened. This will not only tell you whether you truly want it by how you feel as you look back at it from the future, it will also help you identify (in imagined hindsight) all the critical steps it will take to get there. Outline as many critical steps as come to mind.
Write out twenty different things you could do right now to make it happen. Really stretch your thinking in new directions to get all twenty. Now pick the one goal that will have the greatest impact on the achievement of that goal. Try to knock one off your list each day, or week (depending on the goal). Keep going with twenty more, and twenty more, until the goal is achieved. Focus on only one goal at a time, putting all your energy in that one direction. (Trying to work on them all at once can be overwhelming and diffuses your effectiveness and focus).

Thompson sampling is commonly used as a multi-armed bandit algorithm. I have personally used it for an older side project.
“Shipping is a social construct within a company.”
There’s a CLAUDE.md containing Karpathy-inspired Claude Code guidelines.
Every layer of review makes you 10x slower by he of apenwarr/redo fame.

Randomized addition worksheets for kiddos using Bash Pipelines

2018-02-04T16:20:00.000+00:00

Following up on a prior randomized worksheet for reading, here's a way to generate as many simple addition worksheets as you care to print:

#!/bin/bash
# Print a US letter page of addition problems using numbers 0 through 10.
(
    for i in $(seq 1 26); do
        printf "%2d %s %2d = \n" "$((RANDOM % 11))" "+" "$((RANDOM % 11))"
    done
) \
| column -nxc 36 \
| sed G \
| head -n -1 \
| a2ps -1 --chars-per-line=32 --no-header --borders=no

Randomized Reading Lists for Kiddos using Bash Pipelines

2017-06-03T13:09:00.000+00:00

Our kiddo is very good at memorizing stories and word sequences but needs to work on looking at the letters on the page. Simple bash pipelines can produce useful offline learning materials.

For example, print a randomized word list from inline story text for a book your kid loves:

#!/bin/bash
tr -d '",!.-' << EOF                          \
    | tr -s ' ' '\n'                          \
    | sed '/^$/d'                             \
    | sort -u                                 \
    | shuf                                    \
    | column -c 64                            \
    | nl                                      \
    | a2ps -1 --chars-per-line=70 --no-header

The night Max wore his wolf suit and made mischief of one kind
and another
his mother called him "WILD THING!"
...

EOF

Run the script once to produce the word list. Print the source once to have the picture-less story. Carry both in your pocket on the plane/train/etc. After some work on the word list, the kid should be encouraged by "rediscovering" the picture-less story he knows using the sight words he's just practiced. In theory. Still working on the practice.

Another example, print a randomized list of kindergarten sight words:

#!/bin/bash
sort -u <<EOF | shuf | column -c 64 | nl | a2ps -1 --chars-per-line=70 --no-header
a
about
after
again
all
always
am
an
and
any
are
as
ask
at
away
back
ball
be
beautiful
because
been
begin
best
big
but
by
came
can
come
could
couldn't
day
did
do
does
don't
down
each
easy
eat
either
enough
family
find
for
friend
from
fun
get
girl
go
goes
going
got
great
had
has
have
he
her
here
high
him
his
home
house
how
I
idea
if
I'm
in
into
is
it
jump
just
know
last
let
like
little
look
love
make
man
me
might
mom
more
mother
much
my
never
next
no
not
now
of
often
on
or
our
out
over
play
pretty
probably
put
ran
read
ready
run
said
same
sat
saw
say
school
see
she
should
sit
so
soon
special
such
suddenly
take
than
that
the
their
them
themselves
then
there
they
they're
things
think
this
thought
three
through
to
today
together
too
two
under
until
up
us
very
wait
walk
want
was
we
went
were
what
when
where
while
who
will
with
without
yes
you
your
you're
yourself
EOF

Travis-CI config for both recent(ish) gcc and clang

2016-12-11T18:57:00.005+00:00

On account of the age of Travis-CI's build images (I hear) getting a new-ish C++ compiler going is futzy. After much futzing, the following .travis.yml file works for an autoconfiscated project:

language: generic
script: ./bootstrap && ./configure && make all && make check && make distcheck
matrix:
  include:
    - os: linux
      env: COMPILER_NAME=gcc CXX=g++-5 CC=gcc-5
      addons:
        apt:
          sources:
            - ubuntu-toolchain-r-test
          packages:
            - autotools-dev
            - g++-5
    - os: linux
      env: COMPILER_NAME=clang CXX=clang++-3.8 CC=clang-3.8
      addons:
        apt:
          sources:
            - ubuntu-toolchain-r-test
            - llvm-toolchain-precise-3.8
          packages:
            - autotools-dev
            - clang-3.8

Dissertation appeareth

2014-10-28T12:10:00.002+00:00

My dissertation, Reducing turbulence- and transition-driven uncertainty in aerothermodynamic heating predictions for blunt-bodied reentry vehicles, appeared online today in the University of Texas Library system. Bonus points if you find the typo in the abstract that I accidentally inserted during my final day of editing. Triple word score if you browse through the introductory chapter and ask me questions—my hope is that it is fairly accessible.

Content from Chapter 6, Characteristics of the Homogenized Boundary Layers at Atmospheric Reentry-like Conditions, will be presented at APS DFD 2014 at Stanford in a few weeks. Man, I need to finish those slides...

Very cool is that, as of today, NASA is testing the Orion MPCV on December 4th. That means soon they'll be some real flight data against which my simulation-based predictions found in Chapter 7, Detecting Turbulence-Sustaining Regions on Blunt-Bodied Reentry Vehicles, can be compared.

Happily, the dissertation source code attachments appear to have been preserved too. That said, the GitHub suzerain and ESIO repositories should be preferred over the electronic dissertation attachments for anything other than sleuthing out precisely what I implemented in my thesis. I've already written about the openly available data sets generated for the work.

(Image courtesy of NASA)

Data sets from my dissertation

2014-08-11T15:03:00.003+00:00

This past week I successfully defended my doctoral dissertation. Two of the three direct numerical simulation data sets I generated during my thesis research are online at turbulence.ices.utexas.edu if anyone's interested:

Sub- through Supersonic Coleman-like Channels

2014-06-05T18:46:00.003+00:00

I finally cleaned up my compressible, turbulent channel results computed with my thesis code, Suzerain. The dataset includes instantaneous planar averages of 180+ quantities collected in situ during the production runs along with rigorous sampling error estimates for the final ensemble results.

If you want to quickly visualize something, a little wrapper utility makes it a snap. So, without further ado, gratuitous eye candy generated with summary_surf.py -C 256 -f coleman3k15.h5 bar_u_v bar_u bar_v:

Installing Chromium under $HOME on RHEL 6-ish x86_64 systems

2014-04-10T13:52:00.000+00:00

Based upon Install Chromium (with Pepper Flash) on CentOS/Red Hat (RHEL) 6.5 with modifications to permit non-root usage...

mkdir ~/workaround && cd ~/workaround
wget http://people.centos.org/hughesjr/chromium/6/x86_64/RPMS/chromium-31.0.1650.63-2.el6.x86_64.rpm # 32-bit seemingly in repo too
rpm2cpio chromium-31.0.1650.63-2.el6.x86_64.rpm | cpio -idmv
./opt/chromium-browser/chromium-browser # Bombs on sandboxing complaints
./opt/chromium-browser/chromium-browser --no-sandbox # Confirm behaves for you
mv ./opt/chromium-browser ~ # Moving the whole directory into a permanent location
echo '#/bin/sh' > ~/bin/chromium-browser # Assuming you have ~/bin in your path
echo 'exec $HOME/chromium-browser/chromium-browser --no-sandbox "$@"' >> ~/bin/chromium-browser
chmod a+x ~/bin/chromium-browser
chromium-browser http://www.google.com & # Rejoice
cd && rm -rf ~/workaround # Hygiene

The are glaring drawbacks to running Chromium with --no-sandbox so don't do it without considering its implications.

Twelfth

2014-03-29T23:05:00.002+00:00

A fun holdover from the days when I was last gainfully employed-- the 12th patent on which I'm part inventor was issued earlier this month: Converged call flow modeling and converged web service interface design.

I {hate,heart} NaN

2014-03-28T02:42:00.000+00:00

For two week's I've intermittently been tracking down an issue where suddenly a flow profile goes from turbulent/sane to a uniform flow profile in a single time step.

For awhile now I've been running with a custom banded solver that permits

mixed precision factorization
use of approximate factorizations, and
iterative refinement.

Relative to ZGBSVX this has been a net win. I get firm control over the quality of my linear system solutions and save a factor of 10 (yes, 10) over LAPACK's Cadillac banded solve.

It turns out that I didn't harden my one-off solver against NaNs. Ah, NaNs. Those lovely things that can make puzzling things like the following happen to a simulation:

The problem wasn't the NaN showing up in a computation, as I'd notice that. The problem was NaN showing up in a residual computation. Necessarily, that NaN failed a residual tolerance check. Because the tolerance check was false, I'd kick back a linear solution consisting of all zeros from an initial solution residual calculation that I'd performed.

What happened next was a comedy of my best intentions. I had a forcing constraint set so that if my solution failed to match my freestream, the state profile was forced to match. As my solution was all zeros, that NaN residual combined with the forcing caused my solution to become the freestream in a single time step. And suddenly my simulations went from sane to uniform instantaneously.

This came to me on the motorcycle while riding home after a rough day.

I simultaneously love and hate the beauty that is floating point.

helm: a proportional-integral-derivative controller implementation

2014-03-17T06:10:00.001+00:00

The class of homogenized boundary layer models I'm using in my thesis (developed by Spalart, made compressible by Guarini et al, and most recently extended by Topalian et al) has an adjustable knob called a "slow growth rate" that controls the thickness of the boundary layer. One can manually fiddle with it. One can use RANS simulations and hope that the value obtained produces something similar in a DNS. I aim to apply some basic control theory by bolting a PID controller onto my simulations.

It turns out everybody and their brother intuitively derive the equations governing a basic PID controller. Then they wave their hands a bit about how to solve windup woes, bumpless transition, and deal with incremental/velocity forms. Not that it doesn't work, but they drift away from the continuous equations to do so. Then they cough up O(10) lines of code assuming a constant, discrete sampling rate.

To permit variable sampling and understand where/how the fixes are made, I dug around until I found a nice treatment in Astrom & Murray (Available online), wrote up the variant of their PID derivation that I needed including the discretization, coded up the algorithm, and then put together a small test driver.

Aside from vanilla C99, the implementation has no dependencies. I hope someone else can put it to use.

One bit

2014-03-16T18:51:00.004+00:00

Despite coding being proverbially all zeros and ones, it's not often that a single, isolated bit is damning.

Today, however, I spent four hours tracking down where I wrote 0 when I should have written 1.

Python generator functions abstracting Python-ish vs C++-ish syntax

2014-02-01T21:58:00.002+00:00

Today, I've been attaching a parser to some SymPy-based logic for obtaining uncertainty propagation expressions based upon Taylor Series Methods. While SymPy is happy to parse Python-ish files, I've already got the expressions I want to manipulate coded up in C++. I'd like to permit parsing either Python-ish or C++-ish input in a manner that gives useful file/line information whenever SymPy dislikes the content.

The Python yield keyword provides a really clean mechanism to abstract away such differences in file syntax:


# TODO Line continuation via trailing backslash
def statements_by_newline(files=None):
    r'''
    Generate (filename, lineno, statement) tuples by parsing the provided
    filenames with newline-separated, whitespace-trimmed statements.
    Comments are introduced by a '#' and extend until the end of line.

    >>> with tempfile.NamedTemporaryFile() as f:
    ...     print("""a=1       # Trailing comments
    ...                        # Not every line must have a statement
    ...              f         # Nor every line involve assignment
    ...           """, file=f)
    ...     f.flush()
    ...     for (_, lineno, stmt) in statements_by_newline(f.name):
    ...         print(lineno, stmt)
    1 a=1
    3 f
    '''
    # Process input line-by-line...
    f = fileinput.FileInput(files)
    for line in f:

        # ...remove comments occurring after the first '#' character
        line, _, _ = line.partition('#')

        # ...trim then yield statement only on nontrivial line
        line = line.strip()
        if line:
            yield (f.filename(), f.filelineno(), line)


# TODO Behavior on lingering statement content without semicolon
  def statements_by_semicolon(files=None):
      r'''
      Generate (filename, lineno, statement) tuples by parsing the provided
      filenames with semicolon-separated, whitespace-trimmed statements.
      Comments are introduced by a '//' and extend until the end of line.
  
      >>> with tempfile.NamedTemporaryFile() as f:
      ...     print("""a=1;      // Trailing comments may include ';'
      ...              b =       // Statements may span lines
      ...                  c;
      ...              1;2;;     // Multiple may appear with empty ignored
      ...           """, file=f)
      ...     f.flush()
      ...     for (_, lineno, stmt) in statements_by_semicolon(f.name):
      ...         print(lineno, stmt)
      1 a=1
      3 b = c
      4 1
      4 2
      '''
      # Process input line-by-line maintaining any active statement...
      f = fileinput.FileInput(files)
      stmt = []
      for line in f:
  
          # ...remove comments defined as the first '//' observed
          line, _, _ = line.partition('//')
  
          # ...and yield any statements separated by semicolons
          # being careful to permit continuation from prior lines.
          while line:
              head, sep, line = line.partition(';')
              head = head.strip()
              if head:
                  stmt.append(head)
              if sep and stmt:
                  yield (f.filename(), f.filelineno(), ' '.join(stmt))
                  del stmt[:]

Quite slickly, one can now write


def parser(statements_generator):
    for (filename, lineno, stmt) in statements_generator:
        try:
            pass # Manipulate stmt with SymPy
        except SyntaxError as e:
            e.filename = filename
            e.lineno   = lineno
            raise

producing somewhat usable error messages even though the SymPy handling bits know nothing about the original file syntax.

-fplan9-extensions

2013-12-16T22:49:00.000+00:00

While reading 21st Century C, which shows some nice GCC extensions for stuffing anonymous struct members inside structs, I happened across -fplan9-extensions:

One can smell the homespun vtable lurking in the OOP use case...

Dos

2013-12-12T18:48:00.001+00:00

About a week back, my wife gave birth to our second son Oxford C Thomas Ulerich.

First, pensive:

Second, at maximal yawn:

Driving a GSL Root Finder

2013-12-12T18:40:00.000+00:00

The GNU Scientific Library one-dimensional root finding routines are handy, but I never remember how to drive them properly. Here is what I essentially always end up re-distilling from the examples:

int fsolver_solve(
        gsl_root_fsolver * const s,
        gsl_function     * const f,
        const size_t             maxiter,
        const double             epsabs,
        const double             epsrel,
        double           * const lower,
        double           * const upper,
        double           * const root)
{
    // Initialize fsolver on [lower, upper]
    gsl_error_handler_t * h = gsl_set_error_handler_off();    // Push handler
    int status = gsl_root_fsolver_set(s, f, *lower, *upper);
    status = (GSL_SUCCESS == status) ? GSL_CONTINUE : status;

    // Proceed until success, failure, or maximum iterations reached
    // On success, overwrite *location as described in API documentation.
    *root = GSL_NAN;
    for (size_t iter = 1; iter <= maxiter && status == GSL_CONTINUE; ++iter) {
        if (GSL_SUCCESS != (status = gsl_root_fsolver_iterate(s))) break;
        *lower = gsl_root_fsolver_x_lower(s);
        *upper = gsl_root_fsolver_x_upper(s);
        status = gsl_root_test_interval(*lower, *upper, epsabs, epsrel);
    }
    if (status == GSL_SUCCESS) {
        *root = gsl_root_fsolver_root(s);
    }
    gsl_set_error_handler(h);                                 // Pop handler
    return status;
}

Generating the Blasius boundary layer profile

2013-10-15T02:10:00.002+00:00

I've been working on some boundary layer edge detection routines for Suzerain and wanted to use the Blasius boundary layer as a test case. The Blasius boundary layer produces a slick ODE that can only be solved numerically. Ganapol has a nice article on it and the more general Falkner—Skan equation. He also presents some nice tabulated data which I'd fit with an Akima, but I've found that (surprise surprise) the Akima natural end conditions disturb the second derivative of my fits sufficiently that it makes my test cases lousier than I'd like. Since Ganapol was the nicest tabulated Blasius data that I'd seen (meaning lots of digits, large similarity coordinate eta) and it didn't meet my needs, I set off to generate more (comparable number of digits, even larger similarity coordinate) using the GNU Scientific Library's ODEIV2 capabilities:

This code produces output matching Ganapol's everywhere to a minimum of eight digits. So though I'm reporting more than eight here, do not trust more than eight. The results are:

                   eta                       f                      fp                     fpp
0.0000000000000000e+00  0.0000000000000000e+00  0.0000000000000000e+00  3.3205733621519629e-01
2.0000000000000001e-01  6.6409997145970585e-03  6.6407792096250848e-02  3.3198383711462798e-01
4.0000000000000002e-01  2.6559884017994733e-02  1.3276416076102221e-01  3.3146984420145503e-01
6.0000000000000009e-01  5.9734637498038382e-02  1.9893725242221899e-01  3.3007912757429625e-01
8.0000000000000004e-01  1.0610822083904069e-01  2.6470913872311741e-01  3.2738927014925229e-01
1.0000000000000000e+00  1.6557172578927976e-01  3.2978003124966698e-01  3.2300711668694282e-01
1.2000000000000002e+00  2.3794871728892703e-01  3.9377610443395650e-01  3.1658919106111544e-01
1.4000000000000001e+00  3.2298157382953580e-01  4.5626176470513380e-01  3.0786539179016786e-01
1.6000000000000001e+00  4.2032076550162573e-01  5.1675678442261486e-01  2.9666346145571931e-01
1.8000000000000000e+00  5.2951803774381023e-01  5.7475814388945690e-01  2.8293101725975589e-01
2.0000000000000000e+00  6.5002436993528900e-01  6.2976573650238588e-01  2.6675154569727827e-01
2.2000000000000002e+00  7.8119333701057347e-01  6.8131037723602750e-01  2.4835091319037131e-01
2.4000000000000004e+00  9.2229012563454160e-01  7.2898193506257503e-01  2.2809176068668360e-01
2.6000000000000001e+00  1.0725059767878351e+00  7.7245502114856535e-01  2.0645462679942550e-01
2.8000000000000003e+00  1.2309773023143091e+00  8.1150962319910902e-01  1.8400659386536070e-01
3.0000000000000000e+00  1.3968082308703464e+00  8.4604444365799358e-01  1.6136031954087834e-01
3.2000000000000002e+00  1.5690949600067619e+00  8.7608145517247749e-01  1.3912805557242577e-01
3.4000000000000004e+00  1.7469500939488432e+00  9.0176122143676474e-01  1.1787624608752340e-01
3.6000000000000001e+00  1.9295251697605302e+00  9.2332966588164878e-01  9.8086278784280084e-02
3.8000000000000003e+00  2.1160298171720697e+00  9.4111799672931340e-01  8.0125918139197061e-02
4.0000000000000000e+00  2.3057464184620726e+00  9.5551822981069434e-01  6.4234121091690577e-02
4.2000000000000002e+00  2.4980396627069701e+00  9.6695707375360584e-01  5.0519747486645686e-02
4.4000000000000004e+00  2.6923609375430866e+00  9.7587083213647785e-01  3.8972610853629498e-02
4.6000000000000005e+00  2.8882479900178160e+00  9.8268350076070032e-01  2.9483772011648642e-02
4.8000000000000007e+00  3.0853206551774823e+00  9.8778952620078742e-01  2.1871186347443238e-02
5.0000000000000000e+00  3.2832736651563144e+00  9.9154190016439347e-01  1.5906798685318153e-02
5.2000000000000002e+00  3.4818676115086635e+00  9.9424553535992810e-01  1.1341788968929135e-02
5.4000000000000004e+00  3.6809190628975084e+00  9.9615530396275309e-01  7.9276598147061551e-03
5.6000000000000005e+00  3.8802906776333757e+00  9.9747776821291501e-01  5.4319576799275147e-03
5.8000000000000007e+00  4.0798819392396917e+00  9.9837549365019085e-01  3.6484136667473462e-03
6.0000000000000000e+00  4.2796209225138426e+00  9.9897287243586053e-01  2.4020398437572996e-03
6.2000000000000002e+00  4.4794572972826767e+00  9.9936254171909067e-01  1.5501706906563828e-03
6.4000000000000004e+00  4.6793566154314172e+00  9.9961170171767588e-01  9.8061511700977232e-04
6.6000000000000005e+00  4.8792958110602429e+00  9.9976787021003244e-01  6.0804426478449074e-04
6.8000000000000007e+00  5.0792597724490030e+00  9.9986381903703803e-01  3.6956257014031428e-04
7.0000000000000000e+00  5.2792388110290958e+00  9.9992160414794995e-01  2.2016895527113460e-04
7.2000000000000002e+00  5.4792268473431696e+00  9.9995571727792665e-01  1.2856980723515674e-04
7.4000000000000004e+00  5.6792201473338295e+00  9.9997545768489782e-01  7.3592983389223794e-05
7.6000000000000005e+00  5.8792164658040509e+00  9.9998665513912843e-01  4.1290311113698544e-05
7.8000000000000007e+00  6.0792144810719346e+00  9.9999288116610119e-01  2.2707751402803766e-05
8.0000000000000000e+00  6.2792134313460615e+00  9.9999627453530060e-01  1.2240926243249920e-05
8.2000000000000011e+00  6.4792128866784848e+00  9.9999808745923757e-01  6.4679786108453658e-06
8.4000000000000004e+00  6.6792126094414330e+00  9.9999903687484326e-01  3.3499397531974408e-06
8.5999999999999996e+00  6.8792124710150580e+00  9.9999952424780447e-01  1.7006679885717248e-06
8.8000000000000007e+00  7.0792124032167214e+00  9.9999976948975089e-01  8.4628412130585306e-07
9.0000000000000000e+00  7.2792123706452294e+00  9.9999989045379900e-01  4.1278790156475232e-07
9.2000000000000011e+00  7.4792123552968919e+00  9.9999994893901312e-01  1.9735668380412326e-07
9.4000000000000004e+00  7.6792123482031105e+00  9.9999997665715090e-01  9.2489158677487331e-08
9.6000000000000014e+00  7.8792123449874136e+00  9.9999998953401714e-01  4.2485812620375726e-08
9.8000000000000007e+00  8.0792123435577192e+00  9.9999999539788897e-01  1.9129831304430804e-08
1.0000000000000000e+01  8.2792123429343132e+00  9.9999999801539019e-01  8.4429158651022967e-09
1.0200000000000001e+01  8.4792123426677222e+00  9.9999999916068538e-01  3.6524803913092198e-09
1.0400000000000000e+01  8.6792123425559158e+00  9.9999999965190545e-01  1.5488074704694815e-09
1.0600000000000001e+01  8.8792123425099305e+00  9.9999999985842569e-01  6.4375569794427733e-10
1.0800000000000001e+01  9.0792123424913829e+00  9.9999999994353506e-01  2.6227617757128940e-10
1.1000000000000000e+01  9.2792123424840440e+00  9.9999999997791622e-01  1.0473955128094568e-10
1.1200000000000001e+01  9.4792123424811994e+00  9.9999999999153044e-01  4.0999322474265197e-11
1.1400000000000000e+01  9.6792123424801169e+00  9.9999999999681477e-01  1.5731015212516414e-11
1.1600000000000001e+01  9.8792123424797147e+00  9.9999999999882527e-01  5.9163099772618016e-12
1.1800000000000001e+01  1.0079212342479567e+01  9.9999999999957512e-01  2.1810177063481187e-12
1.2000000000000000e+01  1.0279212342479513e+01  9.9999999999984923e-01  7.8810042675859475e-13
1.2200000000000001e+01  1.0479212342479494e+01  9.9999999999994749e-01  2.7913740190928823e-13
1.2400000000000000e+01  1.0679212342479486e+01  9.9999999999998201e-01  9.6910000670083129e-14
1.2600000000000001e+01  1.0879212342479486e+01  9.9999999999999389e-01  3.2978678842745192e-14
1.2800000000000001e+01  1.1079212342479485e+01  9.9999999999999789e-01  1.1000489193601443e-14
1.3000000000000000e+01  1.1279212342479484e+01  9.9999999999999922e-01  3.5967050786090774e-15
1.3200000000000001e+01  1.1479212342479485e+01  9.9999999999999967e-01  1.1526879056075572e-15
1.3400000000000000e+01  1.1679212342479484e+01  9.9999999999999978e-01  3.6210349563133137e-16
1.3600000000000000e+01  1.1879212342479484e+01  9.9999999999999978e-01  1.1149817624085130e-16

If you look at the last two rows of fp you'll see that double precision has most likely run out of steam by eta = 13.4. Using gsl_odeiv2_step_rk4imp or some other choice instead of gsl_odeiv2_step_rk8pd will tend to cause the solver to fail somewhere before here rather than to simply stop producing updated values in fp. Interestingly, gsl_odeiv2_step_rk8pd will run out to about eta = 38.6 producing fpp = 1.35e-155 before fpp becomes non-decreasing (indicating the physics is glaringly b0rked as opposed to just wholly b0rked).

For want of a 2-line patch...

2013-10-07T14:40:00.003+00:00

There's been much brouhaha about the Dread Pirate Roberts getting partially nabbed for using Stack Overflow. What struck me most about his question is he asked it only because PHP was missing a numeric constant, CURLPROXY_SOCKS5_HOSTNAME, which it should have had. Sure enough, there's an unaddressed bug (as of PHP 5.5.4) about the missing constant with an attached patch:

Developer: dr.scre@yandex.com

--- interface.c 2013-08-16 00:42:04.000000000 +0400
+++ interface_my.c 2013-08-18 03:12:28.948548811 +0400
@@ -827,6 +827,8 @@
  REGISTER_CURL_CONSTANT(CURLPROXY_HTTP);
  REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS4);
  REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS5);
+ REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS4A);
+ REGISTER_CURL_CONSTANT(CURLPROXY_SOCKS5_HOSTNAME);
 
  /* Curl Share constants */
  REGISTER_CURL_CONSTANT(CURLSHOPT_NONE);

For want of a 2-line patch, a $1.2B empire was lost.

On Working in the Dark.

2013-09-24T04:01:00.000+00:00

At 7 PM tonight, despite my father's long-standing advice about working on things when pressed for time, I start futzing with the right turn signal switch on a recently-new-to-me '99 BMW R1100S. The switch has been skittish the last two days. It's no fun to find out that traffic doesn't think you're switching lanes when you think you've been clearly signalling it for an eighth of a mile. Michelle has to leave to teach yoga at 7:45 PM. This leaves me forty-five minutes to work before I must watch the kiddo. Night is about to fall. Sans garage, I'm working in the driveway.

I have the handlebar control assembly down to the switch innards apart in five minutes, see some grime, and decide to make a run for some electrical cleaner rather than to try my luck applying to the contact surfaces the fine-grit sandpaper that I brought outside. To give Michelle a chance to get ready to teach, I snag the two-and-a-half-year-old in his PJs and we go by car to an auto store on East 7th. After a long, slow line, we're back at 7:30. I get the switch cleaned out (after accidentally shooting electrical cleaner into a hangnail. Don't. Ever. Do. This.) and start putting stuff back together.

Now it's getting dark. Michelle brings out a flashlight. I get the electrical bits back together. Michelle has to leave and brings out our shoeless son Ozark, his Magna Doodle, and his wooden toy pliers. She coaxes Ozark into staying put next to me on the driveway and takes off. He miraculously stays out of the small collection of bike parts and is content to play around on the driveway while I chew on a flashlight trying to point it in the right direction as I re-insert screws and curse the finicky-to-button-up assembly. Ozark disappears over to the left side of the bike and is farting around with his wooden pliers near the left fork. I ask him to come around to my side and he ignores me. No matter as he's being uncommonly good. I periodically inquire what he's up to and he responds promptly.

At 7:55 I get everything back together well-enough that the repair will sit for the night and I can double check it in the morning. I'm elated that nothing bad happened on a hurry-up repair job in the dusk. This has never happened to me in my life.

Suddenly, I hear a weird scritching sound. I ask Ozark what he's doing. Out of the dark on the far side of the bike a little voice proudly replies "I'm sanding the motorcycle". He's got the fine-grit sandpaper and is rubbing it against the fairing near the front headlight. Fortunately the cosmetic damage is light. I crack up. He cracks up. I call my dad to convey the story. Ozark re-cracks up when he hears my dad crack up on the phone. Then the kiddo and I go inside and drink far too much chocolate milk.

An iostream insertion wrapper to provide full-precision floating point output for C++

2013-09-13T20:35:00.000+00:00

In C++ one often wants output full precision floating point data. Iostreams make this a pain. Especially when you'd like the results to line up nicely in your terminal without requiring everything to be in scientific notation. Because reading "12" as 12 is easier than parsing 1.2e+01.

From my research code Suzerain, here's a header-only stream insertion wrapper up to the task. First, a simple use case with output:

using suzerain::fullprec;
cout << fullprec<>(1.23456789012345678e-5) << endl; // "   1.23456789012e-05"
cout << fullprec<>(1.23456789012345678e-4) << endl; // "   1.23456789012e-04"
cout << fullprec<>(1.23456789012345678e-3) << endl; // "   1.23456789012e-03"
cout << fullprec<>(1.23456789012345678e-2) << endl; // "   0.012345678901235"
cout << fullprec<>(1.23456789012345678e-1) << endl; // "   0.123456789012346"
cout << fullprec<>(1.23456789012345678e+0) << endl; // "   1.234567890123457"
cout << fullprec<>(1.23456789012345678e+1) << endl; // "  12.345678901234567"
cout << fullprec<>(1.23456789012345678e+2) << endl; // " 123.456789012345681"
cout << fullprec<>(1.23456789012345678e+3) << endl; // "   1.23456789012e+03"
cout << fullprec<>(1.23456789012345678e+4) << endl; // "   1.23456789012e+04"
cout << fullprec<>(1.23456789012345678e+5) << endl; // "   1.23456789012e+05"

Now the code. You'll need to swap real_t for double in your context as suzerain::real_t is defined elsewhere.

Worst open source release ever: Suzerain

2013-09-12T04:55:00.000+00:00

Though it's far from in a public-ready state, I'm tired of my research code, Suzerain, having no public presence whatsoever:

Wiki
Roadmap
Issue Tracking
Bitbucket Repository (though a word of caution-- the main repository is still private and this is a mirror)
GitHub Repository (ditto, because who can pick between 'em, right?)
Google Group

Though primarily my baby up until a year ago, the cast of characters now includes all of whom are affiliated with The Center for Predictive Engineering and Computational Science (PECOS) within The Institute for Computational Engineering and Sciences (ICES) at The University of Texas at Austin.

This work is supported by the Department of Energy [National Nuclear Security Administration] under Award Number [DE-FC52-08NA28615].

Somewhat taming the bump function's derivatives

2013-09-11T15:05:00.001+00:00

Often I need to initialize some smooth pulse in a simulation. Today, for example, I'm working with acoustic and entropy pulses to test the effectiveness of nonreflecting boundary conditions for the Euler equations (see, e.g., Baum et al). Bump functions are nice for this purpose as they're infinitely smooth and have compact support.

Awhile back I realized that using just a classical bump function produced large gradients which had to be resolved. Years ago I used Mathematica to see if taking some power of the classical bump function, which remains infinitely smooth, could produce smaller gradients better suited for numerical use.

The punchline is that using the fourth power of the bump function, BumpPower[4] in the following parlance, is Goodness (TM). The following Mathematica notebook demonstrates the problem and discusses how one arrives at this empirical result:

The obligatory XMonad configuration post

2013-08-13T01:20:00.002+00:00

Since I've been loving XMonad for the past several months on a 2-up desktop and a 1-up laptop, here's the obligatory personal XMonad configuration post:

General comments:

This started from the vanilla, session-manager-aware Fedora XMonad configuration.
The Windows key is the modifier.
The default dmenu_run key, mod-p, interferes with some monitor-swapping hotkey on Ubuntu. Hence the second keymapping.
Toggling maximization in one keypress has been handy.
I like the mod+arrow combinations better than the suggested CycleWS ones. Rather than moving through a bunch of empty workspaces, these permit you to just move through workspaces with windows and to get a clean workspace with a single keypress. Much thanks to Marshall Lochbaum and Brandon Allbery for chiming in on the XMonad mailing list with the followTo implementation.
The prev/next screen items permit throwing windows back and forth when 2-up.
I find the REFLECTX binding handy when 2-up to push the non-main chat window off to the leftmost monitor position.
Layout.Tabbed's simpleTabbed is additionally available as a layout option.
New windows spawn outside the master pane with the master window keeping focus.

Please drop a comment if you happen to find anything useful or want to contribute a tweak.

Python should have Haskell's $ operator

2013-07-24T14:38:00.001+00:00

In Python, I often want to repeatedly say "apply some function to the remainder of the current statement". Think foo(bar(baz(qux, quux))). In my text editor, which mostly automatically handles the parenthesis correctly, this is a quick thing to type.

Within IPython, statements like that are tedious. IPython does have a limited version of this in its automatic parenthesis feature. Notice how many syntax error gotchas lurk in those examples.

Haskell's $ operator is pretty sweet. All of the following are equivalent in Haskell:

putStrLn (show (1 + 1))
putStrLn (show $ 1 + 1)
putStrLn $ show (1 + 1)
putStrLn $ show $ 1 + 1

Python should adopt Haskell's $ operator. That is, the following should be equivalent:

foo(bar(baz(qux, quux)))
foo $ bar $ baz(qux, quux)
foo $ bar $ baz $ qux, quux

Though odd looking, there's easy consistency for unary functions:

foo()
foo $

Haters of the new-ish print might find respite in print $ foo.

Plus ça change.org

2013-06-26T04:13:00.001+00:00

This past fall I spun up a change.org petition entitled 83rd Texas State Legislature: Reduce traffic congestion by legalizing lane-splitting for motorcycles. As of right now, 1,664 people signed the petition. Sadly, despite gathering this tome of names and much late-night letter writing to both newspapers and elected officials, the Texas legislature didn't introduce the desired bill.

But there may be hope for the 84th legislature in two years... Today I got an unexpected and very cool email from the office of Senator Kirk Watson. Watson said he'll try to get lane splitting formally studied between now and the next legislature. I'll redefine success to match this outcome and claim it. The full message follows.