Let’s find out how loud it would be if all the toddlers in China, localized to a single point, started screaming in unison.
China population: 1.3 billion
The age of toddling is roughly defined as 12-24 months
China Population, 0-4 years in age = 120 million
Assuming roughly equal distribution amongst that age bracket, that’s about 30 million toddlers.
According to this site, babies crying can reach about 115 decibels. Gah. that’s loud.
Now, let’s look at decibels.
While you can’t just add decibels together, you can use this handy equation:
10 * log((10^(a / 10)) + (10^(b / 10)))
Where (a) and (b) are two decibels that you are adding. To expand this to 30 million crying toddlers it’s best to use a program. I started with excel using a simple loop:
Dim i, limit As Integer
Dim multiplier As String
i = Cells(4, 5).Value
limit = Cells(3, 5).Value
multiplier = Cells(6, 4).Value
Cells(5, 2) = multiplier
i = (i + 1)
Cells(4, 7) = i
Loop Until i = (limit + 1)
This macro loops through the equation substituting in the current sound level and adding one baby at a time until we reach the limit set by the user. Ideally, the culmination of 30 million babies.
The problem here is that I’m not a very efficient programmer and this program runs excel’s memory dry after a mere 25,000 babies. After four times through the program, I was getting decibel levels of about 165 for 100,000 screaming toddlers. But, since we need 30 million, and I didn’t want to have to click through the program twelve hundred times, I had to call in the big guns. Enter Ryan Schenk.
Ryan Schenk took my code and re-implemented it as a ruby program. Take a look here:
unless (NUM_BABIES = ARGV.first.to_i) > 0
abort(“You need to tell me how many babies are crying\n” +
“\nruby cry_baby.rb 1234 # Where 1234 is the number of babies”)
SINGLE_CRY_VOLUME = 115.0
current_decibel_level = 0.0
current_decibel_level = 10.0 * Math.log10( (10.0 ** (current_decibel_level/10.0)) + (10.0 ** (SINGLE_CRY_VOLUME/10.0)))
He has 8 cpus on his computer so he can run 8 of these scripts in parallel, each computing the volume of 30m/8 babies. Ryan deems this the most efficient way to do it, one process per cpu core.
THE GRAND TOTAL:
You’ll note that all the toddlers in China, operating as a singularity, screaming in unison is almost as loud as a Saturn rocket.
Fun side notes:
This analysis looks at pure decibels and as such acts as a very rough estimation. If somehow the babies were screaming in different phases there would be the possibility that the babies crying would cancel each other out resulting in zero sound.
Hmm. this makes me wonder if you could build a speaker to read the sound wave of a crying baby and immediately respond with the inverse wave canceling out the cry.
We could call it Dr. ShutUp.