In the meantime though, if you want to do real-time audio synthesis in Javascript without requiring Chrome or special beta plugins for other browsers, one alternative is to use a Flash SWF that calls out to Javascript to do the audio generation. This post describes such a SWF.

Here’s the general idea: the ActionScript 3 code for the SWF uses the Sound class’ SampleDataEvent mechanism to periodically request sample data. The SampleDataEvent handler uses the ExternalInterface class to call a generateAudio() function implemented in Javascript; that function computes the audio sample values, and returns them to the SWF.

Code for a proof-of-concept can be found below. The full source code for the SWF is in one class, FlashAudioOutput. The Javascript code just generates a sine tone, but in principle you could of course generate whatever audio data you like.

The code is generally pretty obvious. The only tricky bit is how to transfer a block of audio sample data from Javascript to ActionScript. The most obvious way would be to use an Array, but this turns out to be horrendously inefficient. Incredible as it may seem, it’s actually more efficient to pass the data as a String!

That’s accomplished using Javascript code that converts an Array of normalized (-1,1) floating point numbers to a very long string of 16-bit integers represented in hexadecimal. That’s done in function convertToHexString() below. In the ActionScript code, the SampleDataEvent handler does the reverse operation of converting the string of hexadecimal values back to normalized float-point values.

Here’s the ActionScript code for the FlashAudioOutput class:

package
{
	import flash.display.Sprite;
	import flash.events.SampleDataEvent;
	import flash.external.ExternalInterface;
	import flash.media.Sound;
	
	/**
	 * A class to allow real-time audio generation in Javascript in browsers that
	 * don't support the HTML5 real-time audio API. Calls out to a generateAudio
	 * function at regular intervals to get a buffer of audio in the form of
	 * a string of 16-bit signed hexadecimal interleaves (LRLR...) samples.
	 */
	public class FlashAudioOutput extends Sprite
	{
		private const NUM_CHANNELS:uint = 2;			// Audio output is stereo
		private const CHUNK_LEN:uint = 8192;			// Number of stereo sample pairs per SampleDataEvent
		private const SAMPLE_RATE:Number = 44100;		// Sample rate (Hz)
		
		public function FlashAudioOutput()
		{
			var isAvailable:Boolean = ExternalInterface.available;
			if (!isAvailable)
			{
				trace("ExternalInterface not available!");
				return;
			}
			
			// Create Sound object for and start real-time audio 'callbacks'
			var snd:Sound = new Sound;
			snd.addEventListener(SampleDataEvent.SAMPLE_DATA, onSampleData);
			snd.play();
		}
		
		
		/**
		 * Called at regular intervals to request new audio
		 * data to be sent to the output.
		 */
		private function onSampleData(ev:SampleDataEvent):void
		{
			const BITS_PER_SAMPLE:uint = 16;		// Number of bits per sample
			const HEX_DIGITS_PER_SAMPLE:uint = 4;	// Number of hexadecimal digits per 16-bit sample
			const SHRT_MAX:Number = 32767.0;		// Maximum signed 16-bit number
			const SCALE:Number = 1.0/SHRT_MAX;		// For scaling from 16-bit signed int to normalized [-1,1] range
			const TWO_TO_16TH:Number = 65536;		// 2^16. For two's complement conversion

			
			// Call out to the Javascript audio generation function
			var hexBuf:String = ExternalInterface.call("generateAudio", CHUNK_LEN);
			
			var expectedLength:uint = NUM_CHANNELS * CHUNK_LEN * HEX_DIGITS_PER_SAMPLE;
			if (hexBuf.length != expectedLength)
				trace("hexString not expected length", hexBuf.length, expectedLength);
			
			var pos:uint = 0;
			for (var i:uint = 0; i < NUM_CHANNELS*CHUNK_LEN; i++)
			{
				// Get next 16-bit, 4 digit hex number
				var sub:String = hexBuf.substr(pos, HEX_DIGITS_PER_SAMPLE);
				pos += HEX_DIGITS_PER_SAMPLE;
				
				// Convert from 16-bit two's complement hexadecimal
				// to floating point number in range [-1,1]
				var val:Number = parseInt(sub, BITS_PER_SAMPLE);
				if (val > SHRT_MAX)
					val -= TWO_TO_16TH;
				val *= SCALE;
				
				// Write to output
				ev.data.writeFloat(val);
			}
		}
	}
}

And here’s the relevant bit of Javascript code:

			var phase = 0.0;
			var phaseInc = 2*Math.PI*440/44100;
			
			// Audio generation function. Called at regular intervals by the audio output SWF.
			function generateAudio(n)
			{
				// Generate a sine tone
				// Exercise for developer: make more interesting sound :-)
				var x = new Array(2*n);
				var pos = 0;
				for (i = 0; i < n; i++)
				{
					var val = 0.1*Math.sin(phase);
					x[pos++] = val;	// Left
					x[pos++] = val;	// Right
					phase += phaseInc;
				}

				return convertToHexString(x);
			}

			// 
			// Converts an array of floating point sample values into 16-bit hexadecimal
			// two's complement representation. Input values are expected to be in
			// [-1,1] range and are clipped if they exceed it.		
			function convertToHexString(x)
			{
				SHRT_MAX = 32767.0;
				TWO_TO_16TH = 65536;
				BITS_PER_SAMPLE = 16;
				HEX_DIGITS_PER_SAMPLE = 4;
			
				n = x.length;
				hexBuf = "";
	
				// For each sample			
				for (i = 0; i < n; i++)
				{
					val = x[i];
				
					// Clip to range [-1,1]
					if (val > 1)
						val = 1;
					else if (val < -1)
						val = -1;
				
					// Scale and convert to two's complement form						
					val = Math.floor(SHRT_MAX*val);
					if (val < 0)
						val += TWO_TO_16TH;
					
					// Convert to hexadecimal
					hex = val.toString(BITS_PER_SAMPLE);

					// Append to string, adding leading zeros if necessary
					pad = HEX_DIGITS_PER_SAMPLE - hex.length;
					while (pad--)
						hexBuf += "0";
					hexBuf += hex;
				}
				return hexBuf;
			}

A running implementation of the above can be found here.

Have fun with the code. Feel free to use it however you like. Comments are always welcome.

Note: to copy the code without the line numbers, just mouse over the top-right part are of each listing. Some icons will appear, one of which is for “copy to clipboard”. Click that, then paste into whatever editor you use for Flash development.

I first put AudioStretch online in late 2009, and I got a lot of traffic for a while, especially after André-Michelle tweeted about it. In retrospect, though, it really didn’t sound very good. I think people were just intrigued that stuff like this could be done at all in Flash.

Since then, I’ve made some huge improvements to the sound quality – better bass response, better transient handling, vastly better inter-channel phase coherence. I’ve added more speed options as well – you can even go to 0% speed, which can be pretty cool for working out notes of chords. (The UI is still really basic. Improvements coming soon!). So if you haven’t tried it in a while, or if you’ve never tried it at all, I invite you to give it a go:

Try AudioStretch Now!

Let me know what you think!

Incidentally, I have no plans to publicly release the code for AudioStretch. If you’re wondering how it works, here’s what I can tell you: it’s loosely based on the phase vocoder technique, but also embodies loads of proprietary tricks which I might write up one day…

Unlike some PC sound cards, the Mac doesn’t have an audio loopback feature to send the output to the input. It’s possible to physically route the output to the input using a 1/8″ to 1/8″ inch stereo cable connecting the audio output jack to the audio input jack, but that’s really crude, and isn’t digital.

The solution I found is Soundflower, a free download from Cycling 74, the makers of Max. It provides a virtual sound output, to which you can route the Mac’s audio output by going to System Preferences / Sound.

Whatever audio is sent to that output is routed to Soundflower’s virtual sound input, which can be set as your Mac’s default sound input (also via System Preferences / Sound).

Using Soundflower, I can record the sound output from my web browser (and whatever else I’m running) to a sound recording app such as Audacity or the QuickTime Player (which despite its name, can also do recording).

Note that if you route audio to Soundflower, you won’t hear it out your headphones or speakers. The workaround is to route your sound recorder’s output to your Mac’s (real, physical) audio output, and turn on the record monitoring function. In Audacity, you can set the former from the Playback menu in Audacity / Preferences / Devices; and the latter by checking the “Software Playthrough” checkbox in Audacity / Preferences / Recording.

This made me wonder: how reliable have S&P’s ratings on long-term debt really been historically?  They’ve been doing it for a long time, so presumably if they were really good at it, they would boast about their track record. Indeed, S&P would compete the other ratings agencies (Fitch, Moody’s) based on the accuracy of their predictions.

It’s well-known that S&P and the other ratings agencies were spectacularly wrong in the case of collateralized debt obligations, much of which rated as AAA. I wouldn’t be at all surprised if they’ve been wrong in less spectacular ways much of the time.

Presumably each credit rating corresponds to a probability of payout, and given historical data, one could check how well the ratings matched reality.   For example, if I were to look at all US-dollar denominated 10-year bonds issued in the year 2000, for which S&P had a rating at the time of issue, by 2010 one could tally up how they performed.

For simplicity, the performance of a particular bond could be expressed as a binary (yes/no) answer to a simple question: did the borrower pay the bond-holders the stipulated interest and principal?

If the ratings were worth anything, the probability of “yes” should be highest for the AAA bonds, and progressively lower for lower ratings (AA+, AA, etc. all the way to C).

Furthermore, the probabilities should be fairly stable over time; for example the probability of default for a 10-year bond rated BBB at issue in 1970 should be the same as that for a 10-year bond rated BBB in 2000. Certainly economic conditions in the 1970s were different from those in the 2000s, and some things are difficult to predict (e.g. the oil crisis in the 1970s, 9-11 in 2001), but the ratings guys are supposedly experts, so their ratings should be robust – or at least better than those of astrologists.

Does anyone know whether such back checking of ratings has been done? If it has been done, the information certainly sure isn’t easy to find.

Back to that recent downgrade: if I bought a 10-yr AAA US bond issued five years ago, according to S&P it’s now AA+… which sort of means the AAA rating wasn’t really correct to begin with. A prediction for long-term creditworthiness isn’t worth much if you’re allowed to change that prediction part-way!

According to a CityWire article, The Bank of England says that synthetic ETFs spell danger, and that  ‘An investor is not just exposed to the index that he or she thought they were exposed to but also to the counter party risk of the institution.’

Great. It’s risky enough being exposed to the stock market. Who needs exposure to institutional risk as well? Even before 2008, it was pretty clear that banks could fail. In 1995, Barings Bank failed due to the actions of just one reckless and over-ambitious trader.

Meanwhile a recent article in the Economist lists a variety of risks and complications that most ETF investors are blissfully unaware of.

Over the past couple of years, I’ve bought and sold various ETFs with no problem, and I still have some money in ETFs. They still seem like the best way to get some diversification, especially exposure to markets that might otherwise be difficult to invest in. For example, there’s no way I could possibly by shares in all companies in the S&P 500.

However, given the complicated structure of some ETFs and the risks now being exposed, I’m now definitely going to be more careful. You should be too…

Got a call on my home phone line from a woman with a strong Indian accent claiming to be with Windows Live support, telling me they’ve been receiving error reports from my computer. The connection was really bad, worse than the cheapest VoIP service. She asked me to switch on my computer and follow some instructions to fix the problem.

I was immediately suspicious, since I only have Macs here, though I do occasionally run Windows on them  (XP under VMWare on my MacBook Pro, and Windows 7 on my iMac in BootCamp). Besides, why would they have my home phone number? If I register software at all and have to give a phone number, I always use my mobile number, not my home phone.

So I asked to speak to her manager. A fellow with a thick Indian accent comes online, I ask where he’s from, he says (implausibly) Australia. I ask him when these error reports came in, he says “over past three months”. I ask for the date and time of the most recent one. He says “is continuous, today, yesterday”. I tell him I haven’t run Windows today or yesterday, and that I don’t trust his organization, and hang up.

In retrospect, I should have just followed along (or pretended to follow along) to find out what they wanted me to do. I wouldn’t be surprised if it involved downloading some special software to “fix the error” – software that would actually just copy files, track keystrokes, etc.

Anyone out there had a similar experience?

I was curious whether I’d get a similar performance disparity with some less trivial computation, so I ported my “even faster” AS3 FFT implementation to C#. The C# FFT uses only managed code (no pointers) so you can use it in Silverlight. I didn’t attempt to make any C#-specific optimizations, just did the minimal changes to get it to build.

As in my earlier C# vs. Flash performance test, I once again found that the C# implementation is much faster, nearly 4x faster than AS3. For 1000 forward-inverse pairs of 1024 pt FFTs, my C# FFT takes ~85 ms. The same test with the AS3 FFT takes over 300 ms.

I’m releasing the C# FFT code under the MIT license, which means you can pretty much do whatever you like with it, as long as you keep the comment block that says I wrote it and that you can do whatever you like with it . If you find it useful or have suggestions to improve it, feel free to leave a comment.

Update 3 August 2011: Graeme West reported some strange results using my FFT. I dug into it, and discovered a bug: the sign for the imaginary part of the “twiddle factors” was incorrect. I’ve fixed it now – just required changing the if (inverse) condition to if (inverse == false). I never noticed because for real input data (i.e. where the imaginary component is zero), the only impact on the output was that the sign of the imaginary component was flipped, and that had no effect on magnitude spectra (which is what I normally was computing). 

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace SpeedTest
{
	/**
	 * Performs an in-place complex FFT.
	 *
	 * Released under the MIT License
	 *
	 * Copyright (c) 2010 Gerald T. Beauregard
	 *
	 * Permission is hereby granted, free of charge, to any person obtaining a copy
	 * of this software and associated documentation files (the "Software"), to
	 * deal in the Software without restriction, including without limitation the
	 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
	 * sell copies of the Software, and to permit persons to whom the Software is
	 * furnished to do so, subject to the following conditions:
	 *
	 * The above copyright notice and this permission notice shall be included in
	 * all copies or substantial portions of the Software.
	 *
	 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
	 * IN THE SOFTWARE.
	 */
	public class FFT2
	{
		// Element for linked list in which we store the
		// input/output data. We use a linked list because
		// for sequential access it's faster than array index.
		class FFTElement
		{
			public double re = 0.0;		// Real component
			public double im = 0.0;		// Imaginary component
			public FFTElement next;		// Next element in linked list
			public uint revTgt;			// Target position post bit-reversal
		}

		private uint m_logN = 0;		// log2 of FFT size
		private uint m_N = 0;			// FFT size
		private FFTElement[] m_X;		// Vector of linked list elements

		/**
		 *
		 */
		public FFT2()
		{
		}

		/**
		 * Initialize class to perform FFT of specified size.
		 *
		 * @param	logN	Log2 of FFT length. e.g. for 512 pt FFT, logN = 9.
		 */
		public void init(
			uint logN )
		{
			m_logN = logN;
			m_N = (uint)(1 << (int)m_logN);

			// Allocate elements for linked list of complex numbers.
			m_X = new FFTElement[m_N];
			for (uint k = 0; k < m_N; k++)
				m_X[k] = new FFTElement();

			// Set up "next" pointers.
			for (uint k = 0; k < m_N-1; k++)
				m_X[k].next = m_X[k+1];

			// Specify target for bit reversal re-ordering.
			for (uint k = 0; k < m_N; k++ )
				m_X[k].revTgt = BitReverse(k,logN);
		}

		/**
		 * Performs in-place complex FFT.
		 *
		 * @param	xRe		Real part of input/output
		 * @param	xIm		Imaginary part of input/output
		 * @param	inverse	If true, do an inverse FFT
		 */
		public void run(
			double[] xRe,
			double[] xIm,
			bool inverse = false )
		{
			uint numFlies = m_N >> 1;	// Number of butterflies per sub-FFT
			uint span = m_N >> 1;		// Width of the butterfly
			uint spacing = m_N;			// Distance between start of sub-FFTs
			uint wIndexStep = 1; 		// Increment for twiddle table index

			// Copy data into linked complex number objects
			// If it's an IFFT, we divide by N while we're at it
			FFTElement x = m_X[0];
			uint k = 0;
			double scale = inverse ? 1.0/m_N : 1.0;
			while (x != null)
			{
				x.re = scale*xRe[k];
				x.im = scale*xIm[k];
				x = x.next;
				k++;
			}

			// For each stage of the FFT
			for (uint stage = 0; stage < m_logN; stage++)
			{
				// Compute a multiplier factor for the "twiddle factors".
				// The twiddle factors are complex unit vectors spaced at
				// regular angular intervals. The angle by which the twiddle
				// factor advances depends on the FFT stage. In many FFT
				// implementations the twiddle factors are cached, but because
				// array lookup is relatively slow in C#, it's just
				// as fast to compute them on the fly.
				double wAngleInc = wIndexStep * 2.0*Math.PI/m_N;
				if (inverse == false)
					wAngleInc *= -1;
				double wMulRe = Math.Cos(wAngleInc);
				double wMulIm = Math.Sin(wAngleInc);

				for (uint start = 0; start < m_N; start += spacing)
				{
					FFTElement xTop = m_X[start];
					FFTElement xBot = m_X[start+span];

					double wRe = 1.0;
					double wIm = 0.0;

					// For each butterfly in this stage
					for (uint flyCount = 0; flyCount < numFlies; ++flyCount)
					{
						// Get the top & bottom values
						double xTopRe = xTop.re;
						double xTopIm = xTop.im;
						double xBotRe = xBot.re;
						double xBotIm = xBot.im;

						// Top branch of butterfly has addition
						xTop.re = xTopRe + xBotRe;
						xTop.im = xTopIm + xBotIm;

						// Bottom branch of butterly has subtraction,
						// followed by multiplication by twiddle factor
						xBotRe = xTopRe - xBotRe;
						xBotIm = xTopIm - xBotIm;
						xBot.re = xBotRe*wRe - xBotIm*wIm;
						xBot.im = xBotRe*wIm + xBotIm*wRe;

						// Advance butterfly to next top & bottom positions
						xTop = xTop.next;
						xBot = xBot.next;

						// Update the twiddle factor, via complex multiply
						// by unit vector with the appropriate angle
						// (wRe + j wIm) = (wRe + j wIm) x (wMulRe + j wMulIm)
						double tRe = wRe;
						wRe = wRe*wMulRe - wIm*wMulIm;
						wIm = tRe*wMulIm + wIm*wMulRe;
					}
				}

				numFlies >>= 1; 	// Divide by 2 by right shift
				span >>= 1;
				spacing >>= 1;
				wIndexStep <<= 1;  	// Multiply by 2 by left shift
			}

			// The algorithm leaves the result in a scrambled order.
			// Unscramble while copying values from the complex
			// linked list elements back to the input/output vectors.
			x = m_X[0];
			while (x != null)
			{
				uint target = x.revTgt;
				xRe[target] = x.re;
				xIm[target] = x.im;
				x = x.next;
			}
		}

		/**
		 * Do bit reversal of specified number of places of an int
		 * For example, 1101 bit-reversed is 1011
		 *
		 * @param	x		Number to be bit-reverse.
		 * @param	numBits	Number of bits in the number.
		 */
		private uint BitReverse(
			uint x,
			uint numBits)
		{
			uint y = 0;
			for (uint i = 0; i < numBits; i++)
			{
				y <<= 1;
				y |= x & 0x0001;
				x >>= 1;
			}
			return y;
		}
	}
}

LocalFileReadWrite is very simple web app that displays a TextBox and two Buttons, Save and Open. Clicking the Open button allows you to open a *.txt and display it in the TextBox. You can then edit the text, click Save to save the contents of the TextBox into another file. It’s a bit like Notepad.exe, but with even fewer features

You can try it here.

A zip of the whole project can be found here. It’s buildable with MS Visual Web Developer 2010 Express. Most of it’s boilerplate stuff you get when you create a new project. The only files I modified were the C# file MainPage.xaml.cs and the XAML file MainPage.xaml.

I was pleasantly surprised at how little code was required. It’s even less complicated than reading/writing local files in Flash (see Mike Chambers’ post on that).

Here’s the C# code:

using System;
using System.Windows;
using System.Windows.Controls;
using System.Diagnostics;		// Debug.WriteLine
using System.Text;				// UTF8Encoding
using System.IO;				// Stream, IOStream

namespace LocalFileReadWrite
{
	public partial class MainPage : UserControl
	{
		private const String FILE_FILTER = "Text files (*.txt)|*.txt";
		private const String WELCOME = "Type text here. Click 'Open' to open any *.txt file. Click 'Save' to save to a new *.txt file (or overwrite an existing one).";

		public MainPage()
		{
			InitializeComponent();
			textBox.Text = WELCOME;
		}

		private void OnOpenButtonClick(object sender, RoutedEventArgs e)
		{
			OpenFileDialog openFileDialog = new OpenFileDialog();
			openFileDialog.Filter = FILE_FILTER;

			if (openFileDialog.ShowDialog() == true)
			{
				System.IO.FileStream fileStream = openFileDialog.File.OpenRead();
				byte[] textBytes = new byte[fileStream.Length];
				fileStream.Read(textBytes, 0, textBytes.Length);
				textBox.Text = UTF8Encoding.UTF8.GetString(textBytes, 0, textBytes.Length);
			}
		}

		private void OnSaveButtonClick(object sender, RoutedEventArgs e)
		{
			SaveFileDialog saveFileDialog = new SaveFileDialog();
			saveFileDialog.Filter = FILE_FILTER;

			if (saveFileDialog.ShowDialog() == true)
			{
				System.IO.Stream stream = saveFileDialog.OpenFile();
				byte[] textBytes = UTF8Encoding.UTF8.GetBytes(textBox.Text);
				stream.Write(textBytes, 0, textBytes.Length);
				stream.Close();
			}
		}
	}
}

And here’s the XAML:

<UserControl x:Class="LocalFileReadWrite.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="380" d:DesignWidth="696">

    <Grid x:Name="LayoutRoot" Background="White">
        <Button Content="Open" Height="23" HorizontalAlignment="Left" Margin="12,12,0,0" Name="openButton" VerticalAlignment="Top" Width="75" Click="OnOpenButtonClick" />
        <Button Content="Save" Height="23" HorizontalAlignment="Left" Margin="93,12,0,0" Name="saveButton" VerticalAlignment="Top" Width="75" Click="OnSaveButtonClick" />
        <TextBox Margin="12,41,12,12" Name="textBox" TextWrapping="Wrap" VerticalScrollBarVisibility="Auto" AcceptsReturn="True" />
    </Grid>
</UserControl>

Reading and writing text files is of course just one thing you can do given the ability to read/write local files. One can imagine creating all sorts of handy web-based utilities – hex editors, waveform editors, image editors – all running in web pages, and accessible from Mac or PC.

Feel free to use and modify the code as you wish, though some sort of attribution (a link or comment in the code) is always appreciated. Enjoy!

Recently I’ve been experimenting with Silverlight and C#, and it generally seems much speedier than Flash and AS3. So I re-did the test I did a few months back, doing repeated element-by-element addition of two long arrays, this time using C#. I also redid the AS3 timing test, since I got a faster MacBook Pro since my last post on this subject. The core of the C# timing test code looks like this:

			int startTime = System.Environment.TickCount;
			for (int j = 0; j < LOOPS; j++)
			{
				for (int k = 0; k < N; k++)
				{
					z[k] = x[k] + y[k];
				}
			}
			int endTime = System.Environment.TickCount;

So here’s how Silverlight/C# stacks up against Flash/AS3:

So for this simple test, C# arrays are over 5x faster than Vectors in AS3, and over double the speed of linked lists. This is only one test, of course, but if this sort of difference in performance is typical, it clearly has big implications on what’s possible on the two platforms. In particular, it makes Silverlight/C# very attractive for real-time audio applications, which require lots of array accessing and number crunching.  [Update 6 April 2011: I also found that an FFT I wrote ran ~4x faster in C# than in AS3. See An FFT in C#].

Tests were run on my MacBook Pro (2.66 GHz Intel Core i7, Mac OS 10.6.6), with Flash Player 10.1.52.14 and Silverlight 4.0.60129.0.

For the full C# timing test code, click “show code” below.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Diagnostics;

namespace SpeedTest
{
	public partial class MainPage : UserControl
	{
        private const int N = 5000;		// No. of elements in arrays
        private const int LOOPS = 5000;	// No. of times to repeat the calculations

		public MainPage()
		{
			InitializeComponent();

			int elapsed = ArrayTest();
			status.Content = "Elapsed: " + elapsed.ToString(); // Note: 'status' is a 'Label' defined in the project's xaml file.
		}

		/**
		 * Add elements of one array to elements of another
		 * array, and put the results into a third array.
		 */
		private int ArrayTest()
		{
			// Create arrays
			double[] x = new double[N];
			double[] y = new double[N];
			double[] z = new double[N];

			// Initialize them with some values
			for (int k = 0; k < N; k++)
			{
				x[k] = k;
				y[k] = k;
				z[k] = 0.0;
			}

			// Add the values in the two arrays, with result
			// in a third array.  Repeat many times.
			int startTime = System.Environment.TickCount;
			for (int j = 0; j < LOOPS; j++)
			{
				for (int k = 0; k < N; k++)
				{
					z[k] = x[k] + y[k];
				}
			}
			int endTime = System.Environment.TickCount;

			// Return the elapsed time.
			return (endTime - startTime);
		}
	}
}

For example, if a share is currently trading at $100 per share, and the company earnings $10 per share per year, the company’s PE is 10.  All else being equal, shares trading with a low PE are better value than those with a high PE.

Something to watch out for with the PE ratio is that while the numerator P is the current share price, the denominator E is a trailing value – sometimes by more than you might expect. Often the earnings for the last complete fiscal year is used.  If you’re already 3 quarters into the current fiscal year, that means the E in the PE ratio is a full 9 months out of date… and when the current full year results come out, the PE ratio can suddenly jump higher or lower, even if the share price P remains constant (which it won’t for long).

Consider, for example, a company with earnings of $40M in the most recent fiscal year, and a market cap of $200M.  That would give it a PE of 5 – attractive enough to attract some punters looking for bargains. Now suppose you dig a tiny bit deeper and find that in earnings in the first three quarters of the current fiscal year are only $7.5M.  Assuming the trend continues for the final quarter, the full year earnings would be ~$10 M… and the PE would suddenly jump to 200/10 = 20.  Not so attractive.

If you’re lucky, a quoted PE will use the earnings over the most recent 4 quarters, in which case it’s sometimes written as “PE (ttm)” where “ttm” means “Trailing Twelve Months“.  Even so it means the end date of that sliding 12-month window can be up to one quarter out of date, and its mid-point up to 3 quarters out of date.

For shares traded on the SGX, I refer a lot to Shares Investment website, which uses the most recent reporting year in its PE values.  For info on US companies, I refer to Yahoo Finance uses TTM.

In some ways, P/E is a bit of a silly ratio, as it goes to positive infinity as earnings approach zero… and flips to a huge negative number if a company reports a tiny loss. In fact, when earnings go negative, the PE is generally given as NA (“not applicable”).

Personally I prefer to think of the reciprocal of the PE ratio, namely the EP ratio – the earnings per share divided by the share price - as it’s well-behaved for earnings near zero, and meaningful even for losses.  The denominator of the EP ratio never hits zero (though it can come frighteningly close, e.g. if you were unfortunate enough to hold shares in Nortel). EP is also easier to compare with interest rates (e.g. on bonds or fixed deposits).  Consider a company with a very high PE ratio, say 50.  That’s the same as an EP ratio of 0.02 or 2%.  If shares in a company have a PE ratio of 50, you’re probably be better off owning a safe bond yielding 2%, unless you’re really confident the a company’s earnings will grow a lot in upcoming years.