Eric Woroshow

Powers of Four in C#

2010-09-17T00:00:00-07:00

I recently implemented a function in C# to check if an unsigned integer is a power of four as a part of my new game and I wanted to share two possible implementations. The first relies on the fact that a power of four (1) has only a single bit set and (2) has an even number of zero bits after the one.

    public static bool IsPowerOfFour(uint n)
    {
        if (n != 0 && (n & (n - 1)) == 0) // single bit set
        {
            int count = 0;
            while (n > 1)
            {
                n >>= 1;
                count += 1;
            }
            return (count % 2) == 0 ? true : false; // even zero bits
        }
        return false;
    }

For 32-bit unsigned integers we can employ some bit manipulation to acheive the same effect, by checking that we have a power of two that is also a power of four.

    public static bool IsPowerOfFour(uint n)
    {
        return (n & (n - 1)) == 0 && (n & 0x5555555) != 0;
    }

Bresenham's Line Algorithm in C#

2010-05-20T00:00:00-07:00

I recently implemented Bresenham’s line algorithm in C# as part of a new game I am developing. I thought I would share my implementation. I particularly like the interface of returning the points on the line as an IEnumerable.

    public static IEnumerable<Point> GetPointsOnLine(int x0, int y0, int x1, int y1)
    {
        bool steep = Math.Abs(y1 - y0) > Math.Abs(x1 - x0);
        if (steep)
        {
            int t;
            t = x0; // swap x0 and y0
            x0 = y0;
            y0 = t;
            t = x1; // swap x1 and y1
            x1 = y1;
            y1 = t;
        }
        if (x0 > x1)
        {
            int t;
            t = x0; // swap x0 and x1
            x0 = x1;
            x1 = t;
            t = y0; // swap y0 and y1
            y0 = y1;
            y1 = t;
        }
        int dx = x1 - x0;
        int dy = Math.Abs(y1 - y0);
        int error = dx / 2;
        int ystep = (y0 < y1) ? 1 : -1;
        int y = y0;
        for (int x = x0; x <= x1; x++)
        {
            yield return new Point((steep ? y : x), (steep ? x : y));
            error = error - dy;
            if (error < 0)
            {
                y += ystep;
                error += dx;
            }
        }
        yield break;
    }

Smallest Palindrome Bases in Haskell

2009-12-26T00:00:00-08:00

Everybody loves palindromes, right? I do, at least. That’s why I was excited when I learned that every number can be a palindrome when it’s written in the appropriate base. There is a trivial proof for this property: any number N > 3 is a palindrome in base N-1 because it may be written “11”. So here is my solution, in Haskell, to this CodeChef problem, that finds the smallest base that makes any given number a palindrome.

    isPalindromeInBase :: Integer -> Integer -> Bool
    isPalindromeInBase value base = step leftmost 1
        where leftmost = base ^ floor(log(fromInteger value) / log(fromInteger base))
              step left right
                  | left <= right             = True
                  | digit left == digit right = step (left `div` base) (right * base)
                  | otherwise                 = False
              digit position = (value `div` position) `mod` base
    
    smallestPalindromeBase :: Integer -> Integer
    smallestPalindromeBase 1 = 2
    smallestPalindromeBase 2 = 3
    smallestPalindromeBase value = step 2
        where step base 
                  | base >= value || isPalindromeInBase value base = base
                  | otherwise                                      = step (base + 1)
    
    main = interact (unlines . map (show . smallestPalindromeBase . read) . tail . lines)

This is certainly not the fastest solution possible. Indeed it is downright naive. But hopefully the logic is clear.

Naive Knight's Tour in Haskell

2009-03-11T00:00:00-07:00

So tonight I was helping a friend with a CS 134 assignment that involved a recursive solution to the Knight’s Tour problem. The assignment included a rather ugly solution in Java and I wondered what a comparable solution in Haskell might look like. I spent the past few minutes hacking together such a function.

    tourTo :: Int -> (Int,Int) -> [[(Int,Int)]]
    tourTo n finish = [pos:path | (pos,path) <- tour (n*n)]
        where tour 1 = [(finish, [])]
              tour k = [(pos', pos:path) |
                           (pos, path) <- tour (k-1),
                           pos' <- (filter (`notElem` path) (jumps n pos))]
              jumps n (r, c) = filter onBoard
                  [(r+2, c+1), (r+1, c+2), (r-2, c+1), (r+1, c-2),
                   (r+2, c-1), (r-1, c+2), (r-2, c-1), (r-1, c-2)]
                  where onBoard (r, c) = r >= 1 && c >= 1 && r <= n && c <= n

It works (as far as I can tell) but it’s unbearably slow. Two optimizations come to mind: using a map rather than a list to store the visited squares and using a heuristic to select the next move location. The latter is implemented in the Java version; if motivation strikes I’ll post a better/faster(/harder/stronger) version.

Quirky Java

2009-02-22T00:00:00-08:00

This term I’m taking a course on compiler construction, CS 444. For the course I, along with my group members Peter and Ian, am developing a compiler for a subset of Java. So far we have finished the scanner and parser. It’s been an illuminating experience learning about the quirkiness hidden deep in the Java Language Specification and I wanted to share a few of the more esoteric constructs we discovered.

I successfully compiled all of the following examples on my aging Windows XP laptop with javac 1.6.0_04. First, a single semicolon is valid Java file! So

    // in Quirky.java
    ;

is a perfectly valid and so is

    // in Quirky.java
    ;
    class Quirky {
        ;
    }

Javac will happily generate bytecode for both files. More single-character strangeness: a single $ or _ are valid Java identifiers. Hence, with a wanton willingness to abuse the language,

    // in $.java
    class $ {
        class $$ {
            $ $($ $) { return null; }
        }
    }
    class _ {
        _ _(_ _) { return null; }
    }

can be compiled into $.class, $$$$.class and _.class! Finally the array brackets can appear in unexpected places as

    // in Quirky.java
    class Quirky {
        int[] twoDim() [] { return null; }
    }

generates a method twoDim that returns a two-dimensional array int[][].

Project Euler Problems 4-8

2009-01-12T00:00:00-08:00

More Haskell, more Project Euler. Again I thought I would share my solutions to the next few problems. I should point out in advance that, for the most part, these are naive solutions. I plan on taking a second pass later to devise more clever approaches.

Problem 4

    answer = maximum . filter isPalindrome $ products
        where products = [ x*y | x <- [111..999], y <- [x..999] ]
              isPalindrome n = n == reverse n 0
                where reverse 0 r = r
                      reverse n r = reverse (n `div` 10) (r * 10 + n `mod` 10)

Problem 5

    answer = head . filter good $ [20,40..]
        where good n = not $ any (\t -> n `rem` t /= 0) [2..19]

Problem 6

    answer = squareSum - sumSquare
        where squareSum = (sum [1..100]) ^ 2
              sumSquare = sum $ map (^2) [1..100]

Problem 7

    primes :: [Integer]
    primes = 2:3:primes'
        where 1:p:candidates = [6*k+r | k <- [0..], r <- [1,5]]
              primes'        = p : filter isPrime candidates
              isPrime n      = all (not . divides n) $ takeWhile (\p-> p*p <= n) primes'
              divides n p    = n `mod` p == 0
    answer = primes !! 10001

Problem 8

    import Char
    largestDigitProduct d n = maximum products
        where products = [ digitProduct x digits | x <- [0..995]]
              digitProduct t ds = product $ take d (drop t ds)
              digits = map digitToInt (show n)
    answer = largestDigitProduct 5 <number>

Project Euler Problems 1-3

2008-10-15T00:00:00-07:00

Tonight I’ve been using Haskell to tackle Project Euler. I thought I would share my solutions to the first three problems.

Problem 1

    naiveAnswer = sum [x | x <- [1..999], x `mod` 3 == 0 || x `mod` 5 == 0]
    betterAnswer = sumDiv 3 + sumDiv 5 - sumDiv 15
        where sumDiv n = sum [n,n+n..999]

Problem 2

    fibs = 1 : 1 : zipWith (+) fibs (tail fibs)
    answer = sum . takeWhile (< 4000000) . filter even $ fibs

Problem 3

    largestFactor :: Integer -> Integer
    largestFactor n = search n 1 2
        where search q f d | q == 1         = f
                           | q < d*d        = q
                           | q `mod` d == 0 = loop (q`div`d) d d
                           | otherwise      = loop q f (d+1)
    answer = largestFactor 600851475143

I’d love to hear any comments on how Haskell-y these solutions are.

A Tiny Guide to GCC Inline Assembly

2008-06-12T00:00:00-07:00

So I’m working on a real-time operating system for school, and in the process I’ve needed to write a ton of IA32 inline assembly. GCC’s inline assembly syntax isn’t immediately straightforward so it’s been an interesting process of trial, error, and documentation to piece together the specifics. This guide presents my accumulated knowledge on the subject.

Assembly Syntax

GCC uses AT&T assembly syntax. The highlights:

instruction source, destination
The first operand is the source, the second is the destination.
%register
Register names are prefixed with a percent sign. (Or a %% in certain circumstances; see the second on operands below.)
$literal
Literal values are prefixed with a dollar sign. The literal $10 specifies decimal 10 while $0x10 specifies hexadecimal 16.
instruction{b,w,l}
The instruction suffix denotes the operand size. The b, w, and l specify byte (8-bit), word (16-bit), and long word (32-bit) memory references. (Always include the size! If you omit it the GNU assembler will attempt to guess for you which is usually a Bad Idea.)
segment:offset(base, index, scale)
Memory access syntax. Note that the offset and scale constants are not prefixed with $ but the register references still need a %.
ljmp/lcall $segment, $offset
Control transfer instructions may be prefixed with an l to indicate a far jump to another code segment. (Similarly, there is lret $stackadjust.)
*branch-address
Branch addressing using literals or registers is prefixed with an asterisk.

Here are a few examples of valid code that illustrate these points.

    pushl %eax
    movl $8, %ebx
    movb $0x11, %al
    movl %es:16(%ebx, %edi, 4), %eax
    ret *100
    jmp *%ecx
    lcall $0x10, farcalllabel

Inline Syntax

The basic format for GCC inline assembly is as follows.

    __asm__
    __volatile__      /* optional */
    (
    assembly code
    : output operands /* optional */
    : input operands  /* optional */
    : clobber list    /* optional */
    );

For example, below is code to turn on bit 1 in flag then store the value in new_flag.

    int flag, new_flag;
    __asm__
    (
    "movl %1, %%eax \n"
    "orw $2, %%ax \n"
    "movl %%ax, %0 \n"
    : "=r"(new_flag) /* output */
    : "r"(flag)      /* input */
    : "%eax"         /* clobbered register */
    );

Preamble

The __asm__ keyword marks the start of the inline assembly statement. While using asm without the underscores is also valid in some contexts, it will not compile with the -std=c99 option. Moreover, the underscores prevent conflicts with asm defined elsewhere in your code.

The optional __volatile__ keyword indicates the assembly code has important side-effects and guarantees GCC will not delete it if it is reachable. It does not, however, guarantee that the assembly code will not be moved relative to other code.

Code

The assembly code specifies the instructions to execute. Each instruction (or label) is enclosed within double quotes and terminated by a newline.

Operands

The general pattern for an operand is "constraint"(expression) and multiple operands are separated by commas.

In the assembly code each operand is reference by number, where %0 is the first output operand, %1 is the second, and so on, and %N-1 is the last input operand. Because the operands are indicated by a percent sign the register names must now be prefixed with two percent signs, like %%eax.

C expressions provide the input and output operands for the assembly code. An output expression (an lvalue) specifies where a result should be stored. An input expression specifies either a location (lvalue) or value (rvalue) as input to the code.

Constraints help to decided the addressing mode and registers used for the input and output operands. Of the many constraints available, only a few are used frequently. These we discuss below.

m: The operand is stored in memory, at any memory address. (Instructions will operate on the data directly in memory.)
r: The operand is stored in a general-purpose register. (GCC generates code to transfer the operand to or from memory and the register it chooses.)
i: The operand is an immediate integer.
0,…,9: The operand matches the operand with the specified number. (GCC will use the same variable for both operands. The two operands that match must be one input-only operand and one output-only operand.)

Constraints may also have modifiers which provide additional control over the behavior of the operands. Three common constraints are:

=: Operand is write-only
+: Operand is both read and written
&: Operand is clobbered early (i.e., is modified before the instruction is finished using the input operands, meaning it may not lie in a register used as an input operand or any part of memory)

Clobber List

The clobber list should contain:

The registers modified, either explicitly or implicitly, by your code.
If your code modifies the condition code register, “cc”.
If your code modifies memory, “memory”.

The clobber list informs GCC of the state potentially changed by your code so it won’t make incorrect assumptions about the state and break things (always a Bad Thing).

Examples

To further illustrate all the stuff stuffed into this guide, I’ve pulled a few examples from my operating system.

To load the interrupt descriptor table register:

    void set_idt (idt_pointer_t *ptr) {
        __asm__ __volatile__ (
        "lidt %0 \n" : : "m"(ptr) );
    }

To set the kernel code segment:

    void set_kcs () {
        __asm__ __volatile__ (
        "ljmp %0, $farjmp \n"
        "farjmp: \n"
        "nop \n"
        : "i"(KERNEL_SEG_CODE) );
    }

To move bytes:

    void kcopy (unsigned int src, unsigned int dst,
                unsigned int nbytes) {
        __asm__ __volatile__ (
        "cld \n"
        "rep \n"
        "movsb \n"
        :
        : "S"(src), "D"(dst), "c"(nbytes)
        : "%esi", "%edi", "%ecx" );
    }

References

I pulled this information from a variety of sources, chief among them: