Jonathan Landrum http://jonlandrum.com Code examples from my time in college Sun, 05 Feb 2012 06:07:10 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 Fun With Diamonds http://jonlandrum.com/2012/02/05/fun-with-diamonds/ http://jonlandrum.com/2012/02/05/fun-with-diamonds/#comments Sun, 05 Feb 2012 06:07:10 +0000 Jonathan http://jonlandrum.com/?p=202 Continue reading →]]> I was googling for programming challenges today and ran across one that was more than twenty years old. It was an old scan of an assignment a fellow posted about his days in college taking Pascal. The idea behind the challenge is to write a program that takes user input for size, and builds a diamond out of characters to the size specified.

Write a program which draws a diamond of the form illustrated below. The letter which is to appear at the widest point of the figure (E in the example) is to be specified as input data.

Diamond Challenge

Problem is, I’d never made a diamond program before. The closest I’ve come was a Christmas tree program, which replaces the bottom of the diamond with a trunk. It’s a bit easier to make because you don’t have to think about reversing your algorithm.

So to start this project, I first built a standard diamond program. These types of programs ask for an integer, and build a diamond out of asterisks with the middle row containing the specified number of asterisks.

I then modified the program to be a “hollow” diamond, with the middle asterisks being replaced by space characters. After mastering that, I felt confident in my algorithm to take on the character diamond. It proved only slightly more challenging than the hollow diamond, really just replacing the calls to print an asterisk with a call to print a character from an array which stored all the letters. Here’s a screen capture of an example output:

Character Diamond

All in all, I am very well pleased with the outcome of this program. I tested it with every letter, and it performs flawlessly every time. It may not be the shortest algorithm to produce the character diamond, but it’s mine.

~Jonathan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

// ==================================================
// Programmer:  Jonathan Landrum
// Date:        4 February 2012
// ==================================================
// Program:     char-diamond.cpp
// Purpose:     Takes user input of one character and
//              returns a diamond of that size.
// Assumptions: 1.) Input is a single letter (char).
//                  Any other input will return un-
//                  expected results.
// ==================================================
 
#include <iostream>
#include <string>
 
using namespace std;
 
// --------------------------------------------------
// Global Variables
// --------------------------------------------------
char letter[26] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
	           'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
 
// --------------------------------------------------
// main():
// Does ALL the things!
// --------------------------------------------------
int main () {
 
	// ------------------------------------------
	// Declare variables, not war
	// ------------------------------------------
	char in;
	int  counter;
	int  input;
	int  level;
	int  spaces;
 
	// ------------------------------------------
	// Introduce the program
	// ------------------------------------------
	cout << endl;
	cout << "---------------------------" << endl;
	cout << "-    Character Diamond    -" << endl;
	cout << "---------------------------" << endl;
	cout << endl;
	cout << "             A" << endl;
	cout << "            B B" << endl;
	cout << "           C   C" << endl;
	cout << "          D     D" << endl;
	cout << "         E       E" << endl;
	cout << "          D     D" << endl;
	cout << "           C   C" << endl;
	cout << "            B B" << endl;
	cout << "             A" << endl;
	cout << endl;
	cout << "This program asks for a" << endl;
	cout << "character, and returns a" << endl;
	cout << "diamond of that size." << endl;
	cout << endl;
 
	// ------------------------------------------
	// Main processing loop
	// ------------------------------------------
	cout << "Enter a single letter for the size of your diamond: ";
	cin  >> in;
 
	input = toupper(in) - 64;
	input = input * 2 - 1;
	counter = 1;
	level = 0;
 
	while (counter < input) {
		if (input % 2 == 0)
			spaces = ((input - counter) / 2) + 1;
		else
			spaces = (input - counter) / 2;
 
		for (int c = 0; c < spaces; c++)
			cout << " ";
 
		cout << letter[level];
 
		if (counter == 1)
			spaces = 0;
		else
			spaces = counter - 2;
 
		for (int i = 0; i < spaces; i++)
			cout << " ";
 
		if (counter != 1)
			cout << letter[level] << endl;
		else
			cout << endl;
 
		counter += 2;
		level++;
	} // End while
	while (counter > 0) {
		if (input % 2 == 0)
			spaces = ((input - counter) / 2) + 1;
		else
			spaces = (input - counter) / 2;
 
		for (int j = 0; j < spaces; j++)
			cout << " ";
 
		cout << letter[level];
 
		if (counter == 1)
			spaces = 0;
		else
			spaces = counter - 2;
 
		for (int n = 0; n < spaces; n++)
			cout << " ";
 
		if (counter != 1)
			cout << letter[level] << endl;
		else
			cout << endl;
 
		counter -= 2;
		level--;
	} // End while
 
	return (0);
} // End main
]]> http://jonlandrum.com/2012/02/05/fun-with-diamonds/feed/ 0 Finding the Difference of Sums using C++ http://jonlandrum.com/2012/02/03/finding-the-difference-of-sums-using-cpp/ http://jonlandrum.com/2012/02/03/finding-the-difference-of-sums-using-cpp/#comments Fri, 03 Feb 2012 20:13:27 +0000 Jonathan http://jonlandrum.com/?p=178 Continue reading →]]> Someone asked online what the difference was between the sum of the squares and the square of the sums. For instance, if you were to add all the natural numbers from 1 to 10, and then square it, would it be larger, smaller, or the same size if you squared each integer first and then added them?

12 + 22 + 32 + … + 82 + 92 + 102 (Sum of the squares)
(1 + 2 + 3 + … + 8 + 9 + 10)2 (Square of the sums)

At first glance, this seems like a fine job for a couple loops, or perhaps recursion. But there’s actually a much more efficient way to go about this problem, and the answer is brought to us by a fine mathematician named Leonhard Euler.

Euler is one of the men responsible for bringing us Calculus (he actually is responsible for more of Calculus than Newton) and one of the topics discussed in the second semester of Single-variable Calculus is Summation. Using these summation algorithms, it is possible to do some very intriguing calculations without going through the rote process of cycling through the list.

For a short set such as the first ten integers, it’s not a problem. But suppose the question was of the first ten million integers? That would take a looping algorithm a long time. But it would take almost exactly the same time as doing the first 10 using Euler’s algorithms.

Algorithm for summing integers:
Algorithm for summing integers

Algorithm for summing squares of integers:
Algorithm for summing squares of integers

With these algorithms, it’s trivial to find the answer to the problem at hand. Nevertheless, I’ve written a program anyway, if for no other reason than to show how to use these algorithms.

~Jonathan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

// ==================================================
// Programmer:  Jonathan Landrum
// Date:        3 February 2012
// ==================================================
// Program:     difference.cpp
// Purpose:     Finds the difference between the sum
//              of the squares and the square of the
//              sums of the first 100 integers.
// Assumptions: None.
// ==================================================
 
#include <iostream>
using namespace std;
 
// --------------------------------------------------
// main():
// Does ALL the things!
// --------------------------------------------------
int main () {
 
	// ------------------------------------------
	// Declare variables, not war
	// ------------------------------------------
	int sumSquares;
	int squareSums;
	int difference;
 
	// ------------------------------------------
	// Introduce the program
	// ------------------------------------------
	cout << endl;
	cout << "--------------------------------" << endl;
	cout << "-    Finding the Difference    -" << endl;
	cout << "--------------------------------" << endl;
	cout << endl;
	cout << "This program seeks to find the" << endl;
	cout << "difference between the sum of" << endl;
	cout << "squares and the square of the" << endl;
	cout << "sums." << endl;
	cout << endl;
 
	// ------------------------------------------
	// Main processing loop
	// ------------------------------------------
 
	/* ******************************************
	   Yes, you can use loops here, but why would
	   you want to? There are already algorithms
	   for finding these answers.
	   ****************************************** */
 
	sumSquares = 100 * 101 * 201 / 6;     // Algorithm for summing squares:  n(n+1)(2n+1)/6
	squareSums = 100 * 101 / 2;           // Algorithm for summing integers: n(n+1)/2
	squareSums = squareSums * squareSums; // Now squaring it
 
	if (sumSquares - squareSums > 0) {
		difference = sumSquares - squareSums;
		cout << "sumSquares is larger. (" << sumSquares << ")" << endl;
	} else {
		difference = squareSums - sumSquares;
		cout << "squareSums is larger. (" << squareSums << ")" << endl;
	} // End if
 
 
	// ------------------------------------------
	// Return the results
	// ------------------------------------------
	cout << difference << " is the difference between " << squareSums << " and " << sumSquares << endl;	
	return (0);
} // End main
]]> http://jonlandrum.com/2012/02/03/finding-the-difference-of-sums-using-cpp/feed/ 0 Finding the Smallest Integer Evenly Divisible by all the Numbers from 1 to 20 http://jonlandrum.com/2012/02/02/finding-the-smallest-integer-evenly-divisible-by-all-the-numbers-from-1-to-20/ http://jonlandrum.com/2012/02/02/finding-the-smallest-integer-evenly-divisible-by-all-the-numbers-from-1-to-20/#comments Thu, 02 Feb 2012 15:22:24 +0000 Jonathan http://jonlandrum.com/?p=172 Continue reading →]]> I found this programming assignment online today. It posits that 2,520 is the smallest number evenly divisible by all the natural numbers from 1 to 10. The question is, what is the smallest number evenly divisible by all the natural numbers from 1 to 20? It seemed like the best idea to me to save the answers in a boolean array, one cell for each of the numbers from 1 to 20, and if every answer is true, then we have our number. I tested it, got the correct result, and the answer is surprisingly large. Suffice it to say, it took a minute to get there.

~Jonathan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

// ==================================================
// Programmer:  Jonathan Landrum
// Date:        2 February 2012
// ==================================================
// Program:     evenlyDivisible.cpp
// Purpose:     Finds the smallest number evenly
//              divisible by all the natural numbers
//              from 1 to 20.
// Assumptions: None.
// ==================================================
 
#include <iostream>
 
using namespace std;
 
// --------------------------------------------------
// main():
// Does ALL the things!
// --------------------------------------------------
int main () {
 
	// ------------------------------------------
	// Declare variables, not war
	// ------------------------------------------
	bool answers[20];
	bool divisible = false; // Not true for 20
	int  number    = 20;    // But logical place to start
 
	// ------------------------------------------
	// Introduce the program
	// ------------------------------------------
	cout << endl;
	cout << "----------------------------" << endl;
	cout << "-     Evenly Divisible     -" << endl;
	cout << "----------------------------" << endl;
	cout << endl;
	cout << "This program checks to find" << endl;
	cout << "the smallest number that is" << endl;
	cout << "evenly divisible by all the" << endl;
	cout << "integers from 1 to 20." << endl;
	cout << endl;
	cout << "Processing..." << endl;
 
	// ------------------------------------------
	// Main processing loop
	// ------------------------------------------
	while (divisible == false) {
		for (int counter = 1; counter <= 20; counter++) {
			if (number % counter == 0) {
				answers[counter - 1] = true;
			} else {
				answers[counter - 1] = false;
			} // End if
		} // End for
		if (answers[0]  == true &&
		    answers[1]  == true &&
		    answers[2]  == true &&
		    answers[3]  == true &&
		    answers[4]  == true &&
		    answers[5]  == true &&
		    answers[6]  == true &&
		    answers[7]  == true &&
		    answers[8]  == true &&
		    answers[9]  == true &&
		    answers[10] == true &&
		    answers[11] == true &&
		    answers[12] == true &&
		    answers[13] == true &&
		    answers[14] == true &&
		    answers[15] == true &&
		    answers[16] == true &&
		    answers[17] == true &&
		    answers[18] == true &&
		    answers[19] == true) {
			divisible = true;
		} else {
			number++;
		} // End if
	} // End while
 
	// ------------------------------------------
	// Return the results
	// ------------------------------------------
	cout << "The answer is " << number << endl;
 
	return (0);
} // End main
]]> http://jonlandrum.com/2012/02/02/finding-the-smallest-integer-evenly-divisible-by-all-the-numbers-from-1-to-20/feed/ 0 Adding the Even Numbers of the Fibonacci Sequence http://jonlandrum.com/2012/02/01/adding-the-even-numbers-of-the-fibonacci-sequence/ http://jonlandrum.com/2012/02/01/adding-the-even-numbers-of-the-fibonacci-sequence/#comments Wed, 01 Feb 2012 14:39:49 +0000 Jonathan http://jonlandrum.com/?p=165 Continue reading →]]> Suppose you want to find all the even numbers in the Fibonacci Sequence less than, say, 4,000,000, and you want to add them together. This can easily be done with a couple of methods in C++ or the language of your choice.

The idea behind the Fibonacci sequence is to add the previous two numbers together to get the current number. So you get 0, 1, 1, 2, 3, 5, 8, 13, 21 and so on, ad infinitum. If we were to take only the even ones and add them, what would you get? In the case of the previous list, only 2 and 8 are even, so you would get 10. This program runs the computation to 4,000,000 and it gave me the answer in less than one second.

~Jonathan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

// ==================================================
// Programmer:  Jonathan Landrum
// Date:        1 February 2012
// ==================================================
// Program:     evenFibonacci.cpp
// Purpose:     Summs the even numbers in the
//              Fibonacci sequence that are less
//              than 4,000,000.
// Assumptions:	None.
// ==================================================
 
#include <iostream>
#include <string>
 
using namespace std;
 
// --------------------------------------------------
// Function prototypes
// --------------------------------------------------
int fib(int);
 
// --------------------------------------------------
// main():
// Does ALL the things!
// --------------------------------------------------
int main () {
 
	// ----------------------------------------------
	// Declare variables, not war
	// ----------------------------------------------
	int c = 0;
	int number;
	int sum = 0;
 
	// ----------------------------------------------
	// Introduce the program
	// ----------------------------------------------
	cout << endl;
	cout << "-----------------------------" << endl;
	cout << "-      Even Fibonaccis      -" << endl;
	cout << "-----------------------------" << endl;
	cout << endl;
	cout << "1, 2, 3, 5, 8, 13, 21, 34,..." << endl;
	cout << endl;
	cout << "This program calculates the" << endl;
	cout << "Fibonacci sequence and adds" << endl;
	cout << "the even ones less than" << endl;
	cout << "4,000,000 together." << endl;
 
	// ----------------------------------------------
	// Main processing loop
	//
	// There are a few different ways to accomplish
	// this. I chose this algorithm because it made
	// sense to me. You can also get rid of the first
	// "if" by putting "number < 4000000" in the
	// while test, and moving "number = fib(c)" to
	// after "c++".
	//
	// This algorithm returns the answer in <1 second
	// on my laptop.
	// ----------------------------------------------
	while (true) {                 // Need to keep it going
		number = fib(c);
		if (number >= 4000000) // until we can break
			break;
		if (number % 2 == 0)
			sum += number;
		c++;
	} // End while
 
	// ----------------------------------------------
	// Return the results
	// ----------------------------------------------
	cout << sum << endl;
	cout << "-----------------------------" << endl;
	cout << "\\\\//_ Live long and prosper." << endl;
	return (0);
} // End main
 
// --------------------------------------------------
// fib():
// Calculates the integer in the Fibonacci sequence
// at the input space. 2 returns 1, 7 returns 13, ...
// --------------------------------------------------
int fib (int in) {
	int out;
 
	if (in == 0 || in == 1) {
		out = in;
	} else {
		out = (fib(in-2) + fib(in-1));
	} // End if
 
	return out;
} // End fib
]]> http://jonlandrum.com/2012/02/01/adding-the-even-numbers-of-the-fibonacci-sequence/feed/ 0 Sum of Threes and Fives http://jonlandrum.com/2012/01/31/sum-of-threes-and-fives/ http://jonlandrum.com/2012/01/31/sum-of-threes-and-fives/#comments Wed, 01 Feb 2012 00:07:21 +0000 Jonathan http://jonlandrum.com/?p=145 Continue reading →]]> I enjoy finding problems to solve with code. I found a page on the internet this afternoon that asked for the sum of all integers between 1 and 1,000 that are divisible by either 3 or 5. I immediately thought of the FizzBuzz program I wrote a while back, and realized the algorithm is actually quite similar. It’s just what you do with those threes and fives that’s different in this case. Either way, it was a fun couple of minutes putting to code what I’d been mulling over.

~Jonathan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

// ==================================================
// Programmer:  Jonathan Landrum
// Date:        31 January 2012
// ==================================================
// Program:     threeOrFive.cpp
// Purpose:     Adds the integers between 1 and 1,000
//              that are divisible by either 3 or 5.
// Assumptions: None.
// ==================================================
 
#include &lt;iostream>
#include &lt;string>
using namespace std;
 
// --------------------------------------------------
// main():
// Does ALL the things!
// --------------------------------------------------
int main () {
 
	// ----------------------------------------------
	// Declare variables, not war
	// ----------------------------------------------
	int sum = 0;
	int c = 3;
 
	// ----------------------------------------------
	// Introduce the program
	// ----------------------------------------------
	cout << endl;
	cout << "----------------------------" << endl;
	cout << "-    Sum of 3's and 5's    -" << endl;
	cout << "----------------------------" << endl;
	cout << endl;
	cout << "This program adds together the" << endl;
	cout << "integers between 1 and 1,000" << endl;
	cout << "that are divisible by 3 or 5." << endl;
	cout << endl;
 
	// ----------------------------------------------
	// Main processing loop
	// ----------------------------------------------
	while (c < 1000) {
		if (c % 3 == 0 || c % 5 == 0) {
			sum += c;
			cout << c << endl;
		} else if (c % 3 == 0) {
			sum += c;
			cout << c << endl;
		} else if (c % 5 == 0) {
			sum += c;
			cout << c << endl;
		} // end if
		c++;
	} // end while
 
	// ----------------------------------------------
	// Return the answer
	// ----------------------------------------------
	cout << sum << endl;
 
	return (0);
} // End main
]]> http://jonlandrum.com/2012/01/31/sum-of-threes-and-fives/feed/ 0 Fortran Prime Number Calculator http://jonlandrum.com/2012/01/30/fortran-prime-number-calculator/ http://jonlandrum.com/2012/01/30/fortran-prime-number-calculator/#comments Tue, 31 Jan 2012 00:13:15 +0000 Jonathan http://jonlandrum.com/?p=135 Continue reading →]]> This program is one of my favorites I’ve written so far. It takes input from the user for the lower and upper bounds of a range of integers, calculates which numbers in that range are prime numbers, and outputs a list of the primes and the total number of primes found.

I tested the output of this program against this list of primes, and it checked out perfectly. It’s a fairly fast program, returning the primes between 1 and 1,000,000 in about 6 seconds on my machine. Only assumptions are the input must be in Real form. Text input will cause the program to throw an exception.

~Jonathan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

! ----------------------------------------------------------
! Programmer:   Jonathan Landrum
! Date:         21 September 2011
! Class:        CSC 204
! ----------------------------------------------------------
! Program:      primes.exe
! Purpose:      Calculates the number of prime numbers
!               there are in a given range, and returns
!               them in a list.
! Assumptions:  1.) Input from the user is in integer
!                   form. Text input will cause the
!                   program to fail. Real number input
!                   will be truncated into integers.
! ----------------------------------------------------------
 
PROGRAM primes
 
	IMPLICIT NONE
 
	INTEGER   :: total = 0, counter, lower, upper
	CHARACTER :: response
	LOGICAL   :: prime
 
	WRITE (*,*) '******************************************'
	WRITE (*,*) '*                                        *'
	WRITE (*,*) '*     FORTRAN PRIME NUMBER CALCULATOR    *'
	WRITE (*,*) '*                                        *'
	WRITE (*,*) '******************************************'
	WRITE (*,*)
	WRITE (*,*) 'Copyright (c) 2011 Jonathan Landrum'
	WRITE (*,*)
	WRITE (*,*) 'Calculates how many prime numbers are'
	WRITE (*,*) 'between the lower and upper bound given by'
	WRITE (*,*) 'the user, and returns the list of those'
	WRITE (*,*) 'prime numbers.'
	WRITE (*,*)
	WRITE (*,*) 'I wanted to use the Sieve of Eratosthenes'
	WRITE (*,*) 'algorithm, but could not figure out how to'
	WRITE (*,*) 'make it work. Perhaps later.'
	WRITE (*,*)
	WRITE (*,*) 'The output of this program has been checked'
	WRITE (*,*) 'against this list:'
	WRITE (*,*) 'http://primes.utm.edu/lists/small/100000.txt'
	WRITE (*,*)
	WRITE (*,*) '--------------------------------------------------'
	WRITE (*,*)
	WRITE (*,*) 'Would you like to continue? [Y/N]'
	WRITE (*,*)
	READ  (*,*) response
	WRITE (*,*)
 
	! Any response beginning with the letter "y" will work.
	WHILE (response == 'y' .OR. response == 'Y') DO
		WRITE (*,*)
		WRITE (*,*) 'What is the lower bound of numbers you'
		WRITE (*,*) 'would like to check?'
		WRITE (*,*)
		READ  (*,*) lower
		WRITE (*,*)
		WRITE (*,*) 'What is the upper bound of numbers you'
		WRITE (*,*) 'would like to check?'
		WRITE (*,*)
		READ  (*,*) upper
		WRITE (*,*)
 
		! If the user inputs a smaller number for the upper
		! bound, or if they input the same number, ask again
		WHILE ((upper - lower) <= 0) DO
			WRITE (*,*)
			WRITE (*,*) 'ERROR: Upper bound not higher than'
			WRITE (*,*) '       lower bound'
			WRITE (*,*)
			WRITE (*,*) 'What is the lower bound of numbers you'
			WRITE (*,*) 'would like to check?'
			WRITE (*,*)
			READ  (*,*) lower
			WRITE (*,*)
			WRITE (*,*) 'What is the upper bound of numbers you'
			WRITE (*,*) 'would like to check?'
			WRITE (*,*)
			READ  (*,*) upper
			WRITE (*,*)
		END DO ! END while upper is smaller
 
		! We have legitimate numbers
		counter = lower
		total = 0
		WHILE ((counter < upper).AND.(upper > 0)) DO
			IF (Prime(counter)) THEN
				WRITE (*, '(i0,1x)', ADVANCE = 'no') counter
				total = total + 1
			END IF ! Outputs the number
			counter = counter + 1
		END DO ! Processing loop
 
		WRITE (*,*)
		WRITE (*,*)
		WRITE (*,*) 'The number of primes between ',lower,' and ',upper,' is ',total,'.'
		WRITE (*,*)
		WRITE (*,*) '--------------------------------------------------'
		WRITE (*,*)
		WRITE (*,*) 'Would you like to continue? [Y/N]'
		WRITE (*,*)
		READ  (*,*) response
	END DO ! End Continue loop
	WRITE (*,*)
	WRITE (*,*) '\\//_ Live long and prosper.'
END PROGRAM primes
 
! ----------------------------------------------------------
! FUNCTION Prime:
! Determines if the input is a prime number. Returns T or F.
! ----------------------------------------------------------
LOGICAL FUNCTION Prime(n)
	IMPLICIT NONE
 
	INTEGER :: n, i
 
	IF (n <= 1) THEN                             ! 1 is not prime (Really, it's not)
		Prime = .FALSE.
	ELSE IF ((n == 2).OR.(n == 3)) THEN          ! Hardcode 2 and 3
		Prime = .TRUE.
	ELSE IF (MOD(n,2) == 0) THEN                 ! Get rid of evens
		Prime = .FALSE.
 
	! All other cases are out, so now we check to see if
	! n is divisible by the odd numbers from 3 on.
	ELSE
		i = 3
		Prime = .TRUE.                           ! Assume it's prime, then prove
		DO                                       ! If i^2 is not a root of n, or if n%i = 0
			IF (i*i > n .OR. MOD(n,i) == 0) EXIT !(Won't be larger than the square)
			i = i + 2                            ! Iterate the counter by 2 to get odds
		END DO
 
		! Record the answer
		IF (i*i > n) THEN
			Prime = .TRUE.
		ELSE
			Prime = .FALSE.
		END IF
	END IF ! We have our answer
END FUNCTION Prime
]]> http://jonlandrum.com/2012/01/30/fortran-prime-number-calculator/feed/ 0 Automating Terminal Commands in Mac OS X with Bash http://jonlandrum.com/2012/01/28/automating-terminal-commands-in-mac-os-x-with-bash/ http://jonlandrum.com/2012/01/28/automating-terminal-commands-in-mac-os-x-with-bash/#comments Sat, 28 Jan 2012 22:28:38 +0000 Jonathan http://jonlandrum.com/?p=82 Continue reading →]]> Coming from the Linux world, Mac was somewhat familiar to me, yet somewhat foreign. One such example is the system hides most of the files and directories I was accustomed to seeing and using as a Linux user. Also, the terminal commands to show and re-hide these directories don’t follow standard Unix terminal syntax. So I had to do some researching to find what the commands even are, and then I could put them in a Bash script that could be run with a single click. But first, the commands:

defaults write com.apple.finder AppleShowAllFiles TRUE
killall Finder

The first line is the business end, the second one restarts Finder with the new setting. And you can type these in a Terminal window right now and get the desired results. But what about automating this? Instead of typing all this out — and possibly misspelling it a time or two (ask me how I know) — let’s make a shell script that contains the commands, and keep it in our user directory for easy access:

1
2
3

#!/bin/bash
defaults write com.apple.finder AppleShowAllFiles TRUE
killall Finder

The only difference this time is the new first line. That specifies which shell we’re using, in this case Bash. It’s called the shebang line, and it tells Terminal which program to use to interpret the commands. Copy and paste those three lines into TextEdit or your favorite text editor, and save it as show.sh or something similar. Then change the “TRUE” to “FALSE” at the end of the second line, like this:

1
2
3

#!/bin/bash
defaults write com.apple.finder AppleShowAllFiles FALSE
killall Finder

and save that as hide.sh or something similar. Put these two files in your user root directory, in the same place where your Documents, Desktop, Music, and Pictures folders are.

Example Directory Layout

An example directory layout. Put show.sh and hide.sh in your user root like this.

Next we have to make them executable. Open Terminal (it will already be cd’d to your user root directory) and enter this command:

$ chmod +x show.sh && chmod +x hide.sh

This will make our two files executable. Now give them a whirl:

$ ./show.sh
$ ./hide.sh

The ./ tells Terminal to run that program. This should open your Finder window with hidden files and directories showing, but faded to show you the difference. And when you run hide.sh Finder will close and reopen, with those files and directories hidden. If that’s what you got, then continue to the final step to make them clickable. If not, go back through this tutorial and start from scratch. Make sure you’ve typed everything correctly.

The last step is open a Finder window and select show.sh, then type Command-i to bring up the information menu. Under the “Open with:” dropdown, select “Other…”, and in the window that pops up, scroll to the bottom to the “Utilities” directory, open that, and then scroll to Terminal and select it.

You may have to change the “Enable:” menu from “Recommended Applications” to “All Applications” in order to select it. Tick the “Always Open With” checkbox, and click “Add”. Repeat this last step for hide.sh.

Double-click show.sh and confirm it works, then do the same for hide.sh. If everything works as expected, you’re all set! You can access these programs from the command line or from Finder the way you’ve done just now.

If you have other commands you’d like to automate, you can simply replace what’s in either of these scripts with that command, save it as a new .sh file, make it executable, set it to open with Terminal, and you’re golden. For timed automation, you can even have these programs run with cron so that they’re executed for you on a regular schedule. How’s that for automation?

~Jonathan

]]> http://jonlandrum.com/2012/01/28/automating-terminal-commands-in-mac-os-x-with-bash/feed/ 0 Solving the Quadratic Equation with Fortran http://jonlandrum.com/2012/01/27/solving-the-quadratic-equation-with-fortran/ http://jonlandrum.com/2012/01/27/solving-the-quadratic-equation-with-fortran/#comments Sat, 28 Jan 2012 04:29:40 +0000 Jonathan http://jonlandrum.com/?p=77 Continue reading →]]> An interesting assignment given last semester was to write a program that returned the results of the Quadratic Equation to find the roots of a quadratic polynomial. What’s so interesting about that, you ask? The professor wanted the imaginary roots. In the end, it only took an “if” block to get it, but it did take some thought to get it right. At the time, this was one of my more proud moments as a programmer.

~Jonathan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

! ---------------------------------------------------------
! Programmer:   Jonathan Landrum
! Date:         15 September 2011
! Class:        CSC 204
! ---------------------------------------------------------
! Program Name: quadraticEquation.exe
! Purpose:      Calculates the roots of a quadratic
!               equation, returning whether they are real
!               roots or imaginary roots.
! Assumptions:  1.) The input is in the form of a real
!                   number, not text. Text will cause the
!                   program to return an error.
! ---------------------------------------------------------
 
PROGRAM quadraticEquation
 
	IMPLICIT NONE
 
	! ------------------------------------------------------
	! Variables:
	! The response variable is a single character variable,
	! and input longer than one character will be truncated.
	! So technically, any word starting with the letter "y"
	! will keep the program running. Feature, not a bug(TM).
	! ------------------------------------------------------
	REAL		:: a, b, c, d = 0, fraction, radical
	CHARACTER	:: response
 
	! Introduce the program and ask for initial response
	WRITE (*,*) '*****************************************'
	WRITE (*,*) '*                                       *'
	WRITE (*,*) '* FORTRAN Quadratic Equation Calculator *'
	WRITE (*,*) '*                                       *'
	WRITE (*,*) '*****************************************'
	WRITE (*,*)
	WRITE (*,*) 'Copyright (c) 2011 Jonathan Landrum'
	WRITE (*,*)
	WRITE (*,*) 'This program calculates the roots of the'
	WRITE (*,*) 'quadratic equation, and returns whether'
	WRITE (*,*) 'the roots are real or imaginary.'
	WRITE (*,*)
	WRITE (*,*) 'The calculation is in the form:'
	WRITE (*,*) '(-B +/- (SQRT(B^2 - 4*A*C))'
	WRITE (*,*) '---------------------------'
	WRITE (*,*) '            2A'
	WRITE (*,*)
	WRITE (*,*) 'Do you want to continue? [Y/N]'
	WRITE (*,*)
 
	READ  (*,*) response ! Anything besides Y terminates
 
	! -----------------------------------------------------
	! Main Loop:
	! Keeps the user in the program until they choose to
	! close it.
	! -----------------------------------------------------
	WHILE ((response == 'Y') .OR. (response == 'y')) DO
 
		! -------------------------------------------------
		! Input Loop:
		! Takes in three real numbers for calculation.
		! -------------------------------------------------
		WRITE (*,*)
		WRITE (*,*) 'Enter a value for "A":'
		READ  (*,*) a
		WRITE (*,*) 'Enter a value for "B":'
		READ  (*,*) b
		WRITE (*,*) 'Enter a value for "C":'
		READ  (*,*) c
 
		d = b*b - 4*a*c
 
		! -------------------------------------------------
		! Computation Loop:
		! Determines if the discriminant is negative, and
		! computes the results.
		! -------------------------------------------------
		IF (d < 0) THEN
			fraction = -b/(2.0*a)
			radical  = (SQRT(ABS(d)))/(2.0*a)
			WRITE (*,*)
			WRITE (*,*) 'IMAGINARY ROOTS'
			WRITE (*,*)
			WRITE (*,*) fraction, ' + ', radical, 'i'
			WRITE (*,*) fraction, ' - ', radical, 'i'
		ELSE IF (d .EQ. 0) THEN
			WRITE (*,*)
			WRITE (*,*) 'REPEATED REAL ROOTS'
			WRITE (*,*)
			WRITE (*,*) -b/(2.0*a)
		ELSE
			WRITE (*,*)
			WRITE (*,*) 'REAL ROOTS'
			WRITE (*,*)
			WRITE (*,*) (-b + SQRT(d))/(2.0*a)
			WRITE (*,*) (-b - SQRT(d))/(2.0*a)
		END IF ! End computation Loop
 
		WRITE (*,*)
		WRITE (*,*) 'Do you want to convert another set of numbers? [Y/N]'
		WRITE (*,*)
		READ  (*,*) response ! Anything besides Y terminates
	END DO ! End Main Program Loop
 
	WRITE (*,*)
	WRITE (*,*) '\\//_ Live long and prosper.'
END PROGRAM quadraticEquation
]]> http://jonlandrum.com/2012/01/27/solving-the-quadratic-equation-with-fortran/feed/ 0 Plotting Radioactive Decay with Fortran and ES-Plot http://jonlandrum.com/2012/01/26/plotting-radioactive-decay-with-fortran-and-es-plot/ http://jonlandrum.com/2012/01/26/plotting-radioactive-decay-with-fortran-and-es-plot/#comments Fri, 27 Jan 2012 00:51:08 +0000 Jonathan http://jonlandrum.com/?p=66 Continue reading →]]> One of the assignments in Fortran last semester was to plot the exponential population growth of the United States between the years 1790 and 1860. Since I had recently taken Chemistry that summer, I also wrote a program to model the decay of the radioactive isotope Carbon-14, the isotope used in Radiocarbon Dating.

This program calculates the data, exports it to a CSV file, and finally calls the ES-Plot program and feeds it the CSV for data. An example output is below:

Carbon-14 Decay Model

In the graphic above, the vertical axis is number of moles present, and the horizontal axis is the number of years since the start of decay. It is difficult to read the numbers, but the first labeled tick mark is “1E+4”, 10,000 years. The average half-life of Carbon-14 is 5,730±40 years, not labeled here. The last tick mark is 40,000 years.

The user can input any quantity in moles for the program to calculate, but calculation will stop at 0.01% of the calculated mass because anything less than that is trivial in this case and is difficult to see in the resulting graphic. You will notice, therefore, that subsequent calculations result in the same graphic. That is because the decay rate of Carbon-14 is the same, regardless of quantity.

~Jonathan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

! ----------------------------------------------------------
! Programmer:   Jonathan Landrum
! Date:         22 October 2011
! Class:        CSC 204
! ----------------------------------------------------------
! Program:      decay.f95
! Purpose:      Calculates and plots the radioactive decay
!               of Carbon-14. The half-life of Carbon-14 is
!               5,730 +/- 40 years. I have chosen 5,730 for
!               this model's lambda, as it is the mean.
! Assumptions:  1.) ES-Plot is installed.
!                   http://goo.gl/wmhZw
! ----------------------------------------------------------
 
PROGRAM decay
 
    IMPLICIT NONE
 
    CHARACTER                   :: response
    INTEGER                     :: t
    REAL                        :: p0, mass
    DOUBLE PRECISION, PARAMETER :: e = 2.71828182845904523536 !     ln 0.5
    DOUBLE PRECISION, PARAMETER :: k = -0.0001209680943385594 ! k = ------
                                                              !     lambda
 
    WRITE (*,*) '*******************************************'
    WRITE (*,*) '*                                         *'
    WRITE (*,*) '*FORTRAN CARBON RADIOACTIVE DECAY MODELLER*'
    WRITE (*,*) '*                                         *'
    WRITE (*,*) '*******************************************'
    WRITE (*,*)
    WRITE (*,*) 'Copyright (c) 2011 Jonathan Landrum'
    WRITE (*,*)
    WRITE (*,*) 'Calculates and plots the radioactive decay'
    WRITE (*,*) 'of Carbon-14 to the stable Nitrogen isotope'
    WRITE (*,*) 'Nitrogen-14, its most common isotope.'
    WRITE (*,*)
    WRITE (*,*) 'The half-life of Carbon-14 is 5,730 +/- 40'
    WRITE (*,*) 'years. I have chosen 5,730 for this model,'
    WRITE (*,*) 'as it is the mean.'
    WRITE (*,*)
    WRITE (*,*) 'Assumptions: 1.) ES-Plot is installed.'
    WRITE (*,*) '                 http://goo.gl/wmhZw'
    WRITE (*,*)
    WRITE (*,*) '------------------------------------------'
    WRITE (*,*)
    WRITE (*,*) 'Would you like to continue? [Y/N]'
    WRITE (*,*)
    READ  (*,*) response
    WRITE (*,*)
 
    ! Any response beginning with the letter "y" will work.
    WHILE (response == 'y' .OR. response == 'Y') DO
 
        WRITE  (*,*) 'How many moles of Carbon-14 do you want'
        WRITE  (*,*) 'to test?'
        WRITE  (*,*)
        READ   (*,*) p0
 
        t      = 0
        mass   = p0
 
        OPEN   (UNIT=8, FILE='decay.csv', status='unknown')
 
1       FORMAT (1X,I6,A2,F6.3)
 
        WRITE  (*,*) 'Year,   Mass'
        WRITE  (*,*) '------------'
        WRITE  (8,*) '$ Carbon-14 Decay Model'
 
        WHILE  (mass >= (p0 * 0.01)) DO
            mass  = (p0 * (e ** (k * t)))
            WRITE (8,*) t, ', ', mass
            WRITE (*,1) t, ', ', mass
            t     = t + 1
        END DO
 
        CLOSE  (8)
 
        WRITE  (*,*)
        WRITE  (*,*) '------------'
        WRITE  (*,*) 'End of list.'
        WRITE  (*,*)
        WRITE  (*,*) 'File "decay.csv" successfully created.'
        WRITE  (*,*) 'Calling ESPlot...'
 
        CALL SYSTEM ('"C:\Program Files (x86)\ESPlot\esplot.exe" decay.csv')
 
        WRITE  (*,*) 'Process Complete'
        WRITE  (*,*)
        WRITE  (*,*) '------------------------------------------'
        WRITE  (*,*) 'Would you calculate another mass? [Y/N]'
        WRITE  (*,*)
        READ   (*,*) response
        WRITE  (*,*)
    END DO ! Continue loop
    WRITE (*,*) '\\//_ Live long and prosper.'
END PROGRAM decay
]]> http://jonlandrum.com/2012/01/26/plotting-radioactive-decay-with-fortran-and-es-plot/feed/ 0 Birthday Problem http://jonlandrum.com/2012/01/25/birthday-problem/ http://jonlandrum.com/2012/01/25/birthday-problem/#comments Wed, 25 Jan 2012 18:33:49 +0000 Jonathan http://jonlandrum.com/?p=54 Continue reading →]]> In Probability and Stats last semester, my professor assigned us the project of determining how many students there would need to be in a class in order to have a 50/50 chance of having a repeat birth date. It’s called the Birthday Problem or Birthday Paradox. He mentioned that it’s quite a popular problem in probability classes, and that we cannot look online for the answer.

He wanted us to use our intuition to form a method for finding the answer. Obviously, since I’m a CS major, I turned to the computer for my answer. I was taking Fortran that same semester, so it was the freshest language on my mind. Any programming language would probably do, but I chose this one. A lot of what I’ve seen on the web with this problem is written in C or C++, so I feel I have a slight advantage here. ;~] Upon compiling and running the program, I came to my answer in less than one second: 23.

~Jonathan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

! ---------------------------------------------------------
! Programmer:      Jonathan Landrum
! Date:            20 September 2011
! Class:           MAT 353
! ---------------------------------------------------------
! Program:         birthdays.exe
! Purpose:         Calculates the number of people you
!                  would need to question in order to have
!                  a 50% chance in getting two or more
!                  duplicate birth dates among the set.
! Assumptions:     None.
! ---------------------------------------------------------
 
PROGRAM BIRTHDAYS
	IMPLICIT NONE
 
	REAL      :: probability = 0.0, compliment = 1.0, days = 365
	INTEGER   :: counter = 1
	CHARACTER :: response
 
	WRITE (*,*) '******************************************'
	WRITE (*,*) '*                                        *'
	WRITE (*,*) '* FORTRAN DUPLICATE BIRTHDATE CALCULATOR *'
	WRITE (*,*) '*                                        *'
	WRITE (*,*) '******************************************'
	WRITE (*,*)
	WRITE (*,*) 'Calculates the number of people you would'
	WRITE (*,*) 'need to question in order to have a 50/50'
	WRITE (*,*) 'chance in having a duplicate birthdate.'
	WRITE (*,*)
	WRITE (*,*) 'This program takes no arguments from the'
	WRITE (*,*) 'user, except to continue after this line.'
	WRITE (*,*)
	WRITE (*,*) 'Would you like to continue? [Y/N]'
	WRITE (*,*)
	READ  (*,*) response
 
	! Any response beginning with the letter "y" will do.
	WHILE (response == 'y' .OR. response == 'Y') DO
 
		! -------------------------------------------------
		! Main:
		! This loop begins at 1 with the calculation and
		! continues until probability is greater than 50%.
		! -------------------------------------------------
		WHILE (probability < 0.51) DO
			compliment  = compliment * (days/365)
			probability = 1.0 - compliment
 
			WRITE (*,*) '| ', counter, ' | ', probability, ' |'
 
			counter = counter + 1
			days    = days - 1
		END DO ! Main loop
 
		WRITE (*,*)
		WRITE (*,*) 'Would you like to continue? [Y/N]'
		WRITE (*,*)
		READ  (*,*) response
	END DO ! Continue loop
	WRITE (*,*)
	WRITE (*,*) '\\//_ Live long and prosper.'
END PROGRAM BIRTHDAYS
]]> http://jonlandrum.com/2012/01/25/birthday-problem/feed/ 0