Sohcahtoa!

Mathematics can ask you to remember things that have no obvious connection to common sense. Either because it’s arbitrary (the name of a function in respect to what it computes) or because you haven’t quite figured all the details out. In either cases, a few mnemonics are always useful!

The first series of mnemonics you’ll learn is to remember constants. Constants like and have special importance in modern mathematics—beyond plain creepy piphilia.

The notation for is due to William Jones who first used it in print in 1707. He chose probably because it had some mnemonic connection to perimeter, which make sense given the context. The notation was adopted and popularized by Euler, which in turn introduced the notation for the base of the natural logarithm. It appeared in print in 1736.[1]

The constants and are both transcendental irrational numbers.

The discipline of remembering digits of either—and of in particular—has risen to Olympic levels. For every day use knowing the values to 6 or 16 digits is probably quite sufficient¹. To remember to 20 digits, the following English poem does the trick:

3      Pie
141592 I wish I could determine Pi
65358  Eureka, cried the great inventor
9793   Christmas pudding, Christmas pie
23846  Is the problem’s very center

And, indeed, . For , we have the same kind of poem:

2718281 We require a mnemonic to remember

And, indeed, quite so, . If you really want a whole lot of digits, you can have a look at Simon Plouffe’s page of world records.

*
* *

Trigonometric functions such as sine, cosine, and tangent are somewhat named arbitrarily. Maybe not tangent, because, more than the two others, it suggest something of a straight line, a slope. Fortunately, there’s a rather simple—if Japanese-sounding—mnemonic for those. Take a deep breath and say it out loud: SOHCAHTOA!

Indeed, sine is opposite over hypotenuse, cosine is adjacent over hypotenuse, and tangent is opposite over adjacent:

*
* *

Keeping up with a Japanese theme, a friend of mine, understanding nothing of the right-hand rule, came up with a simple mnemonic for remembering the vector cross product rules:

There’s also:

Let us look at a mitsudomoe crest:

You can imagine it spinning clockwise:

or counter-clockwise:

If the mitsudomoe is spinning clockwise, pen down , , and in a clockwise manner:

If you read the products clockwise, the answer is the next vector clockwise. Indeed, .

The same works if you use it counter-clockwise: the answer is the next vector in counter-clockwise order: .

You can recompute the identities using the definition of cross-product based on the matrix determinant:

But that’s a lot of work.

*
* *

Mnemonics are always useful, if you manage to remember them. I mean it seriously. I think it’s easier to remember to 6 digits than to remember a 20-word poem. The clockwise/counter-clockwise analogy is a lot easier to remember if you’re a visual like I am.

*
* *

The Hidari Mitsudomoe images are based on a work released under the creative commons. The derived works complies with the license. The hiragana ’sohcahtoa’ calligraphy is mine, I retain full rights on this image.

References

[1] Florian Cajori — A History of Mathematical Notations — Dover, 1993 (also available in two volumes: V.1 and V.2).

---

¹ 6–7 decimal digits corresponds to the safe precision of IEEE 754 float, 16 corresponds to double.

Features I’d like to see in my Editor.

Do you ever have pipe-dreams about what you should be able to do with your computer? Like those crazy virtual interfaces like they had in the movie Minority Report or like every CSI lab seems to have? (well, that’s at the movies, of course). What about just more down-to-earth matters such as making large, complex documents such as source code more legible? I have few ideas—maybe a bit wacky.

Those Pesky Applications!

Regardless of which operating you’re using, you’re bound to encounter applications that cause you problems. Some applications cause you problems so often that you eventually place a custom launcher or even a keyboard short-cut to a command that kills the applications. Firefox used to be one, but since version 3, it’s been much better. I still have problems, though now it’s always related to the Flash plug-in (which is rather troublesome in 64 bits mode). Another one that cause me problems regularly, is EvilEvolution, the Exchange client for Linux.

One essential *nix command you should know, is kill. The kill command dispatches a signal to a process, by default, SIGTERM. This message instructs the process to terminate. It can ignore the signal, but in general, it will close gracefully after freeing resources. If the program ignores the signal or is in an unstable state, you can kill it “harder” by using kill -9, which sends the process an unmaskable SIGKILL. The process terminates instantly under most circumstances.

Bundling Memory Accesses (Part I)

There’s always a question whether having “more bits” in a CPU will help. Is 64 bits better than 16? If so, how? Is it only that you have bigger integers to count further? Or maybe more accessible memory? Well, quite obviously, being able to address a larger memory or performing arithmetic on larger number is quite useful because, well, 640KB isn’t all that much, and counting on 16 bits doesn’t get your that far.

But there are other advantages to using the widest registers available for computation. Often, algorithms that scan the memory using only small chunks—like bytes or words—can be sped up quite a bit using bundled reads/writes. Let us see how.

Why Validating Input so Hard in C?

Validating input from file or keyboard is probably the most difficult thing to get right in C. Not only is it difficult to get right regardless of the programming language, C really doesn’t do much to help you. There’s the standard library, mostly accessible through the two headers <stdlib.h> and <stdio.h>. However, the facilities provided by the C library are rustic at best. They haven’t aged well, and they’re clunky.

For this post, I will limit I/O validation to grabbing input from text files, whether through a redirection, pipe, file, or console input. I may discuss binary or highly structured formats like XML in a later post, but let us first limit ourselves to a few simple cases.

Stir Fried Stupid

A well structured library will contain functions that are grouped together in a same logical unit to help you perform a set of tasks more easily. This could be reading graphics files, or managing time and dates. Good libraries include just enough functions so that you have access to the complete functionality, but nothing superfluous.

Too often, libraries catch featuritis and grow large with less used functions that were added at some point to scratch a minor hitch. Worst, you discover functions hidden in a library that you’re not sure what to do with them, but sometimes, you find functions that are positively stupid. What is even more surprising is where you can find them. I found a couple in the GNU C Library.

Channel Mixing and Pseudo-Inverses

Let’s say we want to mix three channels onto two because the communication device has only two available channels but we still want to emulate a three channel link. If we can afford coding, then it’s not a problem because we can build our own protocol so add any number of channels using a structured data stream. But what if we cannot control the channel coding at all? In CDs, for example, there’s no coding: there are two channels encoded in PCM and a standard CD player wouldn’t understand the sound if it was encoded otherwise.

The solution is to mix the three channels in a quasi-reversible way, and in a way that the two channels can be listened to without much interference. One possible way is to mix the third channel is to use a phase-dependant encoding. Early “quadraphonic” audio systems did something quite similar. You can also use a plain time-domain “mixing matrix” to mix the three channels onto two. Quite expygeously, let us choose the matrix:

Lost+Found: Ghostly Geometry

Lusine – “Two Dots” from Ghostly International on Vimeo.

Live Video Color Gamut

The other day—well, a year ago or so—I was invited to visit CBC’s digital TV studios in Montréal by the SMPTE Montréal. We were shown around, even in the somewhat small control rooms. Amongst all the displays, dials, monitors, and misc. blinkenlights, I noticed a small LCD display showing an hexagonal projection of the current show’s color gamut in (or maybe ?), probably for quality assessment purposes. I thought it was pretty cool, actually.

Let’s see how we can realize this projection with as little CPU time as possible.

Wallpaper: Believe… or don’t

Believe, or dont. 1920×1200