phimuemue.com

This is probably my last post here. I’m thinking about moving all posts to phimuemue.com.

phimuemue.com is not completely finished yet and has not too much content yet, but it will be filled more and more over the time.

Here is a randomized algorithm that (eventually) solves an instance of a SAT-Problem (in polynomial time).

The problem must be given in conjunctive normal form. The algorithm uses the following format for the problem:

Let’s call our boolean variables . I want to show the format for the algorithm with an example. Consider the following CNF: . A satisfiying combination of variables would be: (1 corresponds with true, 0 corresponds with false).

The above formula would be translated into the following array of arrays:

[[1,-2],[1,3],[2,3,-4]]

The first element, [1,-2] shows, that is used normal and is negated. The other elements show things correspondingly.

Here’s the source code (Ruby):

# Input format: Array of arrays
# [[+1,+2],[-1,+3]] => (A or B) and (-A or C)
# i.e. sign indicates, wether variable is beeing neglected (-) or not (+)
# !!! Special: Using 1-indexed subarrays (otherwise problems with sign and 0)

def randomBool()
  return (rand(2)==0)
end

# controls the whole CNF
def validateField(field, belegung)
  result=true
  field.each { |b|
    result=(result and validateSubField(b, belegung))
  }
  return result
end

# controls a subarray of the CNF
def validateSubField(field,belegung)
  result=false
  field.each { |b|
    zw = belegung[b.abs]
    if (b<0)
      zw = (not zw)
    end
    result = (result or zw)
  }
  return result
end

# n is the number of variables
def solve(field, n)
  result = Array.new(n+1){ |i| randomBool() }
  timeout=200
  timeout.times{
    # look for corrupt clause
    field.each { |e|
      if (not validateSubField(e, result))
        zw = rand(e.length)
        result[e[zw]]=(not result[e[zw]])
        break
      end
    }
  }
  result[0]="Result:"
  if (validateField(field, result))
    return result
  end
  return "No solution found in #{timeout} steps found"
end

# Generates a CNF using n variables and l subfields with k elements
def generateRandomCNF(n, l, k)
  result = Array.new(l){ Array.new(k) }
  result.each { |f|
    f.length.times{ |i|
      a = (rand(n)*((rand(2.0)-0.5)*2)).to_i
      while (a==0)
        a = (rand(n)*((rand(2.0)-0.5)*2)).to_i
      end
      f[i]=a
    }
  }
end

def dosomething(a, b):
    result=0
    while (a):
        if (a&1):
            result+=b
        b=b<<1
        a=a>>1
    return result

The function needs a to be a positive integer and b to be an integer.

What does the function do? Can you tell how it works?

Partial shifts

Consider an array . A k-shift (notation: ) is an operation that takes the k-th element and moves it to the first position. For example .

The goal is to sort the array using only k-shifts. Give an polynomial-time algorithm that calculates the minimum number of shifts to sort the array, and the shifts itself.

Bonus: What is the expected number of moves?

Finding minimum / maximum

Given an array, that either consists of first ascending and then descending numbers (e.g. 0, 3, 5, 7, 9, 13, 7, 4, 2), of first descending and then ascending numbers (e.g. 10, 8, 3, 2, 5, 7, 9).

Give an efficient algorithm that computes the position of the maximum or minimum, respectively.

Finding palindromes

A palindrom is a sequence of signs that can be read from left to right and right to left without changing, that is: .

Given an array of characters, find the longest palindromic subarray efficiently (that is: ).

Stack sorting

Given a stack, sort its content using only:

Tree distances

Given a undirected, unweighted tree, give an preprocessing algorithm, so that all distances from node to node can be computed in .

The task is to find an algorithm that runs in .

Here are some tipps that could make maintaining and reading your code a bit easier.

Dead Code

Many programmers tend to comment out their code, if they want to test something. This leads to dead code:

int a;
cin >> a;
// Old Test, no more needed
/*if (a>=20) {
 doSomething()
}*/
if (a>=30) {
 doSomethingElse()
}

Of course, the above example is very trivial, but if the doSomething-Routines are sufficiently long, and the commented-out code is too much, you get a mess of no more used code. So just refactor it and remove the code you don’t need anymore:

int a;
cin >> a;
if (a>=30) {
 doSomethingElse()
}

Tricky constants

Often, we use integer numbers to identify something. Let’s consider a function that takes an integer as argument and interprets it as something special. In our case, the number stands for a mathematical operation:

int calculate(int a, int b, int operation){
 if (operation==1) return a+b;
 if (operation==2) return a-b;
 if (operation==3) return a*b;
 if (operation==4) return a/b;
}

If our constants are not as simple as in the example above, we can easily forget, what they stand for. For that reason, it is better to define them as constants somewhere and checking against the constants:

#define OP_ADD 1
#define OP_SUB 2
#define OP_MUL 3
#define OP_DIV 4
int calculate(int a, int b, int operation){
 if (operation==OP_ADD) return a+b;
 if (operation==OP_SUB) return a-b;
 if (operation==OP_MUL) return a*b;
 if (operation==OP_DIV) return a/b;
}

Long and confusing methods

If method definitions are too long, they are much harder to handle. If one discovers lenghty methods, it could be a sign that the problem isn’t split up well enough into smaller subproblems. So source out some passages of the code to make it easier to read and maintain.

A rule of thumb says, that every method should fit on a single screen page so it can be read completely without scrolling.

Ugly looking code

I often come across code that isn’t well-formatted. That is, there is (almost) no indentation, no whitespace, etc…

Consider the following example snippet:

void bubbleSort(int *a,int l){
for(int j=l-1;j>0;--j){
for(int i=0;i<j;++i){
if(a[i]>a[i+1]){
int tmp=a[i];
a[i]=a[i+1];
a[i+1]=tmp;}}}}

Of course, the above example is extreme. But it is quite easy to do it more nicely:

// *a   array to sort
//  l   size of the array
void bubbleSort(int *a,int l){
   for(int upper=l-1;upper>0;--upper){
      for(int pos=0;pos<upper;++pos){
         if(a[pos]>a[pos+1]){
            int tmp=a[pos];
            a[pos]=a[pos+1];
            a[pos+1]=tmp;
         }
      }
   }
}

Describe the arguments to a function (if not obvious). If necessary, allow yourself to use whitespace. That structures the code enormously.

Don’t use superflous comments

Consider the following snippet:

float p(int s){
   // initial value of result: 1
   float res = 1;
   // do s steps
   for (int i = 1; i < s; ++i){
      // calculate reciprocal value and add it.
      res = 1 + (1/res);
   }
   return res;
}

Do you know what it does? If not, see the snippet below:

// approximates the golden ratio (~1.61)
float p(int s){
   float res = 1;
   for (int i = 1; i < s; ++i){
      res = 1 + (1/res);
   }
   return res;
}

Give comments that explain the things you can not see directly from the code.

Or even better, use appropriate describing method names (if possible). (Thanks to gutzofter for his hint.)

float approximateGoldenRatio(int steps){
   float res = 1;
   for (int i = 1; i < steps; ++i){
      res = 1 + (1/res);
   }
   return res;
}

Conclusion

Even if it seems quite simple to follow these common sense tipps, it is often more difficult than one might think.

It is useful to control the code from time to time end eventually refactor it, so it can be read better. To put it in a nutshell:

You can download the file here. It is just a draft, but i’m offering it here, because i hope it could help somebody.

The following article gives a general insight how floats could be logarithmized faster. It shows an approximative algorithm that can be extended to get more accurate results.

It should be clear, that doesnt really matter wich base we choose to calculate the logarithm. We can write every logarithm (with positive base):

.

This means, if we have calculated a logarithm for a certain base, we can just compute the logarithm for any other base. As we will se later, for logarithmizing float numbers, it is convenient to choose base 2.

Lets assume we are working with 32-bit float numbers, that is, we have four bytes to form a float.

The internal representation of float numbers is essential to understand how the algorithm works. The image below shows float representation according to IEEE-754:

That means ( denotes the bit at position ):

S stands for sign , i.e. -1 or 1 (respectively, in bits: 1 or 0)

E stands for a biased exponent. That means, that the exponent is calculated as the normal binary number minus 128:

M stands for mantissa. Mantissa is calculated as follows:

(See Wikipedia for details.)

If we know as integral numbers (each in binary notation), we can calculate the value . If we want to calculate the logarithm, we can easily write:

No we see, why we chose base 2 for our calculations. If our logarithm base is 2, we can easily substitute , that is, the exponent can be extracted quite easily. For the mantissa, we can either generate a lookup table or approximate the logarithm.

Implementation

The following section shows how the above thoughts could be transferred to an implementation.

I wrote a small assembler routine (in NASM):

; file log2.asm
GLOBAL _log2ASS						; C-Signature:		void log2ASS(float a, float* b)

section .data						

log2: 	dd 0
		dd 0.169925
		dd 0.321928
		dd 0.459432
		dd 0.584963
		dd 0.70044
		dd 0.807355
		dd 0.906891

_log2ASS:
start_log:
	push ebp
	mov ebp, esp

	push eax				;
	push ebx				;
	push ecx				;

	; exponent extraction.
	mov eax, [ebp+8]		; read argument
	and eax, 0x7F800000		;
	sar eax, 23				;
	sub eax, 127			;
	mov ecx, [ebp+12]		;
	mov [ecx], eax			; save extracted exponent (in target)

	; mantissa extraction
	mov eax, [ebp+8]		;
	and eax, 0x007FFFFF		;
	sar eax, 20				;

	mov ebx, 4
	mul ebx
	add eax, dword log2		;

	finit					;
	fld dword [eax]			; read log(mantisse).
	fild dword [ecx]		; read extracted exponent
	faddp st1				; add them together

	mov eax, [ebp+12]
	fstp dword [eax]		; write result to target.

	pop ecx				;
	pop ebx				;
	pop eax				;
	pop ebp				;

	ret					;

Running Windows Vista we can compile this file (called log2.asm) via nasm -f elf log2.asm. This creates an object file called log2.o.

Now we can call the created routine from C the following way:

// declare extern function
extern void log2ASS(float a, float* b);

int main(int argc, char *argv[]){
	float a = 16.5978e23;
	float result;
	log2ASS(a, &result);
	printf ("Calculated result: %e\n", result);
}

We see, that log2ASS expects 2 parameters. The first parameter is the number we want to logarithmize, the second argument is a pointer to a memory cell, where the routine writes back the result (in float format). To use this function, you must ensure that the linker knows where to find log2ASS. Therefore we specify that the linker includes the generated file log2.o.

Technique

The described routine works quite simple and is a pretty straightforward implementation of the mentioned equation

Let me demonstrate how the exponents extraction works:

After that we have to subtract the bias 127, and then we have the correct exponent.

We extract the mantissa in an analog manner. The above implementation calculates the logarithm of the mantissa using a lookup table. Therefore, it discards the 20 lowest bits (thus the implementation loses much accuracy) and calculates an approximation of the logaritm using the three highest bits of the mantissa.

Since we do consider three mantissa bits only, i can specify all the possible configurations:

Bits	value	log(value)
000		1.0		0
001		1.125	0.169925
010		1.25	0.321928
011		1.375	0.459432
100		1.5		0.584963
101		1.625	0.70044
110		1.75	0.807355
111		1.875	0.906891

You can see that these are the values we save in our lookuptable log2. The mantissas logarithm can now been calculated via a simple lookup. We use the three highest bits of the mantissa as an offset.

After calculating these two numbers, we can simply add them. This is done in the floating point unit (FPU). After that, we write the sum to the given memory location.

Improvements, Conclusion

The described implementation uses only the three highest mantissa bits and yields just a rough approximation of the logarithm therefore. It works relatively fine for float values with big exponents, because the exponents are calculated exactly. If the exponents are big enough, the mantissa logarithm carries no weight. If we want to be more precise even for small exponents, we have to make the mantissa logarithm more accurate. So one first improvement could be to consider more mantissa bits in order to get a more precise logarithm. Of course each additional bit doubles the size of the lookup table. I chose to consider three bits only because i wanted to emphasize the principle.

Furthermore, this implementation doesnt deal very well with special cases (such as NAN or negative numbers). Therefore one would introduce some assertions to ensure that the method works correct.

Because this method does no error handling, no assertions and only approximates the results, it is quite fast.

If we wanted to cover all possibilities for the mantissa (and hence get maximum precision), we would have to store byte, that is 16 gigabyte. I suppose that the FPU-intern routines uses the provided thought, but does interpolate cleverly over the lookup table.

As said in the beginning, we can easily compute the logarithm for other bases by dividing the result of the above routine , so we get:

-module(testmodule).
-export([waitforinput/0]).

waitforinput() ->
receive
 finished -> io:format("waitforinput stopped.",[]);
 X ->
  io:format("received ~p~n",[X]),
  waitforinput()
end.

Correspondingly, we can write a function, that sends a message to the upper function (after we created the process with the register-function. Before doing so, we have to make the waitforinput-function accessible by registering it.

register (receiver, spawn(testmodule, waitforinput, []).

senditem(X)->
 receiver ! X.

(Consider this elegant Syntax: receiver ! X means: Send X to receiver.)

After that, we can send things to the waitforinput-function with:

testmodule:senditem("test").
testmodule:senditem({3,2,6}).
testmodule:senditem(finished).

This yields the output:

received "test"
received {3,2,6}
waitforinput stopped.


I dont know where it leads me, but i like the concept very much because of its quite good readability and idea. As far as i know, it is quite easy to integrate it with, for example, Java. I don’t know all the features of Erlang up to know, but i think, i’ll do something from time to time.

Maze generator

My first “big” project i was fascinated by was a simple program, whose only purpose was to generate a simple maze.
Here you can see an example maze, that i’ve created with a implementation in C#:

Motivation At the beginning this problem seemed unsolvable to me, because i had no idea how to tackle it. After some googling and reading i found the necessary know how to generate a maze.

Outcome Finally i solved this task with graph theoretic considerations: I just had to generate a rectangular grid graph and looked for a minimum spanning tree in it. If you set the edge weights randomly you get a random maze. Alternatively, you could always pick a random edge that doesnt create a circle. Standard algorithms for minimum spanning trees are Kruskals and Prims algorithm. This was my first project to cope with graph theory.

Sorting algorithms of all kinds

Motivation Another problem is sorting data – needed in almost every application in some way. In many programming languages i tried several sorting algorithms.

Bubblesort, Insertionsort or Selectionsort (runtime )

Quicksort (average case )

Mergesort (worst case )

A further goal, that i was following up was to generate a (comparison) sort algorithm, that has runtime – without success.

Outcome Every programmer comes to a point where he has to cope with sorting algorithms. Now i know, that no comparison sort algorithm can acchieve my hoped for runtime of . But with some restrictions and conditions concerning the input data, faster algorithms can be constructed (e.g. radix sort in ).

Parser / Plotter

Motivation Since i got a calculator that accepted terms like (2*4-3)*(2+6*4) and calculated the result, i wanted to develop an algorithm doing the same. Logically, it’s just a stone’s throw away to develop a plotter that prints whole function graphs.

Outcome My first post shows a “remake” of this personal classic (in german). It has just basic functions, plotting is not implemented in the shown version. While first developing the algorithm for computing the results i was very fascinated by the principle of recursion, a very elegant method of solving many problems (but not always the most efficient one).

A free-hand drawing tool

Motivation Drawing graphs (graph theoretic graphs, not function graphs) in LaTeX (with the TikZ-package) is not a very comfortable thing. Because everything has to be described quite detailed simple graphs have long-winded code. With pencil and paper, a graph is drawn in half a minute. With TikZ, you need much more time.

The above simple graph requires round 15 lines of code in TikZ. That’s why i wrote a tiny program providing a “canvas”. You can draw as you would on paper. The software detects rectangles and converts them to graph nodes. If you connect two nodes, it creates an edge. After you have drawn the graph, it can easily been exported to TikZ

Outcome This program saved me a lot of time yet. I have to draw quite many graphs and exporting them to LaTeX (finite automata, networks, etc.). Even if the program is not very sophisticated it is capable of some nice features that make it quite easy to generate (simple) graphs. Adaptions can be made in the TikZ-Code relatively fast.