Need an extra line there.

Hope this works...

.gitignore

@@ -0,0 +1,8 @@
+# Ignore CMake files:
+CMakeCache.txt
+CMakeFiles/
+cmake_install.cmake
+Makefile
+
+# Ignore build files:
+build/

.travis.yml

@@ -0,0 +1,13 @@
+# Define the language
+language: c
+
+addons:
+    apt:
+        packages:
+            - build-essential
+            - cmake
+
+script:
+    - cd build/
+    - cmake -DCMAKE_BUILD_TYPE=Release ..
+    - make

CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 2.6)
+project(MMMCalc)
+
+if(CMAKE_BUILD_TYPE STREQUAL "")
+    set(CMAKE_BUILD_TYPE RelWithDebInfo)
+endif()
+
+set(CMAKE_C_FLAGS "-std=gnu99 -Wall -Wextra -Werror -Wfatal-errors -Wmissing-declarations -pedantic-errors")
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS} -g -O0")
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS} -O3")
+set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS} -g -O3")
+set(CMAKE_C_FLAGS_MIN_SIZEREL "${CMAKE_C_FLAGS} -Os")
+
+set(SRCS
+    src/main.c)
+
+add_executable(mmmcalc ${SRCS})

README.md

@@ -1,6 +1,21 @@
 MMMCalc
 =======
+[![Build Status](https://travis-ci.org/Deathsbreed/MMMCalc.svg?branch=master)](https://travis-ci.org/Deathsbreed/MMMCalc)
 
-This is a very simple project, it was made for educational purposes (hence why it is open-source), and I encourage everyone to contribute if they have something to add.
+MMMCalc is a program I made after school one day after having to learn about Mean, Median, and Mode for the thousandth time. So instead of doing my actual homework I decided to make this program which would do it for me. Of course, the program with this is that your teachers often ask you to show your work. Well, fear not! For MMMCalc shows you **its** work. After it does its calculations, if you turn on _verbose mode_ (by using the `-v` argument) it will show you how MMMCalc got to that answer that it's giving you. After going through Mean, Median, and Mode (the reason why this program is called **MMM**Calc) I decided to add a few other basic statistical properties to it.
 
-To contact me, send me an e-mail at <nicolas.ortega.froysa@gmail.com>.
+I hope this helps someone to make their millionth time of doing Mean, Median, and Mode in school a little less of a pain in the ass.
+
+### Compiling
+MMMCalc uses [CMake](http://cmake.org/) to compile. Please install the C development tools and CMake (along with whichever build script you plan on having CMake generate) in order to run this command.
+```bash
+$ cd build/
+$ cmake ..
+$ make
+```
+
+### Contributing
+To contribute, simply open a pull request, however, be aware that this code is licensed under a GNU GPLv3 and so will yours.
+
+### License
+All code in this repository is under the [GNU GPLv3](/LICENSE).

src/MMMCalc.java

@@ -1,91 +0,0 @@
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * @author Nicolás A. Ortega
- * @copyright (C) Nicolás A. Ortega
- * @license GNU General Public License 3.0 (GPLv3)
- * @year 2014
- * 
- */
-public class MMMCalc {
-	private static float[] numArray;
-
-	public static void main(String[] args) {
-		System.out.println("Welcome to MMMCalc v0.1, a simple tool for basic statistics calculations.\n" +
-			"This software is licensed under the GNU GPLv3 license and comes WITHOUT WARRANTY.\n");
-		if(args.length > 0) {
-			float sNum = 0;
-			numArray = new float[args.length];
-
-			for(int i = 0; i < args.length; i++) {
-				numArray[i] = Float.parseFloat(args[i]) - 0f;
-			}
-
-			int nL = numArray.length;
-			float tmp = 0;
-			for(int i = 0; i < nL; i++) {
-				for(int j = 0; j >= (i+1); j--) {
-					if(numArray[j] < numArray[j-1]) {
-						tmp = numArray[j];
-						numArray[j] = numArray[j-1];
-						numArray[j-1] = tmp;
-					}
-				}
-			}
-
-			calcMean();
-			calcMedian();
-			calcMode();
-		} else {
-			System.out.println("You did not mention any variables.");
-		}
-	}
-
-	private static void calcMean() {
-		float mean = 0;
-		float sum = 0;
-
-		for(float i: numArray) {
-			sum += i;
-		}
-
-		mean = sum / (float)numArray.length;
-
-		System.out.println("Mean: " + mean);
-	}
-
-	private static void calcMedian() {
-		int midVar = 0;
-
-		midVar = numArray.length / 2;
-
-		System.out.println("Median: " + numArray[midVar]);
-	}
-
-	private static void calcMode() {
-		HashMap<Float, Float> fx = new HashMap<Float, Float>();
-
-		for(float x: numArray) {
-			Float f = fx.get(x);
-			if(f == null) {
-				fx.put(x, (float)1);
-			} else {
-				fx.put(x, f + 1);
-			}
-		}
-
-		float mode = 0;
-		float modeFreq = 0;
-
-		for(Map.Entry<Float, Float> entry: fx.entrySet()) {
-			float freq = entry.getValue();
-			if(freq > modeFreq) {
-				modeFreq = freq;
-				mode = entry.getKey();
-			}
-		}
-
-		System.out.println("Mode: " + mode + " (frequency: " + modeFreq + ")");
-	}
-}

src/main.c

@@ -0,0 +1,128 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <stdbool.h>
+#include <getopt.h>
+#include <unistd.h>
+
+// Version string
+const char *version = "v0.5";
+// Whether or not the calculations should be verbose
+bool verboseFlag = false;
+
+// Function that prints help info
+inline void printHelp();
+
+int main(int argc, char **argv) {
+    // There should always be at least be 2 arguments and no more than 4
+    if(argc <= 1) {
+        fprintf(stderr, "No arguments were provided. Use `-h' for help.\n");
+        return 1;
+    }
+
+    // Variable where the argument is stored
+    int arg;
+    // If help info should be printed
+    bool helpFlag = false;
+    // If version info should be printed
+    bool versionFlag = false;
+    // The file to read the numbers from
+    char *infile = NULL;
+
+    while((arg = getopt(argc, argv, "hvVf:")) != -1) {
+        switch(arg) {
+            case 'h':
+                // Only 2 arguments can be used
+                if(argc != 2) {
+                    fprintf(stderr, "Invalid use of arguments. Use `-h' for help.\n");
+                    return 1;
+                }
+                helpFlag = true;
+                break;
+
+            case 'v':
+                verboseFlag = true;
+                break;
+
+            case 'V':
+                // Only 2 arguments can be used
+                if(argc != 2) {
+                    fprintf(stderr, "Invalid use of arguments. Use `-h' for help.\n");
+                    return 1;
+                }
+                versionFlag = true;
+                break;
+
+            case 'f':
+                // There needs to be between 3 and 4 arguments
+                if(argc > 4 || argc < 3) {
+                    fprintf(stderr, "Invalid use of arguments. Use `-h' for help.\n");
+                }
+                // Set the input file
+                infile = optarg;
+                break;
+
+            case '?':
+                if(optopt == 'f') {
+                    fprintf(stderr, "Option -%c requires an argument.\n", optopt);
+                } else if(isprint(optopt)) {
+                    fprintf(stderr, "Unknown option `-%c'.\n", optopt);
+                } else {
+                    fprintf(stderr, "Unknown character `\\x%x'.\n", optopt);
+                }
+                return 1;
+
+            default:
+                // If we get anything else that's weird just abort
+                abort();
+        }
+    }
+
+    if(helpFlag) {
+        printHelp();
+        return 0;
+    } else if(versionFlag) {
+        printf("%s\n", version);
+        return 0;
+    }
+
+    // Print copyright & license information
+    printf("MMMCalc %s, Copyright (c) 2016 Nicolás A. Ortega.\n", version);
+    printf("This program comes with ABSOLUTELY NO WARRANTY.\n");
+    printf("This program is free software and you are welcome to redistribute\n");
+    printf("under the terms and conditions of the GNU GPLv3 or higher.\n\n");
+
+    // Open a file as read only
+    FILE *numfile = fopen(infile, "r");
+    // Temporary variable to see how many numbers are in this file
+    double num;
+    // The size of the coming nums array
+    int size = 0;
+    // Get the size for the array
+    while(fscanf(numfile, "%lf", &num) == 1) size++;
+    rewind(numfile);
+    printf("There are %d numbers in the file.\n", size);
+    // Create the array with that size
+    double nums[size];
+    for(int i = 0; i < size; i++) {
+        // Store result of fscanf in err
+        int err = fscanf(numfile, "%lf", &nums[i]);
+        // If fscanf returned error exit out of here
+        if(err != 1) {
+            fprintf(stderr, "Error reading entire file.\n");
+            return 1;
+        }
+        // If not let's continue printing
+        printf("%f\n", nums[i]);
+    }
+    return 0;
+}
+
+void printHelp() {
+    printf("Usage: mmmcalc [options]\n");
+    printf("Options:\n");
+    printf(" -f <file> -- The file to read variables from.\n");
+    printf(" -h -- Show this help information.\n");
+    printf(" -v -- Be verbose, prints the equations used.\n");
+    printf(" -V -- Print the version number.\n");
+}

src/manifest.mf

@@ -1,2 +0,0 @@
-Manifest-Version: 0.1
-Main-Class: MMMCalc

src/mmmcalc/MMMCalc.java

@@ -0,0 +1,351 @@
+package mmmcalc;
+
+import java.lang.Math;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author Nicolás A. Ortega
+ * @copyright (C) Nicolás A. Ortega
+ * @license GNU GPLv3
+ * @year 2014
+ * 
+ */
+public class MMMCalc {
+	private static boolean verbose = false;
+	private static float[] numArray;
+	private static float mean = 0;
+	private static float q1 = 0;
+	private static float median = 0;
+	private static float q3 = 0;
+	private static float mode = 0;
+	private static float range = 0;
+	private static float stdDev = 0;
+	private static float variance = 0;
+
+	public static void main(String[] args) {
+		System.out.println("MMMCalc v0.4, Copyright (C) 2014 Nicolás A. Ortega\n" +
+					"This program comes with ABSOLUTELY NO WARRANTY; for details use '-w'\n" +
+					"This is free software, and you are welcome to redistribute it\n" +
+					"under certain conditions; use '-c' for details.\n");
+		if(args.length > 0) {
+			if(args[0].equals("-h")) {
+				System.out.println("Usage:\n" +
+					"  MMMCalc [options] [variables]\n\n" +
+					"Options:\n" +
+					"  -v | -V -- Be verbose (show the work).\n" +
+					"  -w -- Show warranty information.\n" +
+					"  -c -- Show copyright information.\n" +
+					"  -h -- Show this help information.\n");
+			} else if(args[0].equals("-w")) {
+				System.out.println("THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY\n" +
+					"APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT\n" +
+					"HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM 'AS IS' WITHOUT WARRANTY\n" +
+					"OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,\n" +
+					"THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n" +
+					"PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM\n" +
+					"IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF\n" +
+					"ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n");
+			} else if(args[0].equals("-c")) {
+				System.out.println("MMMCalc, a very basic statistics calculator.\n" +
+					"Copyright (C) 2014 Nicolás A. Ortega\n\n" +
+					"This program is free software: you can redistribute it and/or modify\n" +
+					"it under the terms of the GNU General Public License as published by\n" +
+					"the Free Software Foundation, either version 3 of the License, or\n" +
+					"(at your option) any later version.\n\n" +
+					"This program is distributed in the hope that it will be useful,\n" +
+					"but WITHOUT ANY WARRANTY; without even the implied warranty of\n" +
+					"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n" +
+					"GNU General Public License for more details.\n\n" +
+					"You should have received a copy of the GNU General Public License\n" +
+					"along with this program.  If not, see <www.gnu.org/licenses/>.");
+			} else if(args[0].equals("-v") || args[0].equals("-V")) {
+				verbose = true;
+				numArray = new float[args.length - 1];
+
+				for(int i = 0; i < numArray.length; i++) {
+					numArray[i] = Float.parseFloat(args[i+1]);
+				}
+				sortArray();
+
+				calcMean();
+				calcQ1();
+				calcMedian();
+				calcQ3();
+				calcMode();
+				calcRange();
+				calcStdDev();
+				calcVariance();
+			} else {
+				numArray = new float[args.length];
+
+				for(int i = 0; i < args.length; i++) {
+					numArray[i] = Float.parseFloat(args[i]) - 0f;
+				}
+				sortArray();
+
+				calcMean();
+				calcQ1();
+				calcMedian();
+				calcQ3();
+				calcMode();
+				calcRange();
+				calcStdDev();
+				calcVariance();
+			}
+	} else {
+			System.out.println("You did not mention any variables. Use the -h argument for help.");
+		}
+	}
+
+	private static void sortArray() {
+		int nL = numArray.length;
+		float tmp = 0;
+		for(int i = 0; i < nL; i++) {
+			for(int j = (nL-1); j >= (i+1); j--) {
+				if(numArray[j] < numArray[j-1]) {
+					tmp = numArray[j];
+					numArray[j] = numArray[j-1];
+					numArray[j-1] = tmp;
+				}
+			}
+		}
+	}
+
+	private static void calcMean() {
+		float sum = 0;
+
+		for(float i: numArray) {
+			sum += i;
+		}
+
+		mean = sum / (float)numArray.length;
+
+		System.out.println("Mean: " + mean);
+
+		if(verbose) {
+			System.out.print("(");
+			for(int i = 0; i < numArray.length; i++) {
+				System.out.print(numArray[i]);
+				if(i != numArray.length -1) {
+					System.out.print(" + ");
+				}
+			}
+			System.out.print(") / " + numArray.length + " = " + mean + "\n\n");
+		}
+	}
+
+	private static void calcQ1() {
+		int q1Pos;
+		// c stands for case... Cases correspond to their order in the following if statements (4 different cases).
+		int c;
+
+		if(numArray.length % 2.0 == 0) {
+			q1Pos = (int)(numArray.length / 4);
+			if(numArray.length % 4.0 == 0) {
+				q1 = (numArray[q1Pos] + numArray[q1Pos-1]) / 2;
+				c = 1;
+			} else {
+				q1 = numArray[q1Pos];
+				c = 2;
+			}
+		} else {
+			if(Math.ceil(numArray.length / 2.0) % 2.0 == 0) {
+				q1Pos = (int)(Math.ceil(numArray.length / 2.0) / 2.0);
+				q1 = (numArray[q1Pos] + numArray[q1Pos+1]) / 2;
+				c = 3;
+			} else {
+				q1Pos = (int)Math.ceil(numArray.length / 4.0);
+				q1 = numArray[q1Pos];
+				c = 4;
+			}
+		}
+
+		System.out.println("Q1: " + q1);
+
+		if(verbose) {
+			for(int i = 0; i < numArray.length; i++) {
+				if(c == 1) {
+					if(i == q1Pos - 1) {
+						System.out.print(">>" + numArray[i] + " !" + q1  + "! ");
+					} else if(i == q1Pos) {
+						System.out.print(numArray[i] + "<< ");
+					} else {
+						System.out.print(numArray[i] + " ");
+					}
+				} else if(c == 2) {
+					if(i == q1Pos) {
+						System.out.print(">>" + numArray[i] + "<< ");
+					} else {
+						System.out.print(numArray[i] + " ");
+					}
+				} else if(c == 3) {
+					if(i == q1Pos) {
+						System.out.print(">>" + numArray[i] + " !" + q1 + "! ");
+					} else if(i == q1Pos + 1) {
+						System.out.print(numArray[i] + "<< ");
+					} else {
+						System.out.print(numArray[i] + " ");
+					}
+				} else if(c == 4) {
+					if(i == q1Pos) {
+						System.out.print(">>" + numArray[i] + "<< ");
+					} else {
+						System.out.print(numArray[i] + " ");
+					}
+				}
+			}
+			System.out.print("\n\n");
+		}
+	}
+
+	private static void calcMedian() {
+		int midVar = numArray.length / 2;
+		boolean exact;
+
+		if(numArray.length % 2 == 0) {
+			median = (numArray[midVar] + numArray[midVar-1]) / 2;
+			exact = false;
+		} else {
+			median = numArray[midVar];
+			exact = true;
+		}
+
+		System.out.println("Median: " + median);
+
+		if(verbose) {
+			for(int i = 0; i < numArray.length; i++) {
+				if(!exact) {
+					if(i == midVar - 1) {
+						System.out.print(">>" + numArray[i] + " !" + median + "! ");
+					} else if(i == midVar) {
+						System.out.print(numArray[i] + "<< ");
+					} else {
+						System.out.print(numArray[i] + " ");
+					}
+				} else {
+					if(i == midVar) {
+						System.out.print(">>" + numArray[i] + "<< ");
+					} else {
+						System.out.print(numArray[i] + " ");
+					}
+				}
+			}
+			System.out.print("\n\n");
+		}
+	}
+
+	// FIXME: Needs to calculate haflway between the median value and the last value.
+	private static void calcQ3() {
+		/*int q3Pos = (numArray.length * 3) / 4;
+		boolean exact;
+
+		if((numArray.length * 3) % 4 != 0) {
+			q3 = (numArray[q3Pos+1] + numArray[q3Pos]) / 2;
+			exact = false;
+		} else {
+			q3 = numArray[q3Pos];
+			exact = true;
+		}
+
+		System.out.println("Q3: " + q3);
+
+		if(verbose) {
+			for(int i = 0; i < numArray.length; i++) {
+				if(!exact) {
+					if(i == q3Pos) {
+						System.out.print(">>" + numArray[i] + " !" + q3 + "! ");
+					} else if(i == q3Pos + 1) {
+						System.out.print(numArray[i] + "<< ");
+					} else {
+						System.out.print(numArray[i] + " ");
+					}
+				} else {
+					if(i == q3Pos) {
+						System.out.print(">>" + numArray[i] + "<< ");
+					} else {
+						System.out.print(numArray[i] + " ");
+					}
+				}
+			}
+			System.out.print("\n\n");
+		}*/
+		System.out.println("Q3 is not currently functional.\n");
+	}
+
+	private static void calcMode() {
+		HashMap<Float, Float> fx = new HashMap<Float, Float>();
+
+		for(float x: numArray) {
+			Float f = fx.get(x);
+			if(f == null) {
+				fx.put(x, (float)1);
+			} else {
+				fx.put(x, f + 1);
+			}
+		}
+
+		float modeFreq = 0;
+
+		for(Map.Entry<Float, Float> entry: fx.entrySet()) {
+			float freq = entry.getValue();
+			if(freq > modeFreq) {
+				modeFreq = freq;
+				mode = entry.getKey();
+			}
+		}
+
+		System.out.println("Mode: " + mode + " (frequency: " + modeFreq + ")");
+
+		if(verbose) {
+			for(Map.Entry<Float, Float> entry:fx.entrySet()) {
+				System.out.print(entry.getKey() + "(" + entry.getValue() + ") ");
+			}
+			System.out.print("\n\n");
+		}
+	}
+
+	private static void calcRange() {
+		int l = numArray.length -1;
+		range = numArray[l] - numArray[0];
+
+		System.out.println("Range: " + range);
+
+		if(verbose) {
+			System.out.println(numArray[l] + " - " + numArray[0] + " = " + range + "\n");
+		}
+	}
+
+	private static void calcStdDev() {
+		float difSum = 0;
+		for(int i = 0; i < numArray.length; i++) {
+			difSum += numArray[i] - mean;
+		}
+
+		stdDev = difSum / (float)Math.sqrt((double)numArray.length);
+
+		System.out.println("Standard Deviation: " + stdDev);
+
+		if(verbose) {
+			System.out.print("sqrt((");
+			for(int i = 0; i < numArray.length; i++) {
+				System.out.print(numArray[i] + " - " + mean);
+				if(i != numArray.length - 1) {
+					System.out.print(" + ");
+				}
+			}
+			System.out.print(")^2 / " + numArray.length + ") = " + stdDev + "\n\n");
+		}
+	}
+
+	private static void calcVariance() {
+		variance = stdDev * stdDev;
+
+		System.out.println("Variance: " + variance);
+
+		if(verbose) {
+			System.out.println(stdDev + "^2 = " + variance + "\n");
+		}
+	}
+}