Skip to main content.
-->
May 18th, 2005

Pakistan Trains Female Fighter Pilots

Boing boing is linking to a BBC story that Pakistan is now training women to be fighter pilots.

In the human factors course that I took as an undergrad years ago, the professor consulted with the military on the several designs. He told us of the stringent anthropometric (body-shape) requirements for fighter pilots. For example, their arms and legs must be a certain length because the seats cannot be made adjustable for G-forces expected in flight. Their torsos cannot be too tall or the canopy window won’t close; nor too short or the pilot won’t be able to see over the control panel.

There is also a weight restriction. The seat ejectors are designed for a very narrow range of weights (if I remember correctly, something like 175-190lbs). If the pilot is any heavier, there is a risk the ejected seat will not clear the aircraft. If the pilot is too light, there is a risk that ejection will cause severe spinal injury and/or death.

Given that women are, on average, lighter than men, I wonder if these women cadets fit the anthropometric requirements for the aircraft that they will be piloting.

Posted by Ken Dyck as Uncategorized at 9:07 PM EDT

No Comments »

May 17th, 2005

Network Theory Study of the U.S. House of Representatives

A recent paper by Porter, Mucha, Newman, and Warmbrand studies the interconnections of the committees and sub-committees in the U.S. Congress from a network theoretic perspective. They conclude that the distribution of congressmen among the committees is not random — there’s a shocker — that cliques rule over certain parts of the government. For example, there are strong ties between the Select Committee on Homeland Security and the House Rules Committee.

Regardless of the political implications of the study, I found it to be a fun example of network theory.

For those less inclined to read the paper, New Scientist has a summary.

Posted by Ken Dyck as Uncategorized at 8:31 PM EDT

No Comments »

Proving Theorem Provers Correct

In a Los Angeles Times commentary, Margaret Wertheim writes about one of the growning problems in modern mathematics:

People are now claiming proofs for two of the most famous problems in mathematics — the Riemann Hypothesis and the Poincare Conjecture — yet it is far from easy to tell whether either claim is valid. In the first case the purported proof is so long and the mathematics so obscure no one wants to spend the time checking through its hundreds of pages for fear they may be wasting their time. In the second case, a small army of experts has spent the last two years poring over the equations and still doesn’t know whether they add up.

She claims that mathematics is evolving into a postmodern study where, according to Philip Davis, emeritus professor of mathematics at Brown University, mathematics is “a multi-semiotic enterprise” prone to ambiguity and definitional drift.

What I found interesting was this bit:

The [four-colour map] problem was first stated in 1853 and over the years a number of proofs have been given, all of which turned out to be wrong. In 1976, two mathematicians programmed a computer to exhaustively examine all the possible cases, determining that each case does indeed hold. Many mathematicians, however, have refused to accept this solution because it cannot be verified by hand. In 1996, another group came up with a different (more checkable) computer-assisted proof, and in December this new proof was verified by yet another program. Still, there are skeptics who hanker after a fully human proof.

I don’t know if I buy the postmodern angle, but I believe she’s right about the practice of mathematics changing. It seems to me that as the complexity of mathematical problems grows beyond the abilities of human minds, we are going to require computers to prove our theorems for us. My prediction: the job of mathematicians will eventually turn into proving that theorem-proving software is correct.

Posted by Ken Dyck as Uncategorized at 8:01 PM EDT

No Comments »

May 16th, 2005

Solution to SICP Exercise 1.21

Structure and Interpretation of Computer Programs

Solution to Exercise 1.21:

> (smallest-divisor 199)
199
> (smallest-divisor 1999)
1999
> (smallest-divisor 19999)
7

Posted by Ken Dyck as Programming at 8:58 PM EDT

No Comments »

Bjorn Blogs about Eclipse

Bjorn Freeman-Benson has started blogging about the open source development of Eclipse. I’ve had the pleasure to sit through some talks that Bjorn’s given at the past couple EclipseCons, including the tutorial he gave with Darin Wright on the debug framework in February. To say that he’s a bright and articulate guy is a bit of an understatement. I’m looking forward to hearing what he has to say.

Posted by Ken Dyck as Uncategorized at 8:40 PM EDT

No Comments »

May 15th, 2005

Forget Mars and Venus

When I Men are from Mars, Women are from Venus, I was sorely unimpressed with its (lack of) scientific rigour. I came across a Rebuttal from Uranus, a passionate challenge to Gray’s assertions, but found it equally lacking in scientific study.

Happily, Edge has run several stories recently relating to gender differences including a debate between Pinker vs. Spelke on the results of recent gender difference studies, John Gottman’s Mathematics of Love, and Simon Baron-Cohen’s Assortative Mating Theory. Good stuff.

Posted by Ken Dyck as Uncategorized at 7:41 PM EDT

No Comments »

Taking the Digicam Plunge

For an embarrassingly long time, I’ve been promising Mandy that we would buy a digital camera. Last night, we finally took the plunge.

Our main criteria was price. We wanted to spend less than $300. After some surfing around TigerDirect, I found four Kodak cameras that worked: CX6445, CX7530, DX7440, and LS753.

The reviews of the DX7440 and LS753 on Imaging Resource and the dearth of reviews on the CX cameras convinced me that we were looking at a shootout between the DX7440 and the LS753.

Mandy and I compared the two. The LS753 is a 5 megapixel camera, but only has a 2.8x optical zoom. The DX7440 only has 4 megapixels, but a 4.0x optical zoom. We don’t expect that we’ll be printing out to many large (>5×7) photos, so the extra megapixel of resolution didn’t seem all that important. I wanted more than the 2.8x optical zoom of the LS753.

So the DX7440, it was. It should be arriving this week. Expect to see some shots on Flickr by the weekend.

Posted by Ken Dyck as Uncategorized at 9:43 AM EDT

No Comments »

Solution to SICP Exercise 1.20

Structure and Interpretation of Computer Programs

Solution to Exercise 1.20:

;;; Normal Order

; remainder count: 0
(gcd 206 40)

; rc: 0
(if (= 40 0)
    206
    (gcd 40 (remainder 206 40))) 

; rc: 0
(gcd 40 (remainder 206 40)) 

; rc: 0
(if (= (remainder 206 40) 0)
    40
    (gcd (remainder 206 40)
         (remainder 40 (remainder 206 40))))

; rc: 1
(if (= 6 0)
    40
    (gcd (remainder 206 40)
         (remainder 40 (remainder 206 40))))

; rc: 1
(gcd (remainder 206 40)
     (remainder 40 (remainder 206 40)))

; rc: 1
(if (= (remainder 40 (remainder 206 40)) 0)
    (remainder 206 40)
    (gcd (remainder 40 (remainder 206 40))
         (remainder (remainder 206 40)
                    (remainder 40
                               (remainder 206 40)))))

; rc: 2
(if (= (remainder 40 6) 0)
    (remainder 206 40)
    (gcd (remainder 40 (remainder 206 40))
         (remainder (remainder 206 40)
                    (remainder 40
                               (remainder 206 40)))))

; rc: 3
(if (= 4 0)
    (remainder 206 40)
    (gcd (remainder 40 (remainder 206 40))
         (remainder (remainder 206 40)
                    (remainder 40
                               (remainder 206 40)))))

; rc: 3
(gcd (remainder 40 (remainder 206 40))
     (remainder (remainder 206 40)
                (remainder 40
                           (remainder 206 40))))

; rc: 3
(if (= (remainder (remainder 206 40)
                  (remainder 40
                             (remainder 206 40)))
       0)
    (remainder 40 (remainder 206 40))
    (gcd (remainder (remainder 206 40)
                    (remainder 40
                               (remainder 206 40)))
         (remainder (remainder 40 (remainder 206 40))
                    (remainder (remainder 206 40)
                               (remainder 40
                                          (remainder 206 40))))))

; rc: 4
(if (= (remainder 6
                  (remainder 40
                             (remainder 206 40)))
       0)
    (remainder 40 (remainder 206 40))
    (gcd (remainder (remainder 206 40)
                    (remainder 40
                               (remainder 206 40)))
         (remainder (remainder 40 (remainder 206 40))
                    (remainder (remainder 206 40)
                               (remainder 40
                                          (remainder 206 40))))))

; rc: 5
(if (= (remainder 6
                  (remainder 40
                             6))
       0)
    (remainder 40 (remainder 206 40))
    (gcd (remainder (remainder 206 40)
                    (remainder 40
                               (remainder 206 40)))
         (remainder (remainder 40 (remainder 206 40))
                    (remainder (remainder 206 40)
                               (remainder 40
                                          (remainder 206 40))))))

; rc: 6
(if (= (remainder 6 4) 0)
    (remainder 40 (remainder 206 40))
    (gcd (remainder (remainder 206 40)
                    (remainder 40
                               (remainder 206 40)))
         (remainder (remainder 40 (remainder 206 40))
                    (remainder (remainder 206 40)
                               (remainder 40
                                          (remainder 206 40))))))

; rc: 7
(if (= 2 0)
    (remainder 40 (remainder 206 40))
    (gcd (remainder (remainder 206 40)
                    (remainder 40
                               (remainder 206 40)))
         (remainder (remainder 40 (remainder 206 40))
                    (remainder (remainder 206 40)
                               (remainder 40
                                          (remainder 206 40))))))

; rc: 7
(gcd (remainder (remainder 206 40)
                (remainder 40
                           (remainder 206 40)))
     (remainder (remainder 40
                           (remainder 206 40))
                (remainder (remainder 206 40)
                           (remainder 40
                                      (remainder 206 40)))))

; rc: 7
(if (= (remainder (remainder 40
                             (remainder 206 40))
                  (remainder (remainder 206 40)
                             (remainder 40
                                        (remainder 206 40))))
       0)
    (remainder (remainder 206 40)
               (remainder 40
                          (remainder 206 40)))
    (gcd (remainder (remainder 40
                               (remainder 206 40))
                    (remainder (remainder 206 40)
                               (remainder 40
                                          (remainder 206 40))))
         (remainder (remainder (remainder 206 40)
                               (remainder 40
                                          (remainder 206 40)))
                    (remainder (remainder 40
                                          (remainder 206 40))
                               (remainder (remainder 206 40)
                                          (remainder 40
                                                     (remainder 206 40)))))))

; rc: 14 (there were 7 calls to remainder in the = form above)
(if (= 0 0)
    (remainder (remainder 206 40)
               (remainder 40
                          (remainder 206 40)))
    (gcd (remainder (remainder 40
                               (remainder 206 40))
                    (remainder (remainder 206 40)
                               (remainder 40
                                          (remainder 206 40))))
         (remainder (remainder (remainder 206 40)
                               (remainder 40
                                          (remainder 206 40)))
                    (remainder (remainder 40
                                          (remainder 206 40))
                               (remainder (remainder 206 40)
                                          (remainder 40
                                                     (remainder 206 40)))))))

; rc: 14
(remainder (remainder 206 40)
           (remainder 40
                      (remainder 206 40)))

; rc: 15
(remainder 6
           (remainder 40
                      (remainder 206 40)))

; rc: 16
(remainder 6 (remainder 40 6))

; rc: 17
(remainder 6 4)

; rc: 18
2

For normal order, remainder is performed 18 times.

;;; Applicative Order

; rc: 0
(gcd 206 40)

; rc: 0
(if (= 40 0)
    206
    (gcd 40 (remainder 206 40))) 

; rc: 0
(gcd 40 (remainder 206 40))

; rc: 1
(gcd 40 6)

; rc: 1
(if (= 6 0)
    40
    (gcd 6 (remainder 40 6))) 

; rc: 1
(gcd 6 (remainder 40 6))

; rc: 2
(gcd 6 4)

; rc: 2
(if (= 4 0)
    6
    (gcd 4 (remainder 6 4))) 

; rc: 2
(gcd 4 (remainder 6 4))

; rc: 3
(gcd 4 2)

; rc: 3
(if (= 2 0)
    4
    (gcd 2 (remainder 4 2))) 

; rc: 3
(gcd 2 (remainder 4 2))

; rc: 4
(gcd 2 0)

; rc: 4
(if (= 0 0)
    2
    (gcd 0 (remainder 2 0))) 

; rc: 4
2

For applicative order, remainder is only performed four times.

Posted by Ken Dyck as Programming at 9:21 AM EDT

2 Comments »

May 14th, 2005

This just in…

Apparently Eclipse 3.1M7 is out. What’s new?

Posted by Ken Dyck as Uncategorized at 9:49 PM EDT

No Comments »

May 13th, 2005

Solution to SICP Exercise 1.19

Structure and Interpretation of Computer Programs

Solution to Exercise 1.19:

Tqp is defined as:

abq + aq + ap
bbp + aq

If we apply Tpq to itself, we get T2pq:

a ← (bp + aq)q + (bq + aq + ap)q + (bq + aq + ap)p
b ← (bp + aq)p + (bq + aq + ap)q

With some manipulation, this can be rewritten as:

ab(2pq + q2) + a(2pq + q2) + a(p2 + q2)
bb(p2 + q2) + a(2pq + q2)

As we are looking for a transformation of the form

abq′ + aq′ + ap
bbp′ + aq

It should be fairly obvious that

p′ = p2 + q2
q′ = 2pq + q2

Now we can modify our program:

(define (fib n)
  (fib-iter 1 0 0 1 n))

(define (fib-iter a b p q count)
  (cond ((= count 0) b)
        ((even? count)
         (fib-iter a
                   b
                   <strong>(sum-of-squares p q)</strong>     ; compute p'
                   <strong>(+ (* 2 p q) (square q))</strong> ; compute q'
                   (/ count 2)))
        (else (fib-iter (+ (* b q) (* a q) (* a p))
                        (+ (* b p) (* a q))
                        p
                        q
                        (- count 1)))))

(define (square x)
  (* x x))

(define (sum-of-squares x y)
  (+ (square x) (square y)))

Posted by Ken Dyck as Programming at 8:10 PM EDT

No Comments »

« Previous Page« Previous Entries  Next Entries »Next Page »