Voluntocracy

"Mathematical Marbling" to appear in IEEE Computer Graphics and Applications

2011-12-25T20:12:00.000-08:00

A paper on marbling, which I wrote with Shufang Lu, Xiaogang Jin, Hanli Zhao, and Xiaoyang Mao has been accepted for publication:

Lu, S.; Jaffer, A.; Jin, X.; Zhao, H.; Mao, X.; ,
"Mathematical Marbling,"
Computer Graphics and Applications, IEEE , vol.PP, no.99, pp.1, 0
doi: 10.1109/MCG.2011.51
http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=5887299&isnumber=5185484

The Colors of Heat

2011-11-30T19:49:00.000-08:00

Hot objects can glow visibly. Heat Colors for Blacksmiths shows images of mild steel at various temperatures.

At a given temperature, a blackbody will emit more light than any other surface. The table below shows the colors of a blackbody at exponentially decreasing absolute temperate. The left column of colors is how they would naturally appear. The top color is a sky blue, which has a color temperature of approximately 10000 K.

In the right column, each temperature's chromaticity is scaled proportionally to its Celsius temperature.

Read more at http://people.csail.mit.edu/jaffer/Color/Heat.

Script to Monitor Websites

2011-08-20T18:46:00.000-07:00

As the maintainer of several websites, it is annoying to learn that a website has been down for hours or days only by email from a frustrated member of the browsing public.

What is needed is an automated method to periodically check websites and notify me when their status changes (up or down). This method must involve a computer other than the one hosting the website, because a stopped computer can't notify me of anything.

I have created a Unix script "wstatus" to be run periodically by crontab. Its first argument is a URL to retrieve from the website; the second is the email address to send notifications to. The wstatus script puts small files in a $(HOME)/.status/ directory (.status in your home directory).

The crontab entry:

*/10 * * * * $HOME/bin/wstatus http://voluntocracy.org/server-status.txt jaffer@localhost

reads "server-status.txt" from "http://voluntocracy.org" every 10 minutes. If the content or error retrieved differs from the last, then the first line of that content or error is emailed to me (locally). "server-status.txt" contains just the line "voluntocracy.org is up!".

I wonder how often my ISP changes my IP-address:

25 * * * * $HOME/bin/wstatus http://automation.whatismyip.com/n09230945.asp jaffer@localhost

checkes once an hour (at 25 minutes past). Of course, if I move my computer to another network, I get an email notifying me of the change. If you use automation.whatismyip.com, be sure to observe their rule: We ask that automated files hit our site no more then once every five minutes or once every 300 seconds.

The early version of wstatus consisted of just the black code below. But it occasionally sent two email notices for a single change of status when the cron period was small. I believe this happens because cron starts its child processes with less (numerically higher) priority than users have; and these processes queue up while higher priority jobs are running.

The code in red was added to dismiss a wstatus process if another is already running. Among the basic Unix file commands, only rm (ReMove file) returns a status allowing it to be used as a mutex. Thus, to grab the mutex the script tries to remove a file with the extension ".idl". If it succeeded, the script continues to run; otherwise it exits immediately.

This will work except if the script is interrupted and does not restore the ".idl" file. To handle this case, the line in green was added to restore the ".idl" file when the script exits because it doesn't grab the mutex. Whereas the code without the green line will generate only one email per change no matter how many wstatus processes are running simultaneously, with the green line, only suppression of the second wstatus process is guaranteed. If it is the case that double processes occur more frequently than higher multiples, then this approach is reasonable.

wstatus

#! /bin/sh

# Copyright (C) 2011 Aubrey Jaffer

if test -z "$1"; then

    echo "$0: Missing URL (first) argument" 1>&2

    exit 1

elif test -z "$2"; then

    echo "$0: Missing email (second) argument" 1>&2

    exit 1

fi

host=`echo $1 | sed 's%.*//%%' | sed 's%/.*%%'`

sfile=${HOME}/.status/${host}-status.txt

mfile=${HOME}/.status/${host}-status.idl

mkdir -p ${HOME}/.status/

if test -f ${sfile}; then

    if ! rm ${mfile} > /dev/null 2>&1; then

        touch ${mfile}

        exit 0

    fi

    cp -f ${sfile} ${sfile}~

fi

if ! wget -q -T 30 -O- $1 > ${sfile} 2>&1; then

    echo could not reach \"`echo $1 | sed 's%.*//%%'`\" > ${sfile}

fi

if ! (test -f ${sfile}~ && diff -q ${sfile}~ ${sfile} >/dev/null 2>&1;) then

    mail -s "`head -1 ${sfile}`" $2 < ${sfile}

fi

touch ${mfile}

The use of rm as a mutex is rare, perhaps novel. I have not tested whether rm is actually atomic; but even if it isn't, it reduces by an order of magnitude the window of opportunity for repeated messages from wstatus.

Recurrence for Multidimensional Self-Similar Functions

2011-07-06T20:03:00.000-07:00

Staring at this diagram of the Peano space-filling curve inspired the recurrence formula, something I have been seeking for a couple of years. It remains to derive the inverse function and generalize the recurrence to produce Hilbert space-filling functions as well.

If the unit cell is a Hamiltonian Path, the resulting function is a space-filling curve. Functions resulting from unit cells which don't connect all their nodes are still self-similar (fractal).

Once the formula was discovered, creating a better space-filling curve, one which is nearly isotropic, is not difficult. This may not be novel in 2 dimensions, but the higher dimensional varieties are.

Free Convection from Rectangular Plate

2011-06-12T12:20:00.000-07:00

Have completed a milestone in theory of convection (corrected 2012-01-08) http://people.csail.mit.edu/jaffer/SimRoof/Convection/:

Free convection correlations for inclined rectangular plates involve characteristic-lengths L_H, L_W, and L* (area divided by perimeter). Each correlation is computed using its own characteristic-length. Flows are then compared and selected as convective surface-conductances (h).

Proposed is the complete free convective surface conductance for one side of a flat L_H by L_W rectangular isothermal plate inclined θ around the level edge which is L_W long.

L* =	L_H⋅L_W / (2 (L_H+L_W))
R =	min(L_H, L_W)/2
Pr =	c_p⋅μ/k
Ra(L) =	\|ΔT\|⋅g⋅ρ²⋅c_p⋅L³ / (T⋅μ⋅k)
HHT(Ra) =		{0.65 + 0.36 Ra*^1/6}²		1≤Ra*≤1.5×10⁹	θ=−90°
T9.3(Ra) =	{.825 +	.387 Ra^1/6 [1+(.492/Pr)^9/16]^8/27	}²	1≤Ra≤10¹²	θ=0°
Nu₄₅(Ra) =		0.544 Ra^1/5 [1+(0.785/Pr)^3/5]^1/3			θ=+90°

h= k⋅max(	Nu₄₅(Ra(R)) R	,	T9.3(Ra(L_H) cos θ) L_H	)		0°≤θ≤90°		UCT3
h = k⋅max(	HHT(Ra(L) sin(−θ)) L*	,	T9.3(Ra(L_H) cos θ) L_H	)		−90°≤θ≤0°		UHT3

Excess Fructose Content of Foods

2011-05-08T19:57:00.000-07:00

Fructose and glucose are simultaneously absorbed in equal amounts by the intestines. Excess fructose is absorbed by a different mechanism. In individuals with fructose malabsorption, excess fructose remains in the intestines where fermentation causes gastric distress.

Glucose requires insulin to be absorbed from the bloodstream, while fructose does not. There has been vigorous debate as to whether individuals with Diabetes mellitus (a metabolic disease characterized by high blood sugar) should consume or avoid fructose.

In any case, it would be interesting to have a chart showing the spectrum of fructose-heavy to glucose-heavy foods.

The USDA National Nutrient Database gives nutrient values for 7636 foods; but only 1134 of them have fructose and glucose values.

This database was used to create a table of the 1134 foods having fructose and glucose values. The foods are listed in order of decreasing amount of excess fructose.

The database doesn't give data for High Fructose Corn Syrup. Used mostly in soft drinks, HFCS 55 is composed of approximately 55% fructose and 42% glucose. This would give it a 13% excess of fructose, comparable to the 15% and 20% fructose excesses of lemonade powders near the top of the chart.

When dried, the Agave americana plant pictured above has the most excess fructose (39%) of the foods in the database.

Design Pattern for Multi-Format Extract-Transform-Load

2011-03-23T19:00:00.000-07:00

Presented is a design-pattern for single-pass extract-transform-load (ETL) processing of line-oriented files which automatically detects the line format, but which does not require any domain-specific code devoted to deciding the format of the input file.

The Color-Name Dictionaries web-page analyzes and compares more than 3 dozen color dictionaries from book and online sources. The dictionary sources are in 19 (plain-text and HTML) formats. The largest is the "NBS/ISCC Dictionary of Color Names" with 5411 color names; and there are several with over 1300 names. Some color dictionaries are updated or added every year.

The dictionary files share these characteristics:

Each color-name entry appears on a single line.
All the intended color-name entries in a file have the same
format.
A Preamble and comments may be mixed with the color-name
entries.

There are format errors, inconsistencies, duplicates, and collisions (where a color name is repeated with different color coordinates) in some of the files. In spite of this, file->color-dictionary and url->color-dictionary in the SLIB color-database module are able to automatically detect the format and extract and clean the data and insert it into relational tables. This is accomplished in an easy-to-extend fashion using closures. This code is written in Scheme, but the same idea should work in any language with closures.

The main ETL loop has port bound to an input-stream reading from the dictionary source file:

        (do ((line (read-line port) (read-line port)))
            ((eof-object? line)
             (display "Inserted ") (display *idx*) (display " colors") (newline)
             *rcs-header*)
          (let ((colin (parse-rgb-line line)))
            (cond ((equal? "" line))
                  ((not colin) (write-line line))
                  ((numbered-gray? (cadr colin)))
                  (else
                   (for-each
                    (lambda (name)
                      (let ((oclin (color-table:row-retrieve name)))
                        (cond
                         ((and oclin (equal? (car colin) (cadr oclin))))
                         ((not oclin)
                          (set! *idx* (+ 1 *idx*))
                          (color-table:row-insert
                           (list name (car colin) *idx*)))
                         (else (slib:warn 'collision colin oclin)))))
                    (cdr colin))))))

The do loop iterates over the lines read from port, calling parse-rgb-line on each. The call to parse-rgb-line returns false unless the line was parsed as a valid color-dictionary line. If it returns false, line is printed to the log. If it returns a data row, each name in the row is checked for an existing table entry; if it matches, nothing is done; if it doesn't match, a warning is generated; if there is no entry, then it is created.

    (define (parse-rgb-line line)
     ...
        (for-each
         (lambda (method)
           (or ans
               (let ((try (method line)))
                 (cond (try (set! ans try)
                            (display "**** Using method ")
                            (display method-id) (newline)
                            (set! parse-rgb-line method))))))
         (list
          (lambda (line) ...)
          (lambda (line) ...)
          ...
         )))

The construction of parse-rgb-line is a bit unusual. The for-each procedure calls its first argument (lambda (method) ...) with each function (lambda (line) ...) in the list which is its second argument. The first-argument procedure returns immediately if ans is not false. Otherwise, it calls method with the input line. If method returns a data row, then ans is set to it, and no other methods will be called. The test of ans can be eliminated through the use of an escape continuation.

Most importantly, when method returns a data row, it sets parse-rgb-line to method, so that after the current invocation of parse-rgb-line returns (or escapes), the method which worked will be called directly. Thus parse-rgb-line is a self-replacing function!

If parse-rgb-line is defined internally to another procedure, the containing procedure can be reentrant (as SLIB is).

Here is a typical (lambda (line) ...) function:

          (lambda (line)
            (case (sscanf line " %24[a-zA-Z0-9_ ] %d %d %d %e %e %e %s"
                          name r g b ri gi bi junk)
              ((7)
               (set! method-id 'm7)
               (list (check-match line
                                  (color:sRGB r g b)
                                  (floats->rgb ri gi bi))
                     (color-name:canonicalize name)))
              (else #f)))

sscanf is called with 8 variables, but this function will succeed only if exactly 7 are scanned; this is to detect extra stuff on the line. method-id is for reporting which method succeeded. check-match is called to warn if the RGB integer coordinates don't match the floating-point color coordinates.

If a format needs to ignore junk at the end of lines, then it should come after any functions (in the list) whose formats it might spoof. This way, the more specific format takes precedence.

Conclusion

A design-pattern employing a self-replacing function provides single-pass ETL processing of line-oriented files which automatically detects the line format.

Names for Hammer Dulcimer in English Books 1800-2000

2011-03-15T13:05:00.000-07:00

Google Labs has a nice webapp for creating graphs of word- and phrase-frequency versus time for the millions of books they have scanned.

Here is a graph of the frequency of various names for hammer-dulcimer from 1800 to the present. Click on the graph to try out the webapp for your own ideas. One caution; it is case-sensitive.

YouTube Hangs my Ubuntu-10.04 HP-dv7

2011-03-04T13:39:00.000-08:00

At 7:17pm on Mar 2 2011 Ubuntu-10.04.1 running on an HP dv7 (x86_64) ceased to be able to play YouTube videos. Both Chromium and FireFox get wedged. Hulu and other Flash services play without problems. But after a couple of seconds of playing a YouTube video, the screen goes black with white streaks. /var/log/kern.log goes into loop:

Mar  2 19:17:37 dv7 kernel: [ 8232.470145] [drm:radeon_fence_wait] *ERROR* fence(ffff8800b8044980:0x000097BA) 510ms timeout going to reset GPU
Mar  2 19:17:37 dv7 kernel: [ 8232.470157] radeon 0000:01:00.0: GPU softreset 
Mar  2 19:17:37 dv7 kernel: [ 8232.470164] radeon 0000:01:00.0:   R_008010_GRBM_STATUS=0xE53024A4
Mar  2 19:17:37 dv7 kernel: [ 8232.470171] radeon 0000:01:00.0:   R_008014_GRBM_STATUS2=0x00110002
Mar  2 19:17:37 dv7 kernel: [ 8232.470177] radeon 0000:01:00.0:   R_000E50_SRBM_STATUS=0x200000C0
Mar  2 19:17:37 dv7 kernel: [ 8232.470192] radeon 0000:01:00.0:   R_008020_GRBM_SOFT_RESET=0x00007FEE
Mar  2 19:17:37 dv7 kernel: [ 8232.470249] radeon 0000:01:00.0: R_008020_GRBM_SOFT_RESET=0x00000001
Mar  2 19:17:37 dv7 kernel: [ 8232.470314] radeon 0000:01:00.0:   R_000E60_SRBM_SOFT_RESET=0x00000402
Mar  2 19:17:37 dv7 kernel: [ 8232.519205] radeon 0000:01:00.0:   R_008010_GRBM_STATUS=0x00003028
Mar  2 19:17:37 dv7 kernel: [ 8232.519211] radeon 0000:01:00.0:   R_008014_GRBM_STATUS2=0x00000002
Mar  2 19:17:37 dv7 kernel: [ 8232.519217] radeon 0000:01:00.0:   R_000E50_SRBM_STATUS=0x200000C0
Mar  2 19:17:37 dv7 kernel: [ 8232.523318] [drm:radeon_fence_wait] *ERROR* fence(ffff8800b8044980:0x000097BA) 570ms timeout
Mar  2 19:17:37 dv7 kernel: [ 8232.523320] [drm:radeon_fence_wait] *ERROR* last signaled fence(0x000097BA)
Mar  2 19:17:39 dv7 kernel: [ 8235.040219] [drm:radeon_fence_wait] *ERROR* fence(ffff8800c4203ac0:0x000097C3) 510ms timeout going to reset GPU
Mar  2 19:17:39 dv7 kernel: [ 8235.040231] radeon 0000:01:00.0: GPU softreset 
Mar  2 19:17:39 dv7 kernel: [ 8235.040238] radeon 0000:01:00.0:   R_008010_GRBM_STATUS=0xA0003028
Mar  2 19:17:39 dv7 kernel: [ 8235.040245] radeon 0000:01:00.0:   R_008014_GRBM_STATUS2=0x00000002
Mar  2 19:17:39 dv7 kernel: [ 8235.040251] radeon 0000:01:00.0:   R_000E50_SRBM_STATUS=0x200000C0
Mar  2 19:17:39 dv7 kernel: [ 8235.040263] radeon 0000:01:00.0:   R_008020_GRBM_SOFT_RESET=0x00007FEE
Mar  2 19:17:39 dv7 kernel: [ 8235.040319] radeon 0000:01:00.0: R_008020_GRBM_SOFT_RESET=0x00000001
Mar  2 19:17:39 dv7 kernel: [ 8235.040384] radeon 0000:01:00.0:   R_000E60_SRBM_SOFT_RESET=0x00000402
Mar  2 19:17:39 dv7 kernel: [ 8235.089275] radeon 0000:01:00.0:   R_008010_GRBM_STATUS=0x00003028
Mar  2 19:17:39 dv7 kernel: [ 8235.089280] radeon 0000:01:00.0:   R_008014_GRBM_STATUS2=0x00000002
Mar  2 19:17:39 dv7 kernel: [ 8235.089286] radeon 0000:01:00.0:   R_000E50_SRBM_STATUS=0x200000C0
Mar  2 19:17:39 dv7 kernel: [ 8235.091966] [drm:radeon_fence_wait] *ERROR* fence(ffff8800c4203ac0:0x000097C3) 570ms timeout
Mar  2 19:17:39 dv7 kernel: [ 8235.091968] [drm:radeon_fence_wait] *ERROR* last signaled fence(0x000097C3)
Mar  2 19:17:42 dv7 kernel: [ 8237.611578] [drm:radeon_fence_wait] *ERROR* fence(ffff8800c4203f00:0x000097CA) 510ms timeout going to reset GPU
Mar  2 19:17:42 dv7 kernel: [ 8237.611591] radeon 0000:01:00.0: GPU softreset

Reinstalling Flash didn't help. Eight hours earlier, I had updated to 2.6.32-29-generic; but booting with the previous kernel version doesn't help. Installing the "linux-firmware-nonfree" drivers made no difference.

Start-Date: 2011-03-02  10:42:14
Install: linux-headers-2.6.32-29-generic (2.6.32-29.58), linux-headers-2.6.32-29 (2.6.32-29.58), linux-image-2.6.32-29-generic (2.6.32-29.58)
Upgrade: linux-generic (2.6.32.28.32, 2.6.32.29.35), linux-headers-generic (2.6.32.28.32, 2.6.32.29.35), linux-image-generic (2.6.32.28.32, 2.6.32.29.35), linux-libc-dev (2.6.32-28.55, 2.6.32-29.58)
End-Date: 2011-03-02  10:43:29

What has changed to cause this?
Others with the same problem are posting to
http://ubuntuforums.org/showthread.php?t=1699550

Fix Pink / Red YouTube Videos Bug Using Flash 10.2 In Ubuntu
"Possible fix 3" solved the problem by disabling "hardware acceleration" in Flash. So who's bug is this? Is the bug in Flash 10.2 or something it calls? In any case, plugins shouldn't be able to crash X11. So X11 is behaving badly; but the errors show up in "kern.log"; does the kernel deserve some of the blame?

Asperger-Syndrome Software Job Index

2011-02-02T19:53:00.000-08:00

Asperger syndrome is an autism spectrum disorder that is characterized by significant difficulties in social interaction, along with restricted and repetitive patterns of behavior and interests.

In the last few years it seems like more and more job postings for engineers are including requirements for better than average communication or interpersonal skills. Back when I was an undergraduate student, engineering was a good career choice for nerds. Apparently, no longer. Looking at Craigslist - boston software/QA/DBA/etc jobs classifieds for Wed Feb 02, 2011, 19 out of 33 postings require good communication or interpersonal skills. Several of the postings by third-party recruiters didn't have the full job description and might also require those skills. So today's Asperger-syndrome-software-job-index is 42% or less; only 42% of the job postings don't mention communication or interpersonal skills.

Software Development Engineer - (UMass, Boston Campus)
Research Programmer - (Cambridge)	Strong organizational and communication skills and the ability to work with others.
SQL Database Administrator - (Cranston, RI)	Good written and oral communication skills. Good interpersonal skills. Ability to present ideas in user-friendly language.
Software Engineer (Java) - (Downtown Boston)	Excellent verbal and written communication skills. Be able to clearly communicate at both high and basic technical levels.
Data/Analytics Engineer - (Boston)
Developer in Testing - (Boston, MA)	High energy level & excellent people/team member skills Good communication ability
Director of Systems Operations - (Kendall Square, Cambridge, MA)	Excellent customer service attitude, communication skills (written and verbal), and interpersonal skills.
QA Engineer - Java - (Greater Boston)
QA Engineer - (Waltham)
Microsoft Tech. Solutions Prof. - (Virtual)	Excellent written and oral communication skills
Entry-level Tech Support - $60k - (Waltham, MA)	Excellent communication skills
Software Engineer – .NET Development Contractor - (Cambridge, MA)	Good written and oral communication skills
Sr. Software Engineer - Flex/Flash - (Rte. 495 South)
.NET Application Engineer – C# - CSS - SQL - (Boston, MA)
Want to get into the HealthCare field?? VB.NET position open! - (Braintree, MA)
Sr. Software Engineer - (Rt. 128 West)
Junior Java Developer - (Downtown Boston)	Good verbal and written communication skills
iOS Developer - (Providence Rhode Island)
Are you Mark Zuckerberg without the idea? -
Hardware Quality Assurance Engineer - (North Reading)	Strong communication skills and cross-functional leadership
Contract Software Developer - (Boston) img	Strong communication and collaboration skills.
Document Prod Coord. - (Wellesley)
Mid-Level Software Developer - (Boston) img	Strong communication and collaboration skills. Strong communication and collaboration skills.[sic]
Release Engineering Manager - (Boston) img	Strong communication and collaboration skills.
Information Management Software Developer - (Cambridge, MA)	Should have problem solving and research skills along with excellent written and verbal communication skills.
Senior LAMP Developer - (Lexington)	Excellent communication skills
Mid-Level LAMP Developer - (Lexington)	Good communication skills

New webapp to transpose tunes in ABC format.

2011-01-17T18:34:00.000-08:00

I made a web application out of my program to transpose tunes in ABC format.
http://voluntocracy.org/Music/Transpose.html

ABC Music Transpose Program

2011-01-12T21:31:00.000-08:00

I have reorganized my Music Pages and added a page for my program to transpose ABC-format music files.

Don't Install CFLs in the Bathroom

2011-01-12T09:29:00.000-08:00

A correspondent writes:

I just replaced three 60 watt CFLs in my bathroom that had failed in less than 2 years. Box says 4 years for instant on minis.

Its not the glass bulb, but the electronic ballast in the base of the CFL which fails from exposure to moisture.

Most consumer electronics contain semiconductor chips in plastic packages, which do not remain sealed over the product's life. This practice is good enough in dry environments, but hydrogen from moisture infiltrates silicon chips, eventually causing the transistor thresholds to change, which causes failure.

Depending on your local electricity rates, the expected life of a CFL is not long enough to recoup its cost in energy savings if the lamp is used less than two hours a day. Putting CFLs in little-used locations is likely also not energy-efficient considering the energy and materials used to manufacture and dispose of the bulb.

Simulating Availability of Radiative Cooling

2011-01-03T19:13:00.000-08:00

The SimRoof program I have been developing can now create graphs of the availability of radiative cooling. This "Perfect CoolRoof" graph shows that in Guam:

The roof will provide more than 7 W/m² of cooling 99% of the time;
the roof will provide more than 22 W/m² of cooling 90% of the time;
the roof will provide more than 60 W/m² of cooling 50% of the time (the median);
the roof will provide more than 80 W/m² of cooling only 10% of the time;
the roof will provide more than 90 W/m² of cooling only 1% of the time.

Marbling the Torus

2010-12-21T11:33:00.000-08:00

I have cleaned up the math on Marbling the Torus and changed my scripts to oversample the images, resulting in less graininess.

Kjorcevo and Gankino

2010-12-11T21:17:00.000-08:00

I added two kopanicas (11/8) to my Folk Tunes page: Kjorcevo and Gankino.

Modeling Ink Drops

2010-11-29T22:03:00.000-08:00

Added to http://people.csail.mit.edu/jaffer/Marbling/Dropping-Ink.

... given a point P and a new ink drop of radius r centered at C, move the point radially from C to:

C + (P − C) · sqrt

(

1 +

r²

||P − C||²

)

One correspondent complains that, because the divergence of this transform is not zero, it can't be incompressible.

Divergence is defined for a continuously differentiable vector field. But this transform is not continuously differentiable around C; thus its divergence isn't well-defined. The common definition of incompressible is in terms of the divergence of a vector field. For a vector-field where the divergence isn't well-defined, the definition is silent.

However, I can show that this transform preserves the area of all neighborhoods not containing C. Consider the annulus centered on C having inner radius sqrt(a/π) and outer radius sqrt((a+b)/π). Its area is b.

If ink is injected at C forming a new circular region centered on C having area e, the annulus having area b will expand to have an inner radius of sqrt((a+e)/π) and an outer radius of sqrt((a+b+e)/π). The area of the expanded annulus is still b. Note that the expanded annulus is thinner than the original.

Because this transform is radially symmetric, any annulus slice with sides forming angles with C of θ and η will map to the expanded annulus slice between the angles of θ and η. Because the annulus and slices can be made arbitrarily small, all neighborhoods not containing C map to regions having the same area.

ICC Profiles

2010-11-29T21:51:00.000-08:00

From http://people.csail.mit.edu/jaffer/Color/Dictionaries:

Section 10.14, "namedColor2Type", of Specification ICC.1:2004-10 (Profile version 4.2.0.0):

The namedColor2Type is a count value and array of structures that provide colour coordinates for 7-bit ASCII colour names. For each named colour, a PCS and optional device representation of the colour are given. Both representations are 16-bit values and PCS values shall be relative colorimetric. The device representation corresponds to the header's "colour space of data" field. This representation should be consistent with the "number of device components" field in the namedColor2Type. If this field is 0, device coordinates are not provided. The PCS representation corresponds to the header's PCS field. The PCS representation is always provided. Colour names are fixed-length, 32-byte fields including null termination. In order to maintain maximum portability, it is strongly recommended that special characters of the 7-bit ASCII set not be used.

This namedColor2Type specification dates back to version 3.2 (1995), perhaps earlier. Only XYZ and L*a*b* colors are supported. Although version 4.2 defines "multiLocalizedUnicodeType", namedColor2Type is restricted to ASCII (and length less than 32.B). The colors in this table are specific to the profiled device. So namedColor2Type appears to be intended for including "spot" colors (such as from Pantone) in a device profile, not for device-independent color dictionaries.

XKCD Color Name Dictionary

2010-11-23T11:05:00.000-08:00

New on my Color Dictionaries webpage, XKCD Color Name Survey.

XKCD's 2010 color name survey is similar to the Color Naming Experiment. Rectangles of RGB colors on a white background were presented for the subject to name.

Compared with Color Naming Experiment, XKCD has better coverage of the darkest octant.

The catalog compares XKCD with CNE. Most of the darker shades common to both dictionaries are darker in XKCD. Greens seem to be overrepresented, probably a result of generating samples from a color-space which is perceptually very nonuniform.

With its larger set of dark colors, the XKCD Color Name Dictionary surpasses the Color Naming Experiment dictionary (and X11) for surface colors, although a large portion of its colors will not print faithfully.

New Color Dictionary

2010-11-09T20:24:00.000-08:00

New on my Color Dictionaries webpage, US Federal Standard 595C. Although not a general-purpose source, these colors are of use when rendering post-boxes (15050), school-buses (13415), flags (UN Flag Blue 35250), signs and military clothing and equipment.

Simulating Sun-Shielded Roofs

2010-10-07T11:14:00.000-07:00

The SimRoof program I have been developing can now simulate the thermal performance of sun-shielding roof covers.

For more, click on the graph.

Simulating CoolRoofs

2010-09-06T10:07:00.000-07:00

The SimRoof program I have been developing can now simulate the thermal performance of horizontal cool-roofs from the measurements made by coolroofs.org.

For more, click on the graph.

Argiope aurantia

2010-08-11T13:21:00.000-07:00

This spider at about 4.cm is the largest I can remember seeing. It has an interesting zigzag pattern in its web.

chipping-sparrow chicks

2010-07-30T08:19:00.001-07:00

chipping-sparrow chicks, originally uploaded by aubrey_jaffer.

Here are three-day-old chipping-sparrow chicks. The nest is in a yew(?) bush in a neighbor's yard.

West meets East

2010-05-29T18:59:00.000-07:00

2500 years ago, Buddha, sage of the (warrior) Shakya clan, taught:

All is impermanent.

65 years ago, the warrior sage of the MacArthur clan answered:

There is no security, only opportunity.

Storm clouds

2010-05-04T21:05:00.001-07:00

IMG_2160, originally uploaded by aubrey_jaffer.

The sun was shining brightly behind thunderheads.

Color Name Dictionaries

2010-03-07T18:07:00.000-08:00

Newly expanded and updated, Color-Name Dictionaries is my most popular webpage, averaging 150 visits per day. It is linked from Wikipedia and elsewhere. Chirag Mehta has created a Name that Color webapp using the Resene Paint Colours list. There is even a Color Dictionary iPhone app based on the NBS-ISCC Centroids and Dictionaries of Color Names.

Unfortunately, Color-Name Dictionaries has not been noticed by the X.Org Foundation nor the World Wide Web Consortium, whose products contain deeply flawed color dictionaries from the 1980s. Instigating change in the face of so much organizational inertia is a daunting task.

Integers-as-Bits versus Bit-Arrays

2009-12-30T18:52:00.000-08:00

Integers As Bits (SRFI-60) is motivated this way:

Treating integers as two's-complement strings of bits is an arcane but important domain of computer science. It is used for:
hashing;
Galois-field[2] calculations of error-detecting and error-correcting codes;
cryptography and ciphers;
pseudo-random number generation;
register-transfer-level modeling of digital logic designs;
index arithmetic of Fast-Fourier transforms;
packing and unpacking numbers in persistant data structures;
space-filling curves with applications to dimension reduction and sparse multi-dimensional database indexes; and
generating initial values for root-finders and transcendental function algorithms.

Many people's first impulse is to conflate integers with bit-vectors. But this is not useful when we realize that functional operations on immutable integers-as-bits are less inefficient than side-effecting operations on large bit-vectors.

Bit-vectors can be used to construct very fast indexes for database tables having millions of records. To keep the working-set small, creation of megabit arrays is done explicitly; the bit-vector procedures accumulate their results into one of the operands. Functional operations on bignums would be impractical for such an application.

Let

N: be the largest number of significant bits in bignum inputs to a bitwise computation; and
P: be the number of binary bitwise operations (LOGAND, LOGOR, ...) in a computation.

Consider the computation to find the disjunction of P bit-vectors (a OR b OR c ...). Using (bignum) integers-as-bits, P bignums will be allocated and P-1 bignums will be discarded in the course of the computation. Thus it consumes O(PN) space and time.

Accumulating the result of multiple disjunctions in one bit-vector consumes only O(N) storage and O(PN) time.

The worst case for bit-vector accumulation is a full binary tree of 2^q bit-vectors with P=2^q-1 binary operations. By reusing temporary bit-vectors, storage can be limited to O(Nq)=O(NlogP) and O(PN) time.

A clever optimizer could be written to convert functional bitwise expressions into accumulating bit-vector forms, but I haven't found functional bitwise operators to be easier to work with than imperative bit-vector operators for database indexing.

In addition to the generic Array and Array Mapping procedures of SLIB, the following procedures in SCM were written to support the use of bit-vectors as database indexes. This technique works best for indexes having only a few indexed values (with many records per value). One bit-vector is devoted to each indexed value for a field; a 1-bit indicates that the corresponding record has that value in that field. Indexes for values which are sparse can instead be encoded by vectors of integers, each integer indicating the record having that value in that field. Indexes coded in these ways allow fast calculation of complicated queries.

5.4.3 Bit Vectors

Bit vectors can be written and read as a sequence of 0s and 1s prefixed by #*.

#1At(#f #f #f #t #f #t #f) => #*0001010

Some of these operations will eventually be generalized to other uniform-arrays.

Function: bit-count bool bv: Returns the number of occurrences of bool in bv.

Function: bit-position bool bv k: Returns the minimum index of an occurrence of bool in bv which is at least k. If no bool occurs within the specified range #f is returned.

Function: bit-invert! bv: Modifies bv by replacing each element with its negation.

Function: bit-set*! bv uve bool

If uve is a bit-vector, then bv and uve must be of the same length. If bool is #t, then uve is OR'ed into bv; If bool is #f, the inversion of uve is AND'ed into bv.

If uve is a unsigned integer vector, then all the elements of uve must be between 0 and the LENGTH of bv. The bits of bv corresponding to the indexes in uve are set to bool.

The return value is unspecified.

Function: bit-count* bv uve bool

Returns

(bit-count (bit-set*! (if bool bv (bit-invert! bv)) uve #t) #t).

bv is not modified.

Schlep Toolchains

2009-12-15T15:18:00.000-08:00

Schlep Toolchains documents and distributes the hyper-cross-platform technology used to create the WB B-tree database libraries and new implementation of Water for C, C#, and Java from source written in a subset of Scheme.

One might assume that in order for Schlep-dialect code to map to these three languages [C, C#, and Java], the Schlep-dialect must manifest the worst limitations of each language; but translation can actually rectify some of these limitations.

If I had to pick one practical feature of Scheme which elevates it above other languages, it would be internal definitions. The Algorithmic Language Scheme allows procedure definitions (using define, letrec, and named-let) inside of other procedures, which none of C, C#, or Java does. Internal definitions allow calls of internal procedures with a small number of arguments to replace the common alternatives:

duplication of code, or
top-level definitions and calls passing large numbers of arguments.

C and C# have a `goto' statement, enabling Schlep to emulate calling of internal-procedures in the tail position using some variable assignments (sometimes including temporary variable binding to emulate simultaneous assignment) followed by a goto statement. The restriction to the tail-position does not allow internal recursion other than tail-recursion; but this facilitates use of internal procedures in many situations which would otherwise force less desirable practices.

Java lacks a `goto' statement. Tail-called internal procedures are instead implemented using while (true), continue, and break with labels. The resulting Java code is not as readable as the original Scheme-dialect; but that loss in clarity is balanced by greater expressive power.

Schlep-example gives an example of a procedure with an internal procedure and how Schlep translates this procedure into C, C#, and Java.

Implicitly Concurrent `map'

2009-11-14T21:33:00.000-08:00

In my first Implicit Concurrency post I stated that

The Scheme Reports mandate an unspecified-but-serial evaluation order for arguments to procedure-calls, `let' bindings, `letrec' bindings, `do' bindings, and `map'.

The only RnRS mention of concurrency appears in the description of Procedure call:

Note: Although the order of evaluation is otherwise unspecified, the effect of any concurrent evaluation of the operator and operand expressions is constrained to be consistent with some sequential order of evaluation. The order of evaluation may be chosen differently for each procedure call.

Because `do', `let', and `letrec' bindings are defined in terms of (`lambda' and) procedure calls, this restriction applies to them as well.

But the Reports are silent as to the evaluation order for `map'; so it shouldn't have been included in my list.

If the Implicitly Concurrent future is already here, why is it a secret? Because misunderstanding of `map' evaluation order is widespread; in [R6RS] Will `map' order remain unspecified?, W. Clinger writes:

... expecting map to process its elements from left to right has been perhaps the most common order-of-evaluation bug in R5RS programs.

There is a deep connection between concurrent `map' and the other implicit concurrencies. If a metacircular-interpreter uses a concurrent `map' to evaluate arguments to procedure calls, then that interpreter's procedure calls will also be concurrent.

Implicit concurrency can thus be viewed as a basic property of a computing platform. A concurrently-repeatable metacircular-interpreter can be written without using explicit-concurrency primitives which is concurrent when run by a concurrent (implicitly concurrent) implementation and serial when run by a serial implementation.

Implicit Concurrency

2009-10-25T20:23:00.000-07:00

There has been a lot of concern over how to harness the speed potential of multi-core processors without a disruptive reinvention of software engineering. Implicit concurrency is a solution.

The specifications of the algorithmic languages C, C++, OCAML, and Scheme deliberately leave unspecified the order of evaluation of arguments to procedure-calls. If coders are to write programs which display the same behavior when (compiled and) run on different platforms, an easily mastered discipline concerning side-effects of argument expressions must be practiced.

It turns out that this discipline is very similar to that needed in order to write programs which display the same behavior even with concurrent evaluation of arguments (and on different platforms).

Changing from unspecified-order-of-evaluation-of-arguments to concurrent-envaluation-of-arguments in these language specifications would enable them to be implicitly-concurrent:

able to spawn concurrent subtasks at many points in programs,
produce the same result whether run in 1 core (or thread) or 1000,
involve no new language primitives, and
require no complicated code analysis.

Terminology

closed-expression

Let the term closed-expression designate

a Scheme expression and
all state accessible from the value of each free variable in the expression or free in any procedures called from the expression or procedures they call (this can include files).

After the closed-expression is evaluated, the resulting state (or output) is:

the returned value or values,
all state accessible from the value of each free variable in the expression or free in any procedures called from the expression or procedures they call, and
files written by evaluating the expression.

singly-terminate

Let the term singly-terminate designate the condition of the evaluation of a closed-expression that:

returns once and only once and
does not let any continuations escape from the dynamic extent of evaluating the closed expression.

portably-repeatable

Let the term portably-repeatable designate those closed-expressions which singly-terminate and produce identical output for any serial evaluation order allowed by the Scheme report.

The Scheme Reports mandate an unspecified serial evaluation order for arguments to procedure-calls, `let' bindings, `letrec' bindings, `do' bindings, and `map'.

A caveat to portably-repeatable is the non-associativity of floating-point operations. For the extent of this discussion, assume that `+', `*', `-', and `/' with more than 2 arguments are left-associative.

concurrently-repeatable: Let the term concurrently-repeatable designate those closed-expressions which singly-terminate and produce identical output for any concurrent evaluation order where the Scheme report mandates an unspecified serial evaluation order.
Implicitly-Concurrent-Scheme: Let Implicitly-Concurrent-Scheme (ICS) designate an implementation which allows concurrent evaluation anywhere the Scheme report mandates an unspecified serial evaluation order.

Theorems

Theorem 1: All singly-terminating purely functional closed-expressions (including procedures they call) are both portably-repeatable and concurrently-repeatable.

This is because purely functional (sub-)expressions have no side effects; hence they cannot effect the execution of other purely functional (sub-)expressions.

Theorem 2: All concurrently-repeatable closed-expressions are portably-repeatable.

For a given closed-expression, its serial evaluation orders are a subset of its concurrent evaluation orders.

Theorem 3: A single threaded, non-preemptive RnRS (Scheme) implementation is an ICS implementation.

This is because concurrently-repeatable implies portably-repeatable by Theorem 2.

The Programmer Contract

The programmer who wants to write closed-expressions which have repeatable behavior across platforms must currently write portably-repeatable code (among other constraints).

There are relatively few portably-repeatable expressions which are not also concurrently-repeatable. And it is avoiding these few expressions which represents the change of habit for coders. The few expressions involve the potential for multiple threads to have side-effects on shared state.

Examples of portably-repeatable expressions which are not concurrently-repeatable are symmetric calls of a pseudo-random-number-generator having shared state:

(begin
  (require 'random)
  (let ((rs (make-random-state "seed1")))
    (+ (random 9 rs) (random 9 rs))))

Notice that the expressions:

(- (random 9 rs) (random 9 rs))

and

(+ (random 9 rs) (random 19 rs))

are not portably-repeatable; for asymmetrical functions (or asymmetrical argument expressions), the order of calls to `random' causes different results to be returned.

A concurrently-repeatable version of the random sum can be written:

(begin
  (require 'random)
  (let* ((rs (make-random-state "seed1"))
         (rnd1 (random 9 rs)))
    (+ rnd1 (random 9 rs))))

The SLIB random module detects and signals an error if `random' is called concurrently or reentrantly on the same random-state byte-array. A concurrent implementation can thus sometimes catch concurrently-repeatable violations.

The Scheme Reports also leave the order of evaluation unspecified for `map'. Examples of portably-repeatable `map' expressions which are not concurrently-repeatable have side-effecting (set!) shared-state (cnt) within a `map'ped procedure:

(let ((cnt 0))
  (let ((res (map
              (lambda (x)
                (if (negative? x) (set! cnt (+ 1 cnt)))
                (* x x))
              '(-1 2 -3 4 -5 6))))
    (list res cnt)))

Such code can be made concurrently-repeatable by separating the functional and side-effecting parts:

(let ((cnt 0) (lst '(-1 2 -3 4 -5 6)))
  (for-each (lambda (x)
              (if (negative? x) (set! cnt (+ 1 cnt))))
            lst)
  (list (map
         (lambda (x) (* x x))
         lst)
        cnt))

Or the non-functional part can be made functional:

(let ((lst '(-1 2 -3 4 -5 6)))
  (list (map (lambda (x) (* x x)) lst)
        (apply + (map (lambda (x) (if (negative? x) 1 0))
                      lst))))

Or the functional part can be accumulated in the serial `for-each'. This code is forced to run serially by the `for-each'; so it will not gain a speed benefit from concurrent evaluation:

(let ((cnt 0)
      (lst '(-1 2 -3 4 -5 6))
      (nst '()))
  (for-each (lambda (x)
              (if (negative? x) (set! cnt (+ 1 cnt)))
              (set! nst (cons (* x x) nst)))
            lst)
  (list (reverse nst) cnt))

One could also write a serial `map*' procedure to do the same.

Continuations

This expression is portably-repeatable but not concurrently-repeatable because it would return twice:

(call-with-current-continuation
 (lambda (return)
   (/ (return 0) (return 0))))

This expression is neither portably-repeatable nor concurrently-repeatable because whether it returns 0 or 1 depends on the order of evaluation of arguments:

(call-with-current-continuation
 (lambda (return)
   (/ (return 0) (return 1))))

But escape continuations can be used in concurrently-repeatable ways:

(define (careful-div n d)
  (call-with-current-continuation
   (lambda (return)
     (/ n (if (zero? d) (return #f) d)))))

The Implementation Contract

When encountering an expression (list (u) (v)), a parallelizing RnRS implementation must commence an analysis of u and v and everything they call, possibly including other modules, to determine whether any side effects to shared state might depend on concurrent evaluation order. This is the same difficulty that any parallelizing C or Fortran compiler faces. Such an analysis cannot be exhaustive because there is no guarantee that the analysis will terminate (Halting Problem).

When a parallelizing Implicitly-Concurrent-Scheme compiler or interpreter encounters (list (u) (v)), it immediately knows that it can delegate the computation of (u) and (v) to distinct threads. The Programmer Contract to write concurrently-repeatable code insures that no side-effects to shared state will depend on concurrent evaluation order.

Exceptions

When an exception is raised in one thread evaluating an argument in concurrently-repeatable code, it does not effect the evaluation of the other arguments because its side-effects do not interact with the threads of the other arguments. Whether the handler returns or not determines whether the procedure is applied to the result of those argument evaluations.

Conclusion

Implicitly-Concurrent-Scheme is a minor modification to Scheme Report semantics which allows, but does not require, both interpreters and compilers to simply parallelize the execution of programs. No new primitives are introduced. In order to write ICS programs which produce the same output irrespective of concurrent evaluation order requires a regime very similar to the that required of RnRS programs to produce the same output irrespective of serial evaluation order.

Bibliography

[Feeley]
Marc Feeley, An Efficient and General Implementation of Futures on Large Scale Shared-Memory Multiprocessors, PhD thesis, Brandeis University, April 1993, 213 pages.

Energy Revolution Rally at Minute Man National Historic Park

2009-10-25T09:09:00.001-07:00

Concord, MA United States Photo #3 Showing March to Minute Man Statue, originally uploaded by 350.org.

October 24, 2009. Part of 350.org's
International Day of Climate Action,
the Bedford Minuteman Company led the
Energy Revolution Rally march at
Minute Man National Historic Park

2009-10-21T11:14:00.000-07:00

Noticed these Tricyrtis blooming after our first snowfall.

Climate Change: Anthropogenesis Doesn't Matter

2009-10-17T16:31:00.000-07:00

Climate change deniers express a lot of concern over whether climate change is caused by human activities or not. Implicit in asking whether climate change is anthropogenic is an assumption that if climate change isn't caused by humans, then nothing can or should be done to reverse it.

That assumption is absurd; and only serves to derail discussion of how to combat climate change. To see how absurd it is, consider the case of asteroids. If an asteroid large enough to end life-as-we-know-it were discovered to be on a trajectory to impact the earth, it would not be anthropogenic. Should we then not attempt to deflect it from catastrophe?

The important question is: How can we slow or reverse climate change and the destruction of ocean reefs from increased atmospheric CO2?

Biological Space-Filling Curves

2009-10-12T12:42:00.000-07:00

My (Aubrey Jaffer) work on multidimensional space-filling curves is acknowledged in October 9th Science's cover article: "Comprehensive Mapping of Long-Range Interactions Reveals Folding Principles of the Human Genome".
See supplemental-material link.

Search-paths considered harmful

2009-10-07T10:36:00.000-07:00

It has been my experience that dynamic search-paths are disastrous for libraries on commercial and educational computer networks. The search-paths at these sites seem to only grow; paths to newer versions are placed ahead of older versions. It is not uncommon for half of the directories in a path to refer to non-existent directories or non-functioning host machines! The timeouts from hosed or inaccessible networked-file-systems can balloon into minutes the startup time for programs.

Furthermore, transient router outages can cause incompatible versions of libraries to be loaded which, in the Scheme or Lisp case, may not be noticed until the program has run for hours; but more likely will just cause a mysterious failure.

The SLIB Scheme Library's solution to this problem is to have an explicit command [(require 'new-catalog)], typically run after installations, write to a file an association list of features and resolved pathnames. SLIB sessions read this file and thereafter have instantaneous latency to library paths.

If the network can't reach a particular file, the session fails immediately or after the first timeout rather than conducting covert experiments on library version compatibility.

2009-08-26T08:11:00.000-07:00

The fake Fidelity login page on http://www.secureonline.fidelity.us.tc/ was taken down yesterday. It would be interesting to know what precipitated the change.

2009-08-24T18:11:00.000-07:00

"Interdots International" is phishing for Fidelity passwords through a subdomain of their's:
http://www.secureonline.fidelity.us.tc/

http://dic.academic.ru/dic.nsf/enwiki/2392662
says that this organization runs a diploma mill named Concordia College and University.

Interdots' spam manage to evade detection by both Symantec-BrightMail-Gateway and Google-Mail.

Domain Name: us.tc

Registrant, Technical Contact, Admin. Contact
Interdots International
c/o Marius T Strasser, P.O. Box 51, Nea Michaniona , GR-57004
Greece
E-mail: ms@interdots.com
Phone: ++1-253-323-0927
Fax: ++1-253-323-0927

Billing Contact
Juergen Riedel
Postfach 131142, D-70069 Stuttgart
Germany
E-mail: info@citymedia.de
Phone: ++49711-286-5799
Fax: ++49711-286-8450

Resource Records (2):
ns ns1.idnscan.net
ns ns6.idnscan.net