! ----------------------------------------------------------
! FUNCTION LogB:
! Calculates the logarithm of a number to an arbitrary base.
! ----------------------------------------------------------
REAL FUNCTION LogB(n, b)
	IMPLICIT NONE
 
	REAL :: n, b
 
	LogB = LOG10(n) / LOG10(b)
 
	RETURN
 
END FUNCTION LogB

/*********************************
 Programmer:      Jonathan Landrum
 Program:         permutations.cpp
 Date:            1 May 2012
 ---------------------------------
 Assumptions:     None.
 Dependencies:    None.
 *********************************/
 
 
#include <iostream>
using namespace std;
long int factorial (long int in);
 
 
// --------------------------------------------------
// main():
//
// Calls the factorial function, and returns results.
// --------------------------------------------------
int main() {
    int first, second, third, fourth, fifth, sixth;
 
    cout << "/====================================\\" << endl;
    cout << "|                                    |" << endl;
    cout << "|          C++ Permutations          |" << endl;
    cout << "|                                    |" << endl;
    cout << "\\====================================/" << endl;
    cout << endl;
    cout << "This program returns the number of" << endl;
    cout << "permutations there are of the letters" << endl;
    cout << "from A to F where A appears before D." << endl;
    cout << endl;
    cout << "--------------------------------------" << endl;
    cout << "Processing..." << endl;
    cout << endl;
 
    /****************************
     Each factorial(5) is where
     A appears in the set, and
     each factorial(4) is an
     exception where D appears
     before A. Notice that when A
     is first, it doesn't matter
     where D appears.
 
     We could have more easily
     multiplied our factorial
     calculations and gained some
     speed, but I wanted to show
     WHY these numbers are right.
     ****************************/
    first  = factorial(5);
                        // {D,A,X,X,X,X}
    second = factorial(5) - factorial(4);
                        // {D,X,A,X,X,X} & {X,D,A,X,X,X}
    third  = factorial(5) - factorial(4) - factorial(4);
                        // {D,X,X,A,X,X} & {X,D,X,A,X,X} & {X,X,D,A,X,X}
    fourth = factorial(5) - factorial(4) - factorial(4) - factorial(4);
                        // {D,X,X,X,A,X} & {X,D,X,X,A,X} & {X,X,D,X,A,X} & {X,X,X,D,A,X}
    fifth  = factorial(5) - factorial(4) - factorial(4) - factorial(4) - factorial(4);
 
    /****************************
     Notice that factorial(4) x 5
     is equal to factorial(5). So
     this is a wasted calculation
     for the sake of example.
     ****************************/
                        // {D,X,X,X,X,A} & {X,D,X,X,X,A} & {X,X,D,X,X,A} & {X,X,X,D,X,A} & {X,X,X,X,D,A}
    sixth  = factorial(5) - factorial(4) - factorial(4) - factorial(4) - factorial(4) - factorial(4);
 
    cout << " " << first << " <- All where A is 1st" << endl;
    cout << "  " << second << " <- All where A is 2nd" << endl;
    cout << "  " << third  << " <- All where A is 3rd" << endl;
    cout << "  " << fourth << " <- All where A is 4th" << endl;
    cout << "  " << fifth << " <- All where A is 5th" << endl;
    cout << "+  " << sixth << " <- All where A is 6th" << endl;
    cout << "----" << endl;
    cout << " " << first + second + third + fourth + fifth + sixth << endl;
    cout << endl;
    cout << "Process complete." << endl;
    cout << "--------------------------------------" << endl;
    cout << "\\\\//_ Live long and prosper." << endl;
}
 
 
// --------------------------------------------------
// factorial():
//
// Recursive function.
// Returns long int, accepts (long int in).
//
// Calculates the factorial of the given number.
// --------------------------------------------------
long int factorial (long int in) {
    long int result = 0;
 
    if (in == 0)
        result = 1;
    else
        result = in * factorial(in - 1);
 
    return result;
} // End factorial

#include <iostream>
using namespace std;
 
int main () {
    int input = 0;
 
    cout << "Enter the size of your hourglass: ";
    cin  >> input;
 
    for (int c = input - 1; c > 0; --c) {
        for (int i = 0; i < (input - c) - 1; ++i)
            cout << " ";
        for (int i = (2 * c + 1); i > 0; --i)
            cout << "*";
        cout << endl;
    } // End top for loop
    for (int c = 0; c < input; ++c) {
        for (int i = 0; i < (input - c) - 1; ++i)
            cout << " ";
        for (int i = (2 * c + 1); i > 0; --i)
            cout << "*";
        cout << endl;
    } // End bottom for loop
} // End main

import java.util.Scanner;
 
public class hourglass {
	public static void main (String[] args) {
		int input = 0;
		Scanner scan = new Scanner(System.in);
 
		System.out.print ("Enter the size of your hourglass: ");
		input = scan.nextInt();
 
		for (int c = input - 1; c > 0; --c) {
			for (int i = 0; i < (input - c) - 1; ++i)
				System.out.print (" ");
			for (int i = (2 * c + 1); i > 0; --i)
				System.out.print ("*");
			System.out.println ();
		} // End top for loop
		for (int c = 0; c < input; ++c) {
			for (int i = 0; i < (input - c) - 1; ++i)
				System.out.print (" ");
			for (int i = (2 * c + 1); i > 0; --i)
				System.out.print ("*");
			System.out.println ();
		} // End bottom for loop
	}
}

PROGRAM hourglass
	IMPLICIT NONE
 
	INTEGER :: input = 0
	INTEGER :: c
	INTEGER :: i
 
	WRITE (*,'(a)',advance='no') 'Enter the size of your hourglass: '
	READ  (*,*) input
 
	c = input - 1
	DO WHILE (c > 0)
		i = 0
		DO WHILE (i < (input - c) - 1)
			WRITE (*,'(a)',advance='no') ' '
			i = i + 1
		END DO
		i = (2 * c + 1)
		DO WHILE (i > 0)
			WRITE (*,'(a)',advance='no') '*'
			i = i - 1
		END DO
		c = c - 1
		WRITE (*,*)
	END DO
	c = 0
	DO WHILE (c < input)
		i = 0
		DO WHILE (i < (input - c) - 1)
			WRITE (*,'(a)',advance='no') ' '
			i = i + 1
		END DO
		i = (2 * c + 1)
		DO WHILE (i > 0)
			WRITE (*,'(a)',advance='no') '*'
			i = i - 1
		END DO
		c = c + 1
		WRITE (*,*)
	END DO
END PROGRAM hourglass

// ==================================================
// Programmer:  Jonathan Landrum
// Date:        16 April 2012
// ==================================================
// Program:     induce.cpp
// Purpose:     Uses inductive reasoning to show that
//		a number input by the user is a
//		product of primes.
// Assumptions: 1.) The number input is a natural
//		    number.
//		2.) The number input is > 1.
// ==================================================
 
#include <iostream>
using namespace std;
 
// --------------------------------------------------
// Function prototypes
// --------------------------------------------------
void induce(int);
bool prime(int);
 
 
// --------------------------------------------------
// main():
// Calls the induce() function
// --------------------------------------------------
int main () {
 
	// Variables
	int  input = 0;
 
	// Introduce the program
	cout << endl;
	cout << "--------------------------------" << endl;
	cout << "-      Inductive Reasoning     -" << endl;
	cout << "--------------------------------" << endl;
	cout << endl;
	cout << "This program uses recursion to" << endl;
	cout << "show that any natural number > 1" << endl;
	cout << "is a product of primes.";
	cout << endl << endl;
 
	// Get user input
	while (input < 2) {
		cout << "Enter an integer to test: ";
		cin  >> input;
	}
 
	cout << endl;
 
	// Return the results
	induce(input);
	cout << endl;
	cout << "--------------------------------" << endl;
	cout << "\\\\//_ Live long and prosper." << endl;
	return (0);
} // End main
 
 
// --------------------------------------------------
// induce():
// Prints out the results of proving the number input
// is a product of primes.
// --------------------------------------------------
void induce (int n) {
	if (prime(n)) {
		cout << n << " is prime, so it is a product of a single prime." << endl;
	} else {
		cout << "In order to prove that " << n << " is a product of primes" << endl;
		if (n % 13 == 0) {
			cout << "\twe prove that " << n / 13 << " and 13 are products of primes." << endl;
			induce(n/13);
			induce(13);
			cout << "Having proven that " << n / 13 << " and 13 are products of primes," << endl;
			cout << "\twe condlude that " << n << " = " << n / 13 << " * " << 13 << endl;
		} else if (n % 11 == 0) {
			cout << "\twe prove that " << n / 11 << " and 11 are products of primes." << endl;
			induce(n/11);
			induce(11);
			cout << "Having proven that " << n / 11 << " and 11 are products of primes," << endl;
			cout << "\twe condlude that " << n << " = " << n / 11 << " * " << 11 << endl;
		} else if (n % 7 == 0) {
			cout << "\twe prove that " << n / 7 << " and 7 are products of primes." << endl;
			induce(n/7);
			induce(7);
			cout << "Having proven that " << n / 7 << " and 7 are products of primes," << endl;
			cout << "\twe condlude that " << n << " = " << n / 7 << " * " << 7 << endl;
		} else if (n % 5 == 0) {
			cout << "\twe prove that " << n / 5 << " and 5 are products of primes." << endl;
			induce(n/5);
			induce(5);
			cout << "Having proven that " << n / 5 << " and 5 are products of primes," << endl;
			cout << "\twe condlude that " << n << " = " << n / 5 << " * " << 5 << endl;
		} else if (n % 3 == 0) {
			cout << "\twe prove that " << n / 3 << " and 3 are products of primes." << endl;
			induce(n/3);
			induce(3);
			cout << "Having proven that " << n / 3 << " and 3 are products of primes," << endl;
			cout << "\twe condlude that " << n << " = " << n / 3 << " * " << 3 << endl;
		} else if (n % 2 == 0) {
			cout << "\twe prove that " << n / 2 << " and 2 are products of primes." << endl;
			induce(n/2);
			induce(2);
			cout << "Having proven that " << n / 2 << " and 2 are products of primes," << endl;
			cout << "\twe condlude that " << n << " = " << n / 2 << " * " << 2 << endl;
		}
		cout << "\tis a product of primes." << endl;
	}
}
 
 
// --------------------------------------------------
// prime():
// Determines if a number is prime
// --------------------------------------------------
bool prime (int n) {
	// Variables
	bool result;
	int  i;
 
	// Do work
	if (n <= 1) {
		result = false; // 1 is not prime
 
	} else if ((n == 2) || (n == 3)) {
		result = true; // Hard code 2 and 3
 
	} else if (n % 2 == 0) {
		result = false; // Get rid of evens
 
		/* 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;
		result = true; // Assume it's prime, then prove
 
		while (true) {
			/* If i^2 is not a root of n, or if
			 n % i == 0. (Won't be larger than
			 the square.) */
			if ((i * i > n) || (n % i == 0))
				break;
			i += 2; // Iterate by 2 to get odds
		} // End while
 
		// Record the answer
		if (i * i > n)
			result = true;
		else
			result = false;
	} // End if
 
 
	// Return the answer
	return result;
}

#include <cstdlib>
#include <iostream>
#include <string>
 
#define SIZE 10
 
using namespace std;
 
class queue {
private:
	/* Instance Variables */
	int  count;
	int  front;
	int  rear;
public:
	/* Constructor */
	queue();
 
	/* Instance Methods */
	bool isEmpty();
	void enqueue(const int item);
	int  dequeue();
	int  first();
	int  size();
};

#include "queue.h"
 
 
int data[SIZE];
 
queue::queue() {
	count  = 0;
	front  = 0;
	rear   = 0;
 
	for (int i = 0; i < SIZE; ++i)
		data[i] = 0.0;
}
 
bool queue::isEmpty() {
	bool result;
 
	if (count == 0)
		result = true;
	else
		result = false;
 
	return result;
}
 
void queue::enqueue(const int item) {
	if (count < SIZE) {
		data[rear] = item;
		rear = (rear + 1) % SIZE;
		++count;
	} else
		std::cerr << "Error: Attempt to enqueue to full queue\n";
 
}
 
int queue::dequeue() {
	int result = 0;
 
	if (!isEmpty()) {
		result = data[front];
		data[front] = NULL;
		front = (front + 1) % SIZE;
		--count;
	} else
		std::cerr << "Error: Attempt to dequeue from an empty queue\n";
 
	return result;
}
 
int queue::first() {
	return data[front];
}
 
int queue::size() {
	return count;
}

#include "queue.h"
 
 
int main() {
	int   count;
	int   item;
	queue myQueue;
 
	cout << "--------------------------------------------------------\n\n";
	cout << "               Programming a Queue in C++\n\n";
	cout << "--------------------------------------------------------\n\n";
 
	cout << "This program simulates a waiting line -- also called a\n";
	cout << "queue -- using a queue data structure.\n\n";
	cout << "This program only handles integers at the moment; other\n";
	cout << "data types would be trivial to implement.";
 
	for (count = 0; count < SIZE; ++count) {
		cout << "Entry " << count + 1 << ": ";
		cin  >> item;
		myQueue.enqueue(item);
		cout << "Items in the list: " << myQueue.size() << endl;
	}
 
	cout << "\nNow to dequeue those items:\n" << endl;
 
	for (count = 0; count < SIZE; ++count) {
		cout << "Entry " << count + 1 << ": " << myQueue.dequeue() << endl;
	}
 
	return (0);
}

#
# Makefile for queue
#
 
CC=g++
CFLAGS=-g -Wall
 
queue: main.o queue.o
	$(CC) $(CFLAGS) -o queue main.o queue.o
main.o: main.cpp queue.h
	$(CC) $(CFLAGS) -c main.cpp
queue.o: queue.cpp queue.h
	$(CC) $(CFLAGS) -c queue.cpp
 
clean:
	rm -f queue *.o
 
# End of makefile

void stack::addItem(const float item) {
	push(item);
	total += item;
}
 
float stack::returnTotal() {
	return total;
}

#include <cstdlib>
#include <iostream>
#include <string>
 
#define SIZE 10
 
using namespace std;
 
class stack {
private:
	/* Instance Variables */
	int   count;
	float total;
public:
	/* Constructor */
	stack();
 
	/* Instance Methods */
	bool  isEmpty();
	void  push(const float item);
	float pop();
	void  addItem(const float item);
	float returnTotal();
};

#include "checkbook.h"
 
 
float data[SIZE];
 
stack::stack() {
	count = 0;
	total = 0.0;
 
	for (int i = 0; i < SIZE; ++i)
		data[i] = 0.0;
}
 
bool stack::isEmpty() {
	bool result;
 
	if (count == 0)
		result = true;
	else
		result = false;
 
	return result;
}
 
void stack::push(const float item) {
	if (count < SIZE) {
		data[count] = item;
		++count;
	} else
		std::cerr << "Error: Attempt to push to full stack\n";
 
}
 
float stack::pop() {
	float result = -1;
 
	if (!isEmpty()) {
		--count;
		result = data[count];
	} else
		std::cerr << "Error: Attempt to pop from an empty stack\n";
 
	return result;
}
 
void stack::addItem(const float item) {
	push(item);
	total += item;
}
 
float stack::returnTotal() {
	return total;
}

#include "checkbook.h"
 
 
int main() {
	int   count;
	float item;
	stack myStack;
 
	cout << "---------------------------------------------------------\n\n";
	cout << "                      C++ Checkbook\n\n";
	cout << "---------------------------------------------------------\n\n";
 
	cout << "This program simulates a checkbook program. Enter values\n";
	cout << "for each checkbook entry as floating point numbers.\n\n";
 
	for (count = 0; count < SIZE; ++count) {
		cout << "Entry " << count + 1 << ": ";
		cin  >> item;
		myStack.addItem(item);
		cout << "Running total: " << myStack.returnTotal() << "\n\n";
	}
 
	cout << "\nTOTAL: " << myStack.returnTotal() << endl;
 
	return (0);
}

#
# Makefile for checkbook
#
 
CC=g++
CFLAGS=-g -Wall
 
checkbook: main.o checkbook.o
	$(CC) $(CFLAGS) -o checkbook main.o checkbook.o
main.o: main.cpp checkbook.h
	$(CC) $(CFLAGS) -c main.cpp
checkbook.o: checkbook.cpp checkbook.h
	$(CC) $(CFLAGS) -c checkbook.cpp
 
clean:
	rm -f checkbook *.o
 
# End of makefile

#include "stack.h"
 
int main() {
	stack myStack;
	stack_init(myStack);
	int item;
 
	// Demonstrate the dropout
	for (int c = 0; c < 15; ++c) {
		cout << "Enter a number to the stack: ";
		cin  >> item;
		stack_push(myStack, item);
		stack_toString(myStack);
	}
 
	cout << endl;
 
	// Demonstrate an empty collection exception
	for (int c = 0; c < 11; ++c) {
		stack_pop(myStack);
		stack_toString(myStack);
	}
 
	return (0);
}

#include <iostream>
#define SIZE 10
using namespace std;
 
 
struct stack {
	int count;
	int data[SIZE];
};
 
inline void stack_init(struct stack & the_stack) {
	the_stack.count = 0;
}
 
inline void stack_dropOut(struct stack & the_stack) {
	for (int c = 0; c < SIZE; ++c)
		the_stack.data[c] = the_stack.data[c + 1];
 
	--the_stack.count;
}
 
inline bool stack_isEmpty(struct stack & the_stack) {
	return (the_stack.count == 0);
}
 
inline void stack_push(struct stack & the_stack, const int item) {
	if (the_stack.count == SIZE)
		stack_dropOut(the_stack);
 
	the_stack.data[the_stack.count] = item;
	++the_stack.count;
}
 
inline int stack_pop(struct stack & the_stack) {
	if (stack_isEmpty(the_stack)) {
		cout << "Error: Empty Collection Exception" << endl;
		return(-1);
	}
 
	--the_stack.count;
	return (the_stack.data[the_stack.count]);
}
 
inline int stack_peek(struct stack & the_stack) {
	return (the_stack.data[the_stack.count]);
}
 
inline bool stack_size(struct stack & the_stack) {
	return (the_stack.count);
}
 
inline void stack_toString(struct stack & the_stack) {
	for (int c = 0; c < the_stack.count; ++c)
		cout << "Item " << c + 1 << ": " << the_stack.data[c] << endl;
}

// ==================================================
// Programmer:  Jonathan Landrum
// Date:        29 March 2012
// ==================================================
// Program:     combinations.cpp
// Purpose:     Calculates the number of combinations
//		that can be made with given input of
//		discrete items.
// Assumptions: - Input is an integer. Real input
//		  will be cast to the next lowest
//		  integer.
// ==================================================
 
#include <iostream>
#include <string>
 
using namespace std;
 
 
// --------------------------------------------------
// main():
// Calls factorial() and returns results.
// --------------------------------------------------
int main () {
 
	// Variables
	float n, r;
	int   group, choose;
	long int result = 1;
 
	// Introduce the program
	cout << endl;
	cout << "------------------------------------" << endl;
	cout << "-     Combinatorics Calculator     -" << endl;
	cout << "------------------------------------" << endl;
	cout << endl;
	cout << "              /n\\      n!" << endl;
	cout << "        nCr = | | = --------" << endl;
	cout << "              \\r/   r!(n-r)!" << endl;
	cout << endl;
	cout << "This program calculates how many" << endl;
	cout << "combinations can be made of a given" << endl;
	cout << "number of choices, and a given sized" << endl;
	cout << "group from which to choose." << endl;
 
	// Get user input
	try {
		do {
			cout << endl;
 
			cout << "Size of the group (n): ";
 
			cin  >> n;
		} while (n < 0);
 
		do {
			cout << endl;
 
			cout << "Number of choices (r): ";
 
			cin  >> r;
		} while (r < 0);
 
		cout << endl;
 
		group  = (int)n;
		choose = (int)r;
	}
	catch (...) {
		cout << "Error: << Unexpected Input >>" << endl;
		return (-1);
	}
 
	if (choose > group) {
		cout << 0 << endl << endl;
		return (0);
	}
 
	for (int i = 1; i <= choose; ++i)
		result *= ((float)(group - choose + i)/i);
 
	cout << result << endl << endl;
 
	return (0);
} // End main

// ==================================================
// Programmer:  Jonathan Landrum
// Date:        29 March 2012
// ==================================================
// Program:     combinations.cpp
// Purpose:     Calculates the number of combinations
//		that can be made with given input of
//		discrete items.
// Assumptions: - Input is an integer. Real input
//		  will be cast to the next lowest
//		  integer.
// Issues:      - The function factorial() slows down
//		  significantly for input greater
//		  than 23 due to the fact that they
//		  use recursion to calculate their
//		  results.
// ==================================================
 
#include <iostream>
#include <string>
 
using namespace std;
 
 
// --------------------------------------------------
// Function Prototypes
// --------------------------------------------------
long int factorial (long int in);
 
 
// --------------------------------------------------
// main():
// Calls factorial() and returns results.
// --------------------------------------------------
int main () {
 
	// Variables
	float n, r;
	int   group, choose;
	long int result = 1;
 
	// Introduce the program
	cout << endl;
	cout << "------------------------------------" << endl;
	cout << "-     Combinatorics Calculator     -" << endl;
	cout << "------------------------------------" << endl;
	cout << endl;
	cout << "              /n\\      n!" << endl;
	cout << "        nCr = | | = --------" << endl;
	cout << "              \\r/   r!(n-r)!" << endl;
	cout << endl;
	cout << "This program calculates how many" << endl;
	cout << "combinations can be made of a given" << endl;
	cout << "number of choices, and a given sized" << endl;
	cout << "group from which to choose." << endl;
 
	// Get user input
	try {
		do {
			cout << endl;
 
			cout << "Size of the group (n): ";
 
			cin  >> n;
		} while (n < 0);
 
		do {
			cout << endl;
 
			cout << "Number of choices (r): ";
 
			cin  >> r;
		} while (r < 0);
 
		cout << endl;
 
		group  = (int)n;
		choose = (int)r;
	}
	catch (...) {
		cout << "Error: << Unexpected Input >>" << endl;
		return (-1);
	}
 
	if (choose > group) {
		cout << 0 << endl << endl;
		return (0);
	}
 
	result = group;
 
	for (int i = 1; i <= choose - 1; ++i)
		result *= (group - i);
 
	cout << (result/factorial(choose)) << endl << endl;
 
	return (0);
} // End main
 
 
// --------------------------------------------------
// factorial():
//
// Recursive function.
// Returns int, accepts (int in).
// 
// Calculates the factorial of the given number.
// --------------------------------------------------
long int factorial (long int in) {
	long int result = 0;
 
	if (in == 0)
		result = 1;
	else
		result = in * factorial(in - 1);
 
	return result;
} // End factorial

// ==================================================
// Programmer:  Jonathan Landrum
// Date:        29 March 2012
// ==================================================
// Program:     combinations.cpp
// Purpose:     Calculates the number of combinations
//		that can be made with given input of
//		discrete items.
// Assumptions: - Input is an integer. Real input
//		  will be cast to the next lowest
//		  integer.
// Issues:      - The function factorial() slows down
//		  significantly for input greater
//		  than 23 due to the fact that it
//		  uses recursion to calculate its
//		  result.
// ==================================================
 
#include <iostream>
#include <string>
 
using namespace std;
 
 
// --------------------------------------------------
// Function Prototypes
// --------------------------------------------------
long int factorial (long int in);
 
 
// --------------------------------------------------
// main():
// Calls factorial() and returns results.
// --------------------------------------------------
int main () {
 
	// Variables
	float n, r;
	int   group, choose;
 
	// Introduce the program
	cout << endl;
	cout << "-----------------------------------" << endl;
	cout << "-     Combinations Calculator     -" << endl;
	cout << "-----------------------------------" << endl;
	cout << endl;
	cout << "              /n\\      n!" << endl;
	cout << "        nCr = | | = --------" << endl;
	cout << "              \\r/   r!(n-r)!" << endl;
	cout << endl;
	cout << "This program calculates how many" << endl;
	cout << "combinations can be made of a given" << endl;
	cout << "number of choices, and a given sized" << endl;
	cout << "group from which to choose." << endl;
 
	// Get user input
	try {
		do {
			cout << endl;
 
			cout << "Size of the group (n): ";
 
			cin  >> n;
		} while (n < 0);
 
		do {
			cout << endl;
 
			cout << "Number of choices (r): ";
 
			cin  >> r;
		} while (r < 0);
 
		cout << endl;
 
		group  = (int)n;
		choose = (int)r;
	}
	catch (...) {
		cout << "Error: << Unexpected Input >>" << endl;
		return (-1);
	}
 
	if (choose > group) {
		cout << 0 << endl << endl;
		return (0);
	}
 
	cout << (factorial(group)/(factorial(choose) * factorial(group - choose))) << endl << endl;
 
	return (0);
} // End main
 
 
// --------------------------------------------------
// factorial():
//
// Recursive function.
// Returns long int, accepts (long int).
// 
// Calculates the factorial of the given number.
// --------------------------------------------------
long int factorial (long int in) {
	long int result = 0;
 
	if (in == 0 )
		result = 1;
	else
		result = in * factorial(in - 1);
 
	return result;
} // End factorial