Trying to write a prime number tester in as much programming languages as possible. Sounds weird, but I have a great fascination for prime numbers. Writing a small program that will test a number for being prime is always a nice practive run in a new language. Much better than the dead-beaten “Hello World”.
On this page you can find the source codes for the languages I’ve mastered (or started to learn).
My favourite language. This code was the fastest to write.
file: primetest.pl
#!/usr/bin/perl
#########################################
# Test of een getal priem is
#
# In : Getal (integer)
# Out: Priem / Geen Priem
#
# Date: 03-12-2003
# Time to write: 15 minutes
#########################################
use strict;
my ($number,$verbose) = @ARGV;
if (int($number) > 0) {
print IsPrime($number);
} else {
print "Usage:\nperl $0 number [verbosity=0|1]\n";
}
sub IsPrime {
my $number = shift;
# is it even?
if ($number != 2 && $number % 2 == 0) {
return "$number is NOT prime\n";
}
# limit to go to
my $test_limit = int(sqrt($number)) + 1;
print "We will test $number by dividing until $test_limit\n" if ($verbose);
for (my $divisor=3; $divisor<=$test_limit; $divisor +=2) {
print "$number / $divisor = " . ($number/$divisor) ."\n" if ($verbose);
if ($number % $divisor == 0) {
return "$number is NOT prime\n";
}
}
# if we make it until here, the number must be prime
return "$number is prime!\n";
}
Normally PHP is being used extensively for webpage programming. This script is a command-line version of a PHP prime tester. The getInput function was copied from the internet.
file: primetest.php
#!/usr/local/bin/php
<?php
/****************************************
* Test of een getal priem is
*
* In : Getal (integer)
* Out: Priem / Geen Priem
*
* Date: 03-12-2003
* Time to write: 25 minutes
*****************************************/
print "Which number do you want to test: ";
$number = getInput();
print "Shall we be verbose? 0=No, 1=Yes: ";
$verbose = getInput();
if (intval($number) > 0) {
print IsPrime($number,$verbose);
} else {
print "Not a valid number entered\n";
}
function IsPrime($number,$verbose) {
// is it even?
if ($number != 2 && $number % 2 == 0) {
return "$number is NOT prime\n";
}
// limit to go to
$test_limit = intval(sqrt($number)) + 1;
if ($verbose) {
print "We will test $number by dividing until $test_limit\n";
}
for ($divisor=3; $divisor<=$test_limit; $divisor +=2) {
if ($verbose) {
print "$number / $divisor = " . ($number/$divisor) ."\n";
}
if ($number % $divisor == 0) {
return "$number is NOT prime\n";
}
}
// if we make it until here, the number must be prime
return "$number is prime!\n";
}
function getInput ($length = 255) {
$fr = fopen("php://stdin", "r");
$input = fgets($fr, $length);
$input = rtrim($input);
fclose($fr);
return $input;
}
?>
Little more hardcore. Harder to write for me, but should be one of the fastest programs.
file: primetest.h
/*
* primetest.h - definitions for primetest function
*
*/
#ifndef PRIMETEST_H
#define PRIMETEST_H 1
/* functions related to prime numbers */
short IsPrime(unsigned long long, int);
#endif /* PRIMETEST_H */
file: Makefile
# Makefile for primetest.c
#
# compiler to use
CC=xlc
# include for math.h
LDFLAGS=-lm
LIBS=-lm
REMOVE=rm -f
all: primetest
primetest: primetest.o
$(CC) $(LDFLAGS) primetest.o -o $@
clean:
@$(REMOVE) primetest.o primetest
file: primetest.c
#include <math.h>
#include "primetest.h"
#include <stdio.h>
int main (void) {
unsigned long long number;
int verbose;
printf("Which number do you want to test: ");
scanf("%llu",&number);
printf("Shall we be verbose? 0=No, 1=Yes: ");
scanf("%i",&verbose);
if (IsPrime(number,verbose)) {
printf( "\n%llu is prime!\n",number);
} else {
printf("\n%llu is NOT prime\n",number);
}
}
short IsPrime(unsigned long long Number,int verbose) {
unsigned long long divisor,test_limit;
/* quick test for even numbers */
if (Number != 2 && Number % 2 == 0) {
return 0;
}
/* if we end up here, it's not even */
test_limit = (unsigned long long) sqrt( (double) Number);
if (verbose>0) {
printf("%llu will be tested until %llu\n",Number,test_limit);
}
for (divisor=3; divisor<test_limit; divisor+=2) {
if (verbose>0) {
/* convert both numbers to float before dividing */
printf("%llu / %llu = %.4f\n",Number,divisor,((long double)Number / (long doubl
e)divisor));
}
if (Number % divisor == 0) {
/* nope, not a prime */
return 0;
}
}
/* we even survived the loop above, must be prime then */
return 1;
}
Not to much experience with Java (yet). Probably a prettier way to program it, using object methods etc… Took me long to find out the difference between declaring long Number and the faulty Long Number.
file: PrimeTest.java
/****************************************
* Test of een getal priem is
*
* In : Getal (integer)
* Out: Priem / Geen Priem
*
* Date: 15-12-2003
* Time to write: 2 hours
*****************************************/
import java.math.*;
import java.lang.*;
public class PrimeTest {
public static void main (String[] args) {
long Number;
boolean Verbose;
if (args.length <1) {
ShowHelp();
}
/* no verbosity given, default to false */
if (args.length==1) {
Verbose = false;
} else {
Verbose = parseBoolean(args[1]);
}
Number = Long.parseLong(args[0]);
if (IsPrime(Number,Verbose)) {
System.out.println(Long.toString(Number) + " is Prime!");
} else {
System.out.println(Long.toString(Number) + " is not prime");
}
}
/* display usage information */
public static void ShowHelp () {
System.out.println("Usage: java PrimeTest number verbose(true|false) ");
System.exit(0);
}
/* parse a 'boolean' string */
public static boolean parseBoolean(String aBoolean){
if ( aBoolean.equalsIgnoreCase("true") ) {
return true;
} else if ( aBoolean.equalsIgnoreCase("false") ) {
return false;
} else {
throw new IllegalArgumentException("Cannot parse into Boolean: " + aBoolean);
}
}
public static boolean IsPrime(long Num, boolean verbose) {
long divisor,test_limit;
/* quick test for even numbers */
if (Num != 2 && Num % 2 == 0) {
return false;
}
/* if we end up here, it's not even */
test_limit = (long) Math.sqrt(Num);
if (verbose) {
System.out.println(Long.toString(Num) + " will be tested until " + Long.toString(test_limit));
}
for (divisor=3; divisor<test_limit; divisor+=2) {
if (verbose) {
/* convert both numbers to double before dividing */
System.out.println(Long.toString(Num) + " / " + Long.toString(divisor) + " = " + ((double)Num / (double)divisor));
}
if (Num % divisor == 0) {
/* nope, not a prime */
return false;
}
}
/* we even survived the loop above, must be prime then */
return true;
}
}
Visual Basic for Applications. You will need to paste this code into the VBA editor of MS Excel or MS Access and then call it from the immediate window.
Function IsPrime(Number As Long, Verbose As Boolean) As Boolean
Dim test_limit As Long
Dim divisor As Long
' even numbers are not prime (except for 2 ofcourse)
If (Number > 2 And Number Mod 2 = 0) Then
IsPrime = False
Exit Function
End If
test_limit = CLng(Sqr(Number) + 1)
If Verbose Then
MsgBox "We will test " & Number & " by dividing until " & test_limit, vbOKOnly
End If
For divisor = 3 To test_limit Step 2
If Verbose Then
MsgBox Number & " / " & divisor & " = " & (Number / divisor), vbOKOnly
End If
If Number Mod divisor = 0 Then
' not prime
IsPrime = False
Exit Function
End If
Next
' if we get here, the number must be prime
IsPrime = True
End Function
' ##########################################
' check whether a number is prime
'
' In: Number, [verbose]
' out: Is / Isn't prime
'
' Date: 15-12-2003
' Time to write: 15 minutes
' in immediate window do somethin like:
' call primetest(2351113,True)
' ##########################################
Public Sub primetest(Number As Long, Optional Verbose As Boolean = False)
If IsPrime(Number, Verbose) Then
MsgBox Number & " is Prime!", vbOKOnly
Else
MsgBox Number & " is not prime", vbOKOnly
End If
End Sub
JavaScript needs some wrapper HTML. Open the file in a javascript enabled web-browser.
file: primetest.html
<HTML>
<HEAD><TITLE>JavaScript PrimeTest</TITLE></HEAD>
<BODY>
<SCRIPT LANGUAGE="JavaScript">
// ///////////////////////////////////////////////////////
// Test of een getal priem is
// In : Getal (integer)
// Out: Priem / Geen Priem
//
// Date: 16-12-2003
// Time to write: 30 minutes
//////////////////////////////////////////////////////////
function IsPrime (Num, Verbose) {
test_limit = Math.round(Math.sqrt(Num) + 1);
// quick test for even numbers
if (Num != 2 && Num % 2 == 0) {
return false;
}
if (Verbose) {
alert("We will test " + Num + " by dividing until " + test_limit);
}
for (divisor=3; divisor<= test_limit; divisor++) {
if (Verbose) {
alert(Num + " / " + divisor + " = " + (Num / divisor));
}
if (Num % divisor ==0) {
return false;
}
}
return true;
}
function PrimeTest() {
num =document.prime.Number.value;
if (document.prime.Verbose.checked) {
verbose=true;
} else {
verbose=false;
}
if (IsPrime(num,verbose)) {
alert(num + " is Prime!");
} else {
alert(num + " is not prime");
}
}
</SCRIPT>
<FORM NAME="prime">
Number: <INPUT TYPE="Text" Name="Number"><br>
Verbose: <INPUT TYPE="Checkbox" Name="Verbose" VALUE="On"><br>
<INPUT TYPE="Submit" Value="Test!" onClick="javascript:PrimeTest(); return false;">
</FORM>
</BODY>
</HTML>
Golden Oldie. This was the first real programming language I learnt to program with…. back in those university days of 1991. Borland has made the Turbo Pascal compiler available for download from http://community.borland.com/museum/.
Wasn’t easy to remember the correct syntax. Buth the IDE comes with an excellent tutorial.
file: PRIMETES.PAS
program primetest;
{ PrimeTester in TurboPascal 5.5
In : Number , Verbosity
Out: Prime / Not Prime message
Date: 16-12-2003
Time to write: 3 hours (hard time remembering all the syntax)
}
uses Crt;
var
Num : Longint;
Answer: Char;
Verbose: Boolean;
function IsPrime(Number : Longint; Verbose : Boolean) : Boolean;
var
divisor: Longint;
test_limit: Longint;
begin
if (Number > 2) and (Number mod 2 = 0) then
begin
IsPrime := False;
Exit;
end;
test_limit := round(sqrt(Number) +1);
if (Verbose = True) then
begin
WriteLn('We will test ', Number, ' by dividing until ', test_limit);
end;
divisor := 3;
while divisor <= test_limit do
begin
if Verbose then
WriteLn(Num, ' / ', divisor, ' = ' , Num /divisor);
if (Number mod divisor = 0) then
begin
IsPrime := False;
Exit;
end;
{ to increment divisor }
Inc(divisor);
Inc(divisor);
end;
IsPrime := True;
end;
begin
ClrScr;
Write('Which number do you want to test: ');
ReadLn(Num);
Write('Shall we be verbose? Y/N: ');
Answer:= ReadKey;
case Answer of
'Y','y' : Verbose:=True;
else
Verbose:= False;
end;
WriteLn('');
if IsPrime(Num,Verbose) then
WriteLn(Num, ' is Prime!')
else
WriteLn(Num, ' is not prime');
end.
The famous ‘tickle’ programming language. Hard to get used to when you’re accustomed to C-style syntax. It’s not RPN, it’s not LISP (too few parentheses). Did some programming with it in my early working days.
file: primetest.tcl
#####################################
# TCL version of primetester
#
# In: Number, Verbose
# Out: Prime / Not Prime message
#
# Date: 16-12-2003
# Time to write: 1 hour
#####################################
proc IsPrime {Number Verbose} {
set false 0
set true 1
if {$Number > 2 && $Number % 2 == 0} {
return $false
}
set test_limit [expr round(sqrt($Number) + 1)]
if {$Verbose>0} {
puts "We will test $Number by dividing until $test_limit"
}
set divisor 3
while {$divisor <= $test_limit} {
if ($Verbose>0) {
set result [expr (double($Number)/$divisor)]
puts "$Number / $divisor = $result"
}
if {$Number % $divisor == 0} {
return $false
}
incr divisor
incr divisor
}
return $true
}
proc Usage {} {
puts "Usage: tcl primetest.tcl Number \[,Verbose=(0|1)\]"
}
###########################
# MAIN
# get the command line arguments
set Number [lindex $argv 0]
if {$argc == 0} {
Usage
exit
}
if {$argc == 1} {
# if no verbosity is set, we default to false
set Verbose 0
} else {
set Verbose [lindex $argv 1]
}
if { [IsPrime $Number $Verbose] == 0} {
puts "$Number is not prime";
} else {
puts "$Number is Prime!";
}