Groundhog Day
Happy Groundhog Day.
Support Bloggers' Rights!
The real and imaginary parts of impedance are called resistance and reactance while the real and imaginary parts of admittance (the reciprocal of impedance) are called conductance and susceptance.(Jon B. Hagen, Radio Frequency Electronics: Circuits and Applications)
Maybe I should go back to college.
Later on, Hagen says:
Digital processing of the IF signal makes it possible to realize any desired filter amplitude and phase response. Good performance requires sufficient processing power (available in general-purpose digital signal processor (DSP) chips) and high-speed high-resolution analog-to-digital converters. The prospoed standard for advanced television (ATV) requires substantial digital processing at the receiver, not only for obviously digital tasks (decoding, etc.) but also for signal processing, such as adaptive multipath signal cancellation.
Some people seem still not to believe this today!
... you write to Rachel and she responds, so to speak, by turning up in your supermarket forty minutes later.
... or when you have a dream about Wolfgang and she wakes you up by calling you.
Seen in an old edu-sig post:
"We have to reinvent the wheel every once in a while, not because we need a lot of wheels; but because we need a lot of inventors." - Bruce Joyce
(quoted by Jeffrey Elkner, who attributes it to the book Discovering Geometry)
He responded derisively, stating that the university was free but the compiler was not.Richard Stallman, in Open Sources
slashdot had a link to an interesting piece about space elevators (which I'm used to calling orbital towers). It seems that they might be feasible.
If you had to climb to LEO under your own power -- as by walking up stairs -- but you could rest at any point -- it would take under four years, assuming that you could climb the height of the Empire State Building each day. Food, oxygen, and restrooms are serious problems, as is temperature -- considering how difficult it is to climb Mt. Everest, which is just about 2% of the way to LEO. But it would be very rewarding! You could climb up the tower, coming out there other end, so to speak, four years older, much stronger, very hungry, and receiving an "I climbed most of the way out of the Earth's potential well and all I got was this lousy t-shirt" or "I gave myself 400 megajoules of gravitational potential energy and all I got was this lousy t-shirt" or "I accelerated myself into low Earth orbit and all I got was this lousy t-shirt" shirt.
(OK, so that 400 megajoules calculation is bogus -- it's based on multiplying the minimum energy used to climb the Empire State Building by the ratio between an estimate of LEO height and the Empire State Building's height. Since the Earth's gravity falls off as you get higher, though, it's actually much easier as you go -- so you could climb faster and with less energy expenditure and acquire less potential energy. I should do the integral and found out how much energy you actually store.)
On a more serious technical note, there was an interesting claim that you can use measurements of gzip's compression efficiency on various files in order to detect, in a statistically significant way, what language and document type they are, and even who wrote them. I got several e-mail messages about this result, but I haven't found a good link to a good explanation of it yet. If I see a link, I'll link to it. But that's an interesting claim, and it goes on to say something like "you can identify individual authors based on how well gzip compresses their works" (so we could just look at the sizes of federalist.1.txt.gz, federalist.2.txt.gz, etc., to sort out the authorship controversy?).
I tried running something like
#!/usr/bin/python
compression_level = 9
import zlib, sys
results = {}
def entropy(s):
# return zlib's estimate of the compression efficiency of s
# (measured in bits per character)
return len(zlib.compress(s, compression_level))*8.0/len(s)
for i in sys.argv[1:]:
try:
e = entropy(open(i,"r").read())
results[e] = i
except:
pass
k = results.keys()
k.sort()
for i in k:
print ("%.6f"%i), results[i]
and nothing jumped out at me.
In completely separate Python news, Python threads seem very easy to use. Maybe I'll write some multithreaded programs soon.
I thought this discussion in my draft recursion appendix for my Python class 4 handout came out well:
There's a common saying in programming that recursion has to have a "base case" (to prevent an infinite loop). Some people interpret this to mean that there must be a number which gets smaller all the time and a different rule to handle the situation when that number reaches the "bottom". This view of recursion is somewhat too narrow; if you think of recursion as a loop, or as a trip through an enchanted forest, the point is simply that, if you don't want to stay there forever, there must be some way out, and you must be able to reach the way out. We don't necessarily have to say what the way out _is_. It doesn't necessarily have to be a "number always getting smaller"; maybe a fairy shows up and waves a magic wand, or maybe you find a door in the side of a stone, or climb a tree and are carried away by an eagle, or fall through a trap door and end up somewhere else entirely. The point is just that there should be a way out. And, if you want to get out, you should come to it eventually.It's true that the most common recursion examples do use a variable which gets constantly smaller (or constantly larger), or a sequence type whose _size_ gets constantly smaller. But this form is not an absolute requirement. There are good reasons to write recursive code where the objects you're dealing with may well grow _and_ shrink, perhaps many times, before you've reached the end. (One common example is a queue technique, where you have a sort of to-do list. You won't be done until the to-do list is empty, but you may well add and remove things many times before you're done. Furthermore, the act of doing one thing on the to-do list may well involve adding other sub-tasks to the end of the list, so that the list actually appears to get longer, much as your room may temporarily become messier while you're re-organizing it.) There are even, in principle, sometimes good reasons in computer science to write recursive functions which don't necessarily terminate at all. You just wouldn't want to call them in an actual program with input which makes them loop forever, or you'll be waiting a long time for the results.
I had some success with udon noodles, shichimi togarashi, curry powder, green curry paste, soy sauce, teriyaki sauce, basil, bamboo shoots, baby corn, and sesame seeds. Problems: too much shichimi togarashi or curry paste, too little time cooking the bamboo shoots and corn. Also, I didn't have any tofu. But the teriyaki-shichimi togarishi-curry combination is pretty nice. It seems like some of the best-tasting sauce/spice combinations involve something sweet (hoisin sauce, teriyaki sauce, the House of Tsang stir-fry sauce) together with something spicy (curry or chilis).
Contact: Seth David Schoen