Not that straightforward, actually. Apple includes the Hoefler Text font in Mac OS X - its a really nice and readable professional font. Here’s what I did:

(1) You need to obtain the font in the opentype format (otf). Be careful: for me, the TTF version didn’t work. The Postscript type 1 version worked great.
(2) Use otftotfm -a to convert and install the files:

otftotfm -a -e texnansx HoeflerText-Regular.otf -fkern -fliga LY1–HoeflerText-Regular

This installs the regular form in the .texlive subdirectory of your home directory. Do this for all the font shapes you want to use. In the last step you need to create a .fd file:

\DeclareFontFamily{LY1}{HoeflerText}{}\DeclareFontShape{LY1}{HoeflerText}{m}{n}%
{ < -> LY1–HoeflerText-Regular }{}
\DeclareFontShape{LY1}{HoeflerText}{m}{it}{ < -> LY1–HoeflerText-Italic }{}
\DeclareFontShape{LY1}{HoeflerText}{m}{sl}{ < -> LY1–HoeflerText-Bold }{}
\DeclareFontShape{LY1}{HoeflerText}{b}{n}{ < -> LY1–HoeflerText-Bold }{}\DeclareFontShape{LY1}{HoeflerText}{b}{it}%
{ < -> LY1–HoeflerText-BoldItalic }{}

Put this in ~/.texlive2008/texmf-var/tex/latex/HoeflerText/LY1HoeflerText.fd. Again, make sure that all font shapes you want to use are included.

In your Latex document, put

\usepackage[LY1]{fontenc}
\renewcommand{\rmdefault}{HoeflerText}

to use the font.

The picture above was CCed on flickr by liikennevalo, thanks!

I resumed my code katas - this time, I’m using Erlang to solve the problem:

By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
What is the 10001st prime number?

It seems to be clever to have a prime number generator for Project Euler anyway. My implementation is based on the Sieve of Erathosthenes and uses the Prime Number Theorem for an estimate on the size of the sieve. The code is pretty easy:

%% Solves Project Euler task #7: 
%% "By listing the first six prime numbers: 2, 3, 5, 7, 11, 
%% and 13, we can see that the 6th prime is 13.
%% What is the 10001st prime number?"
%% Solution idea: Use the sieve of Erathosthenes.
%% Copyleft Mathias Dalheimer, 09/08/2008.

-module(pe7).
-export([sieve/1, nthprime/1, info/0]).

info() ->
  io:format("Project Euler Problem #7 - use nthprime(10001).~n").

nthprime(N) ->
  % First, estimate the upper bound for Erathosthenes sieve,
  % then use it. See
  %   http://mathworld.wolfram.com/PrimeNumberTheorem.html
  % for more information on the estimate method.
  Max = round(N*(math:log(N) + math:log(math:log(N-1)))),
  io:format("Estimated upper bound for sieve: ~p~n", [Max]),
  nthprime(N, Max).

nthprime(N, Max) ->
  T1 = erlang:now(),
  Primes = sieve(Max),
  T2 = erlang:now(),
  io:format("Runtime of Erathosthenes sieve: ~p ms.~n",
    [(timer:now_diff(T2, T1) / 1000)]),
  lists:nth(N, Primes).

sieve(Max) ->
  Boundary = round(math:sqrt(Max))+1,
  erathosthenes(lists:seq(2, Max), 2, Boundary).

isMultipleOf(X, Base) ->
  if
    X =:= Base -> true;
    (X rem Base =:= 0) -> false;
    true -> true
  end.

erathosthenes(Numbers, Index, Boundary) when Index =< Boundary ->
  PurgedNumbers = [X || X <- Numbers, isMultipleOf(X, Index)],
  %io:format("DEBUG: \tNumbers = ~p,~n\tBoundary = ~p ~n", [PurgedNumbers, Boundary]),
  %io:format("Boundary = ~p ~n", [Boundary]),
  erathosthenes(PurgedNumbers, Index+1, Boundary);
erathosthenes(Numbers, _, _) ->
  Numbers.

HTML code generated by vim-color-improved v.0.4.0.Download this code: pe7.erl

In the erathosthenes function, a list comprehension is used to purge all multiplies of the current Index value. My first attempt didn’t include the Index variable - I simply decreased the boundary. The disadvantage of this method is that it keeps the list of primes bigger over the runtime: Instead of removing the multiples of 2 at the very beginning, they get removed as the last multiples. The size of PurgedNumbers stays bigger, which leads to a runtime of 6.7 seconds. When I use the Index variable, the multiples of 2 get removed first which avoids copying them all the way. The runtime decreases to 1.2 seconds (on my Mac Mini).

Since all variables in Erlang are bound only once, I don’t know how to optimize this further. In C, I would use a bit array to further reduce the memory footprint. But: the Erlang code is much easier to read and write. I think Erlang is just not made for low memory bandwidth requirements :-)

The picture above is an representation of the Ulam spiral, CCed on flickr by no_typographic_man.

FreeRTOS is an open-source realtime operating system for microcontrollers. The ATMega644 of ATMEL provides 64KB of flash program memory in a DIY-friendly 40-pin PDIP package. Read on for how to combine both to my new software development platform.

FreeRTOS provides a nice RTOS for embedded systems and is readily available for various platforms. One timer of the hardware is used to implement multitasking features. A library provides routines for creating tasks and synchronization. Unfortunately, FreeRTOS is currently only ported to the ATMega323 - so I created a basic port to the ATMega644 and stripped all unnecessary features.

Typically, the FreeRTOS demo shows how to implement various threads and let them access the hardware. While it is educating to read the code, it is too bloated to serve as a template for new developments. In addition, I prefer Peter Fleury’s UART library for serial outputs. So, I removed all threads and included the library. To make sure that two threads cannot write to the same UART at the same time, I introduced a mutex per UART to synchronize the output on a per-string basis. Please note that there is no Mutex to synchronize read access. The main program starts two tasks which print “foo” and “bar” to the serial line, respectively. I kept the task surveilance mechanism as implemented in the original FreeRTOS demo (this might become handy ;-))

Here is a peek at the main.c file:

/* Based on FreeRTOS Demo main (AVR-GCC Port). */

#include <stdlib.h>
#include <string.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

/* Scheduler include files. */
#include "FreeRTOS.h"
#include "task.h"
#include "croutine.h"

#include "status.h"
#include "uart.h"

/* Priority definitions for most of the tasks in the demo application.  Some
tasks just use the idle priority. */
#define mainCHECK_TASK_PRIORITY                 ( tskIDLE_PRIORITY + 3 )

/* Baud rate used by the serial port tasks. */
#define UART_BAUD_RATE                  ( ( unsigned portLONG ) 9600 )

/* define CPU frequency in Mhz here if not defined in Makefile */
#ifndef F_CPU
#define F_CPU 16000000UL
#endif

/* LED that is toggled by the check task.  The check task periodically checks
that all the other tasks are operating without error.  If no errors are found
the LED is toggled.  If an error is found at any time the LED is never toggles
again. */
#define mainCHECK_TASK_LED                              ( 7 )

/* The period between executions of the check task. */
#define mainCHECK_PERIOD                                ( ( portTickType ) 3000 / portTICK_RATE_MS  )

/*
 * Function prototypes, see below.
 */
static void serialWriter( void *pvParameters );
static void vErrorChecks( void *pvParameters );
static void prvCheckOtherTasksAreStillRunning( void );
void vApplicationIdleHook( void );

/*
 * status variables.
 */
static portBASE_TYPE serialWriterStatus = pdTRUE;

portSHORT main( void ) {
  /* Setup the LED's for output. */
  statusInitialize();
  uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );
  sei();

  /* Create the tasks defined within this file. */
  xTaskCreate( vErrorChecks, ( signed portCHAR * ) "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );
  xTaskCreate( serialWriter, ( signed portCHAR * ) "Foo", configMINIMAL_STACK_SIZE, "foo", mainCHECK_TASK_PRIORITY, NULL );
  xTaskCreate( serialWriter, ( signed portCHAR * ) "Bar", configMINIMAL_STACK_SIZE, "bar", mainCHECK_TASK_PRIORITY, NULL );
  uart_puts_P("\r\nFreeRTOS template initialized.");

  vTaskStartScheduler();
  return 0;
}

static void vErrorChecks( void *pvParameters ) {
  /* The parameters are not used. */
  ( void ) pvParameters;

  /* Cycle for ever, delaying then checking all the other tasks are still
     operating without error. */
  for( ;; ) {
    vTaskDelay( mainCHECK_PERIOD );
    prvCheckOtherTasksAreStillRunning();
  }
}

static void serialWriter( void *pvParameters ) {
  char* message = pvParameters;
  for (;;) {
        vTaskDelay((portTickType) 100/portTICK_RATE_MS);
        /* Notify a single error. */
        if (uart_puts_P("\r\n") != pdTRUE)
          serialWriterStatus = pdFALSE;
        if (uart_puts(message) != pdTRUE)
          serialWriterStatus = pdFALSE;
  }
}

static void prvCheckOtherTasksAreStillRunning( void ) {
  static portBASE_TYPE xErrorHasOccurred = pdFALSE;
  if( serialWriterStatus != pdTRUE ) {
    xErrorHasOccurred = pdTRUE;
  }

  if( xErrorHasOccurred == pdFALSE ) {
    /* Toggle the LED if everything is okay so we know if an error occurs even if not
       using console IO. */
    statusToggleLED( mainCHECK_TASK_LED );
    uart_puts_P("\r\nAll tasks working.");
  }
}

void vApplicationIdleHook( void ) {
  vCoRoutineSchedule();
}

HTML code generated by vim-color-improved v.0.4.0.Download this code: freertos-atmega644-main.c

You can get the whole package (GPL licensed) from the download page. Have fun! Kudos for the CC’ed chip bug picture go to oskay.

At work I needed to generate random numbers following a combination of two gaussian distributions - which gave me some headache until someone pointed me to using a Monte Carlo approach. Here’s how.

Typically, any programming language provides some way to generate uniformly distributed random numbers, typically in the interval [0,1]. A histogram of the values looks like this:

However, I needed random numbers following the joint distribution of two gaussian distributions. The histogram should look like this:

It turns out that it is rather simple to generate random numbers from an given probability density function (PDF) f(x). The only restriction is that there exists another density function g(x) such that c*g(x) majorizes the density function f(x):

c*g(x) >= f(x) for all x.

The steps are rather simple - to generate a random variate x with density f(x):

1. Generate x with PDF g(x)
2. Generate y uniform on [0, cg(x)]
3. If y <= f(x), then output x and return - otherwise repeat from step 1.

Please note that this approach is applicable to many PDFs, but it can be rather slow, depending on the “hit rate”. The algorithm is simple: You generate two uniform random numbers, x and y. Then, you check if y < f(x) - if true, add x to your collection of random numbers. Otherwise, discard it. Repeat the steps until you have enough random numbers. This method is also called Rejection Sampling and was first described by John von Neumann. Other techniques include Inverse Transformation, Composition and Convolution.

I highly recommend reading Chapters 28 and 29 of Rai Jain’s “The Art of Computer Systems Performance Analysis” which outline techniques for generating random numbers of several distributions.

My ruby implementation consists of a MC wrapper and blocks compute the random variate. Currently, I can create gaussian distributions, exponential distributions and a combination of two gaussian distributions. The toolbox also contains a method to scale the range of the random numbers using a linear transformation approach.

# This file is part of the calana grid workload generator.
# (c) 2008 Mathias Dalheimer, md@gonium.net
#
# The calana grid work$load generator (CGWG) is free software; you can 
# redistribute it and/or modify it under the terms of the GNU General Public 
# License as published by the Free Software Foundation; either version 2 of 
# the License, or any later version.
#
# CGWG is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with CGWG; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
# Read the CGWG location from the environment, warn otherwise
if (ENV["CGWG_HOME"] == nil)
  puts "WARNING: Environment does not define $CGWG_HOME!"
else
  libpath= File.join(File.expand_path(ENV["CGWG_HOME"]), "lib")
  $:.unshift << libpath
end

class Range
  attr_accessor :min, :max
  def initialize(min=0.0, max=1.0)
    @min=min; @max=max;
  end
  def to_s
    "[#{@min}, #{@max}]"
  end
end

class RejectionException < StandardError
end

# A simple function that dumps the given array of values to
# a file in the global temp directory -> this is for debugging
def dumpRTable(values, filename)
  filename = File.join(ENV["HOME"], "tmp", filename);
  puts "Dumping values to #{filename}"
  File.open(filename, "w") {|file|
    file.puts("index\tvalue")
    values.each_index{|index|
      file.puts("#{index}\t#{values[index]}")
    }
  }
end

# Enhance Array: Allow it to shuffle its contents randomly.
class Array
  def shuffle
    sort_by { rand }
  end

  def shuffle!
    self.replace shuffle
  end
end

# Implements the MC approach - takes a block that checks if x < pdf(y).
def generateMCRandoms(amount)
  if not block_given?
    raise "No probability density function check given - aborting"
  end
  values = Array.new
  while values.size() < amount
    u1=rand()
    u2=rand()
    begin
      distvalue = yield(u1, u2)
      values << distvalue
    rescue RejectionException
      # do nothing here, just don't add distvalue
    end
  end
  return values
end

# Used for generating randoms for the user preference setting. 
# uses the composition method to multiplex two gaussian distributions.
# TODO: Eliminate outliers before merging and scaling - see Walsh test,
# http://www.statistics4u.info/fundstat_germ/ee_walsh_outliertest.html
def generateDoubleGaussianRandoms(amount)
  range=Range.new(0,1)
  leftvalues=generateGaussianRandoms(amount/2,mean=0.1,sd=0.1)
  rightvalues=generateGaussianRandoms(amount/2,mean=0.9,sd=0.1)
  values= (leftvalues + rightvalues)
  # We need to shuffle the randoms - otherwise, the two arrays would 
  # maintain their structure, which is not desired.
  values.shuffle!
  return linearTransformation(values, range)
end

# Use rejection method to filter uniform randoms such that they 
# fit the gaussian distribution. See Raj Jain, "The Art of Computer
# Systems Performance Analysis", p. 494.
def generateGaussianRandoms(amount, mean=0.0, sd=1.0, range=nil)
  rawvalues = generateMCRandoms(amount) {|u1, u2|
    x = - Math.log(u1)
    y = Math.exp((-(x-1)**2)/2)
    if (u2 > y)
      raise RejectionException, "Not acceptable random number."
    else
      u3=rand()
      if (u3>0.5)
        mean+sd*x
      else
        mean-sd*x
      end
    end
  }
  if range != nil
    return linearTransformation(rawvalues, range)
  else
    return rawvalues
  end
end

# Generate randoms from an exponential distribution using the rejection
# method. Actually, the inverse method would be far more efficient.
def generateExponentialRandoms(amount, varlambda=1, range=nil)
  rawvalues = generateMCRandoms(amount) {|x, y|
    expvalue = pdf_exponential(x, varlambda)
    if (y > expvalue)
      raise RejectionException, "Not acceptable random number."
    else
      x
    end
  }
  if range != nil
    return linearTransformation(rawvalues, range)
  else
    return rawvalues
  end
end

# Scales a set of raw values using linear transformation.
def linearTransformation(rawvalues, range)
  values=Array.new()
  rawmin=rawvalues.min()
  rawmax=rawvalues.max()
  rawvalues.each{|val|
    values << ((range.max - range.min)/(rawmax-rawmin))*(val-rawmin)+range.min
  }
  return values
end

# Calculates the value of the probability density function (PDF)
# for the gaussian distribution for x with the given parameters.
def pdf_gaussian(x, mean, sd)
  return (1/(sd*Math.sqrt(Math::PI*2)))*Math.exp(-((x-mean)**2/(2*sd**2)))
end

# The PDF of the exponential distribution
def pdf_exponential(x, varlambda)
  if (x<0)
    return 0
  else
    return varlambda*Math.exp(-varlambda * x)
  end
end

# Generate simple uniformly distributed random numbers.
def generateUniformRandoms(amount)
  values=Array.new
  amount.downto(0) {|index|
    values << rand()
  }
  values
end

if __FILE__ == $0
  $verbose = true
  amount=10000
  uniforms=generateUniformRandoms(amount);
  dumpRTable(uniforms, "uniform.txt");
  gaussians=generateGaussianRandoms(amount, mean=0.0, sd=1, range=Range.new(0.0, 1.0));
  dumpRTable(gaussians, "gaussians.txt");
  rawgaussians=generateGaussianRandoms(amount, mean=0.0, sd=1);
  dumpRTable(rawgaussians, "rawgaussians.txt");
  doublegaussians=generateDoubleGaussianRandoms(amount);
  dumpRTable(doublegaussians, "doublegaussians.txt");
  exponentials=generateExponentialRandoms(amount, varlambda=1, range=Range.new(0,1000));
  dumpRTable(exponentials, "exponentials.txt");
end

HTML code generated by vim-color-improved v.0.4.0.Download this code: statistics.rb

The title picture was CCed by Saffana, thanks!

This weekend, I solved problem 4 of Project Euler:

A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.

Find the largest palindrome made from the product of two 3-digit numbers.

I designed a routine that checks whether a given number is a palindrome. This routine is then used inside two loops iterating from 999 downto 0. The first hit is the largest palindrome. The core functionality is here:

This implementation reverses the vector. By using the front and back operators in the other direction, this could be left out. But it serves its purpose for now. You can get the full sourcecode from the download page. Please note that the code in the tarball calculates *all* palindromes smaller than 1000000.

The picture was CCed on flickr by TisseurDeToile -[mangerait bien un petit chat]-.

Eigentlich mag ich ja Internetbanking. Zu normalen Banköffnungszeiten arbeite ich, und ich bin nicht an lokale Banken gebunden. Meine bisherigen Erfahrungen waren auch recht positiv - allerdings beschleichen mich leichte Zweifel, wenn ich mir die Fehlermeldungen der Pluscard GmbH angucke.

Früher hab ich meine Kreditkartenauszüge einfach via Papierpost bekommen, kein Problem. Seitdem ich jedoch eine neue Kreditkarte habe, bekomme ich die nur noch am Kontoauszugsdrucker - oder für 55 ct. via Post. Da ich oft vergesse, am Kontoauszugsdrucker vorbeizuschauen, hab ich mich für den Onlineabruf bei der Pluscard GmbH freischalten lassen.

Ich hatte schon öfter Probleme, mich dort erfolgreich einzuloggen. Heute morgen bekomme ich jedoch obige lustige Fehlermeldung (auf das Bild klicken für eine größere Version). Abgesehen davon, daß es einfach schlechter Stil ist, seinen Kunden so eine Seite zu präsentieren, verwundert mich die Technik dahinter:

Die schreiben meine Logindaten unverschlüsselt in eine “Fehler”-Datenbank!

Meine Kreditkarten- und Paßwortdaten habe ich natürlich ausgegraut, aber die standen da im Klartext. Drumherum noch viele Informationen über den Linux-Rechner (Ich tippe auf SuSE Linux irgendwas). Und was bitte schön haben KDE und Gnome auf einem Webserver verloren? Ich selbst soll also beim Onlinebanking keine Paßwörter notieren, meine Kreditkartennummer nicht weitergeben etc. Aber wenn es um die Fehlersuche geht, dann darf der Admin mal eben schnell alle möglichen Daten einsehen. Hm, was passiert wohl, wenn es jemandem gelingt, die Datenbank zu klauen?

Das eine Packstation mal ausfällt, ist ärgerlich, aber ok. Beim Onlinebanking erwarte ich wesentlich mehr.

This weekend, I tackled the Project Euler problem #3:

The prime factors of 13195 are 5, 7, 13 and 29.
What is the largest prime factor of the number 600851475143 ?

Pretty straightforward: Just test and recurse.

The core of the implementation is here:

Please note that “ull” is a typedef for unsigned long long. For increasing integers, I test whether it is a factor of the given number. If yes, add it to the set of result values and descent one level into the recursion.

In addition, I extended my CMake infrastructure: You can now roll distributions based on CPack. In my oppinion you should start having a distribution target as early as possible within your development cycle. This way, you’re always ready to ship/deploy your software, i.e. for beta testers. Ship early, ship often… And of course automatically. When I type “make release”, CMake builds the software in release mode (”-O3″) and rolls several distributions. This is the output:

As you can see, a DMG image, a self-extracting shell installer and a tar.gz are built. The DMG contains all metadata for a nice MacOS installer - for Windows, a NSIS-based installer would have been created. CPack reuses the dependency information from my CMakeLists.txt files, so I don’t have to maintain another place and avoid duplication.

You simply add CPack to your toplevel CMakeLists.txt:

I choose to add the resulting binary in a subsequent CMakeLists.txt where the binary is compiled:

Pretty easy and maintainable :-) You can get the source package from the download page.

Picture taken by 8#X and CCed on flickr.

Recently, I started to use the autotools for building a project. But I am really unhappy with it - although a lot of special cases can be handled by the toolchain, it is extremely complex to use and prone to user errors. Auto-Hell, I guess… So, this code kata is dedicated to the alternative CMake package. I have written a simple C++ program to solve problem #2 of Project Euler.

The autotools toolchain attempts to solve two problems:

• Configuration: On the compile system, where do libraries etc live?
• Build: How is the software built?

The configuration step is the famous “./configure” everyone comes across when installing software on unix systems. The autotools employ a mix of SH, Commandline-Magic, M4 and fairy dust to handle this. It generates Makefiles so that one can use make to build the software. Additional make targets such as make dist or make install help during deployment of the software.

The problem lies in the complexity of the toolchain: in the mixture of tools that build upon other tools, M4 macros and shell scripts, it is extremely difficult to find errors. If your buildsystem is as complex as the software you’re developing, something is wrong. In addition, the autotools are not really portable to other systems such as windows, at least not straightforward.

For these reasons the KDE project moved away from the autotools. They evaluated many different buildsystems and choose CMake. I played a little bit with it and I am quite happy. Of course, one needs to asses such a system in a bigger scenario in order to judge it, but at a first glance it really does the trick.

There are plenty of articles around - to get you started I suggest Tanner Lovelace’s introduction. In addition, the following resources are helpful:

• Mal ausspannen (German, Linux-Magazin 02/2007)
• Cross-Platform Software Development Using CMake (Linux Magazine)
• The KDE subversion provides also a nice collection of CMake scripts which might give you some ideas.
• The CMake manpage, highly readable reference.

But now, on to building the software. My project directory has the following structure:

.
|– CMakeLists.txt
|– Makefile
|– Modules/
| `– FindLog4Cxx.cmake
|– common/
| |– CMakeLists.txt
| |– common.h
| `– config.h.in
|– problem2/
| |– CMakeLists.txt
| |– problem2.cpp
| `– problem2.hpp
|– src/
| |– CMakeLists.txt
| `– main.cpp
`– timer/
|– CMakeLists.txt
|– clock.cpp
`– clock.hpp


In order to keep things interesting I moved the code for solving the Project Euler task to the problem2 library. There’s a common library that defines project-wide settings. In timer, there’s a little routine for measuring execution times. The main routine lives in the src directory.

The CMakeList.txt files define the tasks to be done by CMake - this can be seen as the equivalent to the Makefile.am files. But you can define much more stuff in there. Here’s the top-level CMakeList.txt file:

I wanted to create a template which can be used as a staring point for later projects. I tend to use the Apache Log4CXX library for producing log messages. In order to discover the include and library directories, I created a CMake module - the equivalent of an Autotools M4 macro. CMake comes with lots of example modules for detecting libraries. But it is also easy to write your own modules. In contrast to the Autotools, all modules are specified in CMake’s own language.

Typically, you want to be able to deactivate all logging during the build process, e.g. prior to shipping the release version. You can define Options which can be set with various GUI tools. On Unix platforms, a curses-based GUI allows you to select your options. In this example, the ENABLE_LOGGING variable gets processed by the CMakeList.txt in the common directory:

This generates a config.h file and copies it to the right location in the build directory. The config.h.in file defines some variables that will be replaced based on the values determined by CMake during the build step. Altogether, I like CMake. It is as powerful as the Autotools but without the quirks of the latter. You can download the example from the download page. There are other tools in the CMake package, namely CTest for testing software - but I’ll save this for another sunday ;-)

Finally, the Project Euler task is to solve the following problem:

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, …

Find the sum of all the even-valued terms in the sequence which do not exceed four million.

The code to solve this problem is pretty easy:

The heaven or hell picture was CC’ed by karmablue.