Entries:
Posts:

Something went wrong getting user information from Channel 9

Latest Achievement:

Something went wrong getting user information from MSDN

Visual Studio Achievements

Latest Achievement:

Something went wrong getting the Visual Studio Achievements

Nicely done, Channel 9 (posted by Dr Herbie).

• Oops, something didn't work.

Getting "follow" information
• sushovande said:
Ion Todirel said:
*snip*

http://www.wolframalpha.com/input/?i=product+of+((1+%2B+1/k)^3+/+(1+%2B+3/k))+for+k+%3D+1+to+inf">http://www.wolframalpha.com/input/?i=product+of+((1+%2B+1/k)^3+/+(1+%2B+3/k))+for+k+%3D+1+to+inf

http://www.wolframalpha.com/input/?i=product+of+((1+%2B+1/k)^3+/+(1+%2B+3/k))+for+k+%3D+1+to+inf">

Although I solved it by counting the number of f's in the first formula, then realizing that the number '9' was special to C9.

Great job!

C

• Charles said:
sushovande said:
*snip*

Great job!

C

Nice job, Charles

• Charles said:

Nicely done, Niners!

To be clear, I had little to do with this clever prank. Dan and Duncan came up with the basic idea, I recruited the best two people in the world IMO, Erik and Brian, to come up with the complex expressions used in the gate (Erik provided the Church numeral encoding(nice job, W3bbo!), Brian the beautiful mathematical expression, of course). Geoff, a recent stellar addition to our dev team, implemented this in record time. Rock star.

So, nicely done Dan, Duncan, Geoff, Erik and Brian.

Happy April Fools,

C

Thanks Charles

This was a fun one. I like to make sure that the 'truth' is always somewhere in the source

• Geoffreyk said:
Charles said:
*snip*

Thanks Charles

This was a fun one. I like to make sure that the 'truth' is always somewhere in the source

My blood started to boil and I was writing a draft email full of abuse in my head!

"Ive been coming to the coffeehouse for six years and......!!!!"

Got me!!!

• Charles said:
sushovande said:
*snip*

Great job!

C

Kudos to everyone who figured it out, figure out a way to find out, and even brute forced through the js.

• LarryLarsen said:
Charles said:
*snip*

Kudos to everyone who figured it out, figure out a way to find out, and even brute forced through the js.

,,i couldnt get in! ... i tried a few things... then i went - wait... it cant be hard...  ahhh    * 9! *

• Am I the only one who got:

f^7 f(x) (fλ).(xλ).f

?

• SlackmasterK said:

Am I the only one who got:

f^7 f(x) (fλ).(xλ).f

?

I'm all for april fools, but this makes it so you can't enter the forums or use the site. Don't see the point of it.

• My first attempt was entering "What is threeive?"  (from an old saturday night live sketch), but that just got me the "Come on, really?" response....

I had to use the equation editor in word to figure out what the sign meant.  Once I found out it stands for product, it was just a matter of putting it in excel.  Thanks for the entertainment and challenge.

• jamie said:
LarryLarsen said:
*snip*

,,i couldnt get in! ... i tried a few things... then i went - wait... it cant be hard...  ahhh    * 9! *

Nice work, Jamie!!
C

• First I...

And then I...

But then...

And suddenly...

And then I ended up here... Now what!?

All in all, my algebra teacher would probably scalp me and go with "Y cannot be 9, Y can only be formulated as Y->9"...

• bureX said:

First I...

And then I...

But then...

And suddenly...

And then I ended up here... Now what!?

All in all, my algebra teacher would probably scalp me and go with "Y cannot be 9, Y can only be formulated as Y->9"...

Wow. Did you also program your FPGA to try to compute it for you?

• Bass said:
bureX said:
*snip*

Wow. Did you also program your FPGA to try to compute it for you?

We'll make a steampunk version eventually

• bureX said:
Bass said:
*snip*

We'll make a steampunk version eventually

I tried computing the value of the product using the highest value of k possible to see how fast it converges, using a 56 node cluster (I know there are better ways to compute something like this; doing it in a hopelessly convoluted way was kind of the point here). The problem is, doubles aren't precise enough, and Math.Pow doesn't support decimals. Does anyone know a good, fast, high precision floating point library for .Net?

EDIT: Worked around the lack of Math.Pow by simply multiplying the value three times. Definitely more precise than double, but also a lot slower. Even on these 56 nodes it takes me about 3.5 minutes to calculate for k = 1 through 10,000,000,000. The same scenario with double takes only 21 seconds, but yields a clearly different result.

Mind you, doing the same thing on my local machine would've taken roughly 7 hours.

• Sven Groot said:
bureX said:
*snip*

I tried computing the value of the product using the highest value of k possible to see how fast it converges, using a 56 node cluster (I know there are better ways to compute something like this; doing it in a hopelessly convoluted way was kind of the point here). The problem is, doubles aren't precise enough, and Math.Pow doesn't support decimals. Does anyone know a good, fast, high precision floating point library for .Net?

EDIT: Worked around the lack of Math.Pow by simply multiplying the value three times. Definitely more precise than double, but also a lot slower. Even on these 56 nodes it takes me about 3.5 minutes to calculate for k = 1 through 10,000,000,000. The same scenario with double takes only 21 seconds, but yields a clearly different result.

Mind you, doing the same thing on my local machine would've taken roughly 7 hours.

Some results with various maximum values of k:

```Max. value of k     Formula value                    Execution time
100,000,000         5.9999998200000059999997770956   15s10,000,000,000      5.9999999982000000009369275168   208s
50,000,000,000      5.9999999996400000005856836804   1069s
```

This is done using decimal. If that's precise enough, and my code has no bugs, we can conclude the product converges quite slowly. Again, this was done on a cluster with 56 nodes (most of which aren't very fast, though). Done locally, it wouldn't taken me about 33 hours. Note that the 100,000,000 job (the first one) takes unnecessarily long because the system I'm using isn't optimized for short jobs.

There, I think I can now safely claim the most elaborate solution to this problem.

• Sven Groot said:
Sven Groot said:
*snip*

Some results with various maximum values of k:

```Max. value of k     Formula value                    Execution time
100,000,000         5.9999998200000059999997770956   15s10,000,000,000      5.9999999982000000009369275168   208s
50,000,000,000      5.9999999996400000005856836804   1069s
```

This is done using decimal. If that's precise enough, and my code has no bugs, we can conclude the product converges quite slowly. Again, this was done on a cluster with 56 nodes (most of which aren't very fast, though). Done locally, it wouldn't taken me about 33 hours. Note that the 100,000,000 job (the first one) takes unnecessarily long because the system I'm using isn't optimized for short jobs.

There, I think I can now safely claim the most elaborate solution to this problem.

Awesome, in our office we did joke about creating a 1000 node azure cluster to do it but it was luch time and there was curry calling

• Sven Groot said:
Sven Groot said:
*snip*

Some results with various maximum values of k:

```Max. value of k     Formula value                    Execution time
100,000,000         5.9999998200000059999997770956   15s10,000,000,000      5.9999999982000000009369275168   208s
50,000,000,000      5.9999999996400000005856836804   1069s
```

This is done using decimal. If that's precise enough, and my code has no bugs, we can conclude the product converges quite slowly. Again, this was done on a cluster with 56 nodes (most of which aren't very fast, though). Done locally, it wouldn't taken me about 33 hours. Note that the 100,000,000 job (the first one) takes unnecessarily long because the system I'm using isn't optimized for short jobs.

There, I think I can now safely claim the most elaborate solution to this problem.

There, I think I can now safely claim the most elaborate solution to this problem.

If I may interject, I suggest we purchase the following gadget (maybe it's listed on ebay, eh?):

...and calculate the product convergence all the way to k=6.1871539834134776012651492465284 x 10^34 (the reciprocal value of Planck's length). Maybe we can halt the Folding@Home or the Seti@Home projects for a temporary period while we use the available CPU time for the calculation of the said problem. After all, this IS channel9, not channel 8.9999999999873293. I, for one, will not stand for this mathematical discrepancy. If anybody has watched the movie Pi, there is a magic number out there that can make all computers become self-aware, predict the functioning of the stock market and reveal god to the Jewish people (maybe it can even aid in the making of lumpless pudding*). If we all work together, maybe we can find this neatly secluded needle in the haystack... or maybe not... after all, I've got some lumpy pudding to tend to (it has just cooled down enough to please my picky taste buds)... Happy april fools day everybody
*Lumpless pudding is not actually sans lumps if there is at least one lump that surpasses Planck's length (all dimensions below Planck's length make "no physical sense", as it seems). Man... that must be some smooth pudding right there.

• Sven Groot said:
Sven Groot said:
*snip*

Some results with various maximum values of k:

```Max. value of k     Formula value                    Execution time
100,000,000         5.9999998200000059999997770956   15s10,000,000,000      5.9999999982000000009369275168   208s
50,000,000,000      5.9999999996400000005856836804   1069s
```

This is done using decimal. If that's precise enough, and my code has no bugs, we can conclude the product converges quite slowly. Again, this was done on a cluster with 56 nodes (most of which aren't very fast, though). Done locally, it wouldn't taken me about 33 hours. Note that the 100,000,000 job (the first one) takes unnecessarily long because the system I'm using isn't optimized for short jobs.

There, I think I can now safely claim the most elaborate solution to this problem.

Take the log of the big product. Each term looks like [ n log(k+1) + (1 - n) log(k) - log(k + n) ], (n is 3, in our example) and the big product is replaced by a big sum. Now investigate the convergence rate of the big sum, taking a look at http://en.wikipedia.org/wiki/Rate_of_convergence