A prime number is a number which is only dividable by one and itself without producing a remainder. That sounds simple enough. I wrote a small program which accepts an integer as a command line argument and prints out all of the prime numbers between 0 and that number.

#include <iostream>
#include <stdlib .h>

bool isPrime(int num) {
  bool prime = true;
  if (num < 2)
    return false;
  for (int i = 2; i < num; ++i) {
    if (num % i == 0)
      prime = false;
  }
  return prime;
}

int main(int argc, char *argv[]) {
  if (argv[1] == NULL)
    return 0;
  const int TOP = atoi(argv[1]);
  std::cout << "Prime Numbers from 0 - " << TOP << ": ";
  for (int j = 0; j <= TOP; ++j) {
    if (isPrime(j))
      std::cout << j << " ";
  }
  std::cout << std::endl;
  return 0;
}

Case 1 was the slowest way that I could dream up of reaching a solution. How could I optimize it? When isPrime() is called, it divides by every single number before the function returns with either a boolean true or false. Once a number has been proven to be non-prime there is no need to continue calculating whether it is prime or not. I replaced the following code:

bool isPrime(int num) {
  bool prime = true;
  if (num < 2)
    return false;
  for (int i = 2; i < num; ++i) {
    if (num % i == 0)
      prime = false;
  }
  return prime;
}

with:

bool isPrime(int num) {
  if (num < 2)
    return false;
  for (int i = 2; i < num; ++i) {
    if (num % i == 0)
      return false;
  }
  return true;
}

The function is quite a bit faster now. The next optimization was a no-brainer. A number can’t be divided by more than half of itself and not produce a remainder. I decided to divide the number of divisors in half by replacing:

  for (int i = 2; i < num; ++i) {

with:

  for (int i = 2; i < (num/2)+1; ++i) {

This produced yet another incremental speedup. I sat on the train and had a fuzzy theory pop up in my head. Can the upper limit of a divisor need to be greater than the square root of a number? It was worth a try:

bool isPrime(int num) {
  if (num < 2)
    return false;
  for (int i = 2; i < (num/2)+1; ++i) {
    if (num % i == 0)
      return false;
  }
  return true;
}

Replaced with:

#include <math .h>

bool isPrime(int num) {
  if (num < 2)
    return false;
  double maxDivisor = pow((double)num+1, 0.5);
  for (int i = 2; i <= (int)maxDivisor; ++i) {
    if (num % i == 0)
      return false;
  }
  return true;
}

The speed increase that case 4 provided was substantial. By this point I was able to solve the problem in a trivial amount of time. This was when I decided that it would be fun to see how others have solved this problem. I searched around and discovered this guy names Eratosthenes (maybe you’ve heard of him). After marveling at the fact that Eratosthenes was able to solve this problem efficiently more than 2000 years ago I dug into learning about the Sieve of Eratosthenes.

Essentially, Eratosthenes was able to efficiently calculate a series of prime numbers by using previous primes in order to help calculate future primes by eliminate non-primes. I then remembered learning about it in high school but it was long gone by the time I reached this problem.

#include <iostream>
#include <stdlib .h>

int main(int argc, char *argv[])
{
  if (argv[1] == NULL)
    return 0;
  const int TOP = atoi(argv[1]);
  std::cout < < "Prime Numbers from 0 - " << TOP << ": ";

  bool* sieve = new bool[TOP+1];
  std::fill_n(sieve, TOP+1, 1);
  sieve[0] = 0;
  sieve[1] = 0;
  for (int i = 2; i <= TOP; ++i) {
    if (sieve[i] == 1) {
      std::cout << i << " ";
      for (int j = i; j <= TOP; j+=i) {
        sieve[j] = 0;
      }
    }
  }
  delete[] sieve;
  return 0;
}

With larger inputs, this was the most optimal way to compute a range of primes that I wrote up. It uses more memory than the previous methods. There are further optimized algorithms which do things like remove memory for even numbers(which are never prime except for 2). I would have dug deeper and attempted the Sieve of Atkin but that was out of the scope of my train ride.

POSIX Threads
Parallelism in Java
OpenMP
TBB
OpenCL
Cuda

I had a great time with the program and look forward to implementing what I have learned into a couple of projects I am working on. I highly recommend this program if you have any interest in multicore programming.

A couple of weeks ago I realized that I barely ever touched my desktop. I thought this was a bit strange and set out to discover why. Well, it did not take long to find out what had happed. You see, my desktop is a dual boot Ubuntu / Windows 7 box which is going on being six years old now. I hate waiting for the thing to boot up. The whole machine is as slow as molasses. Halfway through any project I give up and work on the mac mini. This is the perfect opportunity to start a summer time project.

I decided to build myself a new desktop machine. Convincing myself it would be lots of fun to do it. It will be more challenging this time around. With a little help from Noman this is what I came up with:

Intel Core i7 Processor i7-930 2.80GHz 8 MB LGA1366 CPU

Cooler Master Hyper 212 Plus

Gigabyte LGA1366 Motherboard GA-X58A-UD3R

G.SKILL 6GB (3 x 2GB) 240-Pin DDR3 SDRAM DDR3 1600 (PC3 12800) Triple Channel Kit F3-12800CL9T-6GBNQ

Acer H233H bmid 23-Inch Widescreen LCD Display

EVGA nVidia GeForce GTX260 Core 216-55nm Superclocked 896 MB DDR3 2DVI PCI-Express Video Card 896-P3-1257-AR

Corsair CMPSU-750HX 750-Watt HX Professional Series 80 Plus Certified Power Supply compatible with Core i7 and Core i5

Intel 80 GB X25M Mainstream SATA II Solid State Drive (SSD) Retail Package SSDSA2MH080G2R5

This is the perfect project to kick off the summer. Expect an update once i actually put the thing together.

In an effort to master Emacs, I have installed it on all of the machines I use. These are some of the links that I have found helpful:

Installation:
Windows
Mac: Carbon Emacs

Configuration:
Yegge: 10 Specific Ways to Improve Your Productivity With Emacs
5 Indispensable Tips for Emacs on Windows

Sample configurations:
Yegge: my .emacs file
Phil Hagelberg: emacs-starter-kit
Justin Lilly: Fork of emacs-starter-kit with python support

Extensions / plugins:
Yasnippet
Cedet (C++ development tools)

Misc. / Tutorial:
A Guided Tour of Emacs
Peepcode: Meet Emacs
Learn Emacs in Ten Years
Emacs Subreddit
Fullscreen Emacs on OSX

require 'win32ole'
require 'net/smtp'
require 'yaml'

def send_email(message)
  begin
    msg = <<END_OF_MESSAGE
From: #{$from_alias} <#{$from}>
To: #{$to_alias} <#{$to}>
Subject: #{$subject}
#{message}
END_OF_MESSAGE

    Net::SMTP.start('smtp.company.com') do |smtp|
      smtp.send_message msg, $from, $to
    end
  rescue => error
    puts "Exception: #{error}"
  end
end

$from_alias = "Email Alias"
$from = "processWatcher@company.com"
$subject = "Process Error"
$to_alias = "Email Alias"
$to = "alerts@company.com"

#Server list
$proc = ["Server1", "Server2"]

$proc.each { |record|
  runningProc = false
  begin
    wmi = WIN32OLE.connect("winmgmts://#{record}")
    processes = wmi.ExecQuery("select * from win32_process")
  rescue => error
    puts "Exception: #{error}"
  end
  for process in processes do
    if (process.Name == "SampleProcess.exe")
      puts "Server: #{record} Name: #{process.Name}"
      runningProc = true
    end
  end

  if runningProc
    puts "Process on #{record} not running as of #{Time.now}. Please check the server."
    send_email("Process on #{record} not running as of #{Time.now}. Please check the server.")
  end
}

begin
  File.copy(line.strip, root + templine.strip)
rescue => error
  puts "Error Copying File: Exception: #{error}"
  error
end