As I write this, I’m waiting for the tournament phase to run, so have no idea how well I’ve done. Quite early on in the competition, I had tried out the submission process, uploading minor changes to the example hunter game, so I had competed is as many preliminary rounds as anyone else, and had won 59 of the 78 of the randomly selected preliminary round matches, including 23 of the last 27, so I think I’ve got a good chance of doing well.

The Game

The game is basically a snow fight between two teams of four players, looking out for the trees. You write code to control one team, deciding what to do each turn, for 180 turns.

There were two ways of scoring points in the game, the first is by throwing snowballs at opponents, and the second is by building snowmen to increase your domain. Snowmen can be destroyed, or your opponents can build snowmen close by, both of which reduce your domain score, and it is only the domain at the end of the game that matters (except for extremely rare tie breaker scenarios).

Strategy and Development History

Sample code was provided for three example teams. Each example had all four players executing a single strategy, pretty much independently. There was a team that build a protective snow fort, stock piled snow balls, and threw them at any opponent that came close. There was a team of players that ran around trying to build snowmen, and there was a team of players that ran around throwing snow balls at opponents.

I started by adapting the snowman maker and the hunter examples into strategies that individual team members could adopt, and found that three hunters with one snowman maker seemed to work quite well.

I set about improving the strategies, concentrating first on the hunter, till I had code in the basic structure:

1. Each of 4 “Player” objects have a “Strategy”
2. “Game” controller that sets up the 4 players, each with their specific strategy. Then repeatedly:
   • Reads game state input,
   • Determines who can throw snowballs at what,
   • Asks each of 4 players to determine their move
   • If there are combination of players that have said they could use a snowball, and players who say they’re willing to give up a snowball, and the throw is possible, do that
   • Picks a run destination for players who don’t have anything better to do, repeating till the player can follow the shortest (simple) path to:
     • Closest uncharted territory,
     • Closest unsighted territory,
     • Random location
   • Report each player’s move
3. Profit

Hitting an opponent gets 10 points that can’t be taken back, and as an added bonus dazes the opponent for 4 turns. Building a snowman in a good position is worth up to 193 points, but can be easily undone by the opponent.

The three hunter team members ended up attempting the following actions:

1. Finish a snowman that they’re standing next to.
2. Avoid being hit by a likely throw from an opponent.
3. Throw a snow ball at an opponent.
4. Take the head off an opponent’s snowman.
5. Pick up a snow ball.
6. Throw a snow ball at an opponent’s snowman.
7. Create a snow ball.
8. Stand up.

When none of those were appropriate, the game controller would send the player running off to explore.

I improved the hunters to divide the targets amongst the players, and to not throw multiple snowballs at the same opponent, since each hit sets the dazed count back to 4, when there was a good chance that a new opponent would come into range and be able to be dazed next turn (particularly at the start of the game when the opponents first meet).

The throw calculation was extended to examine every possible throw, from each player, seeing what could be hit, rather than trying to calculate the best throw in order to try and hit a specific target.

I then improved my snowman builder, improving both determining the optimal places to build, and the actual build process.

If the opponent was seen to be moving, I estimated their next movement, and considered where they were likely to be when a thrown snowball might hit them, and also changed the targeting code to prefer the furthest throw (from each player) that would hit an opponent, rather than the first or last found.

I think that was the last submitted state.

Snowman Difficulties

The best place to build a snowman is right where an enemy snowman is, since it only takes two moves (once crouching): picking up their (snowball) head, and putting it back again. The domain change is at best -193 and +193 to me, for a differential of 386 in 2 turns… why would you bother spending 3 turns to make and throw a snowball for a measly 10 points?

I tried multiple snowman makers, who’d take pot-shots at the enemy too, but they all decided on the same spot to try building snowmen, and got in each other’s way.

I tried getting them to build in different spots, by allocating locations in turn, removing the area round each new location from consideration, but this wasn’t optimised, nor terribly good. In order for them to not be pummelled by the enemy (code for my previous submissions), they needed to be carrying around a snowball, which they’d need to drop when they started building. It wasn’t working out very well for them.

I tried specialising the snowman making players, having two hunters, and one player that makes the snowman base and head, while the last player makes the snowman’s middle. However that was twice as susceptible to long delays in building, since either player could get hit and dazed.

I tried to figure out the best player each turn to be a snowman builder, thinking that when one player is hit, another can take over, and that as soon as a snowman is built, the player who just built it is better off becoming a hunter, and someone else is more likely to be close to a better spot for building a snowman… and that’s where I started running into bugs.

Specifically, I’d have 2 players fighting to be the snowman maker. If one was chosen as a fighter this turn, it’d crouch to make themselves a snowball. If chosen as the snowman it’d stand to run to the best place to build the snowman. However the “best” player – new snowman location combination kept switching to the player who was crouching, so I had two players who were ignoring the fight, and pretending they were on a virtual see-saw.

Route Finding

I thought that the reason for the flipping of best snowman making player was due to the different path a standing person follows from that which a crouching person follows. The first time I took a good look at the situation, the closer player to the best spot was crouching next to a hedge, and I presumed that the crawling path would go along the hedge and the running path would try and fail to go through the hedge, so that player was good, was picked, would stand, and not be able to move to the best location, but another crouching player who was further away could get there, and roles would switch.

I had also had in the back of my mind that the simple arrangement of trees in the examples might not be so simple in the tournament, so I spent a long Sunday evening coding a variety of path finding algorithms. I implemented Floyd-Warshall first (here is a applet), since I needed to know path distances between a large combination of points, but it takes far too long to calculate. I then implemented Hadlock’s algorithm, which was fast enough, but still had the strange flip-flopping behaviour! I then identified that I had a bug where I calculated the potential benefit of a snowman location; I was accidentally ignoring the path distance for each player, so crouching players were better, not because of any path restrictions, but because they were one move closer to picking up snow.

Once I’d got that fixed, I played against a number of my previous submitted players, but lost badly on more maps than I narrowly won on, so instead of submitting my new code, I decided to go with the previous code, and went to sleep.

Postscript

I’ve since found and squashed more bugs in my path finding algorithm, and I had only been using it to determine the distance – my players were still moving according to the much simpler path rules.

One interesting thing is that a really minor weighting change on whether one action is better than another, can affect a single move, and the entire game after that is different, often with a large difference in who gets pinned down and pelted with snowballs, instead of running around switching heads of opponents snowmen, and consequently a very large difference in scores.

The best player in the preliminary rounds appears to be winning in the prisoners dilemma stakes… by assuming a newly seen opponent able to throw at it will do so, and he’ll try and catch the throw, end up with two snowballs, and throw one right back the next turn. My strategy was to likewise assume such a throw from an opponent, and dodge sideways if I thought the dodge would work. Unfortunately dodging was pretty rare, and I think I should probably have tried to catch first too.

Competition Results

I hope to edit this post and write something about the actual tournament when it completes.

We use a multi-module maven project, using mvn eclipse:eclipse to generate our eclipse projects, and that continued to work just fine, with the projects seeming to be imported without issue.

I noticed that Tomcat 7 is now listed in the set of servers that can be configured, and indeed the WTP 3.2.0 New and Noteworthy lists that in it’s “Servers” section. Handy, but as we’re hosting our own application, we do not need to test against Tomcat 7 yet.

I next noticed that the view of web projects added to the server included a couple of jars. Strange. I still haven’t figured out why a small number of the many included jars get shown in that view.

The first thing I tried to investigate showed that specifying what gets deployed as part of your web application has been changed too. That’s shown in the Java EE section of WTP’s New and Noteworthy.

The applications deployed and ran ok, though a number of times I’ve tried starting tomcat only to have it complain that one of the web applications can’t find hibernate classes, and looking in the deployed directory, the jar is indeed missing.

The next thing I noticed is that a whole lot of classes now show warnings. Apparently I should now change from using @SuppressWarnings(“unchecked”) to the new and more accurate @SuppressWarnings(“rawtypes”) or according to the JDT New and Noteworthy, set the suppressRawWhenUnchecked=true system property when starting eclipse.

Another JDT change highlighted that our method of starting up one of our application included an unused object allocation. That actually highlighted that we were starting threads from within a constructor… something that is rife with difficulties, and to be discouraged.

While investigating what various people on StackOverflow recommend for eclipse.ini options I discovered the details of Oracle’s changing the executable and libraries’ organisation meta-data, and how eclipse has been using those to identify Sun’s JVM and apply Sun’s -XX:MaxPermSize setting. Oracle have changed the organisation back again for build 7 of Java 6 update 21.

I have not yet started using Helios for personal projects, since for the last little while I’ve been trying my hand at creating an Android application, implementing a nice looking Tree Mapping View showing space used by a various tables and indexes of a PostgreSQL database. The page detailing how to set up the eclipse plugins for Android development still says: “There are known issues with the ADT plugin running with Eclipse 3.6. Please stay on 3.5 until further notice.”

So far this sounds like a lack of any compelling reasons to upgrade.

However…

Using the market to install the SVN plugins we use was a much nicer experience than in previous versions, and being able to find out about other plugins from within eclipse is great.

I’m also going to start using package name abbreviations, so that all our packages of the format:

nz.co.mycompany.myproduct.subcomponentA.internalpackage1

can be nicely and succinctly shown as

{A}.internalpackage1

Something I usually do with a new eclipse installation is tune the startup parameters, editing the eclipse.ini file to show me the workspace location. This is because I often work with multiple workspaces, one showing the current production code for investigating symptoms and behaviour of the production system, and one showing later code with a number of development changes. Eclipse 3.6 has a new preferences option that lets you specify a workspace name to show in the title, which works much better as you do not need to restart eclipse for it to take affect, you can use a short code for your workspace, and it appears first in the title, before the perspective and application name.

Lastly I’m looking forward to experimenting with all the new options for controlling the formatter. I believe I can finally now get it set up to alter the code formatting to my liking more consistently.

I thought I’d add the equivalents from the perspective of an Eclipse-using Java developer…

Definr.com

Definr.com isn’t specific to a single programming language.

I simply type things into Google Chrome’s Omnibar.

FxCop & Gendarme

FindBugs

PMD

Visual Studio Class Diagrams

Perhaps AgileJ though I do not use it.

Snippets

Snippets in Eclipse

Creating extensions to snippets

StyleCop

Checkstyle

NAnt

Ant

Maven 2

NUnit

junit

TestDriven.Net

junit is integrated into all IDEs

Sandcastle

Perhaps Doxia?

TeamCity

TeamCity supports java

CruiseControl

Continuum

Hudson

Gump

ReSharper

Mylyn is probably the closest productivity adding, IDE-changing example.

1. Support for {@inheritDoc} in the javadoc popups.
   • This is encourages its use, which in turn encourages documenting why a method has been overridden, or what’s so special about this particular implementation, without having to repeat the purpose of the method itself.
2. Warnings when a method overrides a synchronized method, but isn’t synchronized itself.
   • It’s hard enough as it is to ensure you get the intended multi-threaded behaviour. This change can help prevent an error that while not very common, can be very hard to spot.
3. When auto-reformatting an entire class, I can keep the line breaks that I’ve added.
   • This caters for where the formatting rules are too general, and are not aware that I’d find some things much clearer if split into multiple lines in very specific places.
4. Constructor completion has been made more useful, by offering more appropriate suggestions.
   • I also often save myself some typing by writing the right hand side of the assignment, then using a quick assist to assign the result to a new variable.
5. By holding down Ctrl, and hovering on a method, I can chose whether to jump to the declaration, or the implementation.
   • I still find this method of navigation difficult though, preferring to keep my hands on the keyboard, navigating to the method call, pressing Ctrl-T, and choosing which implementing or declaring class I wish to view. (That’s not a new feature.)
   • What I’d like is a companion for F3’s mapping of “Go To Declaration” that with a single key press I can “Go To Implementation”. However I can’t find that command in the key binding preferences page.

Most of my coding these days is in java, so some of Scott’s best practices need altering to my situation, e.g. junit.jar instead of nunit.framework.dll.

For reference, I disagree to varying extents with #1, #2, #3, and #5, and agree with #4, #6, and #7.

However I believe that best practices are often relative to the situation you find yourself in. That situation includes which IDE you are using, and how best to use it, how large your team is, how complex your application is, etc.

I also think that it is an excellent idea to consider which practices consciously or unconsciously drive your coding practice, and whether any of them could be improved. Scott himself says that best practices change over time, and his blog seems to have a long running theme of identifying some of these changes. I commend him for identifying and documenting what he does, providing advice for others to consider, and asking for feedback.

Here are my reasons for disagreeing with some of his NUnit best practices, from my junit in eclipse standpoint:

#1

I primarily disagree since all too often the tests are not distributed with the code being tested. When dealing with some-one else’s code, I don’t have their test cases, so if I have problems with their code, I can’t simply find out whether their test cases still work in my environment, nor whether I’m using parts of their code which are not covered by their tests.

Secondly, I disagree with “don’t be lazy”. We should all be striving to have our best practices also be the easiest things to do.

#2 & #3

These are things that should be integrated into your IDE and dependency management tools. They appear to be workarounds for poor visual studio defaults when you wish to use NUnit to test your code.

#5

I prefer the idea of starting by writing test cases in a style that documents what you want to achieve. That then drives what methods you need, and perhaps how they should be collected into various interfaces. I refer to this as an idea since I’m not particularly disciplined in developing in this way.

Overall though, I’d say that I agree with Scott in that solid unit testing using a tool like NUnit is best practice.

There is a function named pi, (written as the greek symbol), but pi isn’t used in reference to circles’ diameters and circumferences, but is instead (as far as I can tell) P. I. standing for prime index. pi(x) is equal to the number of primes equal to or less than x.

By altering my representation slightly so that the number one is represented as a single box:

So that two is the first prime, so two is a box with the representation of one inside it (which is how I previously drew three).

Then the representation of any number n is drawn by producing n‘s prime factors, f₀ to f_k and each factor f_i is drawn as a box with the representation of pi(f_i) inside it.

To make the representation slightly more aesthetic, you can fill in all the gaps with the representation of one. This is because everything is multiplied, and you can of course multiply by one as many times as you like without altering the product. Multiplication is also commutative, so the boxes may be rearranged to give a pleasant looking number, so long as the number of boxes within any box stays the same.

Multiplication is simply a case of drawing both sets of boxes for the numbers being multiplied.

Division and rational numbers are probably best drawn with a numerator over a divisor separated by a line. Common factors are easily identified and removed.

By contrast, addition and subtraction are intensely difficult.

Here’s a walk-through of representing your birthday as a bunch of boxes:

You could draw the number for the day, month and year individually, but you’ll probably end up with more a more interesting drawing if you start with one large number n = YYYYMMDD. So for my birthday, 8th September 1972, n=19720908

The first step is to produce the prime factors. There are lots of ways of doing this. The easiest way if you are reading this online is to use an online tool. The one from Maths Is Fun says my prime factors are 6763 x 3 x 3 x 3 x 3 x 3 x 3 x 2 x 2.

So I need nine boxes, containing the representation of pi of each factor.

Though boxes can be arranged in any way you like, in order to demonstrate the technique I’ll stay consistent, showing these vertically, as otherwise by the end of the post I’ll be running out of room. Web pages have a fixed width, but can be infinitely long:

There’s an online calculator of pi(n) too here.

It reports that there are:

871 primes less than or equal to 6763

2 primes less than or equal to 3

1 prime less than or equal to 2

So our boxes need to be:

We repeat the process for each of these numbers, drawing a box for each prime factor, and writing pi(factor) in each box.

The prime factors of 871 are 67 x 13, so we need two boxes.

2 is prime, so each of the 2s need a single box.

1 has been defined as a box with nothing in it.

pi(67) = 19

pi(13) = 6

pi(2) we’ve previously seen = 1

So our boxes need to be:

Producing prime factors again, 19 is prime, so a single box is needed. 6s prime factors are 3 x 2, so two boxes needed

We’ll replace 1s as before.

So we’ve got:

Evaluating the pi functions gives:

Factorising gives:

Evaluating the pi functions gives:

Replacing the last 1s with their representation of an empty box gives the final representation:

Rearranging this into a pleasing arrangement gives

The list of new features is no longer as easy to find, since it was linked to from the download page for the milestone releases, and since the releases are now release candidates, there are no new features.

These will no doubt be combined into a single what’s new page for the final release, but until then, the lists for each milestone release are well worth a read: M1 M2 M3 M4 M5 M6 M7

Update: As expected, the release of 3.4 is accompanied by a new New and Noteworthy page. What’s also worth reviewing is the feature comparison page for the various Ganymede packages.

My personal favourite dozen new features:

1. System Proxy Settings – One less place to change those settings when I plug the laptop in somewhere new.
2. Default console and file encoding – I develop on Windows for Linux.
3. Shearing – I love the pun.
4. The improved error log view, and the Plug-in registry view enhancements – these will help when trying out misbehaving plug-ins.
5. Line support in overview ruler – much faster navigation.
6. Runnable JAR export wizard – no more searching for and installing third party plug-ins to do this simple thing.
7. Different highlighting for read and write occurrences of the selected or searched for element – this is fantastic.
8. Direct interaction with text hovers – less hand movement is good. Being able to click through to other javadocs is fantastic.
9. Breadcrumb navigation – this is a quite good compromise between ease of use and screen real estate.
10. Support for external class folders – I haven’t used this yet, but can think of some past experiences where it would have been useful.
11. Java compiler on multi-CPU machines – parallelisation is how we go faster these days.
12. Quick Assist becomes even more helpful.

Eclipse’s quick assist feature saves a huge amount of work. There’s no need to go looking through menus and dialogs to find the right place to activate the thing you want to do right now, you simply hit Ctrl-1 and what you want to do is invariably in the short list that immediately pops up. The “what’s new” pages list these additional assists and fixes:

M1
-    Helps with regular expressions in find/replace
-    Helps correct spelling in CVS commits
M2
-    PDE Quickfix for Java file issues
-    Add @throws or @exception javadoc tag
-    Select a missing method error in the Problems view and Quick Fix
-    Create getter and setters for fields (encapsulate fields)
-    Extract method on expressions
-    Helps with the new SWT Templates
-    Helps with user created templates
M3
-    Code completion helps with casts
-    Complete static members of not yet imported types
M4
-    Ensure source entries found in build.properties are properly accounted for in the plug-in manifest
-    Diagnosis (and removal quick fix) of redundant superinterfaces
-    Improved key binding support
-    Convert to StringBuffer
M5
-    Improved cursor jumping
M6
-    New Javadoc tags to annotate (PDE) API with explicit restrictions
-    Quick fix provided for missing or incorrect @since tags
-    The Java problem hover now offers all available quick fixes
-    Use MessageFormat for string concatenation
-    Extract local variable (without replacing all occurrences)
-    only show templates applicable at the current location
M7
-    Remove invalid use of API Javadoc tags
-    Inserting parameter name also shows guessed arguments
-    Shows gory details of improved text search

It doesn’t need that feature though, since using IE’s feeds, it also uses IE’s feed updating mechanism. I don’t really like IE’s feed updating mechanism, since it is a background task that keeps using my laptop’s resources when it wants to, rather than when I want it to.

Investigating how it updates, I discovered that I can disable the background task, and when I want the feeds updated, I can run:

msfeedssync forcesync

I thought I’d blog about it, since there are currently so few mentions (in English) of this.

I created a shortcut to run that on my Quick Launch bar. Can anyone comment on where to find a pre-installed rss icon?

Left to right are the factors, rearrange at will. The vertical arrangement represents the power.

Here are some of the results shown in the previously generated style, and recreated as groups of concentric squares.

2:[]

[]

3:[[]]
 ____
[    ]
[ [] ]
[____]

4:[]([])

[]

[]

5:[[[]]]
 ________
[  ____  ]
[ [    ] ]
[ [ [] ] ]
[ [____] ]
[________]

6:[[]][]
 ____
[    ]
[ [] ]
[____] []

7:[[]([])]
 ____
[    ]
[ [] ]
[    ]
[ [] ]
[____]

8:[]([[]])
 ____
[    ]
[ [] ]
[____]

[]

9:[[]]([])

[]
 ____
[    ]
[ [] ]
[____]

10:[[[]]][]
 ________
[  ____  ]
[ [    ] ]
[ [ [] ] ]
[ [____] ]
[________] []

11:[[[[]]]]
 ____________
[  ________  ]
[ [  ____  ] ]
[ [ [    ] ] ]
[ [ [ [] ] ] ]
[ [ [____] ] ]
[ [________] ]
[____________]

...

293:[[[[[[]]]]][]]
 _______________________
[  ________________     ]
[ [  ____________  ]    ]
[ [ [  ________  ] ]    ]
[ [ [ [  ____  ] ] ]    ]
[ [ [ [ [    ] ] ] ]    ]
[ [ [ [ [ [] ] ] ] ]    ]
[ [ [ [ [____] ] ] ]    ]
[ [ [ [________] ] ]    ]
[ [ [____________] ]    ]
[ [________________] [] ]
[_______________________]

294:[[]([])]([])[[]][]

[]
 ____
[    ]
[ [] ]  ____
[    ] [    ]
[ [] ] [ [] ]
[____] [____] []

295:[[[[]([])]]][[[]]]
 ____________
[  ________  ]
[ [  ____  ] ]
[ [ [    ] ] ]
[ [ [ [] ] ] ]  ________
[ [ [    ] ] ] [  ____  ]
[ [ [ [] ] ] ] [ [    ] ]
[ [ [____] ] ] [ [ [] ] ]
[ [________] ] [ [____] ]
[____________] [________]

296:[[[]][]([])][]([[]])
 ___________   ____
[  ____     ] [    ]
[ [    ] [] ] [ [] ]
[ [ [] ]    ] [____]
[ [____] [] ]
[___________] []

297:[[[[]]]][[]]([[]])
 ____________   ____
[  ________  ] [    ]
[ [  ____  ] ] [ [] ]
[ [ [    ] ] ] [____]
[ [ [ [] ] ] ]  ____
[ [ [____] ] ] [    ]
[ [________] ] [ [] ]
[____________] [____]

298:[[[]([])][[[]]]][]
 ___________________
[  ____   ________  ]
[ [    ] [  ____  ] ]
[ [ [] ] [ [    ] ] ]
[ [    ] [ [ [] ] ] ]
[ [ [] ] [ [____] ] ]
[ [____] [________] ]
[___________________] []

299:[[[]]([])][[[]][]]
 ________
[        ]
[  []    ]  ___________
[  ____  ] [  ____     ]
[ [    ] ] [ [    ]    ]
[ [ [] ] ] [ [ [] ]    ]
[ [____] ] [ [____] [] ]
[________] [___________]

300:[[[]]]([])[[]][]([])

[]
 ________
[  ____  ]
[ [    ] ]  ____
[ [ [] ] ] [    ] []
[ [____] ] [ [] ]
[________] [____] []

One of the IP addresses of this blog: 72.233.2.56:

 ______________________   ____________
[                      ] [  ________  ]
[ []                   ] [ [  ____  ] ]                ____________
[  ________            ] [ [ [    ] ] ]               [  ________  ]
[ [  ____  ]           ] [ [ [ [] ] ] ]  ___________  [ [  ____  ] ]  ____          ____
[ [ [    ] ]  ____     ] [ [ [    ] ] ] [  ____     ] [ [ [    ] ] ] [    ]        [    ]
[ [ [ [] ] ] [    ]    ] [ [ [ [] ] ] ] [ [    ]    ] [ [ [ [] ] ] ] [ [] ]  ____  [ [] ]
[ [ [____] ] [ [] ]    ] [ [ [____] ] ] [ [ [] ]    ] [ [ [____] ] ] [    ] [    ] [____]
[ [________] [____] [] ] [ [________] ] [ [____] [] ] [ [________] ] [ [] ] [ [] ]
[______________________] [____________] [___________] [____________] [____] [____] []

Explanation: The IP 72.233.2.56 = 1223230008

1223230008 = 863 * 59 * 13 * 11 * 7 * 3 * 2^3

863 is the 150th prime. 150 = 5^2 * 3 * 2

59 is the 17th prime. 17 is the 7th prime.

13 is the 6th prime.

Desired Application

I chose to implement a weird idea that I had a couple of years ago: Instead of representing natural numbers in base 10, or any other fixed base, record the prime factorisation. Instead of recording how many 1s, 10s, 100s, 1000s, etc. to sum, you can record how many 2s, 3s, 5s, 7s, 11s, 13s, etc. to multiply. (With a special code for 1.) Each prime number is indexed, and referred to by its index, such that, for example the number 288 (base 10) = 3^2 x 2^5, which is 3 (the second prime) to the power of 2 (the first prime), multiplied by 2 (the first prime) to the power of 5 (the third prime). The powers are also converted into their representation within this same system.

Using [x] to refer to the x’th prime, we get 288 (base 10)

= [2] ^ [1] x [1] ^ [3]
= [[1]] ^ [1] x [1] ^ [[2]]
= [[1]] ^ [1] x [1] ^ [[[1]]]

Everything reduces to [1], which I then replace with []. Multiplication signs can be removed, and power signs can be replaced with parenthesis to give a cryptic representation: 288 = [[]]([])[]([[[]]])

A cleaner representation may be to replace 1, with (), meaning “to the power of zero”, but that is not what I did for this silly example.

That covers the basic idea for the program: conversion from simple base 10 numbers into these cryptic character sequences representing the prime factorisation.

Generating A Sequence Of Primes

To start with I looked for a way to calculate primes in Scala. The docs on scala.Stream includes a simple definition of the Sieve of Eratosthenes. I started with something similar, which I found on Scala Kurz:

def sieve(s: Stream[Int]): Stream[Int] =
  Stream.cons(s.head, sieve(s.tail filter (_ % s.head != 0)))
val primes = sieve(Stream.from(2))

This simple algorithm is quite easy to understand, but unfortunately is pretty useless, as it is so resource intensive that without changing any JVM runtime parameters, it can only calculate up to the 1641st prime (or the 3715th prime if using the scala runtime, which starts the jvm with a larger heap) before overflowing the stack.

Generating A Sequence Of Primes Efficiently

The Literate Programs site includes the same implementation in its Sieve of Eratosthenes in Scala page, but the Sieve of Eratosthenes in Haskell includes a more efficient functional implementation that I thought I’d convert to Scala (I don’t know Haskell, but the algorithm is explained well).

The most difficult part of the conversion was trying to decipher what foldr1 was supposed to do. I incorrectly assumed it was the same as Stream.foldRight, which I butchered till I arrived at something that seemed to work (The definition of foldr1 below is probably not equivalent to Haskell’s.):

def merge(xs: Stream[Int] , ys: Stream[Int]): Stream[Int] = {
  if (xs.head < ys.head)
    return Stream.cons(xs.head, merge(xs.tail, ys))
  if (xs.head == ys.head)
    return Stream.cons(xs.head, merge(xs.tail, ys.tail))
  return Stream.cons(ys.head, merge(xs, ys.tail))
}
def diff(xs: Stream[Int], ys: Stream[Int]): Stream[Int] = {
  if (xs.head < ys.head)
    return Stream.cons(xs.head, diff(xs.tail, ys))
  if (xs.head == ys.head) return diff(xs.tail, ys.tail)
  return diff(xs, ys.tail)
}
def f(xs: Stream[Int], ys: => Stream[Int]) =
  Stream.cons(xs.head, merge(xs.tail, ys))
def g(p: Int) = Stream.from(p*p,p*2)
def foldr1(f: (Stream[Int], => Stream[Int]) => Stream[Int])
  (s: Stream[Stream[Int]]): Stream[Int] =
  if (s.isEmpty) Stream.empty
  else f(s.head, foldr1(f)(s.tail))
val primes: Stream[Int] =
  Stream.fromIterator((2::3::5::Nil).elements).append(
      diff(Stream.from(7,2), nonprimes))
val nonprimes = foldr1(f)(primes.tail map g)

Now I can calculate up to the 18707th prime, an order of magnitude more that the simple algorithm, in an order of magnitude more lines of code.

Comments in Jorge Ortiz post Fun with Project Euler and Scala also mention the poor resource utilisation of the two-line sieve, and code is supplied for providing a stream of primes using java’s BigInteger.nextProbablePrime(). I’ll leave that for now though, and get back on track…

Determining Prime Factorisation

Next I needed indexed prime factors:

// Prime Factor Tuple: Prime, Power, Index
type Factors = List[(Int, Int, Int)];
def primeFactorsRecurse(i: Int, factors: Factors,
    morePrimes: Stream[Int], index: Int): Factors = {
  if (i == 1) return factors;
  if (i % morePrimes.head == 0) {
    if ((factors != Nil) && (morePrimes.head == factors.head._1)) {
      return primeFactorsRecurse(i / morePrimes.head,
          (morePrimes.head, factors.head._2 + 1, index) ::
          factors.tail,
          morePrimes, index);
    } else {
      return primeFactorsRecurse(i / morePrimes.head,
          (morePrimes.head, 1, index) :: factors,
          morePrimes, index);
    }
  }
  return primeFactorsRecurse(
      i, factors, morePrimes drop 1, index + 1);
}

def primeFactors(i: Int): Factors = {
  if (i == 1) return (1,1,0) :: Nil;
  primeFactorsRecurse(i, Nil, primes, 1);
}

Printing The Numbers

All that is needed now is the code to print the numbers using the unusual representation described above:

def printPrimeFactors(factors: Factors): Unit = {
  factors match{
    case (prime: Int, power: Int, index: Int) :: morefactors =>  {
      if (index > 0) printPrimeFactors("[", index, "]")
      if (power > 1) printPrimeFactors("(", power, ")")
      printPrimeFactors(morefactors)
    }
    case Nil => ();
  }
}

def printPrimeFactors(pre: String, i: Int, post: String): Unit = {
  print(pre)
  printPrimeFactors(primeFactors(i))
  print(post)
}

(1 to 300) foreach {i: Int => printPrimeFactors(i + ":",i,"\n")}

Summary

I was able to create an application in Scala to do what I wanted, while making use of a number of Scala language features.

I’ll welcome corrections, and comments regarding the Scala code, such as how I can create a infix Stream.cons operator to make my code less verbose, or ways to automatically switch to BigInts if the range of Int is surpassed.

I’d also be extremely interested in anyone can think of a use for this representation of natural numbers. The same ideas can be converted into graphical symbols, e.g. using differently sized concentric circles instead of [[[]]], or tracing a path to give a particular “primal squiggle” that uniquely represents a number, (such as an IP address). The order of factors doesn’t matter, so that provides scope to position graphical representations of them in artistically pleasing arrangements.