I recently implemented an algorithm that has to perform checks on all subsets of some large set. A subset of an $n$-sized set can be understood as a binary string of length $n$ where bit $i$ is set if and only if the $i$-th element is in the subset. During my search for code to enumerate such bitstrings, I found the greatest page in the entire internet. If anyone can explain to me how computing the next bit permutation (the last version) works, please do.
Even though this does not really constitute a post with substantial content, this is a blog after all, so I thought I'd let the 8 people who read it know that for the next six weeks, I will be attending a special semester on Algorithms and Complexity in Algebraic Geometry at the Simons Institute for the Theory of Computing in Berkeley. So. If you happen to be in the bay area, give me a shout.
The university supplied me with this really cool yoga 2 pro notebook and even though I have grown to like it, it does have some serious design flaws. I will not go into detail on all of those, but one problem is that they decided to put the End and the Insert key onto the same button, and to press End you have to simultaneously hold the function key, which is on the opposite side of the keyboard ((I am talking about the German Keyboard layout by the way. I realize now that I am quite possibly the only person on the planet with this problem.)). I personally need to press End quite frequently while typing text or code, while Insert is only required occasionally. To make a rather boring story short at the very least, I got myself SharpKeys, an open source tool which alters a registry key that is able to re-map keys as you see fit. It's quite awesome. Apparently, some people use it to turn off the capslock key. WHY THE HELL WOULD I WANT TO DO THAT?
I need to update this wordpress install every once in a while. There are lots of bash scripts on the internet that perform this task, and they are complicated beyond reason. This is what I use:
function cfg {
grep $2 $1/wp-config.php | awk 'BEGIN {FS="[, )\x27]*"}; {print $3;}'
}
echo "> backing up database."
mysqldump --user=$(cfg $1 DB_USER) \
--password=$(cfg $1 DB_PASSWORD) \
--host=$(cfg $1 DB_HOST) \
$(cfg $1 DB_NAME) > backup.database.sql
echo "> backing up website."
tar -cjf backup.files.bz2 $1
echo "> retrieving latest wordpress."
wget -q https://wordpress.org/latest.zip
unzip -qq latest.zip
echo "> updating wordpress."
rm -r $1/wp-includes $1/wp-admin
cp -r wordpress/* $1/
echo "> cleaning up."
rm -r wordpress
rm latest.zip
backup.database.sql and backups the files to backup.files.bz2, then it simply proceeds as described in the wordpress codex for updating manual. I do not see what all the fuzz is about.
When you have a Laptop with Windows 8.1 preinstalled, then you will find yourself having a hard time installing a clean copy of Windows 8 on said Laptop. That, however, might be desirable for various reasons and so I am telling you how it's done. In my case, I am doing it with the firm intention to encrypt the system partition with TrueCrypt Setup 7.1a, which requires me to have an MBR rather than a GPT. There are probably ways to change this in-place, but there's really no point because I want a clean install of Windows anyway.
(more…)
Member variables in python are horrible. They are not visible in the layout of the class which is instantiated, but instead the
__init__ function of a class creates certain member variables for the instance. I have never liked this about python, to be honest. For a recent project, I devised the following solution. Assume you would want this behaviour:
>>> class test(Base):
... # Variables
... number = 4
... string = "hodor"
... # Functions
... def stringmult(self):
... return self.number * self.string
...
>>> test().stringmult()
'hodorhodorhodorhodor'
>>> test(number=2).stringmult()
'hodorhodor'
>>> test(string="Na",number=8).stringmult() + " - Batman!"
'NaNaNaNaNaNaNaNa - Batman!'
>>>
>>> test(end="Batman!")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ctypes.ArgumentError
>>>
Base can be constructed with keyword arguments who must match exactly the correct class variables which you specify. This one does it:
from ctypes import ArgumentError
class Base(object):
def __init__(self, **kwargs):
# "given" is the list of keyword arguments passed to the constructor
# of this object, "needed" is the list of class variables which belong to
# the base class of the object which is being created, which do not end
# with two underscores and which are not a function. Trust me, we do not
# want to meddle with those.
given = list(kwargs.keys())
needed = [attr for attr in dir(self.__class__) if attr[-2:] != '__' \
and type(self.__class__.__dict__[attr])!=type(lambda:0) ]
# Check if keyword arguments have been provided which are not among the
# required arguments and throw an exception if so. Remove this check for
# a less restrictive base class. I wouldn't recommend it.
if not set(given) <= set(needed):
raise ArgumentError()
# First, initialize the attribute dictionary of the object being created
# with a list of default values, indicated by the values of the class
# variables. Then, update the attribute dictionary again with the values
# provided to this constructor.
self.__dict__.update({k: self.__class__.__dict__[k] for k in needed})
self.__dict__.update(kwargs)
It causes me unspeakable agony to see that my post about why sudoku is boring is one of the most frequented posts in this blog, mostly because most of my readers clearly disagree with the title. I recently received an email titled "why sudoku is not all that boring" by an old friend, and he taunted me that the sudoku
S = [
0, 0, 0, 0, 6, 0, 0, 8, 0,
0, 2, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0, 0,
0, 7, 0, 0, 0, 0, 1, 0, 2,
5, 0, 0, 0, 3, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 4, 0, 0,
0, 0, 4, 2, 0, 1, 0, 0, 0,
3, 0, 0, 7, 0, 0, 6, 0, 0,
0, 0, 0, 0, 0, 0, 0, 5, 0 ]
real 51m3.656s
user 50m32.260s
sys 0m2.084s
Since everyone now uses TextSecure (no, really, you should switch too!), everything close to a TextSecure desktop client is not finished enough and I want to type messages from my computer (in the old SMS ages, I did this with MyPhoneExplorer), I decided to remote control my Android device.
The setup is straight forward (if you already have root privileges on your device):
* Install a VNC-Client for Windows (for example RealVNC)
* Install a VNC-Server for Android (for example droid VNC server)
* Go through the settings of the VNC-Server
For some reason I cannot connect from my Computer to the Phone, but "Reverse Connection" works like a charm (don't forget to start the VNC Viewer in listening mode ... as ... some friend of mine did).
Edit: And after a restart of my phone, the normal direction also works.
In the past weeks I've been visiting quite the number of jobs fairs, networking events, trainings on how to hunt for jobs and the like. I certainly learned a lot, albeit mostly things that are obvious after a moment of contemplation or come to you by common sense. Yet a simple reminder and a bit of practice are surely beneficial. High in demand are all these abstract skills we all have been told one too many times to include on your CV (complex and analytical thinking ...) and programming skills (although many employers seem to be happy to train on the job). What somehow fell of my radar and which came up more than once, is a basic knowledge of statistics.
This leaves us in a bit of a pickle because most available material seems to fall into one of the two following categories:
1. Statistic for statisticians: Something we all have very actively decided against studying. All the proofs and constructions and endless excursions into theoretical concepts that haven't yet and maybe never will make their way into practice. Scientific exploration that is fun if and only if you have a thing for statistics.
2. Statistics for undergrads who don't even know if they need it, lectured by junior-professors or assistants who rather spend their time on research than on preparations: What you get is a incoherent bunch of powerpoint slides that seem to live more through examples than concise explanations and miss out on the most important part, namely a self-contained overview over available methods.
To the rescue comes Arnaud Delorme, a computational neuroscientist from the University San Diego. His paper on statistical methods does basically everything you want on 23 pages: A quick recap of the necessary definition, a clean-cut overview over the most common methods and a short concise explanation for each of them with just the right amount of theoretical background and a short demonstrating example.
Sure, towards the end it can be a bit tiresome to go through method after method and you won't want to read it front to back in one go. Of course I also can't guarantee for its exhaustiveness, but it seems like we have a winner when it comes to ratio of usefulness over required time-investment.
Opera was updated. They messed up. Let's not talk about this any more. Let's talk about how to make Firefox your new Opera 12. To get the elephant out of the room right away: Yes, you guessed right, I did not switch to Chrome because I am scared of Google harvesting all my data and browsing habits. So that leaves only Firefox, and I think that they did good with the recent releases. We probably can not get back everything we miss from Opera 12 times, but some of it is possible, and even better in Firefox. First of all, Firefox has bookmarks and you can import them from an HTML export of your old bookmarks. For everything else, continue reading. If you are still missing a feature, feel free to post it with or without solution - in the latter case, I will try and solve it myself.
(more…)
Let $G$ be an affine, connected, reductive group and $X$ a $G$-module. Choose a maximal torus $T\subseteq G$, a Borel $B\subseteq G$ containing $T$ and let $U$ be the unipotent radical of $B$. Denote by the character group of $T$. Let $\Lambda\subseteq\mathbb{X}$ be the set of dominant weights of $G$ with respect to these choices. We can decompose the graded coordinate ring $\mathbb{C}[X]=\bigoplus_{\lambda\in\Lambda} V_{(\lambda)}$ into its isotypic components $V_{(\lambda)}$ of weight $\lambda$. Let
\[ \Lambda_X=\{ \lambda\in\Lambda \mid V_{(\lambda)}\ne\{0\}\} \]
be the set of weights that occur in $\mathbb{C}[X]$.
Let $V_{(\lambda)}\cong V_\lambda^{\oplus n_\lambda}$, where $V_\lambda$ is the irreducible module of highest weight $\lambda$. Each $V_\lambda$ has a highest weight vector which is unique up to scaling - let $f_{\lambda 1}, \ldots, f_{\lambda n_\lambda}\in V_{(\lambda)}$ be linearly independent highest weight vectors.
Claim. *For each $1\le k\le n_\lambda$, if the function $f:=f_{\lambda k}\in\mathbb{C}[X]$ is reducible, then there exist weights $\lambda_1,\ldots,\lambda_r\in\Lambda_X$ such that $\lambda$ is an $\mathbb N$-linear combination of the $\lambda_i$.*
Indeed, about a year ago this statement was completely unclear to me. However, it's actually not that hard to see and I felt like sharing my proof. (more…)
For the group $G=\mathrm{GL}_n(\mathbb{K})$ of invertible matrices over any field, there is the well-known determinant character $\det:G\to\mathbb{K}^\times$ which, well, maps any matrix to its determinant. It has the property that
\[ [G,G]=\mathrm{SL}_n(\mathbb{K})=\{ g\in G \mid \det(g)=1 \}, \]
where $[G,G]$ denotes the derived subgroup of $G$. In more geometric terms, $[G,G]$ is the vanishing of the regular function $\det-1$ on $G$. Because I find it rather cute, I will show that you can find a similar function for all linear, reductive groups.
(more…)