Journal of Dw

I should probably write something here, given that it's been at least a month since I last did! But I've been so busy with schoolthings (and really specialized interests[1]) that I can't think of much to write here, so...

... have some pictures instead! Goldkin drew some expression ones of me: here, here, or on his Twitter page.

And since I finished a rather exhausting assignment a few days ago, I think I'll be mostly unproductive today and do little :) Although I often tend to do more than I intend to, even so...

-

EDIT: And Google glitches of the day. First, try to search for "windows 9" "windows 8" -"windows 95" (yep, with a minus). See if it excludes stuff that contains Windows 95. Nope, instead it highlights the term.
Second, try to exclude something that definitely shouldn't be in any page: "windows 9" "windows 8" -"-windows 95". No hits?

-

[1] Like finding out that the distribution of county and state populations in different places of the world is more likely to be Levy than Cauchy, more likely to be log-normal than uniform, and more likely to be log-gamma than log-normal. At least from the data I have acquired so far, if I'm not doing something wrong.

I am so tired of having to be responsible all the time.

And while playing with HDR photography, I made this - because there can never be enough kitty pictures:



(The above is only a part of the image; the link goes to something that shows almost the whole cat.)

Is this a bug that would lead one to believe the site thinks 0/0 = 1, or am I wrong somewhere?

Hm.

After at least ten years, sqentropy at dyndns is no more.

I have to change my past DW/LJ links at some point so that they don't all break. But that's going to take work and time, so I can't do that just yet!

(New URL is, as I've mentioned, http://sqentropy.ax.lt/ )

I have been very busy lately with lots of assignments to finish and suchlike. But there was one thing I partly discovered on my own in the last mathematics lecture, that I'd like to mention:

We were on the subject of inverse functions, and the professor showed us how to find the derivative of an inverse function without knowing what that inverse function actually is. (This was in the multivariate case, but the logic holds both there and if you have only one variable.)

But then I started thinking: couldn't this be used to find the inverse function itself? Just repeat finding the derivative for the second, third, fourth, etc, derivative and then construct a Taylor series. And I asked about this, and he said that, indeed, that was possible.

One of the nice things about mathematics is that if you're not violating any of the premises, any trick you can think of will work. There's no god of mathematics that simply says "now you're just being a smartass" :)

(Later, he dealt with the theory of finding a graph curve (y = f(a, b, c, ...)) for a more general function (that inputs and outputs a vector), in the vicinity of a point. He proved that the curve will always exist given certain preconditions, but not how to find it. So I asked how one may find it, and he said that "in general, you'll have to do it numerically. There may be closed-form tricks in certain special cases, but I don't know of them". I later thought that sounded a lot like integration: there are tricks but if you want something fully general, numerical is the way to go :) )

Oh dear, am I tired. (I made some pretty silly test mistakes a few weeks ago, also. Always read the questions in detail, folks![1])

I will say this, however: The functional programming I'm learning about (not what I had a test in) seems to be coloring my thoughts pretty significantly at the moment, because I used some of today's time wondering how to make a C-alike language that would support a more functional style... and I came up with odd syntax like

void foo(int x, int y) = { cout << x << ", " << y << endl; }

("And all functions are simply variables in the global scope") and

void bar() = {
    void foo(int a) = { return(a + 1); }

    int an_array[3] = {1, 2, 3};

    // increments every element in an_array by 1.
    imperative_map(an_array, foo, 3);

    for (int i = 0; i < 3; ++i) {
        cout << a_list[i] << endl;
    }
}

But there might be a language that does this already. Though to be powerful enough, this hypothetical C variant should also support type inference, so that higher order functions like imperative_map can work on any and all types. Either that, or it's typename<T> time!

Er, yeah.

( Read more... )

recursion is fun! It feels more like magic.

Here's a nice functional programming exercise I did today: Given a function that increments an integer and a function that decrements it, create a function that returns the sum of two numbers, where either of the two numbers may be positive or negative.

As for today, all I have to say is...

Yay, all my finals are done... for now. So now I can focus on doing very little until mid-January.

(Though I always will be doing something, even if that is writing weird things here, or making fractal renderers for fun.)

Somehow, I feel quite tired, though. Perhaps I should try not to burden my mind too much, since I have been burdening it quite a bit on the preparations for the finals. But that's easier said than done, because I like using my mind. We'll see how that goes - I know I should rest a bit, but the tiredness itself makes it harder to do the right kind of decisions, so there's some element of positive feedback there.

As for the subjects I had tests in, there were three: mathematics (mostly calculus), numerical analysis (including plain old differential equations), and basic scientific programming. I think I did best at programming, then mathematics, then analysis. Amusingly enough, it was not so much the computer parts of numerical analysis that got me down as the mathematical ones (e.g. analytically solving linear and separable ODEs). I know the logic, but knowing the logic isn't enough: I also have to practice it, and I hadn't done that enough.

The only error I think I made on the programming thing was thinking that a Python dict is a primitive and so clones when you do an assignment of the type x = y. Call-by-sharing languages that exempt some types (but not all) from being references go against my aesthetics (for inconsistency purposes - but I've said so before) and I suppose it's only fitting that what snagged me was that particular feature :)