me@here

min2

2011-07-24T11:07:26Z

Two bit packed number min,

function min2(a,b){
    c = a & b & 0xAAAAAAAA;
    c = c | (c >> 1);
    c = ~c; // o

    //an = ~(a^c);
    an = a ^ c;
    ax = an & 0xAAAAAAAA
    an = an & (ax | (ax >> 1));

    //bn = ~(b^c);
    bn = b ^ c;
    bx = bn & 0xAAAAAAAA;
    bn = bn & (bx | (bx >> 1));

    //return (~(an^c)) & (~(bn^c));
    return (an^c) & (bn^c)
}

jsfx

2011-02-19T19:32:37Z

jsfx is a javascript library (with frontend) for sound effect generation. It needs WAV support from browser to work. Take a look, have fun and build on it. Free to use as you wish.

demo
github

It has already gotten quite good feedback from people. Also I’ve found a nice sequencer that uses jsfx to generate the samples.

sequencer

Hopefully I’ll figure out what to do next with jsfx.

Getting started with rst

2010-09-17T19:40:58Z

I find that using WYSIWYG interfaces for editing simple documents can be often quite uncomfortable and unnecessarily complex. Usually you just need some titles and paragraphs and sometimes to include some pictures.

Here’s a simpler way of doing it. First download rst2pdf and install it. (Or install it any means necessary.)

Here are the basic things to get started. Write this into a ‘example.rst’ file:

================
 Document Title
================
----------
 Subtitle
----------

Chapter 1
=========

Section 1.1
-----------

Subsection 1.1.1
~~~~~~~~~~~~~~~~

Here is some very important
paragraph. Line breaks will be ignored.
A empty line begins a new paragraph.

Section 1.2
-----------

Here's the a paragraph.

Here's the second paragraph.

The syntax is quite intuitive. If you want a header just draw a double line under it. For sub-header use a single line. One important thing is that the line under/over the headers must be as long or longer than the header.

If you want a new paragraph just add an empty line before it. Why doesn’t it just break the line there where I put the enter? Because then it wouldn’t automatically adjust to different layouts and page sizes.

Let’s go on. Let’s say I want to include some lists and an image.

Lists
==============

This is our bullet list:

* Hello
* Big
* World

This is our number list:

1. Hello
2. Big
3. World

Nested lists are also simple:

1. Hello
    a. Big
2. World

Image
==============

This is how to include an image:

.. image :: hello.png
    :width: 3cm
    :align: left

Now execute rst2pdf example.rst and here’s the example.pdf that comes out. That’s all there is for the introduction.

imprecision

2010-09-13T20:24:44Z

This header file provides macros for truncating floating point values in C/C++.

I started thinking about this problem after reading Iñigo Quílez’s article storing floating point in 4k. The problem is that using full floating point precision makes the code less compressable.

For example 1.9f will be translated to hex 0×3ff33333 whereas it would be much better to use 0×3ff30000. If there are a lot of values ending with zeros then they can be compressed quite efficiently.

Iñigo Quílez’s idea was to precalculate and define each value from 0.00 to 1.99 that give an exact hex number in a header file and then use the defined values. This method can get a little long when you would try this with more values.

My idea was to do the calculation at compile time with macros.

First thing idea I tried was the most obvious – convert the floating point value to it’s IEEE format, mask out the values and then convert it back. Unfortunately this ended with problems as gcc doesn’t let you convert float to int that easily. First I had to get the address of the value then convert it to void, then to int pointer then to int and then mask it out — then get address, void, float pointer, float. Problem is that during compile-time we don’t know where the value is and therefore we have to use a temporary variable. Basically I didn’t find a way that compiler could optimize it out.

Then the second thing I tried was using multiplication, masking and division:

((float)((int)(x*256) & ~((1 << (ilog(x) - 1)) - 1) )/256.0f)

Then tested to find a values that provide the least amount of errors and found out that this method is also easily modifiable for different sizes of imprecision. That means you can truncate different amount of nybbles quite easily.

Anyway download the file imprecision.h.

#define ilog(x) \
     x < 2 ? 1 : x < 4 ? 2 : x < 8 ? 3 : \
     x < 16 ? 4 : x < 32 ? 8 : x < 64 ? 9 : \
     x < 128 ? 10 : x < 256 ? 11 : \ 
     x < 512 ? 12 : 13
#define _P(x,y) ((float)((int)(x*(int)y) & \
                          ~((1 << (ilog(x) - 1)) - 1) )/y);
#define P4(x) _P(x,256.0f)
#define P3(x) _P(x,16.0f)
#define P5(x) _P(x,4096.0f)
#define P(x) P4(x)

P4 won’t use more than 4 nybbles of hex values and the same goes for the others. So it’s easy to use with different precisions.

measus

2010-09-13T20:10:54Z

Measus is a perl script that automates speed testing multiple programs over different files and arguments.

For example you have programs brute-force, shift-or, kmp and grep. You want to test pattern searching with patterns “aaaa”, “bbbb”, “ababba”. Also you want to test with differemt files “abc.txt” and “bbb.txt”. Also testing only one run is useless so you want to run each test 10 times. To do this testing you’ll need to create a setup file:

$iterations = 10;

@programs = (
    "grep => grep -c PAT FILE",
    "brute-force => ./bf PAT FILE",
    "shift-or => ./sor PAT FILE",
    "kmp => ./kmp PAT FILE",
);

@patterns = (
    "aaaa",
    "bbbb",
    "ababba",
);

@files = (
    "abc 16MB => ../data/abc.txt",
    "b* 16MB => ../data/bbb.txt",
);

Then you can run it with:

./measus.pl log_tabdelim.pl setup.pl

Download it from here: measus.zip