39 files changed, 4575 insertions, 1771 deletions

diff --git a/src/org/unitConverter/UnitsDatabase.java b/src/org/unitConverter/UnitsDatabase.java
new file mode 100755
index 0000000..e5d2f67
--- /dev/null
+++ b/src/org/unitConverter/UnitsDatabase.java
@@ -0,0 +1,1479 @@
+/**
+ * Copyright (C) 2018 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.unitConverter;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.AbstractSet;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import org.unitConverter.dimension.UnitDimension;
+import org.unitConverter.math.DecimalComparison;
+import org.unitConverter.math.ExpressionParser;
+import org.unitConverter.unit.DefaultUnitPrefix;
+import org.unitConverter.unit.LinearUnit;
+import org.unitConverter.unit.SI;
+import org.unitConverter.unit.Unit;
+import org.unitConverter.unit.UnitPrefix;
+
+/**
+ * A database of units, prefixes and dimensions, and their names.
+ * 
+ * @author Adrien Hopkins
+ * @since 2019-01-07
+ * @since v0.1.0
+ */
+public final class UnitsDatabase {
+	/**
+	 * A map for units that allows the use of prefixes.
+	 * <p>
+	 * As this map implementation is intended to be used as a sort of "augmented view" of a unit and prefix map, it is
+	 * unmodifiable but instead reflects the changes to the maps passed into it. Do not edit this map, instead edit the
+	 * maps that were passed in during construction.
+	 * </p>
+	 * <p>
+	 * The rules for applying prefixes onto units are the following:
+	 * <ul>
+	 * <li>Prefixes can only be applied to linear units.</li>
+	 * <li>Before attempting to search for prefixes in a unit name, this map will first search for a unit name. So, if
+	 * there are two units, "B" and "AB", and a prefix "A", this map will favour the unit "AB" over the unit "B" with
+	 * the prefix "A", even though they have the same string.</li>
+	 * <li>Longer prefixes are preferred to shorter prefixes. So, if you have units "BC" and "C", and prefixes "AB" and
+	 * "A", inputting "ABC" will return the unit "C" with the prefix "AB", not "BC" with the prefix "A".</li>
+	 * </ul>
+	 * </p>
+	 * <p>
+	 * This map is infinite in size if there is at least one unit and at least one prefix. If it is infinite, some
+	 * operations that only work with finite collections, like converting name/entry sets to arrays, will throw an
+	 * {@code UnsupportedOperationException}.
+	 * </p>
+	 * 
+	 * @author Adrien Hopkins
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	private static final class PrefixedUnitMap implements Map<String, Unit> {
+		/**
+		 * The class used for entry sets.
+		 * 
+		 * @author Adrien Hopkins
+		 * @since 2019-04-13
+		 * @since v0.2.0
+		 */
+		private static final class PrefixedUnitEntrySet extends AbstractSet<Map.Entry<String, Unit>> {
+			/**
+			 * The entry for this set.
+			 * 
+			 * @author Adrien Hopkins
+			 * @since 2019-04-14
+			 * @since v0.2.0
+			 */
+			private static final class PrefixedUnitEntry implements Entry<String, Unit> {
+				private final String key;
+				private final Unit value;
+
+				/**
+				 * Creates the {@code PrefixedUnitEntry}.
+				 * 
+				 * @param key
+				 *            key
+				 * @param value
+				 *            value
+				 * @since 2019-04-14
+				 * @since v0.2.0
+				 */
+				public PrefixedUnitEntry(final String key, final Unit value) {
+					this.key = key;
+					this.value = value;
+				}
+
+				@Override
+				public String getKey() {
+					return this.key;
+				}
+
+				@Override
+				public Unit getValue() {
+					return this.value;
+				}
+
+				@Override
+				public Unit setValue(final Unit value) {
+					throw new UnsupportedOperationException();
+				}
+			}
+
+			/**
+			 * An iterator that iterates over the units of a {@code PrefixedUnitNameSet}.
+			 * 
+			 * @author Adrien Hopkins
+			 * @since 2019-04-14
+			 * @since v0.2.0
+			 */
+			private static final class PrefixedUnitEntryIterator implements Iterator<Entry<String, Unit>> {
+				// position in the unit list
+				private int unitNamePosition = 0;
+				// the indices of the prefixes attached to the current unit
+				private final List<Integer> prefixCoordinates = new ArrayList<>();
+
+				// values from the unit entry set
+				private final Map<String, Unit> map;
+				private final List<String> unitNames;
+				private final List<String> prefixNames;
+
+				/**
+				 * Creates the {@code UnitsDatabase.PrefixedUnitMap.PrefixedUnitNameSet.PrefixedUnitNameIterator}.
+				 * 
+				 * @since 2019-04-14
+				 * @since v0.2.0
+				 */
+				public PrefixedUnitEntryIterator(final PrefixedUnitEntrySet set) {
+					this.map = set.map;
+					this.unitNames = new ArrayList<>(set.map.units.keySet());
+					this.prefixNames = new ArrayList<>(set.map.prefixes.keySet());
+				}
+
+				/**
+				 * @return current unit name
+				 * @since 2019-04-14
+				 * @since v0.2.0
+				 */
+				private String getCurrentUnitName() {
+					final StringBuilder unitName = new StringBuilder();
+					for (final int i : this.prefixCoordinates) {
+						unitName.append(this.prefixNames.get(i));
+					}
+					unitName.append(this.unitNames.get(this.unitNamePosition));
+
+					return unitName.toString();
+				}
+
+				@Override
+				public boolean hasNext() {
+					if (this.unitNames.isEmpty())
+						return false;
+					else {
+						if (this.prefixNames.isEmpty())
+							return this.unitNamePosition >= this.unitNames.size() - 1;
+						else
+							return true;
+					}
+				}
+
+				/**
+				 * Changes this iterator's position to the next available one.
+				 * 
+				 * @since 2019-04-14
+				 * @since v0.2.0
+				 */
+				private void incrementPosition() {
+					this.unitNamePosition++;
+
+					if (this.unitNamePosition >= this.unitNames.size()) {
+						// we have used all of our units, go to a different prefix
+						this.unitNamePosition = 0;
+
+						// if the prefix coordinates are empty, then set it to [0]
+						if (this.prefixCoordinates.isEmpty()) {
+							this.prefixCoordinates.add(0, 0);
+						} else {
+							// get the prefix coordinate to increment, then increment
+							int i = this.prefixCoordinates.size() - 1;
+							this.prefixCoordinates.set(i, this.prefixCoordinates.get(i) + 1);
+
+							// fix any carrying errors
+							while (i >= 0 && this.prefixCoordinates.get(i) >= this.prefixNames.size()) {
+								// carry over
+								this.prefixCoordinates.set(i--, 0); // null and decrement at the same time
+
+								if (i < 0) { // we need to add a new coordinate
+									this.prefixCoordinates.add(0, 0);
+								} else { // increment an existing one
+									this.prefixCoordinates.set(i, this.prefixCoordinates.get(i) + 1);
+								}
+							}
+						}
+					}
+				}
+
+				@Override
+				public Entry<String, Unit> next() {
+					if (!this.hasNext())
+						throw new NoSuchElementException("No units left!");
+					// if I have prefixes, ensure I'm not using a nonlinear unit
+					// since all of the unprefixed stuff is done, just remove nonlinear units
+					if (!this.prefixCoordinates.isEmpty()) {
+						while (this.unitNamePosition < this.unitNames.size()
+								&& !(this.map.get(this.unitNames.get(this.unitNamePosition)) instanceof LinearUnit)) {
+							this.unitNames.remove(this.unitNamePosition);
+						}
+					}
+
+					final String nextName = this.getCurrentUnitName();
+
+					this.incrementPosition();
+
+					return new PrefixedUnitEntry(nextName, this.map.get(nextName));
+				}
+			}
+
+			// the map that created this set
+			private final PrefixedUnitMap map;
+
+			/**
+			 * Creates the {@code PrefixedUnitNameSet}.
+			 * 
+			 * @param map
+			 *            map that created this set
+			 * @since 2019-04-13
+			 * @since v0.2.0
+			 */
+			public PrefixedUnitEntrySet(final PrefixedUnitMap map) {
+				this.map = map;
+			}
+
+			@Override
+			public boolean add(final Map.Entry<String, Unit> e) {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public boolean addAll(final Collection<? extends Map.Entry<String, Unit>> c) {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public void clear() {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public boolean contains(final Object o) {
+				// get the entry
+				final Entry<String, Unit> entry;
+
+				try {
+					// This is OK because I'm in a try-catch block.
+					@SuppressWarnings("unchecked")
+					final Entry<String, Unit> tempEntry = (Entry<String, Unit>) o;
+					entry = tempEntry;
+				} catch (final ClassCastException e) {
+					throw new IllegalArgumentException("Attempted to test for an entry using a non-entry.");
+				}
+
+				return this.map.containsKey(entry.getKey()) && this.map.get(entry.getKey()).equals(entry.getValue());
+			}
+
+			@Override
+			public boolean containsAll(final Collection<?> c) {
+				for (final Object o : c)
+					if (!this.contains(o))
+						return false;
+				return true;
+			}
+
+			@Override
+			public boolean isEmpty() {
+				return this.map.isEmpty();
+			}
+
+			@Override
+			public Iterator<Entry<String, Unit>> iterator() {
+				return new PrefixedUnitEntryIterator(this);
+			}
+
+			@Override
+			public boolean remove(final Object o) {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public boolean removeAll(final Collection<?> c) {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public boolean removeIf(final Predicate<? super Entry<String, Unit>> filter) {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public boolean retainAll(final Collection<?> c) {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public int size() {
+				if (this.map.units.isEmpty())
+					return 0;
+				else {
+					if (this.map.prefixes.isEmpty())
+						return this.map.units.size();
+					else
+						// infinite set
+						return Integer.MAX_VALUE;
+				}
+			}
+
+			@Override
+			public Object[] toArray() {
+				if (this.map.units.isEmpty() || this.map.prefixes.isEmpty())
+					return super.toArray();
+				else
+					// infinite set
+					throw new UnsupportedOperationException("Cannot make an infinite set into an array.");
+			}
+
+			@Override
+			public <T> T[] toArray(final T[] a) {
+				if (this.map.units.isEmpty() || this.map.prefixes.isEmpty())
+					return super.toArray(a);
+				else
+					// infinite set
+					throw new UnsupportedOperationException("Cannot make an infinite set into an array.");
+			}
+
+		}
+
+		/**
+		 * The class used for unit name sets.
+		 * 
+		 * @author Adrien Hopkins
+		 * @since 2019-04-13
+		 * @since v0.2.0
+		 */
+		private static final class PrefixedUnitNameSet extends AbstractSet<String> {
+			/**
+			 * An iterator that iterates over the units of a {@code PrefixedUnitNameSet}.
+			 * 
+			 * @author Adrien Hopkins
+			 * @since 2019-04-14
+			 * @since v0.2.0
+			 */
+			private static final class PrefixedUnitNameIterator implements Iterator<String> {
+				// position in the unit list
+				private int unitNamePosition = 0;
+				// the indices of the prefixes attached to the current unit
+				private final List<Integer> prefixCoordinates = new ArrayList<>();
+
+				// values from the unit name set
+				private final Map<String, Unit> map;
+				private final List<String> unitNames;
+				private final List<String> prefixNames;
+
+				/**
+				 * Creates the {@code UnitsDatabase.PrefixedUnitMap.PrefixedUnitNameSet.PrefixedUnitNameIterator}.
+				 * 
+				 * @since 2019-04-14
+				 * @since v0.2.0
+				 */
+				public PrefixedUnitNameIterator(final PrefixedUnitNameSet set) {
+					this.map = set.map;
+					this.unitNames = new ArrayList<>(set.map.units.keySet());
+					this.prefixNames = new ArrayList<>(set.map.prefixes.keySet());
+				}
+
+				/**
+				 * @return current unit name
+				 * @since 2019-04-14
+				 * @since v0.2.0
+				 */
+				private String getCurrentUnitName() {
+					final StringBuilder unitName = new StringBuilder();
+					for (final int i : this.prefixCoordinates) {
+						unitName.append(this.prefixNames.get(i));
+					}
+					unitName.append(this.unitNames.get(this.unitNamePosition));
+
+					return unitName.toString();
+				}
+
+				@Override
+				public boolean hasNext() {
+					if (this.unitNames.isEmpty())
+						return false;
+					else {
+						if (this.prefixNames.isEmpty())
+							return this.unitNamePosition >= this.unitNames.size() - 1;
+						else
+							return true;
+					}
+				}
+
+				/**
+				 * Changes this iterator's position to the next available one.
+				 * 
+				 * @since 2019-04-14
+				 * @since v0.2.0
+				 */
+				private void incrementPosition() {
+					this.unitNamePosition++;
+
+					if (this.unitNamePosition >= this.unitNames.size()) {
+						// we have used all of our units, go to a different prefix
+						this.unitNamePosition = 0;
+
+						// if the prefix coordinates are empty, then set it to [0]
+						if (this.prefixCoordinates.isEmpty()) {
+							this.prefixCoordinates.add(0, 0);
+						} else {
+							// get the prefix coordinate to increment, then increment
+							int i = this.prefixCoordinates.size() - 1;
+							this.prefixCoordinates.set(i, this.prefixCoordinates.get(i) + 1);
+
+							// fix any carrying errors
+							while (i >= 0 && this.prefixCoordinates.get(i) >= this.prefixNames.size()) {
+								// carry over
+								this.prefixCoordinates.set(i--, 0); // null and decrement at the same time
+
+								if (i < 0) { // we need to add a new coordinate
+									this.prefixCoordinates.add(0, 0);
+								} else { // increment an existing one
+									this.prefixCoordinates.set(i, this.prefixCoordinates.get(i) + 1);
+								}
+							}
+						}
+					}
+				}
+
+				@Override
+				public String next() {
+					if (!this.hasNext())
+						throw new NoSuchElementException("No units left!");
+					// if I have prefixes, ensure I'm not using a nonlinear unit
+					// since all of the unprefixed stuff is done, just remove nonlinear units
+					if (!this.prefixCoordinates.isEmpty()) {
+						while (this.unitNamePosition < this.unitNames.size()
+								&& !(this.map.get(this.unitNames.get(this.unitNamePosition)) instanceof LinearUnit)) {
+							this.unitNames.remove(this.unitNamePosition);
+						}
+					}
+
+					final String nextName = this.getCurrentUnitName();
+
+					this.incrementPosition();
+
+					return nextName;
+				}
+			}
+
+			// the map that created this set
+			private final PrefixedUnitMap map;
+
+			/**
+			 * Creates the {@code PrefixedUnitNameSet}.
+			 * 
+			 * @param map
+			 *            map that created this set
+			 * @since 2019-04-13
+			 * @since v0.2.0
+			 */
+			public PrefixedUnitNameSet(final PrefixedUnitMap map) {
+				this.map = map;
+			}
+
+			@Override
+			public boolean add(final String e) {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public boolean addAll(final Collection<? extends String> c) {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public void clear() {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public boolean contains(final Object o) {
+				return this.map.containsKey(o);
+			}
+
+			@Override
+			public boolean containsAll(final Collection<?> c) {
+				for (final Object o : c)
+					if (!this.contains(o))
+						return false;
+				return true;
+			}
+
+			@Override
+			public boolean isEmpty() {
+				return this.map.isEmpty();
+			}
+
+			@Override
+			public Iterator<String> iterator() {
+				return new PrefixedUnitNameIterator(this);
+			}
+
+			@Override
+			public boolean remove(final Object o) {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public boolean removeAll(final Collection<?> c) {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public boolean removeIf(final Predicate<? super String> filter) {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public boolean retainAll(final Collection<?> c) {
+				throw new UnsupportedOperationException();
+			}
+
+			@Override
+			public int size() {
+				if (this.map.units.isEmpty())
+					return 0;
+				else {
+					if (this.map.prefixes.isEmpty())
+						return this.map.units.size();
+					else
+						// infinite set
+						return Integer.MAX_VALUE;
+				}
+			}
+
+			@Override
+			public Object[] toArray() {
+				if (this.map.units.isEmpty() || this.map.prefixes.isEmpty())
+					return super.toArray();
+				else
+					// infinite set
+					throw new UnsupportedOperationException("Cannot make an infinite set into an array.");
+
+			}
+
+			@Override
+			public <T> T[] toArray(final T[] a) {
+				if (this.map.units.isEmpty() || this.map.prefixes.isEmpty())
+					return super.toArray(a);
+				else
+					// infinite set
+					throw new UnsupportedOperationException("Cannot make an infinite set into an array.");
+			}
+		}
+
+		/**
+		 * The units stored in this collection, without prefixes.
+		 * 
+		 * @since 2019-04-13
+		 * @since v0.2.0
+		 */
+		private final Map<String, Unit> units;
+
+		/**
+		 * The available prefixes for use.
+		 * 
+		 * @since 2019-04-13
+		 * @since v0.2.0
+		 */
+		private final Map<String, UnitPrefix> prefixes;
+
+		// caches
+		private Collection<Unit> values = null;
+		private Set<String> keySet = null;
+		private Set<Entry<String, Unit>> entrySet = null;
+
+		/**
+		 * Creates the {@code PrefixedUnitMap}.
+		 * 
+		 * @param units
+		 *            map mapping unit names to units
+		 * @param prefixes
+		 *            map mapping prefix names to prefixes
+		 * @since 2019-04-13
+		 * @since v0.2.0
+		 */
+		public PrefixedUnitMap(final Map<String, Unit> units, final Map<String, UnitPrefix> prefixes) {
+			// I am making unmodifiable maps to ensure I don't accidentally make changes.
+			this.units = Collections.unmodifiableMap(units);
+			this.prefixes = Collections.unmodifiableMap(prefixes);
+		}
+
+		@Override
+		public void clear() {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Unit compute(final String key,
+				final BiFunction<? super String, ? super Unit, ? extends Unit> remappingFunction) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Unit computeIfAbsent(final String key, final Function<? super String, ? extends Unit> mappingFunction) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Unit computeIfPresent(final String key,
+				final BiFunction<? super String, ? super Unit, ? extends Unit> remappingFunction) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public boolean containsKey(final Object key) {
+			// First, test if there is a unit with the key
+			if (this.units.containsKey(key))
+				return true;
+
+			// Next, try to cast it to String
+			if (!(key instanceof String))
+				throw new IllegalArgumentException("Attempted to test for a unit using a non-string name.");
+			final String unitName = (String) key;
+
+			// Then, look for the longest prefix that is attached to a valid unit
+			String longestPrefix = null;
+			int longestLength = 0;
+
+			for (final String prefixName : this.prefixes.keySet()) {
+				// a prefix name is valid if:
+				// - it is prefixed (i.e. the unit name starts with it)
+				// - it is longer than the existing largest prefix (since I am looking for the longest valid prefix)
+				// - the part after the prefix is a valid unit name
+				// - the unit described that name is a linear unit (since only linear units can have prefixes)
+				if (unitName.startsWith(prefixName) && prefixName.length() > longestLength) {
+					final String rest = unitName.substring(prefixName.length());
+					if (this.containsKey(rest) && this.get(rest) instanceof LinearUnit) {
+						longestPrefix = prefixName;
+						longestLength = prefixName.length();
+					}
+				}
+			}
+
+			return longestPrefix != null;
+		}
+
+		@Override
+		public boolean containsValue(final Object value) {
+			return this.units.containsValue(value);
+		}
+
+		@Override
+		public Set<Entry<String, Unit>> entrySet() {
+			if (this.entrySet == null) {
+				this.entrySet = new PrefixedUnitEntrySet(this);
+			}
+			return this.entrySet;
+		}
+
+		@Override
+		public Unit get(final Object key) {
+			// First, test if there is a unit with the key
+			if (this.units.containsKey(key))
+				return this.units.get(key);
+
+			// Next, try to cast it to String
+			if (!(key instanceof String))
+				throw new IllegalArgumentException("Attempted to obtain a unit using a non-string name.");
+			final String unitName = (String) key;
+
+			// Then, look for the longest prefix that is attached to a valid unit
+			String longestPrefix = null;
+			int longestLength = 0;
+
+			for (final String prefixName : this.prefixes.keySet()) {
+				// a prefix name is valid if:
+				// - it is prefixed (i.e. the unit name starts with it)
+				// - it is longer than the existing largest prefix (since I am looking for the longest valid prefix)
+				// - the part after the prefix is a valid unit name
+				// - the unit described that name is a linear unit (since only linear units can have prefixes)
+				if (unitName.startsWith(prefixName) && prefixName.length() > longestLength) {
+					final String rest = unitName.substring(prefixName.length());
+					if (this.containsKey(rest) && this.get(rest) instanceof LinearUnit) {
+						longestPrefix = prefixName;
+						longestLength = prefixName.length();
+					}
+				}
+			}
+
+			// if none found, returns null
+			if (longestPrefix == null)
+				return null;
+			else {
+				// get necessary data
+				final String rest = unitName.substring(longestLength);
+				// this cast will not fail because I verified that it would work before selecting this prefix
+				final LinearUnit unit = (LinearUnit) this.get(rest);
+				final UnitPrefix prefix = this.prefixes.get(longestPrefix);
+
+				return unit.withPrefix(prefix);
+			}
+		}
+
+		@Override
+		public boolean isEmpty() {
+			return this.units.isEmpty();
+		}
+
+		@Override
+		public Set<String> keySet() {
+			if (this.keySet == null) {
+				this.keySet = new PrefixedUnitNameSet(this);
+			}
+			return this.keySet;
+		}
+
+		@Override
+		public Unit merge(final String key, final Unit value,
+				final BiFunction<? super Unit, ? super Unit, ? extends Unit> remappingFunction) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Unit put(final String key, final Unit value) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public void putAll(final Map<? extends String, ? extends Unit> m) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Unit putIfAbsent(final String key, final Unit value) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Unit remove(final Object key) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public boolean remove(final Object key, final Object value) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Unit replace(final String key, final Unit value) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public boolean replace(final String key, final Unit oldValue, final Unit newValue) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public void replaceAll(final BiFunction<? super String, ? super Unit, ? extends Unit> function) {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public int size() {
+			if (this.units.isEmpty())
+				return 0;
+			else {
+				if (this.prefixes.isEmpty())
+					return this.units.size();
+				else
+					// infinite set
+					return Integer.MAX_VALUE;
+			}
+		}
+
+		@Override
+		public Collection<Unit> values() {
+			if (this.values == null) {
+				this.values = Collections.unmodifiableCollection(this.units.values());
+			}
+			return this.values;
+		}
+	}
+
+	/**
+	 * The exponent operator
+	 * 
+	 * @param base
+	 *            base of exponentiation
+	 * @param exponentUnit
+	 *            exponent
+	 * @return result
+	 * @since 2019-04-10
+	 * @since v0.2.0
+	 */
+	private static final LinearUnit exponentiateUnits(final LinearUnit base, final LinearUnit exponentUnit) {
+		// exponent function - first check if o2 is a number,
+		if (exponentUnit.getBase().equals(SI.SI.getBaseUnit(UnitDimension.EMPTY))) {
+			// then check if it is an integer,
+			final double exponent = exponentUnit.getConversionFactor();
+			if (DecimalComparison.equals(exponent % 1, 0))
+				// then exponentiate
+				return base.toExponent((int) (exponent + 0.5));
+			else
+				// not an integer
+				throw new UnsupportedOperationException("Decimal exponents are currently not supported.");
+		} else
+			// not a number
+			throw new IllegalArgumentException("Exponents must be numbers.");
+	}
+
+	/**
+	 * The units in this system, excluding prefixes.
+	 * 
+	 * @since 2019-01-07
+	 * @since v0.1.0
+	 */
+	private final Map<String, Unit> prefixlessUnits;
+
+	/**
+	 * The unit prefixes in this system.
+	 * 
+	 * @since 2019-01-14
+	 * @since v0.1.0
+	 */
+	private final Map<String, UnitPrefix> prefixes;
+
+	/**
+	 * The dimensions in this system.
+	 * 
+	 * @since 2019-03-14
+	 * @since v0.2.0
+	 */
+	private final Map<String, UnitDimension> dimensions;
+
+	/**
+	 * A map mapping strings to units (including prefixes)
+	 * 
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	private final Map<String, Unit> units;
+
+	/**
+	 * A parser that can parse unit expressions.
+	 * 
+	 * @since 2019-03-22
+	 * @since v0.2.0
+	 */
+	private final ExpressionParser<LinearUnit> unitExpressionParser = new ExpressionParser.Builder<>(
+			this::getLinearUnit).addBinaryOperator("+", (o1, o2) -> o1.plus(o2), 0)
+					.addBinaryOperator("-", (o1, o2) -> o1.minus(o2), 0)
+					.addBinaryOperator("*", (o1, o2) -> o1.times(o2), 1).addSpaceFunction("*")
+					.addBinaryOperator("/", (o1, o2) -> o1.dividedBy(o2), 1)
+					.addBinaryOperator("^", UnitsDatabase::exponentiateUnits, 2).build();
+
+	/**
+	 * A parser that can parse unit prefix expressions
+	 * 
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	private final ExpressionParser<UnitPrefix> prefixExpressionParser = new ExpressionParser.Builder<>(this::getPrefix)
+			.addBinaryOperator("*", (o1, o2) -> o1.times(o2), 0).addSpaceFunction("*")
+			.addBinaryOperator("/", (o1, o2) -> o1.dividedBy(o2), 0)
+			.addBinaryOperator("^", (o1, o2) -> o1.toExponent(o2.getMultiplier()), 1).build();
+
+	/**
+	 * A parser that can parse unit dimension expressions.
+	 * 
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	private final ExpressionParser<UnitDimension> unitDimensionParser = new ExpressionParser.Builder<>(
+			this::getDimension).addBinaryOperator("*", (o1, o2) -> o1.times(o2), 0).addSpaceFunction("*")
+					.addBinaryOperator("/", (o1, o2) -> o1.dividedBy(o2), 0).build();
+
+	/**
+	 * Creates the {@code UnitsDatabase}.
+	 * 
+	 * @since 2019-01-10
+	 * @since v0.1.0
+	 */
+	public UnitsDatabase() {
+		this.prefixlessUnits = new HashMap<>();
+		this.prefixes = new HashMap<>();
+		this.dimensions = new HashMap<>();
+		this.units = new PrefixedUnitMap(this.prefixlessUnits, this.prefixes);
+	}
+
+	/**
+	 * Adds a unit dimension to the database.
+	 * 
+	 * @param name
+	 *            dimension's name
+	 * @param dimension
+	 *            dimension to add
+	 * @throws NullPointerException
+	 *             if name or dimension is null
+	 * @since 2019-03-14
+	 * @since v0.2.0
+	 */
+	public void addDimension(final String name, final UnitDimension dimension) {
+		this.dimensions.put(Objects.requireNonNull(name, "name must not be null."),
+				Objects.requireNonNull(dimension, "dimension must not be null."));
+	}
+
+	/**
+	 * Adds to the list from a line in a unit dimension file.
+	 * 
+	 * @param line
+	 *            line to look at
+	 * @param lineCounter
+	 *            number of line, for error messages
+	 * @since 2019-04-10
+	 * @since v0.2.0
+	 */
+	private void addDimensionFromLine(final String line, final long lineCounter) {
+		// ignore lines that start with a # sign - they're comments
+		if (line.isEmpty())
+			return;
+		if (line.contains("#")) {
+			this.addDimensionFromLine(line.substring(0, line.indexOf("#")), lineCounter);
+			return;
+		}
+
+		// divide line into name and expression
+		final String[] parts = line.split("\t");
+		if (parts.length < 2)
+			throw new IllegalArgumentException(String.format(
+					"Lines must consist of a dimension name and its definition, separated by tab(s) (line %d).",
+					lineCounter));
+		final String name = parts[0];
+		final String expression = parts[parts.length - 1];
+
+		if (name.endsWith(" ")) {
+			System.err.printf("Warning - line %d's dimension name ends in a space", lineCounter);
+		}
+
+		// if expression is "!", search for an existing dimension
+		// if no unit found, throw an error
+		if (expression.equals("!")) {
+			if (!this.containsDimensionName(name))
+				throw new IllegalArgumentException(
+						String.format("! used but no dimension found (line %d).", lineCounter));
+		} else {
+			// it's a unit, get the unit
+			final UnitDimension dimension;
+			try {
+				dimension = this.getDimensionFromExpression(expression);
+			} catch (final IllegalArgumentException e) {
+				System.err.printf("Parsing error on line %d:%n", lineCounter);
+				throw e;
+			}
+
+			this.addDimension(name, dimension);
+		}
+	}
+
+	/**
+	 * Adds a unit prefix to the database.
+	 * 
+	 * @param name
+	 *            prefix's name
+	 * @param prefix
+	 *            prefix to add
+	 * @throws NullPointerException
+	 *             if name or prefix is null
+	 * @since 2019-01-14
+	 * @since v0.1.0
+	 */
+	public void addPrefix(final String name, final UnitPrefix prefix) {
+		this.prefixes.put(Objects.requireNonNull(name, "name must not be null."),
+				Objects.requireNonNull(prefix, "prefix must not be null."));
+	}
+
+	/**
+	 * Adds a unit to the database.
+	 * 
+	 * @param name
+	 *            unit's name
+	 * @param unit
+	 *            unit to add
+	 * @throws NullPointerException
+	 *             if unit is null
+	 * @since 2019-01-10
+	 * @since v0.1.0
+	 */
+	public void addUnit(final String name, final Unit unit) {
+		this.prefixlessUnits.put(Objects.requireNonNull(name, "name must not be null."),
+				Objects.requireNonNull(unit, "unit must not be null."));
+	}
+
+	/**
+	 * Adds to the list from a line in a unit file.
+	 * 
+	 * @param line
+	 *            line to look at
+	 * @param lineCounter
+	 *            number of line, for error messages
+	 * @since 2019-04-10
+	 * @since v0.2.0
+	 */
+	private void addUnitOrPrefixFromLine(final String line, final long lineCounter) {
+		// ignore lines that start with a # sign - they're comments
+		if (line.isEmpty())
+			return;
+		if (line.contains("#")) {
+			this.addUnitOrPrefixFromLine(line.substring(0, line.indexOf("#")), lineCounter);
+			return;
+		}
+
+		// divide line into name and expression
+		final String[] parts = line.split("\t");
+		if (parts.length < 2)
+			throw new IllegalArgumentException(String.format(
+					"Lines must consist of a unit name and its definition, separated by tab(s) (line %d).",
+					lineCounter));
+		final String name = parts[0];
+		final String expression = parts[parts.length - 1];
+
+		if (name.endsWith(" ")) {
+			System.err.printf("Warning - line %d's unit name ends in a space", lineCounter);
+		}
+
+		// if expression is "!", search for an existing unit
+		// if no unit found, throw an error
+		if (expression.equals("!")) {
+			if (!this.containsUnitName(name))
+				throw new IllegalArgumentException(String.format("! used but no unit found (line %d).", lineCounter));
+		} else {
+			if (name.endsWith("-")) {
+				final UnitPrefix prefix;
+				try {
+					prefix = this.getPrefixFromExpression(expression);
+				} catch (final IllegalArgumentException e) {
+					System.err.printf("Parsing error on line %d:%n", lineCounter);
+					throw e;
+				}
+				this.addPrefix(name.substring(0, name.length() - 1), prefix);
+			} else {
+				// it's a unit, get the unit
+				final Unit unit;
+				try {
+					unit = this.getUnitFromExpression(expression);
+				} catch (final IllegalArgumentException e) {
+					System.err.printf("Parsing error on line %d:%n", lineCounter);
+					throw e;
+				}
+
+				this.addUnit(name, unit);
+			}
+		}
+	}
+
+	/**
+	 * Tests if the database has a unit dimension with this name.
+	 * 
+	 * @param name
+	 *            name to test
+	 * @return if database contains name
+	 * @since 2019-03-14
+	 * @since v0.2.0
+	 */
+	public boolean containsDimensionName(final String name) {
+		return this.dimensions.containsKey(name);
+	}
+
+	/**
+	 * Tests if the database has a unit prefix with this name.
+	 * 
+	 * @param name
+	 *            name to test
+	 * @return if database contains name
+	 * @since 2019-01-13
+	 * @since v0.1.0
+	 */
+	public boolean containsPrefixName(final String name) {
+		return this.prefixes.containsKey(name);
+	}
+
+	/**
+	 * Tests if the database has a unit with this name, taking prefixes into consideration
+	 * 
+	 * @param name
+	 *            name to test
+	 * @return if database contains name
+	 * @since 2019-01-13
+	 * @since v0.1.0
+	 */
+	public boolean containsUnitName(final String name) {
+		return this.units.containsKey(name);
+	}
+
+	/**
+	 * @return a map mapping dimension names to dimensions
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	public Map<String, UnitDimension> dimensionMap() {
+		return Collections.unmodifiableMap(this.dimensions);
+	}
+
+	/**
+	 * Gets a unit dimension from the database using its name.
+	 * 
+	 * <p>
+	 * This method accepts exponents, like "L^3"
+	 * </p>
+	 * 
+	 * @param name
+	 *            dimension's name
+	 * @return dimension
+	 * @since 2019-03-14
+	 * @since v0.2.0
+	 */
+	public UnitDimension getDimension(final String name) {
+		Objects.requireNonNull(name, "name must not be null.");
+		if (name.contains("^")) {
+			final String[] baseAndExponent = name.split("\\^");
+
+			final UnitDimension base = this.getDimension(baseAndExponent[0]);
+
+			final int exponent;
+			try {
+				exponent = Integer.parseInt(baseAndExponent[baseAndExponent.length - 1]);
+			} catch (final NumberFormatException e2) {
+				throw new IllegalArgumentException("Exponent must be an integer.");
+			}
+
+			return base.toExponent(exponent);
+		}
+		return this.dimensions.get(name);
+	}
+
+	/**
+	 * Uses the database's data to parse an expression into a unit dimension
+	 * <p>
+	 * The expression is a series of any of the following:
+	 * <ul>
+	 * <li>The name of a unit dimension, which multiplies or divides the result based on preceding operators</li>
+	 * <li>The operators '*' and '/', which multiply and divide (note that just putting two unit dimensions next to each
+	 * other is equivalent to multiplication)</li>
+	 * <li>The operator '^' which exponentiates. Exponents must be integers.</li>
+	 * </ul>
+	 * 
+	 * @param expression
+	 *            expression to parse
+	 * @throws IllegalArgumentException
+	 *             if the expression cannot be parsed
+	 * @throws NullPointerException
+	 *             if expression is null
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	public UnitDimension getDimensionFromExpression(final String expression) {
+		Objects.requireNonNull(expression, "expression must not be null.");
+
+		// attempt to get a dimension as an alias first
+		if (this.containsDimensionName(expression))
+			return this.getDimension(expression);
+
+		// force operators to have spaces
+		String modifiedExpression = expression;
+		modifiedExpression = modifiedExpression.replaceAll("\\*", " \\* ");
+		modifiedExpression = modifiedExpression.replaceAll("/", " / ");
+		modifiedExpression = modifiedExpression.replaceAll(" *\\^ *", "\\^");
+
+		// fix broken spaces
+		modifiedExpression = modifiedExpression.replaceAll(" +", " ");
+
+		return this.unitDimensionParser.parseExpression(modifiedExpression);
+	}
+
+	/**
+	 * Gets a unit. If it is linear, cast it to a LinearUnit and return it. Otherwise, throw an
+	 * {@code IllegalArgumentException}.
+	 * 
+	 * @param name
+	 *            unit's name
+	 * @return unit
+	 * @since 2019-03-22
+	 * @since v0.2.0
+	 */
+	private LinearUnit getLinearUnit(final String name) {
+		// see if I am using a function-unit like tempC(100)
+		if (name.contains("(") && name.contains(")")) {
+			// break it into function name and value
+			final List<String> parts = Arrays.asList(name.split("\\("));
+			if (parts.size() != 2)
+				throw new IllegalArgumentException("Format nonlinear units like: unit(value).");
+
+			// solve the function
+			final Unit unit = this.getUnit(parts.get(0));
+			final double value = Double.parseDouble(parts.get(1).substring(0, parts.get(1).length() - 1));
+			return unit.getBase().times(unit.convertToBase(value));
+		} else {
+			// get a linear unit
+			final Unit unit = this.getUnit(name);
+			if (unit instanceof LinearUnit)
+				return (LinearUnit) unit;
+			else
+				throw new IllegalArgumentException(String.format("%s is not a linear unit.", name));
+		}
+	}
+
+	/**
+	 * Gets a unit prefix from the database from its name
+	 * 
+	 * @param name
+	 *            prefix's name
+	 * @return prefix
+	 * @since 2019-01-10
+	 * @since v0.1.0
+	 */
+	public UnitPrefix getPrefix(final String name) {
+		try {
+			return new DefaultUnitPrefix(Double.parseDouble(name));
+		} catch (final NumberFormatException e) {
+			return this.prefixes.get(name);
+		}
+	}
+
+	/**
+	 * Gets a unit prefix from a prefix expression
+	 * <p>
+	 * Currently, prefix expressions are much simpler than unit expressions: They are either a number or the name of
+	 * another prefix
+	 * </p>
+	 * 
+	 * @param expression
+	 *            expression to input
+	 * @return prefix
+	 * @throws IllegalArgumentException
+	 *             if expression cannot be parsed
+	 * @throws NullPointerException
+	 *             if any argument is null
+	 * @since 2019-01-14
+	 * @since v0.1.0
+	 */
+	public UnitPrefix getPrefixFromExpression(final String expression) {
+		Objects.requireNonNull(expression, "expression must not be null.");
+
+		// attempt to get a unit as an alias first
+		if (this.containsUnitName(expression))
+			return this.getPrefix(expression);
+
+		// force operators to have spaces
+		String modifiedExpression = expression;
+		modifiedExpression = modifiedExpression.replaceAll("\\*", " \\* ");
+		modifiedExpression = modifiedExpression.replaceAll("/", " / ");
+		modifiedExpression = modifiedExpression.replaceAll("\\^", " \\^ ");
+
+		// fix broken spaces
+		modifiedExpression = modifiedExpression.replaceAll(" +", " ");
+
+		return this.prefixExpressionParser.parseExpression(modifiedExpression);
+	}
+
+	/**
+	 * Gets a unit from the database from its name, looking for prefixes.
+	 * 
+	 * @param name
+	 *            unit's name
+	 * @return unit
+	 * @since 2019-01-10
+	 * @since v0.1.0
+	 */
+	public Unit getUnit(final String name) {
+		try {
+			final double value = Double.parseDouble(name);
+			return SI.SI.getBaseUnit(UnitDimension.EMPTY).times(value);
+		} catch (final NumberFormatException e) {
+			return this.units.get(name);
+		}
+
+	}
+
+	/**
+	 * Uses the database's unit data to parse an expression into a unit
+	 * <p>
+	 * The expression is a series of any of the following:
+	 * <ul>
+	 * <li>The name of a unit, which multiplies or divides the result based on preceding operators</li>
+	 * <li>The operators '*' and '/', which multiply and divide (note that just putting two units or values next to each
+	 * other is equivalent to multiplication)</li>
+	 * <li>The operator '^' which exponentiates. Exponents must be integers.</li>
+	 * <li>A number which is multiplied or divided</li>
+	 * </ul>
+	 * This method only works with linear units.
+	 * 
+	 * @param expression
+	 *            expression to parse
+	 * @throws IllegalArgumentException
+	 *             if the expression cannot be parsed
+	 * @throws NullPointerException
+	 *             if expression is null
+	 * @since 2019-01-07
+	 * @since v0.1.0
+	 */
+	public Unit getUnitFromExpression(final String expression) {
+		Objects.requireNonNull(expression, "expression must not be null.");
+
+		// attempt to get a unit as an alias first
+		if (this.containsUnitName(expression))
+			return this.getUnit(expression);
+
+		// force operators to have spaces
+		String modifiedExpression = expression;
+		modifiedExpression = modifiedExpression.replaceAll("\\+", " \\+ ");
+		modifiedExpression = modifiedExpression.replaceAll("-", " - ");
+		modifiedExpression = modifiedExpression.replaceAll("\\*", " \\* ");
+		modifiedExpression = modifiedExpression.replaceAll("/", " / ");
+		modifiedExpression = modifiedExpression.replaceAll("\\^", " \\^ ");
+
+		// fix broken spaces
+		modifiedExpression = modifiedExpression.replaceAll(" +", " ");
+
+		// the previous operation breaks negative numbers, fix them!
+		// (i.e. -2 becomes - 2)
+		for (int i = 2; i < modifiedExpression.length(); i++) {
+			if (modifiedExpression.charAt(i) == '-'
+					&& Arrays.asList('+', '-', '*', '/', '^').contains(modifiedExpression.charAt(i - 2))) {
+				// found a broken negative number
+				modifiedExpression = modifiedExpression.substring(0, i + 1) + modifiedExpression.substring(i + 2);
+			}
+		}
+
+		return this.unitExpressionParser.parseExpression(modifiedExpression);
+	}
+
+	/**
+	 * Adds all dimensions from a file, using data from the database to parse them.
+	 * <p>
+	 * Each line in the file should consist of a name and an expression (parsed by getDimensionFromExpression) separated
+	 * by any number of tab characters.
+	 * <p>
+	 * <p>
+	 * Allowed exceptions:
+	 * <ul>
+	 * <li>Anything after a '#' character is considered a comment and ignored.</li>
+	 * <li>Blank lines are also ignored</li>
+	 * <li>If an expression consists of a single exclamation point, instead of parsing it, this method will search the
+	 * database for an existing unit. If no unit is found, an IllegalArgumentException is thrown. This is used to define
+	 * initial units and ensure that the database contains them.</li>
+	 * </ul>
+	 * 
+	 * @param file
+	 *            file to read
+	 * @throws IllegalArgumentException
+	 *             if the file cannot be parsed, found or read
+	 * @throws NullPointerException
+	 *             if file is null
+	 * @since 2019-01-13
+	 * @since v0.1.0
+	 */
+	public void loadDimensionFile(final File file) {
+		Objects.requireNonNull(file, "file must not be null.");
+		try (FileReader fileReader = new FileReader(file); BufferedReader reader = new BufferedReader(fileReader)) {
+			// while the reader has lines to read, read a line, then parse it, then add it
+			long lineCounter = 0;
+			while (reader.ready()) {
+				this.addDimensionFromLine(reader.readLine(), ++lineCounter);
+			}
+		} catch (final FileNotFoundException e) {
+			throw new IllegalArgumentException("Could not find file " + file, e);
+		} catch (final IOException e) {
+			throw new IllegalArgumentException("Could not read file " + file, e);
+		}
+	}
+
+	/**
+	 * Adds all units from a file, using data from the database to parse them.
+	 * <p>
+	 * Each line in the file should consist of a name and an expression (parsed by getUnitFromExpression) separated by
+	 * any number of tab characters.
+	 * <p>
+	 * <p>
+	 * Allowed exceptions:
+	 * <ul>
+	 * <li>Anything after a '#' character is considered a comment and ignored.</li>
+	 * <li>Blank lines are also ignored</li>
+	 * <li>If an expression consists of a single exclamation point, instead of parsing it, this method will search the
+	 * database for an existing unit. If no unit is found, an IllegalArgumentException is thrown. This is used to define
+	 * initial units and ensure that the database contains them.</li>
+	 * </ul>
+	 * 
+	 * @param file
+	 *            file to read
+	 * @throws IllegalArgumentException
+	 *             if the file cannot be parsed, found or read
+	 * @throws NullPointerException
+	 *             if file is null
+	 * @since 2019-01-13
+	 * @since v0.1.0
+	 */
+	public void loadUnitsFile(final File file) {
+		Objects.requireNonNull(file, "file must not be null.");
+		try (FileReader fileReader = new FileReader(file); BufferedReader reader = new BufferedReader(fileReader)) {
+			// while the reader has lines to read, read a line, then parse it, then add it
+			long lineCounter = 0;
+			while (reader.ready()) {
+				this.addUnitOrPrefixFromLine(reader.readLine(), ++lineCounter);
+			}
+		} catch (final FileNotFoundException e) {
+			throw new IllegalArgumentException("Could not find file " + file, e);
+		} catch (final IOException e) {
+			throw new IllegalArgumentException("Could not read file " + file, e);
+		}
+	}
+
+	/**
+	 * @return a map mapping prefix names to prefixes
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	public Map<String, UnitPrefix> prefixMap() {
+		return Collections.unmodifiableMap(this.prefixes);
+	}
+
+	/**
+	 * @return a map mapping unit names to units, including prefixed names
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	public Map<String, Unit> unitMap() {
+		return this.units; // PrefixedUnitMap is immutable so I don't need to make an unmodifiable map.
+	}
+
+	/**
+	 * @return a map mapping unit names to units, ignoring prefixes
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	public Map<String, Unit> unitMapPrefixless() {
+		return Collections.unmodifiableMap(this.prefixlessUnits);
+	}
+}
diff --git a/src/unitConverter/converterGUI/DelegateListModel.java b/src/org/unitConverter/converterGUI/DelegateListModel.java
index 0e9b342..b80f63d 100755
--- a/src/unitConverter/converterGUI/DelegateListModel.java
+++ b/src/org/unitConverter/converterGUI/DelegateListModel.java
@@ -14,8 +14,9 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-package unitConverter.converterGUI;
+package org.unitConverter.converterGUI;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
@@ -50,6 +51,15 @@ final class DelegateListModel<E> extends AbstractListModel<E> implements List<E>
 	private final List<E> delegate;
 
 	/**
+	 * Creates an empty {@code DelegateListModel}.
+	 * 
+	 * @since 2019-04-13
+	 */
+	public DelegateListModel() {
+		this(new ArrayList<>());
+	}
+
+	/**
 	 * Creates the {@code DelegateListModel}.
 	 * 
 	 * @param delegate
diff --git a/src/unitConverter/converterGUI/FilterComparator.java b/src/org/unitConverter/converterGUI/FilterComparator.java
index 27ec3ab..7b17bfc 100755
--- a/src/unitConverter/converterGUI/FilterComparator.java
+++ b/src/org/unitConverter/converterGUI/FilterComparator.java
@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU Affero General Public License

  * along with this program.  If not, see <https://www.gnu.org/licenses/>.

  */

-package unitConverter.converterGUI;

+package org.unitConverter.converterGUI;

 

 import java.util.Comparator;

 import java.util.Objects;

@@ -26,7 +26,7 @@ import java.util.Objects;
  * @since 2019-01-15

  * @since v0.1.0

  */

-public final class FilterComparator implements Comparator<String> {

+final class FilterComparator implements Comparator<String> {

 	/**

 	 * The filter that the comparator is filtered by.

 	 * 

@@ -41,6 +41,13 @@ public final class FilterComparator implements Comparator<String> {
 	 * @since v0.1.0

 	 */

 	private final Comparator<String> comparator;

+	/**

+	 * Whether or not the comparison is case-sensitive.

+	 * 

+	 * @since 2019-04-14

+	 * @since v0.2.0

+	 */

+	private final boolean caseSensitive;

 

 	/**

 	 * Creates the {@code FilterComparator}.

@@ -60,34 +67,63 @@ public final class FilterComparator implements Comparator<String> {
 	 *            string to filter by

 	 * @param comparator

 	 *            comparator to fall back to if all else fails, null is compareTo.

+	 * @throws NullPointerException

+	 *             if filter is null

 	 * @since 2019-01-15

 	 * @since v0.1.0

+	 */

+	public FilterComparator(final String filter, final Comparator<String> comparator) {

+		this(filter, comparator, false);

+	}

+

+	/**

+	 * Creates the {@code FilterComparator}.

+	 * 

+	 * @param filter

+	 *            string to filter by

+	 * @param comparator

+	 *            comparator to fall back to if all else fails, null is compareTo.

+	 * @param caseSensitive

+	 *            whether or not the comparator is case-sensitive

 	 * @throws NullPointerException

 	 *             if filter is null

+	 * @since 2019-04-14

+	 * @since v0.2.0

 	 */

-	public FilterComparator(final String filter, final Comparator<String> comparator) {

+	public FilterComparator(final String filter, final Comparator<String> comparator, final boolean caseSensitive) {

 		this.filter = Objects.requireNonNull(filter, "filter must not be null.");

 		this.comparator = comparator;

+		this.caseSensitive = caseSensitive;

 	}

 

 	@Override

 	public int compare(final String arg0, final String arg1) {

+		// if this is case insensitive, make them lowercase

+		final String str0, str1;

+		if (this.caseSensitive) {

+			str0 = arg0;

+			str1 = arg1;

+		} else {

+			str0 = arg0.toLowerCase();

+			str1 = arg1.toLowerCase();

+		}

+

 		// elements that start with the filter always go first

-		if (arg0.startsWith(this.filter) && !arg1.startsWith(this.filter))

+		if (str0.startsWith(this.filter) && !str1.startsWith(this.filter))

 			return -1;

-		else if (!arg0.startsWith(this.filter) && arg1.startsWith(this.filter))

+		else if (!str0.startsWith(this.filter) && str1.startsWith(this.filter))

 			return 1;

 

 		// elements that contain the filter but don't start with them go next

-		if (arg0.contains(this.filter) && !arg1.contains(this.filter))

+		if (str0.contains(this.filter) && !str1.contains(this.filter))

 			return -1;

-		else if (!arg0.contains(this.filter) && !arg1.contains(this.filter))

+		else if (!str0.contains(this.filter) && !str1.contains(this.filter))

 			return 1;

 

 		// other elements go last

 		if (this.comparator == null)

-			return arg0.compareTo(arg1);

+			return str0.compareTo(str1);

 		else

-			return this.comparator.compare(arg0, arg1);

+			return this.comparator.compare(str0, str1);

 	}

 }

diff --git a/src/unitConverter/converterGUI/GridBagBuilder.java b/src/org/unitConverter/converterGUI/GridBagBuilder.java
index e036677..f1229b2 100755
--- a/src/unitConverter/converterGUI/GridBagBuilder.java
+++ b/src/org/unitConverter/converterGUI/GridBagBuilder.java
@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-package unitConverter.converterGUI;
+package org.unitConverter.converterGUI;
 
 import java.awt.GridBagConstraints;
 import java.awt.Insets;
diff --git a/src/org/unitConverter/converterGUI/MutablePredicate.java b/src/org/unitConverter/converterGUI/MutablePredicate.java
new file mode 100644
index 0000000..e15b3cd
--- /dev/null
+++ b/src/org/unitConverter/converterGUI/MutablePredicate.java
@@ -0,0 +1,70 @@
+/**
+ * Copyright (C) 2019 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.unitConverter.converterGUI;
+
+import java.util.function.Predicate;
+
+/**
+ * A container for a predicate, which can be changed later.
+ * 
+ * @author Adrien Hopkins
+ * @since 2019-04-13
+ * @since v0.2.0
+ */
+final class MutablePredicate<T> implements Predicate<T> {
+	/**
+	 * The predicate stored in this {@code MutablePredicate}
+	 * 
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	private Predicate<T> predicate;
+
+	/**
+	 * Creates the {@code MutablePredicate}.
+	 * 
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	public MutablePredicate(final Predicate<T> predicate) {
+		this.predicate = predicate;
+	}
+
+	/**
+	 * @return predicate
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	public final Predicate<T> getPredicate() {
+		return this.predicate;
+	}
+
+	/**
+	 * @param predicate
+	 *            new value of predicate
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	public final void setPredicate(final Predicate<T> predicate) {
+		this.predicate = predicate;
+	}
+
+	@Override
+	public boolean test(final T t) {
+		return this.predicate.test(t);
+	}
+}
diff --git a/src/org/unitConverter/converterGUI/SearchBoxList.java b/src/org/unitConverter/converterGUI/SearchBoxList.java
new file mode 100644
index 0000000..1995466
--- /dev/null
+++ b/src/org/unitConverter/converterGUI/SearchBoxList.java
@@ -0,0 +1,297 @@
+/**
+ * Copyright (C) 2019 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.unitConverter.converterGUI;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.function.Predicate;
+
+import javax.swing.JList;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextField;
+
+/**
+ * @author Adrien Hopkins
+ * @since 2019-04-13
+ * @since v0.2.0
+ */
+final class SearchBoxList extends JPanel {
+
+	/**
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	private static final long serialVersionUID = 6226930279415983433L;
+
+	/**
+	 * The text to place in an empty search box.
+	 * 
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	private static final String EMPTY_TEXT = "Search...";
+
+	/**
+	 * The color to use for an empty foreground.
+	 * 
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	private static final Color EMPTY_FOREGROUND = new Color(192, 192, 192);
+
+	// the components
+	private final Collection<String> itemsToFilter;
+	private final DelegateListModel<String> listModel;
+	private final JTextField searchBox;
+	private final JList<String> searchItems;
+
+	private boolean searchBoxEmpty = true;
+
+	// I need to do this because, for some reason, Swing is auto-focusing my search box without triggering a focus
+	// event.
+	private boolean searchBoxFocused = false;
+
+	private Predicate<String> customSearchFilter = o -> true;
+	private final Comparator<String> defaultOrdering;
+	private final boolean caseSensitive;
+
+	/**
+	 * Creates the {@code SearchBoxList}.
+	 * 
+	 * @param itemsToFilter
+	 *            items to put in the list
+	 * @since 2019-04-14
+	 */
+	public SearchBoxList(final Collection<String> itemsToFilter) {
+		this(itemsToFilter, null, false);
+	}
+
+	/**
+	 * Creates the {@code SearchBoxList}.
+	 * 
+	 * @param itemsToFilter
+	 *            items to put in the list
+	 * @param defaultOrdering
+	 *            default ordering of items after filtration (null=Comparable)
+	 * @param caseSensitive
+	 *            whether or not the filtration is case-sensitive
+	 * 
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	public SearchBoxList(final Collection<String> itemsToFilter, final Comparator<String> defaultOrdering,
+			final boolean caseSensitive) {
+		super(new BorderLayout(), true);
+		this.itemsToFilter = itemsToFilter;
+		this.defaultOrdering = defaultOrdering;
+		this.caseSensitive = caseSensitive;
+
+		// create the components
+		this.listModel = new DelegateListModel<>(new ArrayList<>(itemsToFilter));
+		this.searchItems = new JList<>(this.listModel);
+
+		this.searchBox = new JTextField(EMPTY_TEXT);
+		this.searchBox.setForeground(EMPTY_FOREGROUND);
+
+		// add them to the panel
+		this.add(this.searchBox, BorderLayout.PAGE_START);
+		this.add(new JScrollPane(this.searchItems), BorderLayout.CENTER);
+
+		// set up the search box
+		this.searchBox.addFocusListener(new FocusListener() {
+			@Override
+			public void focusGained(final FocusEvent e) {
+				SearchBoxList.this.searchBoxFocusGained(e);
+			}
+
+			@Override
+			public void focusLost(final FocusEvent e) {
+				SearchBoxList.this.searchBoxFocusLost(e);
+			}
+		});
+
+		this.searchBox.addCaretListener(e -> this.searchBoxTextChanged());
+		this.searchBoxEmpty = true;
+	}
+
+	/**
+	 * Adds an additional filter for searching.
+	 * 
+	 * @param filter
+	 *            filter to add.
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	public void addSearchFilter(final Predicate<String> filter) {
+		this.customSearchFilter = this.customSearchFilter.and(filter);
+	}
+
+	/**
+	 * Resets the search filter.
+	 * 
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	public void clearSearchFilters() {
+		this.customSearchFilter = o -> true;
+	}
+
+	/**
+	 * @return this component's search box component
+	 * @since 2019-04-14
+	 * @since v0.2.0
+	 */
+	public final JTextField getSearchBox() {
+		return this.searchBox;
+	}
+
+	/**
+	 * @param searchText
+	 *            text to search for
+	 * @return a filter that filters out that text, based on this list's case sensitive setting
+	 * @since 2019-04-14
+	 * @since v0.2.0
+	 */
+	private Predicate<String> getSearchFilter(final String searchText) {
+		if (this.caseSensitive)
+			return string -> string.contains(searchText);
+		else
+			return string -> string.toLowerCase().contains(searchText.toLowerCase());
+	}
+
+	/**
+	 * @return this component's list component
+	 * @since 2019-04-14
+	 * @since v0.2.0
+	 */
+	public final JList<String> getSearchList() {
+		return this.searchItems;
+	}
+
+	/**
+	 * @return index selected in item list
+	 * @since 2019-04-14
+	 * @since v0.2.0
+	 */
+	public int getSelectedIndex() {
+		return this.searchItems.getSelectedIndex();
+	}
+
+	/**
+	 * @return value selected in item list
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	public String getSelectedValue() {
+		return this.searchItems.getSelectedValue();
+	}
+
+	/**
+	 * Re-applies the filters.
+	 * 
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	public void reapplyFilter() {
+		final String searchText = this.searchBoxEmpty ? "" : this.searchBox.getText();
+		final FilterComparator comparator = new FilterComparator(searchText, this.defaultOrdering, this.caseSensitive);
+		final Predicate<String> searchFilter = this.getSearchFilter(searchText);
+
+		this.listModel.clear();
+		this.itemsToFilter.forEach(string -> {
+			if (searchFilter.test(string)) {
+				this.listModel.add(string);
+			}
+		});
+
+		// applies the custom filters
+		this.listModel.removeIf(this.customSearchFilter.negate());
+
+		// sorts the remaining items
+		this.listModel.sort(comparator);
+	}
+
+	/**
+	 * Runs whenever the search box gains focus.
+	 * 
+	 * @param e
+	 *            focus event
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	private void searchBoxFocusGained(final FocusEvent e) {
+		this.searchBoxFocused = true;
+		if (this.searchBoxEmpty) {
+			this.searchBox.setText("");
+			this.searchBox.setForeground(Color.BLACK);
+		}
+	}
+
+	/**
+	 * Runs whenever the search box loses focus.
+	 * 
+	 * @param e
+	 *            focus event
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	private void searchBoxFocusLost(final FocusEvent e) {
+		this.searchBoxFocused = false;
+		if (this.searchBoxEmpty) {
+			this.searchBox.setText(EMPTY_TEXT);
+			this.searchBox.setForeground(EMPTY_FOREGROUND);
+		}
+	}
+
+	/**
+	 * Runs whenever the text in the search box is changed.
+	 * <p>
+	 * Reapplies the search filter, and custom filters.
+	 * </p>
+	 * 
+	 * @since 2019-04-14
+	 * @since v0.2.0
+	 */
+	private void searchBoxTextChanged() {
+		if (this.searchBoxFocused) {
+			this.searchBoxEmpty = this.searchBox.getText().equals("");
+		}
+		final String searchText = this.searchBoxEmpty ? "" : this.searchBox.getText();
+		final FilterComparator comparator = new FilterComparator(searchText, this.defaultOrdering, this.caseSensitive);
+		final Predicate<String> searchFilter = this.getSearchFilter(searchText);
+
+		// initialize list with items that match the filter then sort
+		this.listModel.clear();
+		this.itemsToFilter.forEach(string -> {
+			if (searchFilter.test(string)) {
+				this.listModel.add(string);
+			}
+		});
+
+		// applies the custom filters
+		this.listModel.removeIf(this.customSearchFilter.negate());
+
+		// sorts the remaining items
+		this.listModel.sort(comparator);
+	}
+}
diff --git a/src/org/unitConverter/converterGUI/UnitConverterGUI.java b/src/org/unitConverter/converterGUI/UnitConverterGUI.java
new file mode 100755
index 0000000..e258c6f
--- /dev/null
+++ b/src/org/unitConverter/converterGUI/UnitConverterGUI.java
@@ -0,0 +1,827 @@
+/**
+ * Copyright (C) 2018 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.unitConverter.converterGUI;
+
+import java.awt.BorderLayout;
+import java.awt.GridLayout;
+import java.io.File;
+import java.math.BigDecimal;
+import java.math.MathContext;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Predicate;
+
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JFormattedTextField;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.JTabbedPane;
+import javax.swing.JTextArea;
+import javax.swing.JTextField;
+
+import org.unitConverter.UnitsDatabase;
+import org.unitConverter.dimension.StandardDimensions;
+import org.unitConverter.dimension.UnitDimension;
+import org.unitConverter.unit.BaseUnit;
+import org.unitConverter.unit.NonlinearUnits;
+import org.unitConverter.unit.SI;
+import org.unitConverter.unit.Unit;
+import org.unitConverter.unit.UnitPrefix;
+
+/**
+ * @author Adrien Hopkins
+ * @since 2018-12-27
+ * @since v0.1.0
+ */
+final class UnitConverterGUI {
+	private static class Presenter {
+		/**
+		 * Adds default units and dimensions to a database.
+		 * 
+		 * @param database
+		 *            database to add to
+		 * @since 2019-04-14
+		 * @since v0.2.0
+		 */
+		private static void addDefaults(final UnitsDatabase database) {
+			database.addUnit("metre", SI.METRE);
+			database.addUnit("kilogram", SI.KILOGRAM);
+			database.addUnit("gram", SI.KILOGRAM.dividedBy(1000));
+			database.addUnit("second", SI.SECOND);
+			database.addUnit("ampere", SI.AMPERE);
+			database.addUnit("kelvin", SI.KELVIN);
+			database.addUnit("mole", SI.MOLE);
+			database.addUnit("candela", SI.CANDELA);
+			database.addUnit("bit", SI.SI.getBaseUnit(StandardDimensions.INFORMATION));
+			database.addUnit("unit", SI.SI.getBaseUnit(UnitDimension.EMPTY));
+			// nonlinear units - must be loaded manually
+			database.addUnit("tempCelsius", NonlinearUnits.CELSIUS);
+			database.addUnit("tempFahrenheit", NonlinearUnits.FAHRENHEIT);
+
+			// load initial dimensions
+			database.addDimension("LENGTH", StandardDimensions.LENGTH);
+			database.addDimension("MASS", StandardDimensions.MASS);
+			database.addDimension("TIME", StandardDimensions.TIME);
+			database.addDimension("TEMPERATURE", StandardDimensions.TEMPERATURE);
+		}
+
+		/** The presenter's associated view. */
+		private final View view;
+
+		/** The units known by the program. */
+		private final UnitsDatabase database;
+
+		/** The names of all of the units */
+		private final List<String> unitNames;
+
+		/** The names of all of the prefixes */
+		private final List<String> prefixNames;
+
+		/** The names of all of the dimensions */
+		private final List<String> dimensionNames;
+
+		private final Comparator<String> prefixNameComparator;
+
+		private int significantFigures = 6;
+
+		/**
+		 * Creates the presenter.
+		 * 
+		 * @param view
+		 *            presenter's associated view
+		 * @since 2018-12-27
+		 * @since v0.1.0
+		 */
+		Presenter(final View view) {
+			this.view = view;
+
+			// load initial units
+			this.database = new UnitsDatabase();
+			Presenter.addDefaults(this.database);
+
+			this.database.loadUnitsFile(new File("unitsfile.txt"));
+			this.database.loadDimensionFile(new File("dimensionfile.txt"));
+
+			// a comparator that can be used to compare prefix names
+			// any name that does not exist is less than a name that does.
+			// otherwise, they are compared by value
+			this.prefixNameComparator = (o1, o2) -> {
+				if (!Presenter.this.database.containsPrefixName(o1))
+					return -1;
+				else if (!Presenter.this.database.containsPrefixName(o2))
+					return 1;
+
+				final UnitPrefix p1 = Presenter.this.database.getPrefix(o1);
+				final UnitPrefix p2 = Presenter.this.database.getPrefix(o2);
+
+				if (p1.getMultiplier() < p2.getMultiplier())
+					return -1;
+				else if (p1.getMultiplier() > p2.getMultiplier())
+					return 1;
+
+				return o1.compareTo(o2);
+			};
+
+			this.unitNames = new ArrayList<>(this.database.unitMapPrefixless().keySet());
+			this.unitNames.sort(null); // sorts it using Comparable
+
+			this.prefixNames = new ArrayList<>(this.database.prefixMap().keySet());
+			this.prefixNames.sort(this.prefixNameComparator); // sorts it using my comparator
+
+			this.dimensionNames = new DelegateListModel<>(new ArrayList<>(this.database.dimensionMap().keySet()));
+			this.dimensionNames.sort(null); // sorts it using Comparable
+
+			// a Predicate that returns true iff the argument is a full base unit
+			final Predicate<Unit> isFullBase = unit -> unit instanceof BaseUnit && ((BaseUnit) unit).isFullBase();
+
+			// print out unit counts
+			System.out.printf("Successfully loaded %d units with %d unit names (%d base units).%n",
+					new HashSet<>(this.database.unitMapPrefixless().values()).size(),
+					this.database.unitMapPrefixless().size(),
+					new HashSet<>(this.database.unitMapPrefixless().values()).stream().filter(isFullBase).count());
+		}
+
+		/**
+		 * Converts in the dimension-based converter
+		 * 
+		 * @since 2019-04-13
+		 * @since v0.2.0
+		 */
+		public final void convertDimensionBased() {
+			final String fromSelection = this.view.getFromSelection();
+			if (fromSelection == null) {
+				this.view.showErrorDialog("Error", "No unit selected in From field");
+				return;
+			}
+			final String toSelection = this.view.getToSelection();
+			if (toSelection == null) {
+				this.view.showErrorDialog("Error", "No unit selected in To field");
+				return;
+			}
+
+			final Unit from = this.database.getUnit(fromSelection);
+			final Unit to = this.database.getUnit(toSelection);
+
+			final String input = this.view.getDimensionConverterInput();
+			if (input.equals("")) {
+				this.view.showErrorDialog("Error", "No value to convert entered.");
+				return;
+			}
+			final double beforeValue = Double.parseDouble(input);
+			final double value = to.convertFromBase(from.convertToBase(beforeValue));
+
+			final String output = this.getRoundedString(value);
+
+			this.view.setDimensionConverterOutputText(
+					String.format("%s %s = %s %s", input, fromSelection, output, toSelection));
+		}
+
+		/**
+		 * Runs whenever the convert button is pressed.
+		 * 
+		 * <p>
+		 * Reads and parses a unit expression from the from and to boxes, then converts {@code from} to {@code to}. Any
+		 * errors are shown in JOptionPanes.
+		 * </p>
+		 * 
+		 * @since 2019-01-26
+		 * @since v0.1.0
+		 */
+		public final void convertExpressions() {
+			final String fromUnitString = this.view.getFromText();
+			final String toUnitString = this.view.getToText();
+
+			if (fromUnitString.isEmpty()) {
+				this.view.showErrorDialog("Parse Error", "Please enter a unit expression in the From: box.");
+				return;
+			}
+			if (toUnitString.isEmpty()) {
+				this.view.showErrorDialog("Parse Error", "Please enter a unit expression in the To: box.");
+				return;
+			}
+
+			// try to parse from
+			final Unit from;
+			try {
+				from = this.database.getUnitFromExpression(fromUnitString);
+			} catch (final IllegalArgumentException e) {
+				this.view.showErrorDialog("Parse Error", "Could not recognize text in From entry: " + e.getMessage());
+				return;
+			}
+
+			final double value;
+			// try to parse to
+			final Unit to;
+			try {
+				if (this.database.containsUnitName(toUnitString)) {
+					// if it's a unit, convert to that
+					to = this.database.getUnit(toUnitString);
+				} else {
+					to = this.database.getUnitFromExpression(toUnitString);
+				}
+			} catch (final IllegalArgumentException e) {
+				this.view.showErrorDialog("Parse Error", "Could not recognize text in To entry: " + e.getMessage());
+				return;
+			}
+
+			// if I can't convert, leave
+			if (!from.canConvertTo(to)) {
+				this.view.showErrorDialog("Conversion Error",
+						String.format("Cannot convert between %s and %s", fromUnitString, toUnitString));
+				return;
+			}
+
+			value = to.convertFromBase(from.convertToBase(1));
+
+			// round value
+			final String output = this.getRoundedString(value);
+
+			this.view.setExpressionConverterOutputText(
+					String.format("%s = %s %s", fromUnitString, output, toUnitString));
+		}
+
+		/**
+		 * @return a list of all of the unit dimensions
+		 * @since 2019-04-13
+		 * @since v0.2.0
+		 */
+		public final List<String> dimensionNameList() {
+			return this.dimensionNames;
+		}
+
+		/**
+		 * @return a comparator to compare prefix names
+		 * @since 2019-04-14
+		 * @since v0.2.0
+		 */
+		public final Comparator<String> getPrefixNameComparator() {
+			return this.prefixNameComparator;
+		}
+
+		/**
+		 * @param value
+		 *            value to round
+		 * @return string of that value rounded to {@code significantDigits} significant digits.
+		 * @since 2019-04-14
+		 * @since v0.2.0
+		 */
+		private final String getRoundedString(final double value) {
+			// round value
+			final BigDecimal bigValue = new BigDecimal(value).round(new MathContext(this.significantFigures));
+			String output = bigValue.toString();
+
+			// remove trailing zeroes
+			if (output.contains(".")) {
+				while (output.endsWith("0")) {
+					output = output.substring(0, output.length() - 1);
+				}
+				if (output.endsWith(".")) {
+					output = output.substring(0, output.length() - 1);
+				}
+			}
+
+			return output;
+		}
+
+		/**
+		 * @return a set of all prefix names in the database
+		 * @since 2019-04-14
+		 * @since v0.2.0
+		 */
+		public final Set<String> prefixNameSet() {
+			return this.database.prefixMap().keySet();
+		}
+
+		/**
+		 * Runs whenever a prefix is selected in the viewer.
+		 * <p>
+		 * Shows its information in the text box to the right.
+		 * </p>
+		 * 
+		 * @since 2019-01-15
+		 * @since v0.1.0
+		 */
+		public final void prefixSelected() {
+			final String prefixName = this.view.getPrefixViewerSelection();
+			if (prefixName == null)
+				return;
+			else {
+				final UnitPrefix prefix = this.database.getPrefix(prefixName);
+
+				this.view.setPrefixTextBoxText(String.format("%s%nMultiplier: %s", prefixName, prefix.getMultiplier()));
+			}
+		}
+
+		/**
+		 * @param significantFigures
+		 *            new value of significantFigures
+		 * @since 2019-01-15
+		 * @since v0.1.0
+		 */
+		public final void setSignificantFigures(final int significantFigures) {
+			this.significantFigures = significantFigures;
+		}
+
+		/**
+		 * Returns true if and only if the unit represented by {@code unitName} has the dimension represented by
+		 * {@code dimensionName}.
+		 * 
+		 * @param unitName
+		 *            name of unit to test
+		 * @param dimensionName
+		 *            name of dimension to test
+		 * @return whether unit has dimenision
+		 * @since 2019-04-13
+		 * @since v0.2.0
+		 */
+		public final boolean unitMatchesDimension(final String unitName, final String dimensionName) {
+			final Unit unit = this.database.getUnit(unitName);
+			final UnitDimension dimension = this.database.getDimension(dimensionName);
+			return unit.getDimension().equals(dimension);
+		}
+
+		/**
+		 * Runs whenever a unit is selected in the viewer.
+		 * <p>
+		 * Shows its information in the text box to the right.
+		 * </p>
+		 * 
+		 * @since 2019-01-15
+		 * @since v0.1.0
+		 */
+		public final void unitNameSelected() {
+			final String unitName = this.view.getUnitViewerSelection();
+			if (unitName == null)
+				return;
+			else {
+				final Unit unit = this.database.getUnit(unitName);
+
+				this.view.setUnitTextBoxText(unit.toString());
+			}
+		}
+
+		/**
+		 * @return a set of all of the unit names
+		 * @since 2019-04-14
+		 * @since v0.2.0
+		 */
+		public final Set<String> unitNameSet() {
+			return this.database.unitMapPrefixless().keySet();
+		}
+	}
+
+	private static class View {
+		/** The view's frame. */
+		private final JFrame frame;
+		/** The view's associated presenter. */
+		private final Presenter presenter;
+
+		// DIMENSION-BASED CONVERTER
+		/** The panel for inputting values in the dimension-based converter */
+		private final JTextField valueInput;
+		/** The panel for "From" in the dimension-based converter */
+		private final SearchBoxList fromSearch;
+		/** The panel for "To" in the dimension-based converter */
+		private final SearchBoxList toSearch;
+		/** The output area in the dimension-based converter */
+		private final JTextArea dimensionBasedOutput;
+
+		// EXPRESSION-BASED CONVERTER
+		/** The "From" entry in the conversion panel */
+		private final JTextField fromEntry;
+		/** The "To" entry in the conversion panel */
+		private final JTextField toEntry;
+		/** The output area in the conversion panel */
+		private final JTextArea output;
+
+		// UNIT AND PREFIX VIEWERS
+		/** The searchable list of unit names in the unit viewer */
+		private final SearchBoxList unitNameList;
+		/** The searchable list of prefix names in the prefix viewer */
+		private final SearchBoxList prefixNameList;
+		/** The text box for unit data in the unit viewer */
+		private final JTextArea unitTextBox;
+		/** The text box for prefix data in the prefix viewer */
+		private final JTextArea prefixTextBox;
+
+		/**
+		 * Creates the {@code View}.
+		 * 
+		 * @since 2019-01-14
+		 * @since v0.1.0
+		 */
+		public View() {
+			this.presenter = new Presenter(this);
+			this.frame = new JFrame("Unit Converter");
+			this.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+			// create the components
+			this.unitNameList = new SearchBoxList(this.presenter.unitNameSet());
+			this.prefixNameList = new SearchBoxList(this.presenter.prefixNameSet(),
+					this.presenter.getPrefixNameComparator(), true);
+			this.unitTextBox = new JTextArea();
+			this.prefixTextBox = new JTextArea();
+			this.fromSearch = new SearchBoxList(this.presenter.unitNameSet());
+			this.toSearch = new SearchBoxList(this.presenter.unitNameSet());
+			this.valueInput = new JFormattedTextField(new DecimalFormat("###############0.################"));
+			this.dimensionBasedOutput = new JTextArea(2, 32);
+			this.fromEntry = new JTextField();
+			this.toEntry = new JTextField();
+			this.output = new JTextArea(2, 32);
+
+			// create more components
+			this.initComponents();
+
+			this.frame.pack();
+		}
+
+		/**
+		 * @return value in dimension-based converter
+		 * @since 2019-04-13
+		 * @since v0.2.0
+		 */
+		public String getDimensionConverterInput() {
+			return this.valueInput.getText();
+		}
+
+		/**
+		 * @return selection in "From" selector in dimension-based converter
+		 * @since 2019-04-13
+		 * @since v0.2.0
+		 */
+		public String getFromSelection() {
+			return this.fromSearch.getSelectedValue();
+		}
+
+		/**
+		 * @return text in "From" box in converter panel
+		 * @since 2019-01-15
+		 * @since v0.1.0
+		 */
+		public String getFromText() {
+			return this.fromEntry.getText();
+		}
+
+		/**
+		 * @return index of selected prefix in prefix viewer
+		 * @since 2019-01-15
+		 * @since v0.1.0
+		 */
+		public String getPrefixViewerSelection() {
+			return this.prefixNameList.getSelectedValue();
+		}
+
+		/**
+		 * @return selection in "To" selector in dimension-based converter
+		 * @since 2019-04-13
+		 * @since v0.2.0
+		 */
+		public String getToSelection() {
+			return this.toSearch.getSelectedValue();
+		}
+
+		/**
+		 * @return text in "To" box in converter panel
+		 * @since 2019-01-26
+		 * @since v0.1.0
+		 */
+		public String getToText() {
+			return this.toEntry.getText();
+		}
+
+		/**
+		 * @return index of selected unit in unit viewer
+		 * @since 2019-01-15
+		 * @since v0.1.0
+		 */
+		public String getUnitViewerSelection() {
+			return this.unitNameList.getSelectedValue();
+		}
+
+		/**
+		 * Starts up the application.
+		 * 
+		 * @since 2018-12-27
+		 * @since v0.1.0
+		 */
+		public final void init() {
+			this.frame.setVisible(true);
+		}
+
+		/**
+		 * Initializes the view's components.
+		 * 
+		 * @since 2018-12-27
+		 * @since v0.1.0
+		 */
+		private final void initComponents() {
+			final JPanel masterPanel = new JPanel();
+			this.frame.add(masterPanel);
+
+			masterPanel.setLayout(new BorderLayout());
+
+			{ // pane with all of the tabs
+				final JTabbedPane masterPane = new JTabbedPane();
+				masterPanel.add(masterPane, BorderLayout.CENTER);
+
+				{ // a panel for unit conversion using a selector
+					final JPanel convertUnitPanel = new JPanel();
+					masterPane.addTab("Convert Units", convertUnitPanel);
+
+					convertUnitPanel.setLayout(new BorderLayout());
+
+					{ // panel for input part
+						final JPanel inputPanel = new JPanel();
+						convertUnitPanel.add(inputPanel, BorderLayout.CENTER);
+
+						inputPanel.setLayout(new GridLayout(1, 3));
+
+						final JComboBox<String> dimensionSelector = new JComboBox<>(
+								this.presenter.dimensionNameList().toArray(new String[0]));
+						dimensionSelector.setSelectedItem("LENGTH");
+
+						// handle dimension filter
+						final MutablePredicate<String> dimensionFilter = new MutablePredicate<>(s -> true);
+
+						// panel for From things
+						inputPanel.add(this.fromSearch);
+
+						this.fromSearch.addSearchFilter(dimensionFilter);
+
+						{ // for dimension selector and arrow that represents conversion
+							final JPanel inBetweenPanel = new JPanel();
+							inputPanel.add(inBetweenPanel);
+
+							inBetweenPanel.setLayout(new BorderLayout());
+
+							{ // dimension selector
+								inBetweenPanel.add(dimensionSelector, BorderLayout.PAGE_START);
+							}
+
+							{ // the arrow in the middle
+								final JLabel arrowLabel = new JLabel("->");
+								inBetweenPanel.add(arrowLabel, BorderLayout.CENTER);
+							}
+						}
+
+						// panel for To things
+
+						inputPanel.add(this.toSearch);
+
+						this.toSearch.addSearchFilter(dimensionFilter);
+
+						// code for dimension filter
+						dimensionSelector.addItemListener(e -> {
+							dimensionFilter.setPredicate(string -> View.this.presenter.unitMatchesDimension(string,
+									(String) dimensionSelector.getSelectedItem()));
+							this.fromSearch.reapplyFilter();
+							this.toSearch.reapplyFilter();
+						});
+
+						// apply the item listener once because I have a default selection
+						dimensionFilter.setPredicate(string -> View.this.presenter.unitMatchesDimension(string,
+								(String) dimensionSelector.getSelectedItem()));
+						this.fromSearch.reapplyFilter();
+						this.toSearch.reapplyFilter();
+					}
+
+					{ // panel for submit and output, and also value entry
+						final JPanel outputPanel = new JPanel();
+						convertUnitPanel.add(outputPanel, BorderLayout.PAGE_END);
+
+						outputPanel.setLayout(new GridLayout(3, 1));
+
+						{ // unit input
+							final JPanel valueInputPanel = new JPanel();
+							outputPanel.add(valueInputPanel);
+
+							valueInputPanel.setLayout(new BorderLayout());
+
+							{ // prompt
+								final JLabel valuePrompt = new JLabel("Value to convert: ");
+								valueInputPanel.add(valuePrompt, BorderLayout.LINE_START);
+							}
+
+							{ // value to convert
+								valueInputPanel.add(this.valueInput, BorderLayout.CENTER);
+							}
+						}
+
+						{ // button to convert
+							final JButton convertButton = new JButton("Convert");
+							outputPanel.add(convertButton);
+
+							convertButton.addActionListener(e -> this.presenter.convertDimensionBased());
+						}
+
+						{ // output of conversion
+							outputPanel.add(this.dimensionBasedOutput);
+							this.dimensionBasedOutput.setEditable(false);
+						}
+					}
+				}
+
+				{ // panel for unit conversion using expressions
+					final JPanel convertExpressionPanel = new JPanel();
+					masterPane.addTab("Convert Unit Expressions", convertExpressionPanel);
+
+					convertExpressionPanel.setLayout(new GridLayout(5, 1));
+
+					{ // panel for units to convert from
+						final JPanel fromPanel = new JPanel();
+						convertExpressionPanel.add(fromPanel);
+
+						fromPanel.setBorder(BorderFactory.createTitledBorder("From"));
+						fromPanel.setLayout(new GridLayout(1, 1));
+
+						{ // entry for units
+							fromPanel.add(this.fromEntry);
+						}
+					}
+
+					{ // panel for units to convert to
+						final JPanel toPanel = new JPanel();
+						convertExpressionPanel.add(toPanel);
+
+						toPanel.setBorder(BorderFactory.createTitledBorder("To"));
+						toPanel.setLayout(new GridLayout(1, 1));
+
+						{ // entry for units
+							toPanel.add(this.toEntry);
+						}
+					}
+
+					{ // button to convert
+						final JButton convertButton = new JButton("Convert!");
+						convertExpressionPanel.add(convertButton);
+
+						convertButton.addActionListener(e -> this.presenter.convertExpressions());
+					}
+
+					{ // output of conversion
+						final JPanel outputPanel = new JPanel();
+						convertExpressionPanel.add(outputPanel);
+
+						outputPanel.setBorder(BorderFactory.createTitledBorder("Output"));
+						outputPanel.setLayout(new GridLayout(1, 1));
+
+						{ // output
+							outputPanel.add(this.output);
+							this.output.setEditable(false);
+						}
+					}
+
+					{ // panel for specifying precision
+						final JPanel sigDigPanel = new JPanel();
+						convertExpressionPanel.add(sigDigPanel);
+
+						sigDigPanel.setBorder(BorderFactory.createTitledBorder("Significant Digits"));
+
+						{ // slider
+							final JSlider sigDigSlider = new JSlider(0, 12);
+							sigDigPanel.add(sigDigSlider);
+
+							sigDigSlider.setMajorTickSpacing(4);
+							sigDigSlider.setMinorTickSpacing(1);
+							sigDigSlider.setSnapToTicks(true);
+							sigDigSlider.setPaintTicks(true);
+							sigDigSlider.setPaintLabels(true);
+
+							sigDigSlider.addChangeListener(
+									e -> this.presenter.setSignificantFigures(sigDigSlider.getValue()));
+						}
+					}
+				}
+
+				{ // panel to look up units
+					final JPanel unitLookupPanel = new JPanel();
+					masterPane.addTab("Unit Viewer", unitLookupPanel);
+
+					unitLookupPanel.setLayout(new GridLayout());
+
+					{ // search panel
+						unitLookupPanel.add(this.unitNameList);
+
+						this.unitNameList.getSearchList()
+								.addListSelectionListener(e -> this.presenter.unitNameSelected());
+					}
+
+					{ // the text box for unit's toString
+						unitLookupPanel.add(this.unitTextBox);
+						this.unitTextBox.setEditable(false);
+						this.unitTextBox.setLineWrap(true);
+					}
+				}
+
+				{ // panel to look up prefixes
+					final JPanel prefixLookupPanel = new JPanel();
+					masterPane.addTab("Prefix Viewer", prefixLookupPanel);
+
+					prefixLookupPanel.setLayout(new GridLayout(1, 2));
+
+					{ // panel for listing and seaching
+						prefixLookupPanel.add(this.prefixNameList);
+
+						this.prefixNameList.getSearchList()
+								.addListSelectionListener(e -> this.presenter.prefixSelected());
+					}
+
+					{ // the text box for prefix's toString
+						prefixLookupPanel.add(this.prefixTextBox);
+						this.prefixTextBox.setEditable(false);
+						this.prefixTextBox.setLineWrap(true);
+					}
+				}
+			}
+		}
+
+		/**
+		 * Sets the text in the output of the dimension-based converter.
+		 * 
+		 * @param text
+		 *            text to set
+		 * @since 2019-04-13
+		 * @since v0.2.0
+		 */
+		public void setDimensionConverterOutputText(final String text) {
+			this.dimensionBasedOutput.setText(text);
+		}
+
+		/**
+		 * Sets the text in the output of the conversion panel.
+		 * 
+		 * @param text
+		 *            text to set
+		 * @since 2019-01-15
+		 * @since v0.1.0
+		 */
+		public void setExpressionConverterOutputText(final String text) {
+			this.output.setText(text);
+		}
+
+		/**
+		 * Sets the text of the prefix text box in the prefix viewer.
+		 * 
+		 * @param text
+		 *            text to set
+		 * @since 2019-01-15
+		 * @since v0.1.0
+		 */
+		public void setPrefixTextBoxText(final String text) {
+			this.prefixTextBox.setText(text);
+		}
+
+		/**
+		 * Sets the text of the unit text box in the unit viewer.
+		 * 
+		 * @param text
+		 *            text to set
+		 * @since 2019-01-15
+		 * @since v0.1.0
+		 */
+		public void setUnitTextBoxText(final String text) {
+			this.unitTextBox.setText(text);
+		}
+
+		/**
+		 * Shows an error dialog.
+		 * 
+		 * @param title
+		 *            title of dialog
+		 * @param message
+		 *            message in dialog
+		 * @since 2019-01-14
+		 * @since v0.1.0
+		 */
+		public void showErrorDialog(final String title, final String message) {
+			JOptionPane.showMessageDialog(this.frame, message, title, JOptionPane.ERROR_MESSAGE);
+		}
+	}
+
+	public static void main(final String[] args) {
+		new View().init();
+	}
+}
diff --git a/src/unitConverter/converterGUI/package-info.java b/src/org/unitConverter/converterGUI/package-info.java
index 9f7fa57..1555291 100644
--- a/src/unitConverter/converterGUI/package-info.java
+++ b/src/org/unitConverter/converterGUI/package-info.java
@@ -19,5 +19,6 @@
  * 
  * @author Adrien Hopkins
  * @since 2019-01-25
+ * @since v0.2.0
  */
-package unitConverter.converterGUI;
\ No newline at end of file
+package org.unitConverter.converterGUI;
\ No newline at end of file
diff --git a/src/unitConverter/dimension/BaseDimension.java b/src/org/unitConverter/dimension/BaseDimension.java
index 0c09dce..5e3ddad 100755
--- a/src/unitConverter/dimension/BaseDimension.java
+++ b/src/org/unitConverter/dimension/BaseDimension.java
@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-package unitConverter.dimension;
+package org.unitConverter.dimension;
 
 /**
  * A base dimension that makes up {@code UnitDimension} objects.
diff --git a/src/unitConverter/dimension/OtherBaseDimension.java b/src/org/unitConverter/dimension/OtherBaseDimension.java
index 8c6d25d..8aea2b9 100755
--- a/src/unitConverter/dimension/OtherBaseDimension.java
+++ b/src/org/unitConverter/dimension/OtherBaseDimension.java
@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-package unitConverter.dimension;
+package org.unitConverter.dimension;
 
 import java.util.Objects;
 
diff --git a/src/unitConverter/dimension/SIBaseDimension.java b/src/org/unitConverter/dimension/SIBaseDimension.java
index 928d8d6..c459963 100755
--- a/src/unitConverter/dimension/SIBaseDimension.java
+++ b/src/org/unitConverter/dimension/SIBaseDimension.java
@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU Affero General Public License

  * along with this program.  If not, see <https://www.gnu.org/licenses/>.

  */

-package unitConverter.dimension;

+package org.unitConverter.dimension;

 

 import java.util.Objects;

 

diff --git a/src/unitConverter/dimension/StandardDimensions.java b/src/org/unitConverter/dimension/StandardDimensions.java
index b3edb7d..4b1b814 100755
--- a/src/unitConverter/dimension/StandardDimensions.java
+++ b/src/org/unitConverter/dimension/StandardDimensions.java
@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU Affero General Public License

  * along with this program.  If not, see <https://www.gnu.org/licenses/>.

  */

-package unitConverter.dimension;

+package org.unitConverter.dimension;

 

 /**

  * All of the dimensions that are used by the SI.

diff --git a/src/unitConverter/dimension/UnitDimension.java b/src/org/unitConverter/dimension/UnitDimension.java
index 40e5bbc..dbeaeff 100755
--- a/src/unitConverter/dimension/UnitDimension.java
+++ b/src/org/unitConverter/dimension/UnitDimension.java
@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU Affero General Public License

  * along with this program.  If not, see <https://www.gnu.org/licenses/>.

  */

-package unitConverter.dimension;

+package org.unitConverter.dimension;

 

 import java.util.ArrayList;

 import java.util.HashMap;

diff --git a/src/unitConverter/dimension/package-info.java b/src/org/unitConverter/dimension/package-info.java
index 74895ce..8cb26b1 100755
--- a/src/unitConverter/dimension/package-info.java
+++ b/src/org/unitConverter/dimension/package-info.java
@@ -19,5 +19,6 @@
  * 
  * @author Adrien Hopkins
  * @since 2018-12-22
+ * @since v0.1.0
  */
-package unitConverter.dimension;
\ No newline at end of file
+package org.unitConverter.dimension;
\ No newline at end of file
diff --git a/src/org/unitConverter/math/DecimalComparison.java b/src/org/unitConverter/math/DecimalComparison.java
new file mode 100644
index 0000000..7cdbe5b
--- /dev/null
+++ b/src/org/unitConverter/math/DecimalComparison.java
@@ -0,0 +1,114 @@
+/**
+ * Copyright (C) 2019 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.unitConverter.math;
+
+/**
+ * A class that contains methods to compare float and double values.
+ * 
+ * @author Adrien Hopkins
+ * @since 2019-03-18
+ * @since v0.2.0
+ */
+public final class DecimalComparison {
+	/**
+	 * The value used for double comparison. If two double values are within this value multiplied by the larger value,
+	 * they are considered equal.
+	 * 
+	 * @since 2019-03-18
+	 * @since v0.2.0
+	 */
+	public static final double DOUBLE_EPSILON = 1.0e-15;
+
+	/**
+	 * The value used for float comparison. If two float values are within this value multiplied by the larger value,
+	 * they are considered equal.
+	 * 
+	 * @since 2019-03-18
+	 * @since v0.2.0
+	 */
+	public static final float FLOAT_EPSILON = 1.0e-6f;
+
+	/**
+	 * Tests for equality of double values using {@link #DOUBLE_EPSILON}.
+	 * 
+	 * @param a
+	 *            first value to test
+	 * @param b
+	 *            second value to test
+	 * @return whether they are equal
+	 * @since 2019-03-18
+	 * @since v0.2.0
+	 */
+	public static final boolean equals(final double a, final double b) {
+		return DecimalComparison.equals(a, b, DOUBLE_EPSILON);
+	}
+
+	/**
+	 * Tests for double equality using a custom epsilon value.
+	 * 
+	 * @param a
+	 *            first value to test
+	 * @param b
+	 *            second value to test
+	 * @param epsilon
+	 *            allowed difference
+	 * @return whether they are equal
+	 * @since 2019-03-18
+	 * @since v0.2.0
+	 */
+	public static final boolean equals(final double a, final double b, final double epsilon) {
+		return Math.abs(a - b) <= epsilon * Math.max(Math.abs(a), Math.abs(b));
+	}
+
+	/**
+	 * Tests for equality of float values using {@link #FLOAT_EPSILON}.
+	 * 
+	 * @param a
+	 *            first value to test
+	 * @param b
+	 *            second value to test
+	 * @return whether they are equal
+	 * @since 2019-03-18
+	 * @since v0.2.0
+	 */
+	public static final boolean equals(final float a, final float b) {
+		return DecimalComparison.equals(a, b, FLOAT_EPSILON);
+	}
+
+	/**
+	 * Tests for float equality using a custom epsilon value.
+	 * 
+	 * @param a
+	 *            first value to test
+	 * @param b
+	 *            second value to test
+	 * @param epsilon
+	 *            allowed difference
+	 * @return whether they are equal
+	 * @since 2019-03-18
+	 * @since v0.2.0
+	 */
+	public static final boolean equals(final float a, final float b, final float epsilon) {
+		return Math.abs(a - b) <= epsilon * Math.max(Math.abs(a), Math.abs(b));
+	}
+
+	// You may NOT get any DecimalComparison instances
+	private DecimalComparison() {
+		throw new AssertionError();
+	}
+
+}
diff --git a/src/org/unitConverter/math/ExpressionParser.java b/src/org/unitConverter/math/ExpressionParser.java
new file mode 100644
index 0000000..b2261ed
--- /dev/null
+++ b/src/org/unitConverter/math/ExpressionParser.java
@@ -0,0 +1,708 @@
+/**
+ * Copyright (C) 2019 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.unitConverter.math;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.function.UnaryOperator;
+
+/**
+ * An object that can parse expressions with unary or binary operators.
+ * 
+ * @author Adrien Hopkins
+ * @param <T>
+ *            type of object that exists in parsed expressions
+ * @since 2019-03-14
+ * @since v0.2.0
+ */
+public final class ExpressionParser<T> {
+	/**
+	 * A builder that can create {@code ExpressionParser<T>} instances.
+	 * 
+	 * @author Adrien Hopkins
+	 * @param <T>
+	 *            type of object that exists in parsed expressions
+	 * @since 2019-03-17
+	 * @since v0.2.0
+	 */
+	public static final class Builder<T> {
+		/**
+		 * A function that obtains a parseable object from a string. For example, an integer {@code ExpressionParser}
+		 * would use {@code Integer::parseInt}.
+		 * 
+		 * @since 2019-03-14
+		 * @since v0.2.0
+		 */
+		private final Function<String, T> objectObtainer;
+
+		/**
+		 * The function of the space as an operator (like 3 x y)
+		 * 
+		 * @since 2019-03-22
+		 * @since v0.2.0
+		 */
+		private String spaceFunction = null;
+
+		/**
+		 * A map mapping operator strings to operator functions, for unary operators.
+		 * 
+		 * @since 2019-03-14
+		 * @since v0.2.0
+		 */
+		private final Map<String, PriorityUnaryOperator<T>> unaryOperators;
+
+		/**
+		 * A map mapping operator strings to operator functions, for binary operators.
+		 * 
+		 * @since 2019-03-14
+		 * @since v0.2.0
+		 */
+		private final Map<String, PriorityBinaryOperator<T>> binaryOperators;
+
+		/**
+		 * Creates the {@code Builder}.
+		 * 
+		 * @param objectObtainer
+		 *            a function that can turn strings into objects of the type handled by the parser.
+		 * @throws NullPointerException
+		 *             if {@code objectObtainer} is null
+		 * @since 2019-03-17
+		 * @since v0.2.0
+		 */
+		public Builder(final Function<String, T> objectObtainer) {
+			this.objectObtainer = Objects.requireNonNull(objectObtainer, "objectObtainer must not be null.");
+			this.unaryOperators = new HashMap<>();
+			this.binaryOperators = new HashMap<>();
+		}
+
+		/**
+		 * Adds a binary operator to the builder.
+		 * 
+		 * @param text
+		 *            text used to reference the operator, like '+'
+		 * @param operator
+		 *            operator to add
+		 * @param priority
+		 *            operator's priority, which determines which operators are applied first
+		 * @return this builder
+		 * @throws NullPointerException
+		 *             if {@code text} or {@code operator} is null
+		 * @since 2019-03-17
+		 * @since v0.2.0
+		 */
+		public Builder<T> addBinaryOperator(final String text, final BinaryOperator<T> operator, final int priority) {
+			Objects.requireNonNull(text, "text must not be null.");
+			Objects.requireNonNull(operator, "operator must not be null.");
+
+			// Unfortunately, I cannot use a lambda because the PriorityBinaryOperator requires arguments.
+			final PriorityBinaryOperator<T> priorityOperator = new PriorityBinaryOperator<T>(priority) {
+				@Override
+				public T apply(final T t, final T u) {
+					return operator.apply(t, u);
+				}
+
+			};
+			this.binaryOperators.put(text, priorityOperator);
+			return this;
+		}
+
+		/**
+		 * Adds a function for spaces. You must use the text of an existing binary operator.
+		 * 
+		 * @param operator
+		 *            text of operator to use
+		 * @return this builder
+		 * @since 2019-03-22
+		 * @since v0.2.0
+		 */
+		public Builder<T> addSpaceFunction(final String operator) {
+			Objects.requireNonNull(operator, "operator must not be null.");
+
+			if (!this.binaryOperators.containsKey(operator))
+				throw new IllegalArgumentException(String.format("Could not find binary operator '%s'", operator));
+
+			this.spaceFunction = operator;
+			return this;
+		}
+
+		/**
+		 * Adds a unary operator to the builder.
+		 * 
+		 * @param text
+		 *            text used to reference the operator, like '-'
+		 * @param operator
+		 *            operator to add
+		 * @param priority
+		 *            operator's priority, which determines which operators are applied first
+		 * @return this builder
+		 * @throws NullPointerException
+		 *             if {@code text} or {@code operator} is null
+		 * @since 2019-03-17
+		 * @since v0.2.0
+		 */
+		public Builder<T> addUnaryOperator(final String text, final UnaryOperator<T> operator, final int priority) {
+			Objects.requireNonNull(text, "text must not be null.");
+			Objects.requireNonNull(operator, "operator must not be null.");
+
+			// Unfortunately, I cannot use a lambda because the PriorityUnaryOperator requires arguments.
+			final PriorityUnaryOperator<T> priorityOperator = new PriorityUnaryOperator<T>(priority) {
+				@Override
+				public T apply(final T t) {
+					return operator.apply(t);
+				}
+			};
+			this.unaryOperators.put(text, priorityOperator);
+			return this;
+		}
+
+		/**
+		 * @return an {@code ExpressionParser<T>} instance with the properties given to this builder
+		 * @since 2019-03-17
+		 * @since v0.2.0
+		 */
+		public ExpressionParser<T> build() {
+			return new ExpressionParser<>(this.objectObtainer, this.unaryOperators, this.binaryOperators,
+					this.spaceFunction);
+		}
+	}
+
+	/**
+	 * A binary operator with a priority field that determines which operators apply first.
+	 * 
+	 * @author Adrien Hopkins
+	 * @param <T>
+	 *            type of operand and result
+	 * @since 2019-03-17
+	 * @since v0.2.0
+	 */
+	private static abstract class PriorityBinaryOperator<T>
+			implements BinaryOperator<T>, Comparable<PriorityBinaryOperator<T>> {
+		/**
+		 * The operator's priority. Higher-priority operators are applied before lower-priority operators
+		 * 
+		 * @since 2019-03-17
+		 * @since v0.2.0
+		 */
+		private final int priority;
+
+		/**
+		 * Creates the {@code PriorityBinaryOperator}.
+		 * 
+		 * @param priority
+		 *            operator's priority
+		 * @since 2019-03-17
+		 * @since v0.2.0
+		 */
+		public PriorityBinaryOperator(final int priority) {
+			this.priority = priority;
+		}
+
+		/**
+		 * Compares this object to another by priority.
+		 * 
+		 * <p>
+		 * {@inheritDoc}
+		 * </p>
+		 * 
+		 * @since 2019-03-17
+		 * @since v0.2.0
+		 */
+		@Override
+		public int compareTo(final PriorityBinaryOperator<T> o) {
+			if (this.priority < o.priority)
+				return -1;
+			else if (this.priority > o.priority)
+				return 1;
+			else
+				return 0;
+		}
+
+		/**
+		 * @return priority
+		 * @since 2019-03-22
+		 * @since v0.2.0
+		 */
+		public final int getPriority() {
+			return this.priority;
+		}
+	}
+
+	/**
+	 * A unary operator with a priority field that determines which operators apply first.
+	 * 
+	 * @author Adrien Hopkins
+	 * @param <T>
+	 *            type of operand and result
+	 * @since 2019-03-17
+	 * @since v0.2.0
+	 */
+	private static abstract class PriorityUnaryOperator<T>
+			implements UnaryOperator<T>, Comparable<PriorityUnaryOperator<T>> {
+		/**
+		 * The operator's priority. Higher-priority operators are applied before lower-priority operators
+		 * 
+		 * @since 2019-03-17
+		 * @since v0.2.0
+		 */
+		private final int priority;
+
+		/**
+		 * Creates the {@code PriorityUnaryOperator}.
+		 * 
+		 * @param priority
+		 *            operator's priority
+		 * @since 2019-03-17
+		 * @since v0.2.0
+		 */
+		public PriorityUnaryOperator(final int priority) {
+			this.priority = priority;
+		}
+
+		/**
+		 * Compares this object to another by priority.
+		 * 
+		 * <p>
+		 * {@inheritDoc}
+		 * </p>
+		 * 
+		 * @since 2019-03-17
+		 * @since v0.2.0
+		 */
+		@Override
+		public int compareTo(final PriorityUnaryOperator<T> o) {
+			if (this.priority < o.priority)
+				return -1;
+			else if (this.priority > o.priority)
+				return 1;
+			else
+				return 0;
+		}
+
+		/**
+		 * @return priority
+		 * @since 2019-03-22
+		 * @since v0.2.0
+		 */
+		public final int getPriority() {
+			return this.priority;
+		}
+	}
+
+	/**
+	 * The types of tokens that are available.
+	 * 
+	 * @author Adrien Hopkins
+	 * @since 2019-03-14
+	 * @since v0.2.0
+	 */
+	private static enum TokenType {
+		OBJECT, UNARY_OPERATOR, BINARY_OPERATOR;
+	}
+
+	/**
+	 * The opening bracket.
+	 * 
+	 * @since 2019-03-22
+	 * @since v0.2.0
+	 */
+	public static final char OPENING_BRACKET = '(';
+
+	/**
+	 * The closing bracket.
+	 * 
+	 * @since 2019-03-22
+	 * @since v0.2.0
+	 */
+	public static final char CLOSING_BRACKET = ')';
+
+	/**
+	 * Finds the other bracket in a pair of brackets, given the position of one.
+	 * 
+	 * @param string
+	 *            string that contains brackets
+	 * @param bracketPosition
+	 *            position of first bracket
+	 * @return position of matching bracket
+	 * @throws NullPointerException
+	 *             if string is null
+	 * @since 2019-03-22
+	 * @since v0.2.0
+	 */
+	private static int findBracketPair(final String string, final int bracketPosition) {
+		Objects.requireNonNull(string, "string must not be null.");
+
+		final char openingBracket = string.charAt(bracketPosition);
+
+		// figure out what closing bracket to look for
+		final char closingBracket;
+		switch (openingBracket) {
+			case '(':
+				closingBracket = ')';
+				break;
+			case '[':
+				closingBracket = ']';
+				break;
+			case '{':
+				closingBracket = '}';
+				break;
+			default:
+				throw new IllegalArgumentException(String.format("Invalid bracket '%s'", openingBracket));
+		}
+
+		// level of brackets. every opening bracket increments this; every closing bracket decrements it
+		int bracketLevel = 0;
+
+		// iterate over the string to find the closing bracket
+		for (int currentPosition = bracketPosition; currentPosition < string.length(); currentPosition++) {
+			final char currentCharacter = string.charAt(currentPosition);
+
+			if (currentCharacter == openingBracket) {
+				bracketLevel++;
+			} else if (currentCharacter == closingBracket) {
+				bracketLevel--;
+				if (bracketLevel == 0)
+					return currentPosition;
+			}
+		}
+
+		throw new IllegalArgumentException("No matching bracket found.");
+	}
+
+	/**
+	 * A function that obtains a parseable object from a string. For example, an integer {@code ExpressionParser} would
+	 * use {@code Integer::parseInt}.
+	 * 
+	 * @since 2019-03-14
+	 * @since v0.2.0
+	 */
+	private final Function<String, T> objectObtainer;
+
+	/**
+	 * A map mapping operator strings to operator functions, for unary operators.
+	 * 
+	 * @since 2019-03-14
+	 * @since v0.2.0
+	 */
+	private final Map<String, PriorityUnaryOperator<T>> unaryOperators;
+
+	/**
+	 * A map mapping operator strings to operator functions, for binary operators.
+	 * 
+	 * @since 2019-03-14
+	 * @since v0.2.0
+	 */
+	private final Map<String, PriorityBinaryOperator<T>> binaryOperators;
+
+	/**
+	 * The operator for space, or null if spaces have no function.
+	 * 
+	 * @since 2019-03-22
+	 * @since v0.2.0
+	 */
+	private final String spaceOperator;
+
+	/**
+	 * Creates the {@code ExpressionParser}.
+	 * 
+	 * @param objectObtainer
+	 *            function to get objects from strings
+	 * @param unaryOperators
+	 *            unary operators available to the parser
+	 * @param binaryOperators
+	 *            binary operators available to the parser
+	 * @param spaceOperator
+	 *            operator used by spaces
+	 * @since 2019-03-14
+	 * @since v0.2.0
+	 */
+	private ExpressionParser(final Function<String, T> objectObtainer,
+			final Map<String, PriorityUnaryOperator<T>> unaryOperators,
+			final Map<String, PriorityBinaryOperator<T>> binaryOperators, final String spaceOperator) {
+		this.objectObtainer = objectObtainer;
+		this.unaryOperators = unaryOperators;
+		this.binaryOperators = binaryOperators;
+		this.spaceOperator = spaceOperator;
+	}
+
+	/**
+	 * Converts a given mathematical expression to reverse Polish notation (operators after operands).
+	 * <p>
+	 * For example,<br>
+	 * {@code 2 * (3 + 4)}<br>
+	 * becomes<br>
+	 * {@code 2 3 4 + *}.
+	 * 
+	 * @param expression
+	 *            expression
+	 * @return expression in RPN
+	 * @since 2019-03-17
+	 * @since v0.2.0
+	 */
+	private String convertExpressionToReversePolish(final String expression) {
+		Objects.requireNonNull(expression, "expression must not be null.");
+
+		final List<String> components = new ArrayList<>();
+
+		// the part of the expression remaining to parse
+		String partialExpression = expression;
+
+		// find and deal with brackets
+		while (partialExpression.indexOf(OPENING_BRACKET) != -1) {
+			final int openingBracketPosition = partialExpression.indexOf(OPENING_BRACKET);
+			final int closingBracketPosition = findBracketPair(partialExpression, openingBracketPosition);
+
+			// check for function
+			if (openingBracketPosition > 0 && partialExpression.charAt(openingBracketPosition - 1) != ' ') {
+				// function like sin(2) or tempF(32)
+				// find the position of the last space
+				int spacePosition = openingBracketPosition;
+				while (spacePosition >= 0 && partialExpression.charAt(spacePosition) != ' ') {
+					spacePosition--;
+				}
+				// then split the function into pre-function and function, using the space position
+				components.addAll(Arrays.asList(partialExpression.substring(0, spacePosition + 1).split(" ")));
+				components.add(partialExpression.substring(spacePosition + 1, closingBracketPosition + 1));
+				partialExpression = partialExpression.substring(closingBracketPosition + 1);
+			} else {
+				// normal brackets like (1 + 2) * (3 / 5)
+				components.addAll(Arrays.asList(partialExpression.substring(0, openingBracketPosition).split(" ")));
+				components.add(this.convertExpressionToReversePolish(
+						partialExpression.substring(openingBracketPosition + 1, closingBracketPosition)));
+				partialExpression = partialExpression.substring(closingBracketPosition + 1);
+			}
+		}
+
+		// add everything else
+		components.addAll(Arrays.asList(partialExpression.split(" ")));
+
+		// remove empty entries
+		while (components.contains("")) {
+			components.remove("");
+		}
+
+		// deal with space multiplication (x y)
+		if (this.spaceOperator != null) {
+			for (int i = 0; i < components.size() - 1; i++) {
+				if (this.getTokenType(components.get(i)) == TokenType.OBJECT
+						&& this.getTokenType(components.get(i + 1)) == TokenType.OBJECT) {
+					components.add(++i, this.spaceOperator);
+				}
+			}
+		}
+
+		// turn the expression into reverse Polish
+		while (true) {
+			final int highestPriorityOperatorPosition = this.findHighestPriorityOperatorPosition(components);
+			if (highestPriorityOperatorPosition == -1) {
+				break;
+			}
+
+			// swap components based on what kind of operator there is
+			// 1 + 2 becomes 2 1 +
+			// - 1 becomes 1 -
+			switch (this.getTokenType(components.get(highestPriorityOperatorPosition))) {
+				case UNARY_OPERATOR:
+					final String unaryOperator = components.remove(highestPriorityOperatorPosition);
+					final String operand = components.remove(highestPriorityOperatorPosition);
+					components.add(highestPriorityOperatorPosition, operand + " " + unaryOperator);
+					break;
+				case BINARY_OPERATOR:
+					final String binaryOperator = components.remove(highestPriorityOperatorPosition);
+					final String operand1 = components.remove(highestPriorityOperatorPosition - 1);
+					final String operand2 = components.remove(highestPriorityOperatorPosition - 1);
+					components.add(highestPriorityOperatorPosition - 1,
+							operand2 + " " + operand1 + " " + binaryOperator);
+					break;
+				default:
+					throw new AssertionError("Expected operator, found non-operator.");
+			}
+		}
+
+		// join all of the components together, then ensure there is only one space in a row
+		String expressionRPN = String.join(" ", components).replaceAll(" +", " ");
+
+		while (expressionRPN.charAt(0) == ' ') {
+			expressionRPN = expressionRPN.substring(1);
+		}
+		while (expressionRPN.charAt(expressionRPN.length() - 1) == ' ') {
+			expressionRPN = expressionRPN.substring(0, expressionRPN.length() - 1);
+		}
+		return expressionRPN;
+	}
+
+	/**
+	 * Finds the position of the highest-priority operator in a list
+	 * 
+	 * @param components
+	 *            components to test
+	 * @param blacklist
+	 *            positions of operators that should be ignored
+	 * @return position of highest priority, or -1 if the list contains no operators
+	 * @throws NullPointerException
+	 *             if components is null
+	 * @since 2019-03-22
+	 * @since v0.2.0
+	 */
+	private int findHighestPriorityOperatorPosition(final List<String> components) {
+		Objects.requireNonNull(components, "components must not be null.");
+		// find highest priority
+		int maxPriority = Integer.MIN_VALUE;
+		int maxPriorityPosition = -1;
+
+		// go over components one by one
+		// if it is an operator, test its priority to see if it's max
+		// if it is, update maxPriority and maxPriorityPosition
+		for (int i = 0; i < components.size(); i++) {
+
+			switch (this.getTokenType(components.get(i))) {
+				case UNARY_OPERATOR:
+					final PriorityUnaryOperator<T> unaryOperator = this.unaryOperators.get(components.get(i));
+					final int unaryPriority = unaryOperator.getPriority();
+
+					if (unaryPriority > maxPriority) {
+						maxPriority = unaryPriority;
+						maxPriorityPosition = i;
+					}
+					break;
+				case BINARY_OPERATOR:
+					final PriorityBinaryOperator<T> binaryOperator = this.binaryOperators.get(components.get(i));
+					final int binaryPriority = binaryOperator.getPriority();
+
+					if (binaryPriority > maxPriority) {
+						maxPriority = binaryPriority;
+						maxPriorityPosition = i;
+					}
+					break;
+				default:
+					break;
+			}
+		}
+
+		// max priority position found
+		return maxPriorityPosition;
+	}
+
+	/**
+	 * Determines whether an inputted string is an object or an operator
+	 * 
+	 * @param token
+	 *            string to input
+	 * @return type of token it is
+	 * @throws NullPointerException
+	 *             if {@code expression} is null
+	 * @since 2019-03-14
+	 * @since v0.2.0
+	 */
+	private TokenType getTokenType(final String token) {
+		Objects.requireNonNull(token, "token must not be null.");
+
+		if (this.unaryOperators.containsKey(token))
+			return TokenType.UNARY_OPERATOR;
+		else if (this.binaryOperators.containsKey(token))
+			return TokenType.BINARY_OPERATOR;
+		else
+			return TokenType.OBJECT;
+	}
+
+	/**
+	 * Parses an expression.
+	 * 
+	 * @param expression
+	 *            expression to parse
+	 * @return result
+	 * @throws NullPointerException
+	 *             if {@code expression} is null
+	 * @since 2019-03-14
+	 * @since v0.2.0
+	 */
+	public T parseExpression(final String expression) {
+		return this.parseReversePolishExpression(this.convertExpressionToReversePolish(expression));
+	}
+
+	/**
+	 * Parses an expression expressed in reverse Polish notation.
+	 * 
+	 * @param expression
+	 *            expression to parse
+	 * @return result
+	 * @throws NullPointerException
+	 *             if {@code expression} is null
+	 * @since 2019-03-14
+	 * @since v0.2.0
+	 */
+	private T parseReversePolishExpression(final String expression) {
+		Objects.requireNonNull(expression, "expression must not be null.");
+
+		final Deque<T> stack = new ArrayDeque<>();
+
+		// iterate over every item in the expression, then
+		for (final String item : expression.split(" ")) {
+			// choose a path based on what kind of thing was just read
+			switch (this.getTokenType(item)) {
+
+				case BINARY_OPERATOR:
+					if (stack.size() < 2)
+						throw new IllegalStateException(String.format(
+								"Attempted to call binary operator %s with only %d arguments.", item, stack.size()));
+
+					// get two arguments and operator, then apply!
+					final T o1 = stack.pop();
+					final T o2 = stack.pop();
+					final BinaryOperator<T> binaryOperator = this.binaryOperators.get(item);
+
+					stack.push(binaryOperator.apply(o1, o2));
+					break;
+
+				case OBJECT:
+					// just add it to the stack
+					stack.push(this.objectObtainer.apply(item));
+					break;
+
+				case UNARY_OPERATOR:
+					if (stack.size() < 1)
+						throw new IllegalStateException(String.format(
+								"Attempted to call unary operator %s with only %d arguments.", item, stack.size()));
+
+					// get one argument and operator, then apply!
+					final T o = stack.pop();
+					final UnaryOperator<T> unaryOperator = this.unaryOperators.get(item);
+
+					stack.push(unaryOperator.apply(o));
+					break;
+				default:
+					throw new AssertionError(
+							String.format("Internal error: Invalid token type %s.", this.getTokenType(item)));
+
+			}
+		}
+
+		// return answer, or throw an exception if I can't
+		if (stack.size() > 1)
+			throw new IllegalStateException("Computation ended up with more than one answer.");
+		else if (stack.size() == 0)
+			throw new IllegalStateException("Computation ended up without an answer.");
+		return stack.pop();
+	}
+}
diff --git a/src/org/unitConverter/math/package-info.java b/src/org/unitConverter/math/package-info.java
new file mode 100644
index 0000000..65d6b23
--- /dev/null
+++ b/src/org/unitConverter/math/package-info.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright (C) 2019 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+/**
+ * A module that is capable of parsing expressions of things, like mathematical expressions or unit expressions.
+ * 
+ * @author Adrien Hopkins
+ * @since 2019-03-14
+ */
+package org.unitConverter.math;
\ No newline at end of file
diff --git a/src/unitConverter/package-info.java b/src/org/unitConverter/package-info.java
index e2f7ff7..23dd165 100644
--- a/src/unitConverter/package-info.java
+++ b/src/org/unitConverter/package-info.java
@@ -18,6 +18,7 @@
  * A program that converts units.
  * 
  * @author Adrien Hopkins
+ * @version v0.2.0
  * @since 2019-01-25
  */
-package unitConverter;
\ No newline at end of file
+package org.unitConverter;
\ No newline at end of file
diff --git a/src/unitConverter/unit/AbstractUnit.java b/src/org/unitConverter/unit/AbstractUnit.java
index 24814e8..05a6c17 100644
--- a/src/unitConverter/unit/AbstractUnit.java
+++ b/src/org/unitConverter/unit/AbstractUnit.java
@@ -14,11 +14,11 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-package unitConverter.unit;
+package org.unitConverter.unit;
 
 import java.util.Objects;
 
-import unitConverter.dimension.UnitDimension;
+import org.unitConverter.dimension.UnitDimension;
 
 /**
  * The default abstract implementation of the {@code Unit} interface.
@@ -29,60 +29,6 @@ import unitConverter.dimension.UnitDimension;
  */
 public abstract class AbstractUnit implements Unit {
 	/**
-	 * The number of units created, including base units.
-	 * 
-	 * @since 2019-01-02
-	 * @since v0.1.0
-	 */
-	private static long unitCount = 0;
-
-	/**
-	 * The number of base units created.
-	 * 
-	 * @since 2019-01-02
-	 * @since v0.1.0
-	 */
-	private static long baseUnitCount = 0;
-
-	/**
-	 * @return number of base units created
-	 * @since 2019-01-02
-	 * @since v0.1.0
-	 */
-	public static final long getBaseUnitCount() {
-		return baseUnitCount;
-	}
-
-	/**
-	 * @return number of units created
-	 * @since 2019-01-02
-	 * @since v0.1.0
-	 */
-	public static final long getUnitCount() {
-		return unitCount;
-	}
-
-	/**
-	 * Increments the number of base units.
-	 * 
-	 * @since 2019-01-15
-	 * @since v0.1.0
-	 */
-	public static final void incrementBaseUnitCounter() {
-		baseUnitCount++;
-	}
-
-	/**
-	 * Increments the number of units.
-	 * 
-	 * @since 2019-01-15
-	 * @since v0.1.0
-	 */
-	public static final void incrementUnitCounter() {
-		unitCount++;
-	}
-
-	/**
 	 * The dimension, or what the unit measures.
 	 * 
 	 * @since 2018-12-22
@@ -164,7 +110,6 @@ public abstract class AbstractUnit implements Unit {
 		return this.system;
 	}
 
-	// TODO document and revise units' toString methods
 	@Override
 	public String toString() {
 		return String.format("%s-derived unit of dimension %s", this.getSystem(), this.getDimension());
diff --git a/src/org/unitConverter/unit/BaseUnit.java b/src/org/unitConverter/unit/BaseUnit.java
new file mode 100755
index 0000000..67309cf
--- /dev/null
+++ b/src/org/unitConverter/unit/BaseUnit.java
@@ -0,0 +1,168 @@
+/**
+ * Copyright (C) 2018 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.unitConverter.unit;
+
+import java.util.Objects;
+
+import org.unitConverter.dimension.StandardDimensions;
+import org.unitConverter.dimension.UnitDimension;
+
+/**
+ * A unit that is the base for its dimension. It does not have to be for a base dimension, so units like the Newton and
+ * Joule are still base units.
+ * <p>
+ * {@code BaseUnit} does not have any public constructors or static factories. There are two ways to obtain
+ * {@code BaseUnit} instances.
+ * <ol>
+ * <li>The class {@link SI} in this package has constants for all of the SI base units. You can use these constants and
+ * multiply or divide them to get other units. For example:
+ * 
+ * <pre>
+ * BaseUnit JOULE = SI.KILOGRAM.times(SI.METRE.toExponent(2)).dividedBy(SI.SECOND.toExponent(2));
+ * </pre>
+ * 
+ * </li>
+ * <li>You can also query a unit system for a base unit using a unit dimension. The previously mentioned {@link SI}
+ * class can do this for SI and SI-derived units (including imperial and USC), but if you want to use another system,
+ * this is the way to do it. {@link StandardDimensions} contains common unit dimensions that you can use for this. Here
+ * is an example:
+ * 
+ * <pre>
+ * BaseUnit JOULE = SI.SI.getBaseUnit(StandardDimensions.ENERGY);
+ * </pre>
+ * 
+ * </li>
+ * </ol>
+ * 
+ * @author Adrien Hopkins
+ * @since 2018-12-23
+ * @since v0.1.0
+ */
+public final class BaseUnit extends LinearUnit {
+	/**
+	 * Is this unit a full base (i.e. m, s, ... but not N, J, ...)
+	 * 
+	 * @since 2019-01-15
+	 * @since v0.1.0
+	 */
+	private final boolean isFullBase;
+
+	/**
+	 * Creates the {@code BaseUnit}.
+	 * 
+	 * @param dimension
+	 *            dimension measured by unit
+	 * @param system
+	 *            system that unit is a part of
+	 * @param name
+	 *            name of unit
+	 * @param symbol
+	 *            symbol of unit
+	 * @since 2018-12-23
+	 * @since v0.1.0
+	 */
+	BaseUnit(final UnitDimension dimension, final UnitSystem system) {
+		super(dimension, system, 1);
+		this.isFullBase = dimension.isBase();
+	}
+
+	/**
+	 * Returns the quotient of this unit and another.
+	 * <p>
+	 * Two units can be divided if they are part of the same unit system. If {@code divisor} does not meet this
+	 * condition, an {@code IllegalArgumentException} should be thrown.
+	 * </p>
+	 * 
+	 * @param divisor
+	 *            unit to divide by
+	 * @return quotient of two units
+	 * @throws IllegalArgumentException
+	 *             if {@code divisor} is not compatible for division as described above
+	 * @throws NullPointerException
+	 *             if {@code divisor} is null
+	 * @since 2018-12-22
+	 * @since v0.1.0
+	 */
+	public BaseUnit dividedBy(final BaseUnit divisor) {
+		Objects.requireNonNull(divisor, "other must not be null.");
+
+		// check that these units can be multiplied
+		if (!this.getSystem().equals(divisor.getSystem()))
+			throw new IllegalArgumentException(
+					String.format("Incompatible units for division \"%s\" and \"%s\".", this, divisor));
+
+		return new BaseUnit(this.getDimension().dividedBy(divisor.getDimension()), this.getSystem());
+	}
+
+	/**
+	 * @return true if the unit is a "full base" unit like the metre or second.
+	 * @since 2019-04-10
+	 * @since v0.2.0
+	 */
+	public final boolean isFullBase() {
+		return this.isFullBase;
+	}
+
+	/**
+	 * Returns the product of this unit and another.
+	 * <p>
+	 * Two units can be multiplied if they are part of the same unit system. If {@code multiplier} does not meet this
+	 * condition, an {@code IllegalArgumentException} should be thrown.
+	 * </p>
+	 * 
+	 * @param multiplier
+	 *            unit to multiply by
+	 * @return product of two units
+	 * @throws IllegalArgumentException
+	 *             if {@code multiplier} is not compatible for multiplication as described above
+	 * @throws NullPointerException
+	 *             if {@code multiplier} is null
+	 * @since 2018-12-22
+	 * @since v0.1.0
+	 */
+	public BaseUnit times(final BaseUnit multiplier) {
+		Objects.requireNonNull(multiplier, "other must not be null");
+
+		// check that these units can be multiplied
+		if (!this.getSystem().equals(multiplier.getSystem()))
+			throw new IllegalArgumentException(
+					String.format("Incompatible units for multiplication \"%s\" and \"%s\".", this, multiplier));
+
+		// multiply the units
+		return new BaseUnit(this.getDimension().times(multiplier.getDimension()), this.getSystem());
+	}
+
+	/**
+	 * Returns this unit, but to an exponent.
+	 * 
+	 * @param exponent
+	 *            exponent
+	 * @return result of exponentiation
+	 * @since 2019-01-15
+	 * @since v0.1.0
+	 */
+	@Override
+	public BaseUnit toExponent(final int exponent) {
+		return this.getSystem().getBaseUnit(this.getDimension().toExponent(exponent));
+	}
+
+	@Override
+	public String toString() {
+		return String.format("%s base unit of%s dimension %s", this.getSystem(), this.isFullBase ? " base" : "",
+				this.getDimension());
+	}
+}
diff --git a/src/unitConverter/unit/DefaultUnitPrefix.java b/src/org/unitConverter/unit/DefaultUnitPrefix.java
index d19161b..4a9e487 100755
--- a/src/unitConverter/unit/DefaultUnitPrefix.java
+++ b/src/org/unitConverter/unit/DefaultUnitPrefix.java
@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-package unitConverter.unit;
+package org.unitConverter.unit;
 
 import java.util.Objects;
 
@@ -33,6 +33,7 @@ public final class DefaultUnitPrefix implements UnitPrefix {
 	 * 
 	 * @param multiplier
 	 * @since 2019-01-14
+	 * @since v0.2.0
 	 */
 	public DefaultUnitPrefix(final double multiplier) {
 		this.multiplier = multiplier;
diff --git a/src/org/unitConverter/unit/LinearUnit.java b/src/org/unitConverter/unit/LinearUnit.java
new file mode 100644
index 0000000..1b1ac97
--- /dev/null
+++ b/src/org/unitConverter/unit/LinearUnit.java
@@ -0,0 +1,294 @@
+/**
+ * Copyright (C) 2019 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.unitConverter.unit;
+
+import java.util.Objects;
+
+import org.unitConverter.dimension.UnitDimension;
+import org.unitConverter.math.DecimalComparison;
+
+/**
+ * A unit that is equal to a certain number multiplied by its base.
+ * <p>
+ * {@code LinearUnit} does not have any public constructors or static factories. In order to obtain a {@code LinearUnit}
+ * instance, multiply its base by the conversion factor. Example:
+ * 
+ * <pre>
+ * LinearUnit foot = METRE.times(0.3048);
+ * </pre>
+ * 
+ * (where {@code METRE} is a {@code BaseUnit} instance)
+ * </p>
+ * 
+ * @author Adrien Hopkins
+ * @since 2018-12-22
+ * @since v0.1.0
+ */
+public class LinearUnit extends AbstractUnit {
+	/**
+	 * The value of one of this unit in this unit's base unit
+	 * 
+	 * @since 2018-12-22
+	 * @since v0.1.0
+	 */
+	private final double conversionFactor;
+
+	/**
+	 * 
+	 * Creates the {@code LinearUnit}.
+	 * 
+	 * @param base
+	 *            unit's base
+	 * @param conversionFactor
+	 *            value of one of this unit in its base
+	 * @since 2018-12-23
+	 * @since v0.1.0
+	 */
+	LinearUnit(final BaseUnit base, final double conversionFactor) {
+		super(base);
+		this.conversionFactor = conversionFactor;
+	}
+
+	/**
+	 * Creates the {@code LinearUnit} as a base unit.
+	 * 
+	 * @param dimension
+	 *            dimension measured by unit
+	 * @param system
+	 *            system unit is part of
+	 * @since 2019-01-25
+	 * @since v0.1.0
+	 */
+	LinearUnit(final UnitDimension dimension, final UnitSystem system, final double conversionFactor) {
+		super(dimension, system);
+		this.conversionFactor = conversionFactor;
+	}
+
+	@Override
+	public double convertFromBase(final double value) {
+		return value / this.getConversionFactor();
+	}
+
+	@Override
+	public double convertToBase(final double value) {
+		return value * this.getConversionFactor();
+	}
+
+	/**
+	 * Divides this unit by a scalar.
+	 * 
+	 * @param divisor
+	 *            scalar to divide by
+	 * @return quotient
+	 * @since 2018-12-23
+	 * @since v0.1.0
+	 */
+	public LinearUnit dividedBy(final double divisor) {
+		return new LinearUnit(this.getBase(), this.getConversionFactor() / divisor);
+	}
+
+	/**
+	 * Returns the quotient of this unit and another.
+	 * <p>
+	 * Two units can be divided if they are part of the same unit system. If {@code divisor} does not meet this
+	 * condition, an {@code IllegalArgumentException} should be thrown.
+	 * </p>
+	 * 
+	 * @param divisor
+	 *            unit to divide by
+	 * @return quotient of two units
+	 * @throws IllegalArgumentException
+	 *             if {@code divisor} is not compatible for division as described above
+	 * @throws NullPointerException
+	 *             if {@code divisor} is null
+	 * @since 2018-12-22
+	 * @since v0.1.0
+	 */
+	public LinearUnit dividedBy(final LinearUnit divisor) {
+		Objects.requireNonNull(divisor, "other must not be null");
+
+		// check that these units can be multiplied
+		if (!this.getSystem().equals(divisor.getSystem()))
+			throw new IllegalArgumentException(
+					String.format("Incompatible units for division \"%s\" and \"%s\".", this, divisor));
+
+		// divide the units
+		final BaseUnit base = this.getBase().dividedBy(divisor.getBase());
+		return new LinearUnit(base, this.getConversionFactor() / divisor.getConversionFactor());
+	}
+
+	@Override
+	public boolean equals(final Object obj) {
+		if (!(obj instanceof LinearUnit))
+			return false;
+		final LinearUnit other = (LinearUnit) obj;
+		return Objects.equals(this.getSystem(), other.getSystem())
+				&& Objects.equals(this.getDimension(), other.getDimension())
+				&& DecimalComparison.equals(this.getConversionFactor(), other.getConversionFactor());
+	}
+
+	/**
+	 * @return conversion factor between this unit and its base
+	 * @since 2018-12-22
+	 * @since v0.1.0
+	 */
+	public final double getConversionFactor() {
+		return this.conversionFactor;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = result * prime + this.getSystem().hashCode();
+		result = result * prime + this.getDimension().hashCode();
+		result = result * prime + Double.hashCode(this.getConversionFactor());
+		return result;
+	}
+
+	/**
+	 * Returns the difference of this unit and another.
+	 * <p>
+	 * Two units can be subtracted if they have the same base. If {@code subtrahend} does not meet this condition, an
+	 * {@code IllegalArgumentException} will be thrown.
+	 * </p>
+	 * 
+	 * @param subtrahend
+	 *            unit to subtract
+	 * @return difference of units
+	 * @throws IllegalArgumentException
+	 *             if {@code subtrahend} is not compatible for subtraction as described above
+	 * @throws NullPointerException
+	 *             if {@code subtrahend} is null
+	 * @since 2019-03-17
+	 * @since v0.2.0
+	 */
+	public LinearUnit minus(final LinearUnit subtrahendend) {
+		Objects.requireNonNull(subtrahendend, "addend must not be null.");
+
+		// reject subtrahends that cannot be added to this unit
+		if (!this.getBase().equals(subtrahendend.getBase()))
+			throw new IllegalArgumentException(
+					String.format("Incompatible units for subtraction \"%s\" and \"%s\".", this, subtrahendend));
+
+		// add the units
+		return new LinearUnit(this.getBase(), this.getConversionFactor() - subtrahendend.getConversionFactor());
+	}
+
+	/**
+	 * Returns the sum of this unit and another.
+	 * <p>
+	 * Two units can be added if they have the same base. If {@code addend} does not meet this condition, an
+	 * {@code IllegalArgumentException} will be thrown.
+	 * </p>
+	 * 
+	 * @param addend
+	 *            unit to add
+	 * @return sum of units
+	 * @throws IllegalArgumentException
+	 *             if {@code addend} is not compatible for addition as described above
+	 * @throws NullPointerException
+	 *             if {@code addend} is null
+	 * @since 2019-03-17
+	 * @since v0.2.0
+	 */
+	public LinearUnit plus(final LinearUnit addend) {
+		Objects.requireNonNull(addend, "addend must not be null.");
+
+		// reject addends that cannot be added to this unit
+		if (!this.getBase().equals(addend.getBase()))
+			throw new IllegalArgumentException(
+					String.format("Incompatible units for addition \"%s\" and \"%s\".", this, addend));
+
+		// add the units
+		return new LinearUnit(this.getBase(), this.getConversionFactor() + addend.getConversionFactor());
+	}
+
+	/**
+	 * Multiplies this unit by a scalar.
+	 * 
+	 * @param multiplier
+	 *            scalar to multiply by
+	 * @return product
+	 * @since 2018-12-23
+	 * @since v0.1.0
+	 */
+	public LinearUnit times(final double multiplier) {
+		return new LinearUnit(this.getBase(), this.getConversionFactor() * multiplier);
+	}
+
+	/**
+	 * Returns the product of this unit and another.
+	 * <p>
+	 * Two units can be multiplied if they are part of the same unit system. If {@code multiplier} does not meet this
+	 * condition, an {@code IllegalArgumentException} should be thrown.
+	 * </p>
+	 * 
+	 * @param multiplier
+	 *            unit to multiply by
+	 * @return product of two units
+	 * @throws IllegalArgumentException
+	 *             if {@code multiplier} is not compatible for multiplication as described above
+	 * @throws NullPointerException
+	 *             if {@code multiplier} is null
+	 * @since 2018-12-22
+	 * @since v0.1.0
+	 */
+	public LinearUnit times(final LinearUnit multiplier) {
+		Objects.requireNonNull(multiplier, "other must not be null");
+
+		// check that these units can be multiplied
+		if (!this.getSystem().equals(multiplier.getSystem()))
+			throw new IllegalArgumentException(
+					String.format("Incompatible units for multiplication \"%s\" and \"%s\".", this, multiplier));
+
+		// multiply the units
+		final BaseUnit base = this.getBase().times(multiplier.getBase());
+		return new LinearUnit(base, this.getConversionFactor() * multiplier.getConversionFactor());
+	}
+
+	/**
+	 * Returns this unit but to an exponent.
+	 * 
+	 * @param exponent
+	 *            exponent to exponientate unit to
+	 * @return exponientated unit
+	 * @since 2019-01-15
+	 * @since v0.1.0
+	 */
+	public LinearUnit toExponent(final int exponent) {
+		return new LinearUnit(this.getBase().toExponent(exponent), Math.pow(this.conversionFactor, exponent));
+	}
+
+	@Override
+	public String toString() {
+		return super.toString() + String.format(" (equal to %s * base)", this.getConversionFactor());
+	}
+
+	/**
+	 * Returns the result of applying {@code prefix} to this unit.
+	 * 
+	 * @param prefix
+	 *            prefix to apply
+	 * @return unit with prefix
+	 * @since 2019-03-18
+	 * @since v0.2.0
+	 */
+	public LinearUnit withPrefix(final UnitPrefix prefix) {
+		return this.times(prefix.getMultiplier());
+	}
+}
diff --git a/src/unitConverter/unit/NonlinearUnits.java b/src/org/unitConverter/unit/NonlinearUnits.java
index ec1874c..e47c28f 100755
--- a/src/unitConverter/unit/NonlinearUnits.java
+++ b/src/org/unitConverter/unit/NonlinearUnits.java
@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-package unitConverter.unit;
+package org.unitConverter.unit;
 
 /**
  * Some major nonlinear units.
diff --git a/src/unitConverter/unit/SI.java b/src/org/unitConverter/unit/SI.java
index 54eb4c5..46e6ff1 100644
--- a/src/unitConverter/unit/SI.java
+++ b/src/org/unitConverter/unit/SI.java
@@ -14,14 +14,14 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-package unitConverter.unit;
+package org.unitConverter.unit;
 
 import java.util.HashSet;
 import java.util.Objects;
 import java.util.Set;
 
-import unitConverter.dimension.StandardDimensions;
-import unitConverter.dimension.UnitDimension;
+import org.unitConverter.dimension.StandardDimensions;
+import org.unitConverter.dimension.UnitDimension;
 
 /**
  * The SI, which holds all SI units
diff --git a/src/unitConverter/unit/SIPrefix.java b/src/org/unitConverter/unit/SIPrefix.java
index 54625fb..31d7ff2 100755
--- a/src/unitConverter/unit/SIPrefix.java
+++ b/src/org/unitConverter/unit/SIPrefix.java
@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-package unitConverter.unit;
+package org.unitConverter.unit;
 
 /**
  * The SI prefixes.
diff --git a/src/unitConverter/unit/Unit.java b/src/org/unitConverter/unit/Unit.java
index 54f1423..86fc5a2 100755
--- a/src/unitConverter/unit/Unit.java
+++ b/src/org/unitConverter/unit/Unit.java
@@ -14,11 +14,11 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-package unitConverter.unit;
+package org.unitConverter.unit;
 
 import java.util.Objects;
 
-import unitConverter.dimension.UnitDimension;
+import org.unitConverter.dimension.UnitDimension;
 
 /**
  * A unit that has an associated base unit, and can convert a value expressed in it to and from that base.
diff --git a/src/unitConverter/unit/UnitPrefix.java b/src/org/unitConverter/unit/UnitPrefix.java
index a0c1b7c..9f9645d 100755
--- a/src/unitConverter/unit/UnitPrefix.java
+++ b/src/org/unitConverter/unit/UnitPrefix.java
@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-package unitConverter.unit;
+package org.unitConverter.unit;
 
 /**
  * A prefix that can be attached onto the front of any unit, which multiplies it by a certain value
@@ -25,9 +25,48 @@ package unitConverter.unit;
  */
 public interface UnitPrefix {
 	/**
+	 * Divides this prefix by {@code other}.
+	 * 
+	 * @param other
+	 *            prefix to divide by
+	 * @return quotient of prefixes
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	default UnitPrefix dividedBy(final UnitPrefix other) {
+		return new DefaultUnitPrefix(this.getMultiplier() / other.getMultiplier());
+	}
+
+	/**
 	 * @return this prefix's multiplier
 	 * @since 2019-01-14
 	 * @since v0.1.0
 	 */
 	double getMultiplier();
+
+	/**
+	 * Multiplies this prefix by {@code other}.
+	 * 
+	 * @param other
+	 *            prefix to multiply by
+	 * @return product of prefixes
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	default UnitPrefix times(final UnitPrefix other) {
+		return new DefaultUnitPrefix(this.getMultiplier() * other.getMultiplier());
+	}
+
+	/**
+	 * Raises this prefix to an exponent.
+	 * 
+	 * @param exponent
+	 *            exponent to raise to
+	 * @return result of exponentiation.
+	 * @since 2019-04-13
+	 * @since v0.2.0
+	 */
+	default UnitPrefix toExponent(final double exponent) {
+		return new DefaultUnitPrefix(Math.pow(getMultiplier(), exponent));
+	}
 }
diff --git a/src/unitConverter/unit/UnitSystem.java b/src/org/unitConverter/unit/UnitSystem.java
index ce8c249..550eff6 100755
--- a/src/unitConverter/unit/UnitSystem.java
+++ b/src/org/unitConverter/unit/UnitSystem.java
@@ -14,11 +14,11 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-package unitConverter.unit;
+package org.unitConverter.unit;
 
 import java.util.Objects;
 
-import unitConverter.dimension.UnitDimension;
+import org.unitConverter.dimension.UnitDimension;
 
 /**
  * A system of units. Each unit should be aware of its system.
diff --git a/src/unitConverter/unit/package-info.java b/src/org/unitConverter/unit/package-info.java
index b5deb0c..dd5a939 100644
--- a/src/unitConverter/unit/package-info.java
+++ b/src/org/unitConverter/unit/package-info.java
@@ -19,5 +19,6 @@
  * 
  * @author Adrien Hopkins
  * @since 2019-01-25
+ * @since v0.1.0
  */
-package unitConverter.unit;
\ No newline at end of file
+package org.unitConverter.unit;
\ No newline at end of file
diff --git a/src/test/java/ExpressionParserTest.java b/src/test/java/ExpressionParserTest.java
new file mode 100644
index 0000000..40c91ac
--- /dev/null
+++ b/src/test/java/ExpressionParserTest.java
@@ -0,0 +1,53 @@
+/**
+ * Copyright (C) 2019 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package test.java;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.unitConverter.math.ExpressionParser;
+
+/**
+ * A test for the {@code ExpressionParser} class. This is NOT part of this program's public API.
+ * 
+ * @author Adrien Hopkins
+ * @since 2019-03-22
+ * @since v0.2.0
+ */
+public class ExpressionParserTest {
+	private static final ExpressionParser<Integer> numberParser = new ExpressionParser.Builder<>(Integer::parseInt)
+			.addBinaryOperator("+", (o1, o2) -> o1 + o2, 0).addBinaryOperator("-", (o1, o2) -> o1 - o2, 0)
+			.addBinaryOperator("*", (o1, o2) -> o1 * o2, 1).addBinaryOperator("/", (o1, o2) -> o1 / o2, 1)
+			.addBinaryOperator("^", (o1, o2) -> (int) Math.pow(o1, o2), 2).build();
+
+	/**
+	 * Test method for {@link org.unitConverter.math.ExpressionParser#parseExpression(java.lang.String)}.
+	 */
+	@Test
+	public void testParseExpression() {
+		// test parsing of expressions
+		assertEquals((int) numberParser.parseExpression("1 + 2 ^ 5 * 3"), 97);
+		assertEquals((int) numberParser.parseExpression("(1 + 2) ^ 5 * 3"), 729);
+
+		// ensure it normally goes left to right
+		assertEquals((int) numberParser.parseExpression("1 + 2 + 3 + 4"), 10);
+		assertEquals((int) numberParser.parseExpression("12 - 4 - 3"), 5);
+		assertEquals((int) numberParser.parseExpression("12 - (4 - 3)"), 11);
+		assertEquals((int) numberParser.parseExpression("1 / 2 + 3"), 3);
+	}
+
+}
diff --git a/src/unitConverter/dimension/UnitDimensionTest.java b/src/test/java/UnitDimensionTest.java
index 86db1b8..587cf4c 100755
--- a/src/unitConverter/dimension/UnitDimensionTest.java
+++ b/src/test/java/UnitDimensionTest.java
@@ -14,29 +14,31 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-package unitConverter.dimension;
+package test.java;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static unitConverter.dimension.StandardDimensions.AREA;
-import static unitConverter.dimension.StandardDimensions.ENERGY;
-import static unitConverter.dimension.StandardDimensions.LENGTH;
-import static unitConverter.dimension.StandardDimensions.MASS;
-import static unitConverter.dimension.StandardDimensions.MASS_DENSITY;
-import static unitConverter.dimension.StandardDimensions.QUANTITY;
-import static unitConverter.dimension.StandardDimensions.TIME;
-import static unitConverter.dimension.StandardDimensions.VOLUME;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.unitConverter.dimension.StandardDimensions.AREA;
+import static org.unitConverter.dimension.StandardDimensions.ENERGY;
+import static org.unitConverter.dimension.StandardDimensions.LENGTH;
+import static org.unitConverter.dimension.StandardDimensions.MASS;
+import static org.unitConverter.dimension.StandardDimensions.MASS_DENSITY;
+import static org.unitConverter.dimension.StandardDimensions.QUANTITY;
+import static org.unitConverter.dimension.StandardDimensions.TIME;
+import static org.unitConverter.dimension.StandardDimensions.VOLUME;
 
-import org.junit.jupiter.api.Test;
+import org.junit.Test;
+import org.unitConverter.dimension.SIBaseDimension;
+import org.unitConverter.dimension.UnitDimension;
 
 /**
- * Tests for {@link UnitDimension}.
+ * Tests for {@link UnitDimension}. This is NOT part of this program's public API.
  * 
  * @author Adrien Hopkins
  * @since 2018-12-12
  * @since v0.1.0
  */
-class UnitDimensionTest {
+public class UnitDimensionTest {
 	/**
 	 * Tests {@link UnitDimension#equals}
 	 * 
@@ -44,7 +46,7 @@ class UnitDimensionTest {
 	 * @since v0.1.0
 	 */
 	@Test
-	void testEquals() {
+	public void testEquals() {
 		assertEquals(LENGTH, LENGTH);
 		assertFalse(LENGTH.equals(QUANTITY));
 	}
@@ -56,7 +58,7 @@ class UnitDimensionTest {
 	 * @since v0.1.0
 	 */
 	@Test
-	void testExponents() {
+	public void testExponents() {
 		assertEquals(1, LENGTH.getExponent(SIBaseDimension.LENGTH));
 		assertEquals(3, VOLUME.getExponent(SIBaseDimension.LENGTH));
 	}
@@ -68,7 +70,7 @@ class UnitDimensionTest {
 	 * @since v0.1.0
 	 */
 	@Test
-	void testMultiplicationAndDivision() {
+	public void testMultiplicationAndDivision() {
 		assertEquals(AREA, LENGTH.times(LENGTH));
 		assertEquals(MASS_DENSITY, MASS.dividedBy(VOLUME));
 		assertEquals(ENERGY, AREA.times(MASS).dividedBy(TIME).dividedBy(TIME));
diff --git a/src/test/java/UnitTest.java b/src/test/java/UnitTest.java
new file mode 100755
index 0000000..00fcf3c
--- /dev/null
+++ b/src/test/java/UnitTest.java
@@ -0,0 +1,116 @@
+/**
+ * Copyright (C) 2018 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package test.java;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+
+import org.junit.Test;
+import org.unitConverter.dimension.StandardDimensions;
+import org.unitConverter.math.DecimalComparison;
+import org.unitConverter.unit.BaseUnit;
+import org.unitConverter.unit.LinearUnit;
+import org.unitConverter.unit.SI;
+import org.unitConverter.unit.SIPrefix;
+import org.unitConverter.unit.Unit;
+
+/**
+ * Testing the various Unit classes. This is NOT part of this program's public API.
+ * 
+ * @author Adrien Hopkins
+ * @since 2018-12-22
+ * @since v0.1.0
+ */
+public class UnitTest {
+	/** A random number generator */
+	private static final Random rng = ThreadLocalRandom.current();
+
+	@Test
+	public void testAdditionAndSubtraction() {
+		final LinearUnit inch = SI.METRE.times(0.0254);
+		final LinearUnit foot = SI.METRE.times(0.3048);
+
+		assertEquals(inch.plus(foot), SI.METRE.times(0.3302));
+		assertEquals(foot.minus(inch), SI.METRE.times(0.2794));
+	}
+
+	@Test
+	public void testBaseUnitExclusives() {
+		// this test should have a compile error if I am doing something wrong
+		final BaseUnit metrePerSecondSquared = SI.METRE.dividedBy(SI.SECOND.toExponent(2));
+
+		assertEquals(metrePerSecondSquared, SI.SI.getBaseUnit(StandardDimensions.ACCELERATION));
+	}
+
+	@Test
+	public void testConversion() {
+		final BaseUnit metre = SI.METRE;
+		final Unit inch = metre.times(0.0254);
+
+		assertEquals(1.9, inch.convertToBase(75), 0.01);
+
+		// try random stuff
+		for (int i = 0; i < 1000; i++) {
+			// initiate random values
+			final double conversionFactor = rng.nextDouble() * 1000000;
+			final double testValue = rng.nextDouble() * 1000000;
+			final double expected = testValue * conversionFactor;
+
+			// test
+			final Unit unit = SI.METRE.times(conversionFactor);
+			final double actual = unit.convertToBase(testValue);
+
+			assertEquals(actual, expected, expected * DecimalComparison.DOUBLE_EPSILON);
+		}
+	}
+
+	@Test
+	public void testEquals() {
+		final BaseUnit metre = SI.METRE;
+		final Unit meter = SI.SI.getBaseUnit(StandardDimensions.LENGTH);
+
+		assertEquals(metre, meter);
+	}
+
+	@Test
+	public void testMultiplicationAndDivision() {
+		// test unit-times-unit multiplication
+		final LinearUnit generatedJoule = SI.KILOGRAM.times(SI.METRE.toExponent(2)).dividedBy(SI.SECOND.toExponent(2));
+		final LinearUnit actualJoule = SI.SI.getBaseUnit(StandardDimensions.ENERGY);
+
+		assertEquals(generatedJoule, actualJoule);
+
+		// test multiplication by conversion factors
+		final LinearUnit kilometre = SI.METRE.times(1000);
+		final LinearUnit hour = SI.SECOND.times(3600);
+		final LinearUnit generatedKPH = kilometre.dividedBy(hour);
+
+		final LinearUnit actualKPH = SI.SI.getBaseUnit(StandardDimensions.VELOCITY).dividedBy(3.6);
+
+		assertEquals(generatedKPH, actualKPH);
+	}
+
+	@Test
+	public void testPrefixes() {
+		final LinearUnit generatedKilometre = SI.METRE.withPrefix(SIPrefix.KILO);
+		final LinearUnit actualKilometre = SI.METRE.times(1000);
+
+		assertEquals(generatedKilometre, actualKilometre);
+	}
+}
diff --git a/src/test/java/UnitsDatabaseTest.java b/src/test/java/UnitsDatabaseTest.java
new file mode 100644
index 0000000..9222740
--- /dev/null
+++ b/src/test/java/UnitsDatabaseTest.java
@@ -0,0 +1,260 @@
+/**
+ * Copyright (C) 2019 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package test.java;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.junit.Test;
+import org.unitConverter.UnitsDatabase;
+import org.unitConverter.unit.AbstractUnit;
+import org.unitConverter.unit.DefaultUnitPrefix;
+import org.unitConverter.unit.LinearUnit;
+import org.unitConverter.unit.SI;
+import org.unitConverter.unit.Unit;
+import org.unitConverter.unit.UnitPrefix;
+
+/**
+ * A test for the {@link UnitsDatabase} class. This is NOT part of this program's public API.
+ * 
+ * @author Adrien Hopkins
+ * @since 2019-04-14
+ * @since v0.2.0
+ */
+public class UnitsDatabaseTest {
+	// some linear units and one nonlinear
+	private static final Unit U = SI.METRE;
+	private static final Unit V = SI.KILOGRAM;
+	private static final Unit W = SI.SECOND;
+
+	// used for testing expressions
+	// J = U^2 * V / W^2
+	private static final LinearUnit J = SI.KILOGRAM.times(SI.METRE.toExponent(2)).dividedBy(SI.SECOND.toExponent(2));
+	private static final Unit NONLINEAR = new AbstractUnit(SI.METRE) {
+
+		@Override
+		public double convertFromBase(final double value) {
+			return value + 1;
+		}
+
+		@Override
+		public double convertToBase(final double value) {
+			return value - 1;
+		}
+	};
+
+	// make the prefix values prime so I can tell which multiplications were made
+	private static final UnitPrefix A = new DefaultUnitPrefix(2);
+	private static final UnitPrefix B = new DefaultUnitPrefix(3);
+	private static final UnitPrefix C = new DefaultUnitPrefix(5);
+	private static final UnitPrefix AB = new DefaultUnitPrefix(7);
+	private static final UnitPrefix BC = new DefaultUnitPrefix(11);
+
+	/**
+	 * Test that prefixes correctly apply to units.
+	 * 
+	 * @since 2019-04-14
+	 * @since v0.2.0
+	 */
+	@Test
+	public void testPrefixes() {
+		final UnitsDatabase database = new UnitsDatabase();
+
+		database.addUnit("U", U);
+		database.addUnit("V", V);
+		database.addUnit("W", W);
+
+		database.addPrefix("A", A);
+		database.addPrefix("B", B);
+		database.addPrefix("C", C);
+
+		// get the product
+		final Unit abcuNonlinear = database.getUnit("ABCU");
+		assert abcuNonlinear instanceof LinearUnit;
+
+		final LinearUnit abcu = (LinearUnit) abcuNonlinear;
+		assertEquals(A.getMultiplier() * B.getMultiplier() * C.getMultiplier(), abcu.getConversionFactor(), 1e-15);
+	}
+
+	/**
+	 * Tests the functionnalites of the prefixless unit map.
+	 * 
+	 * <p>
+	 * The map should be an auto-updating view of the units in the database.
+	 * </p>
+	 * 
+	 * @since 2019-04-14
+	 * @since v0.2.0
+	 */
+	@Test
+	public void testPrefixlessUnitMap() {
+		final UnitsDatabase database = new UnitsDatabase();
+		final Map<String, Unit> prefixlessUnits = database.unitMapPrefixless();
+
+		database.addUnit("U", U);
+		database.addUnit("V", V);
+		database.addUnit("W", W);
+
+		// this should work because the map should be an auto-updating view
+		assertTrue(prefixlessUnits.containsKey("U"));
+		assertFalse(prefixlessUnits.containsKey("Z"));
+
+		assertTrue(prefixlessUnits.containsValue(U));
+		assertFalse(prefixlessUnits.containsValue(NONLINEAR));
+	}
+
+	/**
+	 * Tests that the database correctly stores and retrieves units, ignoring prefixes.
+	 * 
+	 * @since 2019-04-14
+	 * @since v0.2.0
+	 */
+	@Test
+	public void testPrefixlessUnits() {
+		final UnitsDatabase database = new UnitsDatabase();
+
+		database.addUnit("U", U);
+		database.addUnit("V", V);
+		database.addUnit("W", W);
+
+		assertTrue(database.containsUnitName("U"));
+		assertFalse(database.containsUnitName("Z"));
+
+		assertEquals(U, database.getUnit("U"));
+		assertEquals(null, database.getUnit("Z"));
+	}
+
+	/**
+	 * Test that unit expressions return the correct value.
+	 * 
+	 * @since 2019-04-14
+	 * @since v0.2.0
+	 */
+	@Test
+	public void testUnitExpressions() {
+		// load units
+		final UnitsDatabase database = new UnitsDatabase();
+
+		database.addUnit("U", U);
+		database.addUnit("V", V);
+		database.addUnit("W", W);
+		database.addUnit("fj", J.times(5));
+		database.addUnit("ej", J.times(8));
+
+		database.addPrefix("A", A);
+		database.addPrefix("B", B);
+		database.addPrefix("C", C);
+
+		// first test - test prefixes and operations
+		final Unit expected1 = J.withPrefix(A).withPrefix(B).withPrefix(C).withPrefix(C);
+		final Unit actual1 = database.getUnitFromExpression("ABV * CU^2 / W / W");
+
+		assertEquals(expected1, actual1);
+
+		// second test - test addition and subtraction
+		final Unit expected2 = J.times(58);
+		final Unit actual2 = database.getUnitFromExpression("2 fj + 6 ej");
+
+		assertEquals(expected2, actual2);
+	}
+
+	/**
+	 * Tests both the unit name iterator and the name-unit entry iterator
+	 * 
+	 * @since 2019-04-14
+	 * @since v0.2.0
+	 */
+	@Test
+	public void testUnitIterator() {
+		// load units
+		final UnitsDatabase database = new UnitsDatabase();
+
+		database.addUnit("J", J);
+
+		database.addPrefix("A", A);
+		database.addPrefix("B", B);
+		database.addPrefix("C", C);
+
+		final Iterator<String> nameIterator = database.unitMap().keySet().iterator();
+		final Iterator<Entry<String, Unit>> entryIterator = database.unitMap().entrySet().iterator();
+
+		int expectedLength = 1;
+		int unitsWithThisLengthSoFar = 0;
+
+		// loop 1000 times
+		for (int i = 0; i < 1000; i++) {
+			// expected length of next
+			if (unitsWithThisLengthSoFar >= (int) Math.pow(3, expectedLength - 1)) {
+				expectedLength++;
+				unitsWithThisLengthSoFar = 0;
+			}
+
+			final String nextName = nameIterator.next();
+			final Unit nextUnit = database.getUnit(nextName);
+			final Entry<String, Unit> nextEntry = entryIterator.next();
+
+			assertEquals(expectedLength, nextName.length());
+			assertEquals(nextName, nextEntry.getKey());
+			assertEquals(nextUnit, nextEntry.getValue());
+
+			unitsWithThisLengthSoFar++;
+		}
+	}
+
+	/**
+	 * Determine, given a unit name that could mean multiple things, which meaning is chosen.
+	 * <p>
+	 * For example, "ABCU" could mean "A-B-C-U", "AB-C-U", or "A-BC-U". In this case, "AB-C-U" is the correct choice.
+	 * </p>
+	 * 
+	 * @since 2019-04-14
+	 * @since v0.2.0
+	 */
+	@Test
+	public void testUnitPrefixCombinations() {
+		// load units
+		final UnitsDatabase database = new UnitsDatabase();
+
+		database.addUnit("J", J);
+
+		database.addPrefix("A", A);
+		database.addPrefix("B", B);
+		database.addPrefix("C", C);
+		database.addPrefix("AB", AB);
+		database.addPrefix("BC", BC);
+
+		// test 1 - AB-C-J vs A-BC-J vs A-B-C-J
+		final Unit expected1 = J.withPrefix(AB).withPrefix(C);
+		final Unit actual1 = database.getUnit("ABCJ");
+
+		assertEquals(expected1, actual1);
+
+		// test 2 - ABC-J vs AB-CJ vs AB-C-J
+		database.addUnit("CJ", J.times(13));
+		database.addPrefix("ABC", new DefaultUnitPrefix(17));
+
+		final Unit expected2 = J.times(17);
+		final Unit actual2 = database.getUnit("ABCJ");
+
+		assertEquals(expected2, actual2);
+	}
+}
diff --git a/src/test/java/package-info.java b/src/test/java/package-info.java
new file mode 100644
index 0000000..3da7fcb
--- /dev/null
+++ b/src/test/java/package-info.java
@@ -0,0 +1,24 @@
+/**
+ * Copyright (C) 2019 Adrien Hopkins
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+/**
+ * All of the Unit Converter tests. Everything in this package is NOT part of Unit Converter's public API.
+ * 
+ * @author Adrien Hopkins
+ * @since 2019-03-16
+ * @since v0.2.0
+ */
+package test.java;
\ No newline at end of file
diff --git a/src/unitConverter/UnitsDatabase.java b/src/unitConverter/UnitsDatabase.java
deleted file mode 100755
index 4816db1..0000000
--- a/src/unitConverter/UnitsDatabase.java
+++ /dev/null
@@ -1,584 +0,0 @@
-/**
- * Copyright (C) 2018 Adrien Hopkins
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package unitConverter;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileReader;
-import java.io.IOException;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-
-import unitConverter.dimension.UnitDimension;
-import unitConverter.unit.AbstractUnit;
-import unitConverter.unit.BaseUnit;
-import unitConverter.unit.DefaultUnitPrefix;
-import unitConverter.unit.LinearUnit;
-import unitConverter.unit.SI;
-import unitConverter.unit.Unit;
-import unitConverter.unit.UnitPrefix;
-
-/**
- * A database of units.
- * 
- * @author Adrien Hopkins
- * @since 2019-01-07
- * @since v0.1.0
- */
-public final class UnitsDatabase {
-	/**
-	 * The units in this system.
-	 * 
-	 * @since 2019-01-07
-	 * @since v0.1.0
-	 */
-	private final Map<String, Unit> units;
-
-	/**
-	 * The unit prefixes in this system.
-	 * 
-	 * @since 2019-01-14
-	 * @since v0.1.0
-	 */
-	private final Map<String, UnitPrefix> prefixes;
-
-	/**
-	 * Creates the {@code UnitsDatabase}.
-	 * 
-	 * @since 2019-01-10
-	 * @since v0.1.0
-	 */
-	public UnitsDatabase() {
-		this.units = new HashMap<>();
-		this.prefixes = new HashMap<>();
-	}
-
-	/**
-	 * Adds all units from a file, using data from the database to parse them.
-	 * <p>
-	 * Each line in the file should consist of a name and an expression (parsed by getUnitFromExpression) separated by
-	 * any number of tab characters.
-	 * <p>
-	 * <p>
-	 * Allowed exceptions:
-	 * <ul>
-	 * <li>Any line that begins with the '#' character is considered a comment and ignored.</li>
-	 * <li>Blank lines are also ignored</li>
-	 * <li>If an expression consists of a single exclamation point, instead of parsing it, this method will search the
-	 * database for an existing unit. If no unit is found, an IllegalArgumentException is thrown. This is used to define
-	 * initial units and ensure that the database contains them.</li>
-	 * </ul>
-	 * 
-	 * @param file
-	 *            file to read
-	 * @throws IllegalArgumentException
-	 *             if the file cannot be parsed, found or read
-	 * @throws NullPointerException
-	 *             if file is null
-	 * @since 2019-01-13
-	 * @since v0.1.0
-	 */
-	public void addAllFromFile(final File file) {
-		Objects.requireNonNull(file, "file must not be null.");
-		try (FileReader fileReader = new FileReader(file); BufferedReader reader = new BufferedReader(fileReader)) {
-			// while the reader has lines to read, read a line, then parse it, then add it
-			long lineCounter = 0;
-			while (reader.ready()) {
-				final String line = reader.readLine();
-				lineCounter++;
-
-				// ignore lines that start with a # sign - they're comments
-				if (line.startsWith("#") || line.isEmpty()) {
-					continue;
-				}
-
-				// divide line into name and expression
-				final String[] parts = line.split("\t");
-				if (parts.length < 2)
-					throw new IllegalArgumentException(String.format(
-							"Lines must consist of a unit name and its definition, separated by tab(s) (line %d).",
-							lineCounter));
-				final String name = parts[0];
-				final String expression = parts[parts.length - 1];
-
-				if (name.endsWith(" ")) {
-					System.err.printf("Warning - line %d's unit name ends in a space", lineCounter);
-				}
-
-				// if expression is "!", search for an existing unit
-				// if no unit found, throw an error
-				if (expression.equals("!")) {
-					if (!this.containsUnitName(name))
-						throw new IllegalArgumentException(
-								String.format("! used but no unit found (line %d).", lineCounter));
-				} else {
-					if (name.endsWith("-")) {
-						final UnitPrefix prefix;
-						try {
-							prefix = this.getPrefixFromExpression(expression);
-						} catch (final IllegalArgumentException e) {
-							System.err.printf("Parsing error on line %d:%n", lineCounter);
-							throw e;
-						}
-						this.addPrefix(name.substring(0, name.length() - 1), prefix);
-					} else {
-						// it's a unit, get the unit
-						final Unit unit;
-						try {
-							unit = this.getUnitFromExpression(expression);
-						} catch (final IllegalArgumentException e) {
-							System.err.printf("Parsing error on line %d:%n", lineCounter);
-							throw e;
-						}
-						AbstractUnit.incrementUnitCounter();
-						if (unit instanceof BaseUnit) {
-							AbstractUnit.incrementBaseUnitCounter();
-						}
-						this.addUnit(name, unit);
-					}
-				}
-			}
-		} catch (final FileNotFoundException e) {
-			throw new IllegalArgumentException("Could not find file " + file, e);
-		} catch (final IOException e) {
-			throw new IllegalArgumentException("Could not read file " + file, e);
-		}
-	}
-
-	/**
-	 * Adds a unit prefix to the database using a custom name
-	 * 
-	 * @param name
-	 *            prefix's name
-	 * @param prefix
-	 *            prefix to add
-	 * @throws NullPointerException
-	 *             if name or unit is null
-	 * @since 2019-01-14
-	 * @since v0.1.0
-	 */
-	public void addPrefix(final String name, final UnitPrefix prefix) {
-		this.prefixes.put(Objects.requireNonNull(name, "name must not be null."),
-				Objects.requireNonNull(prefix, "prefix must not be null."));
-	}
-
-	/**
-	 * Adds a unit to the database using a custom name
-	 * 
-	 * @param name
-	 *            unit's name
-	 * @param unit
-	 *            unit to add
-	 * @throws NullPointerException
-	 *             if unit is null
-	 * @since 2019-01-10
-	 * @since v0.1.0
-	 */
-	public void addUnit(final String name, final Unit unit) {
-		this.units.put(name, Objects.requireNonNull(unit, "unit must not be null."));
-	}
-
-	/**
-	 * Tests if the database has a unit with this name, ignoring prefixes
-	 * 
-	 * @param name
-	 *            name to test
-	 * @return if database contains name
-	 * @since 2019-01-13
-	 * @since v0.1.0
-	 */
-	public boolean containsPrefixlessUnitName(final String name) {
-		return this.units.containsKey(name);
-	}
-
-	/**
-	 * Tests if the database has a unit prefix with this name
-	 * 
-	 * @param name
-	 *            name to test
-	 * @return if database contains name
-	 * @since 2019-01-13
-	 * @since v0.1.0
-	 */
-	public boolean containsPrefixName(final String name) {
-		return this.prefixes.containsKey(name);
-	}
-
-	/**
-	 * Tests if the database has a unit with this name, taking prefixes into consideration
-	 * 
-	 * @param name
-	 *            name to test
-	 * @return if database contains name
-	 * @since 2019-01-13
-	 * @since v0.1.0
-	 */
-	public boolean containsUnitName(final String name) {
-		// check for prefixes
-		for (final String prefixName : this.prefixNameSet()) {
-			if (name.startsWith(prefixName))
-				if (this.containsUnitName(name.substring(prefixName.length())))
-					return true;
-		}
-		return this.units.containsKey(name);
-	}
-
-	/**
-	 * Gets a unit prefix from the database from its name
-	 * 
-	 * @param name
-	 *            prefix's name
-	 * @return prefix
-	 * @since 2019-01-10
-	 * @since v0.1.0
-	 */
-	public UnitPrefix getPrefix(final String name) {
-		return this.prefixes.get(name);
-	}
-
-	/**
-	 * Gets a unit prefix from a prefix expression
-	 * <p>
-	 * Currently, prefix expressions are much simpler than unit expressions: They are either a number or the name of
-	 * another prefix
-	 * </p>
-	 * 
-	 * @param expression
-	 *            expression to input
-	 * @return prefix
-	 * @throws IllegalArgumentException
-	 *             if expression cannot be parsed
-	 * @throws NullPointerException
-	 *             if any argument is null
-	 * @since 2019-01-14
-	 * @since v0.1.0
-	 */
-	public UnitPrefix getPrefixFromExpression(final String expression) {
-		Objects.requireNonNull(expression, "expression must not be null.");
-
-		try {
-			return new DefaultUnitPrefix(Double.parseDouble(expression));
-		} catch (final NumberFormatException e) {
-			if (expression.contains("^")) {
-				final String[] baseAndExponent = expression.split("\\^");
-
-				final double base;
-				try {
-					base = Double.parseDouble(baseAndExponent[0]);
-				} catch (final NumberFormatException e2) {
-					throw new IllegalArgumentException("Base of exponientation must be a number.");
-				}
-
-				final int exponent;
-				try {
-					exponent = Integer.parseInt(baseAndExponent[baseAndExponent.length - 1]);
-				} catch (final NumberFormatException e2) {
-					throw new IllegalArgumentException("Exponent must be an integer.");
-				}
-
-				return new DefaultUnitPrefix(Math.pow(base, exponent));
-			} else {
-				if (!this.containsPrefixName(expression))
-					throw new IllegalArgumentException("Unrecognized prefix name \"" + expression + "\".");
-				return this.getPrefix(expression);
-			}
-		}
-	}
-
-	/**
-	 * Gets a unit from the database from its name, ignoring prefixes.
-	 * 
-	 * @param name
-	 *            unit's name
-	 * @return unit
-	 * @since 2019-01-10
-	 * @since v0.1.0
-	 */
-	public Unit getPrefixlessUnit(final String name) {
-		return this.units.get(name);
-	}
-
-	/**
-	 * Gets a unit from the database from its name, looking for prefixes.
-	 * 
-	 * @param name
-	 *            unit's name
-	 * @return unit
-	 * @since 2019-01-10
-	 * @since v0.1.0
-	 */
-	public Unit getUnit(final String name) {
-		if (name.contains("^")) {
-			final String[] baseAndExponent = name.split("\\^");
-
-			LinearUnit base;
-			try {
-				base = SI.SI.getBaseUnit(UnitDimension.EMPTY).times(Double.parseDouble(baseAndExponent[0]));
-			} catch (final NumberFormatException e2) {
-				final Unit unit = this.getUnit(baseAndExponent[0]);
-				if (unit instanceof LinearUnit) {
-					base = (LinearUnit) unit;
-				} else if (unit instanceof BaseUnit) {
-					base = ((BaseUnit) unit).asLinearUnit();
-				} else
-					throw new IllegalArgumentException("Base of exponientation must be a linear or base unit.");
-			}
-
-			final int exponent;
-			try {
-				exponent = Integer.parseInt(baseAndExponent[baseAndExponent.length - 1]);
-			} catch (final NumberFormatException e2) {
-				throw new IllegalArgumentException("Exponent must be an integer.");
-			}
-
-			final LinearUnit exponentiated = base.toExponent(exponent);
-			if (exponentiated.getConversionFactor() == 1)
-				return exponentiated.getSystem().getBaseUnit(exponentiated.getDimension());
-			else
-				return exponentiated;
-		} else {
-			for (final String prefixName : this.prefixNameSet()) {
-				// check for a prefix
-				if (name.startsWith(prefixName)) {
-					// prefix found! Make sure what comes after it is actually a unit!
-					final String prefixless = name.substring(prefixName.length());
-					if (this.containsUnitName(prefixless)) {
-						// yep, it's a proper prefix! Get the unit!
-						final Unit unit = this.getUnit(prefixless);
-						final UnitPrefix prefix = this.getPrefix(prefixName);
-
-						// Prefixes only work with linear and base units, so make sure it's one of those
-						if (unit instanceof LinearUnit) {
-							final LinearUnit linearUnit = (LinearUnit) unit;
-							return linearUnit.times(prefix.getMultiplier());
-						} else if (unit instanceof BaseUnit) {
-							final BaseUnit baseUnit = (BaseUnit) unit;
-							return baseUnit.times(prefix.getMultiplier());
-						}
-					}
-				}
-			}
-			return this.units.get(name);
-		}
-	}
-
-	/**
-	 * Uses the database's unit data to parse an expression into a unit
-	 * <p>
-	 * The expression is a series of any of the following:
-	 * <ul>
-	 * <li>The name of a unit, which multiplies or divides the result based on preceding operators</li>
-	 * <li>The operators '*' and '/', which multiply and divide (note that just putting two units or values next to each
-	 * other is equivalent to multiplication)</li>
-	 * <li>The operator '^' which exponentiates. Exponents must be integers.</li>
-	 * <li>A number which is multiplied or divided</li>
-	 * </ul>
-	 * This method only works with linear units.
-	 * 
-	 * @param expression
-	 *            expression to parse
-	 * @throws IllegalArgumentException
-	 *             if the expression cannot be parsed
-	 * @throws NullPointerException
-	 *             if any argument is null
-	 * @since 2019-01-07
-	 * @since v0.1.0
-	 */
-	public Unit getUnitFromExpression(final String expression) {
-		Objects.requireNonNull(expression, "expression must not be null.");
-
-		// parse the expression
-		// start with an "empty" unit then apply operations on it
-		LinearUnit unit = SI.SI.getBaseUnit(UnitDimension.EMPTY).asLinearUnit();
-		boolean dividing = false;
-
-		// if I'm just creating an alias, just create one instead of going through the parsing process
-		if (!expression.contains(" ") && !expression.contains("*") && !expression.contains("/")
-				&& !expression.contains("(") && !expression.contains(")") && !expression.contains("^")) {
-			try {
-				return SI.SI.getBaseUnit(UnitDimension.EMPTY).times(Double.parseDouble(expression));
-			} catch (final NumberFormatException e) {
-				if (!this.containsUnitName(expression))
-					throw new IllegalArgumentException("Unrecognized unit name \"" + expression + "\".");
-				return this.getUnit(expression);
-			}
-		}
-
-		// \\* means "asterisk", * is reserved
-		for (final String part : expression.replaceAll("\\*", " \\* ").replaceAll("/", " / ").replaceAll(" \\^", "\\^")
-				.replaceAll("\\^ ", "\\^").split(" ")) {
-			if ("".equals(part)) {
-				continue;
-			}
-			// "unit1 unit2" is the same as "unit1 * unit2", so multiplication signs do nothing
-			if ("*".equals(part)) {
-				continue;
-			}
-			// When I reach a division sign, don't parse a unit, instead tell myself I'm going to divide the next
-			// thing
-			if ("/".equals(part) || "per".equals(part)) {
-				dividing = true;
-				continue;
-			}
-
-			try {
-				final double partAsNumber = Double.parseDouble(part); // if this works, it's a number
-				// this code should not throw any exceptions, so I'm going to throw AssertionErrors if it does
-				try {
-					if (dividing) {
-						unit = unit.dividedBy(partAsNumber);
-						dividing = false;
-					} else {
-						unit = unit.times(partAsNumber);
-					}
-				} catch (final Exception e) {
-					throw new AssertionError(e);
-				}
-			} catch (final NumberFormatException e) {
-				// it's a unit, try that
-
-				if (part.contains("(") && part.endsWith(")")) {
-					// the unitsfile is looking for a nonlinear unit
-					final String[] unitAndValue = part.split("\\(");
-
-					// this will work because I've checked that it contains a (
-					final String unitName = unitAndValue[0];
-					final String valueStringWithBracket = unitAndValue[unitAndValue.length - 1];
-					final String valueString = valueStringWithBracket.substring(0, valueStringWithBracket.length() - 1);
-					final double value;
-
-					// try to get the value - else throw an error
-					try {
-						value = Double.parseDouble(valueString);
-					} catch (final NumberFormatException e2) {
-						throw new IllegalArgumentException("Unparseable value " + valueString);
-					}
-
-					// get this unit in a linear form
-					if (!this.containsPrefixlessUnitName(unitName))
-						throw new IllegalArgumentException("Unrecognized unit name \"" + part + "\".");
-					final Unit partUnit = this.getPrefixlessUnit(unitName);
-					final LinearUnit multiplier = partUnit.getBase().times(partUnit.convertToBase(value));
-
-					// finally, add it to the expression
-					if (dividing) {
-						unit = unit.dividedBy(multiplier);
-						dividing = false;
-					} else {
-						unit = unit.times(multiplier);
-					}
-				} else {
-					// check for exponientation
-					if (part.contains("^")) {
-						final String[] valueAndExponent = part.split("\\^");
-						// this will always work because of the contains check
-						final String valueString = valueAndExponent[0];
-						final String exponentString = valueAndExponent[valueAndExponent.length - 1];
-
-						LinearUnit value;
-
-						// first, try to get the value
-						try {
-							final double valueAsNumber = Double.parseDouble(valueString);
-
-							value = SI.SI.getBaseUnit(UnitDimension.EMPTY).times(valueAsNumber);
-						} catch (final NumberFormatException e2) {
-
-							// look for a unit
-							if (!this.containsUnitName(valueString))
-								throw new IllegalArgumentException("Unrecognized unit name \"" + valueString + "\".");
-							final Unit valueUnit = this.getUnit(valueString);
-
-							// try to turn the value into a linear unit
-							if (valueUnit instanceof LinearUnit) {
-								value = (LinearUnit) valueUnit;
-							} else if (valueUnit instanceof BaseUnit) {
-								value = ((BaseUnit) valueUnit).asLinearUnit();
-							} else
-								throw new IllegalArgumentException("Only linear and base units can be exponientated.");
-						}
-
-						// now, try to get the exponent
-						final int exponent;
-						try {
-							exponent = Integer.parseInt(exponentString);
-						} catch (final NumberFormatException e2) {
-							throw new IllegalArgumentException("Exponents must be integers.");
-						}
-
-						final LinearUnit exponientated = value.toExponent(exponent);
-
-						if (dividing) {
-							unit = unit.dividedBy(exponientated);
-							dividing = false;
-						} else {
-							unit = unit.times(exponientated);
-						}
-					} else {
-						// no exponent - look for a unit
-						// the unitsfile is looking for a linear unit
-						if (!this.containsUnitName(part))
-							throw new IllegalArgumentException("Unrecognized unit name \"" + part + "\".");
-						Unit other = this.getUnit(part);
-						if (other instanceof BaseUnit) {
-							other = ((BaseUnit) other).asLinearUnit();
-						}
-						if (other instanceof LinearUnit) {
-							if (dividing) {
-								unit = unit.dividedBy((LinearUnit) other);
-								dividing = false;
-							} else {
-								unit = unit.times((LinearUnit) other);
-							}
-						} else
-							throw new IllegalArgumentException(
-									"Only linear or base units can be multiplied and divided.  If you want to use a non-linear unit, try the format UNITNAME(VALUE).");
-					}
-				}
-			}
-		}
-
-		// replace conversion-factor-1 linear units with base units
-		// this improves the autogenerated names, allowing them to use derived SI names
-		if (unit != null && unit.getConversionFactor() == 1)
-			return unit.getSystem().getBaseUnit(unit.getDimension());
-		else
-			return unit;
-	}
-
-	/**
-	 * @return an immutable set of all of the unit names in this database, ignoring prefixes
-	 * @since 2019-01-14
-	 * @since v0.1.0
-	 */
-	public Set<String> prefixlessUnitNameSet() {
-		return Collections.unmodifiableSet(this.units.keySet());
-	}
-
-	/**
-	 * @return an immutable set of all of the prefix names in this database
-	 * @since 2019-01-14
-	 * @since v0.1.0
-	 */
-	public Set<String> prefixNameSet() {
-		return Collections.unmodifiableSet(this.prefixes.keySet());
-	}
-}
diff --git a/src/unitConverter/converterGUI/UnitConverterGUI.java b/src/unitConverter/converterGUI/UnitConverterGUI.java
deleted file mode 100755
index b54e0da..0000000
--- a/src/unitConverter/converterGUI/UnitConverterGUI.java
+++ /dev/null
@@ -1,671 +0,0 @@
-/**
- * Copyright (C) 2018 Adrien Hopkins
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package unitConverter.converterGUI;
-
-import java.awt.BorderLayout;
-import java.awt.GridLayout;
-import java.io.File;
-import java.math.BigDecimal;
-import java.math.MathContext;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
-import java.util.function.Predicate;
-
-import javax.swing.BorderFactory;
-import javax.swing.JButton;
-import javax.swing.JFrame;
-import javax.swing.JList;
-import javax.swing.JOptionPane;
-import javax.swing.JPanel;
-import javax.swing.JScrollPane;
-import javax.swing.JSlider;
-import javax.swing.JTabbedPane;
-import javax.swing.JTextArea;
-import javax.swing.JTextField;
-import javax.swing.ListModel;
-import javax.swing.ListSelectionModel;
-
-import unitConverter.UnitsDatabase;
-import unitConverter.dimension.StandardDimensions;
-import unitConverter.dimension.UnitDimension;
-import unitConverter.unit.AbstractUnit;
-import unitConverter.unit.NonlinearUnits;
-import unitConverter.unit.SI;
-import unitConverter.unit.Unit;
-import unitConverter.unit.UnitPrefix;
-
-/**
- * @author Adrien Hopkins
- * @since 2018-12-27
- * @since v0.1.0
- */
-final class UnitConverterGUI {
-	private static class Presenter {
-		/** The presenter's associated view. */
-		private final View view;
-
-		/** The units known by the program. */
-		private final UnitsDatabase units;
-
-		/** The names of all of the units */
-		private final List<String> unitNames;
-
-		/** The names of all of the units, but filtered */
-		private final DelegateListModel<String> unitNamesFiltered;
-
-		/** The names of all of the prefixes */
-		private final List<String> prefixNames;
-
-		/** The names of all of the prefixes */
-		private final DelegateListModel<String> prefixNamesFiltered;
-
-		private final Comparator<String> prefixNameComparator;
-
-		private int significantFigures = 6;
-
-		/**
-		 * Creates the presenter.
-		 * 
-		 * @param view
-		 *            presenter's associated view
-		 * @since 2018-12-27
-		 * @since v0.1.0
-		 */
-		Presenter(final View view) {
-			this.view = view;
-
-			// load initial units
-			this.units = new UnitsDatabase();
-			this.units.addUnit("metre", SI.METRE);
-			this.units.addUnit("kilogram", SI.KILOGRAM);
-			this.units.addUnit("gram", SI.KILOGRAM.dividedBy(1000));
-			this.units.addUnit("second", SI.SECOND);
-			this.units.addUnit("ampere", SI.AMPERE);
-			this.units.addUnit("kelvin", SI.KELVIN);
-			this.units.addUnit("mole", SI.MOLE);
-			this.units.addUnit("candela", SI.CANDELA);
-			this.units.addUnit("bit", SI.SI.getBaseUnit(StandardDimensions.INFORMATION));
-			this.units.addUnit("unit", SI.SI.getBaseUnit(UnitDimension.EMPTY));
-			// nonlinear units - must be loaded manually
-			this.units.addUnit("tempCelsius", NonlinearUnits.CELSIUS);
-			this.units.addUnit("tempFahrenheit", NonlinearUnits.FAHRENHEIT);
-
-			this.units.addAllFromFile(new File("unitsfile.txt"));
-
-			// a comparator that can be used to compare prefix names
-			// any name that does not exist is less than a name that does.
-			// otherwise, they are compared by value
-			this.prefixNameComparator = (o1, o2) -> {
-				if (!Presenter.this.units.containsPrefixName(o1))
-					return -1;
-				else if (!Presenter.this.units.containsPrefixName(o2))
-					return 1;
-
-				final UnitPrefix p1 = Presenter.this.units.getPrefix(o1);
-				final UnitPrefix p2 = Presenter.this.units.getPrefix(o2);
-
-				if (p1.getMultiplier() < p2.getMultiplier())
-					return -1;
-				else if (p1.getMultiplier() > p2.getMultiplier())
-					return 1;
-
-				return o1.compareTo(o2);
-			};
-
-			this.unitNames = new ArrayList<>(this.units.prefixlessUnitNameSet());
-			this.unitNames.sort(null); // sorts it using Comparable
-
-			this.unitNamesFiltered = new DelegateListModel<>(new ArrayList<>(this.units.prefixlessUnitNameSet()));
-			this.unitNamesFiltered.sort(null); // sorts it using Comparable
-
-			this.prefixNames = new ArrayList<>(this.units.prefixNameSet());
-			this.prefixNames.sort(this.prefixNameComparator); // sorts it using my comparator
-
-			this.prefixNamesFiltered = new DelegateListModel<>(new ArrayList<>(this.units.prefixNameSet()));
-			this.prefixNamesFiltered.sort(this.prefixNameComparator); // sorts it using my comparator
-
-			System.out.printf("Successfully loaded %d units (%d base units)", AbstractUnit.getUnitCount(),
-					AbstractUnit.getBaseUnitCount());
-		}
-
-		/**
-		 * Runs whenever the convert button is pressed.
-		 * 
-		 * <p>
-		 * Reads and parses a unit expression from the from and to boxes, then converts {@code from} to {@code to}. Any
-		 * errors are shown in JOptionPanes.
-		 * </p>
-		 * 
-		 * @since 2019-01-26
-		 * @since v0.1.0
-		 */
-		public final void convert() {
-			final String fromUnitString = this.view.getFromText();
-			final String toUnitString = this.view.getToText();
-
-			// try to parse from
-			final Unit from;
-			try {
-				from = this.units.getUnitFromExpression(fromUnitString);
-			} catch (final IllegalArgumentException e) {
-				this.view.showErrorDialog("Parse Error", "Could not recognize text in From entry: " + e.getMessage());
-				return;
-			}
-
-			final double value;
-			// try to parse to
-			final Unit to;
-			try {
-				to = this.units.getUnitFromExpression(toUnitString);
-			} catch (final IllegalArgumentException e) {
-				this.view.showErrorDialog("Parse Error", "Could not recognize text in To entry: " + e.getMessage());
-				return;
-			}
-
-			// if I can't convert, leave
-			if (!from.canConvertTo(to)) {
-				this.view.showErrorDialog("Conversion Error",
-						String.format("Cannot convert between %s and %s", fromUnitString, toUnitString));
-				return;
-			}
-
-			value = to.convertFromBase(from.convertToBase(1));
-
-			// round value
-			final BigDecimal bigValue = new BigDecimal(value).round(new MathContext(this.significantFigures));
-			String output = bigValue.toString();
-
-			// remove trailing zeroes
-			if (output.contains(".")) {
-				while (output.endsWith("0")) {
-					output = output.substring(0, output.length() - 1);
-				}
-				if (output.endsWith(".")) {
-					output = output.substring(0, output.length() - 1);
-				}
-			}
-
-			this.view.setOutputText(String.format("%s = %s %s", fromUnitString, output, toUnitString));
-		}
-
-		/**
-		 * Filters the filtered model for units
-		 * 
-		 * @param filter
-		 *            filter to use
-		 * @since 2019-01-15
-		 * @since v0.1.0
-		 */
-		private final void filterFilteredPrefixModel(final Predicate<String> filter) {
-			this.prefixNamesFiltered.clear();
-			for (final String prefixName : this.prefixNames) {
-				if (filter.test(prefixName)) {
-					this.prefixNamesFiltered.add(prefixName);
-				}
-			}
-		}
-
-		/**
-		 * Filters the filtered model for units
-		 * 
-		 * @param filter
-		 *            filter to use
-		 * @since 2019-01-15
-		 * @since v0.1.0
-		 */
-		private final void filterFilteredUnitModel(final Predicate<String> filter) {
-			this.unitNamesFiltered.clear();
-			for (final String unitName : this.unitNames) {
-				if (filter.test(unitName)) {
-					this.unitNamesFiltered.add(unitName);
-				}
-			}
-		}
-
-		/**
-		 * @return a list model of all of the unit keys
-		 * @since 2019-01-14
-		 * @since v0.1.0
-		 */
-		public final ListModel<String> keyListModel() {
-			return this.unitNamesFiltered;
-		}
-
-		/**
-		 * Runs whenever the prefix filter is changed.
-		 * <p>
-		 * Filters the prefix list then sorts it using a {@code FilterComparator}.
-		 * </p>
-		 * 
-		 * @since 2019-01-15
-		 * @since v0.1.0
-		 */
-		public final void prefixFilterUpdated() {
-			final String filter = this.view.getPrefixFilterText();
-			if (filter.equals("")) {
-				this.filterFilteredPrefixModel(t -> true);
-			} else {
-				this.filterFilteredPrefixModel(t -> t.contains(filter));
-			}
-			this.prefixNamesFiltered.sort(new FilterComparator(filter));
-		}
-
-		/**
-		 * @return a list model of all of the prefix names
-		 * @since 2019-01-15
-		 */
-		public final ListModel<String> prefixNameListModel() {
-			return this.prefixNamesFiltered;
-		}
-
-		/**
-		 * Runs whenever a prefix is selected in the viewer.
-		 * <p>
-		 * Shows its information in the text box to the right.
-		 * </p>
-		 * 
-		 * @since 2019-01-15
-		 * @since v0.1.0
-		 */
-		public final void prefixSelected() {
-			final int index = this.view.getPrefixListSelection();
-			if (index == -1)
-				return;
-			else {
-				final String prefixName = this.prefixNamesFiltered.get(index);
-				final UnitPrefix prefix = this.units.getPrefix(prefixName);
-
-				this.view.setPrefixTextBoxText(String.format("%s%nMultiplier: %s", prefixName, prefix.getMultiplier()));
-			}
-		}
-
-		/**
-		 * @param significantFigures
-		 *            new value of significantFigures
-		 * @since 2019-01-15
-		 */
-		public final void setSignificantFigures(final int significantFigures) {
-			this.significantFigures = significantFigures;
-		}
-
-		/**
-		 * Runs whenever the unit filter is changed.
-		 * <p>
-		 * Filters the unit list then sorts it using a {@code FilterComparator}.
-		 * </p>
-		 * 
-		 * @since 2019-01-15
-		 * @since v0.1.0
-		 */
-		public final void unitFilterUpdated() {
-			final String filter = this.view.getUnitFilterText();
-			if (filter.equals("")) {
-				this.filterFilteredUnitModel(t -> true);
-			} else {
-				this.filterFilteredUnitModel(t -> t.contains(filter));
-			}
-			this.unitNamesFiltered.sort(new FilterComparator(filter));
-		}
-
-		/**
-		 * Runs whenever a unit is selected in the viewer.
-		 * <p>
-		 * Shows its information in the text box to the right.
-		 * </p>
-		 * 
-		 * @since 2019-01-15
-		 * @since v0.1.0
-		 */
-		public void unitNameSelected() {
-			final int index = this.view.getUnitListSelection();
-			if (index == -1)
-				return;
-			else {
-				final String unitName = this.unitNamesFiltered.get(index);
-				final Unit unit = this.units.getUnit(unitName);
-
-				this.view.setUnitTextBoxText(unit.toString());
-			}
-		}
-	}
-
-	private static class View {
-		/** The view's frame. */
-		private final JFrame frame;
-		/** The view's associated presenter. */
-		private final Presenter presenter;
-
-		/** The list of unit names in the unit viewer */
-		private final JList<String> unitNameList;
-		/** The list of prefix names in the prefix viewer */
-		private final JList<String> prefixNameList;
-		/** The unit search box in the unit viewer */
-		private final JTextField unitFilterEntry;
-		/** The text box for unit data in the unit viewer */
-		private final JTextArea unitTextBox;
-		/** The prefix search box in the prefix viewer */
-		private final JTextField prefixFilterEntry;
-		/** The text box for prefix data in the prefix viewer */
-		private final JTextArea prefixTextBox;
-		/** The "From" entry in the conversion panel */
-		private final JTextField fromEntry;
-		/** The "To" entry in the conversion panel */
-		private final JTextField toEntry;
-		/** The output area in the conversion panel */
-		private final JTextArea output;
-
-		/**
-		 * Creates the {@code View}.
-		 * 
-		 * @since 2019-01-14
-		 * @since v0.1.0
-		 */
-		public View() {
-			this.presenter = new Presenter(this);
-			this.frame = new JFrame("Unit Converter");
-			this.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-
-			// create the components
-			this.unitNameList = new JList<>(this.presenter.keyListModel());
-			this.prefixNameList = new JList<>(this.presenter.prefixNameListModel());
-			this.unitFilterEntry = new JTextField();
-			this.unitTextBox = new JTextArea();
-			this.prefixFilterEntry = new JTextField();
-			this.prefixTextBox = new JTextArea();
-			this.fromEntry = new JTextField();
-			this.toEntry = new JTextField();
-			this.output = new JTextArea(2, 32);
-
-			// create more components
-			this.initComponents();
-
-			this.frame.pack();
-		}
-
-		/**
-		 * @return text in "From" box in converter panel
-		 * @since 2019-01-15
-		 * @since v0.1.0
-		 */
-		public String getFromText() {
-			return this.fromEntry.getText();
-		}
-
-		/**
-		 * @return text in prefix filter
-		 * @since 2019-01-15
-		 * @since v0.1.0
-		 */
-		public String getPrefixFilterText() {
-			return this.prefixFilterEntry.getText();
-		}
-
-		/**
-		 * @return index of selected prefix
-		 * @since 2019-01-15
-		 * @since v0.1.0
-		 */
-		public int getPrefixListSelection() {
-			return this.prefixNameList.getSelectedIndex();
-		}
-
-		/**
-		 * @return text in "To" box in converter panel
-		 * @since 2019-01-26
-		 * @since v0.1.0
-		 */
-		public String getToText() {
-			return this.toEntry.getText();
-		}
-
-		/**
-		 * @return text in unit filter
-		 * @see javax.swing.text.JTextComponent#getText()
-		 */
-		public String getUnitFilterText() {
-			return this.unitFilterEntry.getText();
-		}
-
-		/**
-		 * @return index of selected unit
-		 * @since 2019-01-15
-		 * @since v0.1.0
-		 */
-		public int getUnitListSelection() {
-			return this.unitNameList.getSelectedIndex();
-		}
-
-		/**
-		 * Starts up the application.
-		 * 
-		 * @since 2018-12-27
-		 * @since v0.1.0
-		 */
-		public final void init() {
-			this.frame.setVisible(true);
-		}
-
-		/**
-		 * Initializes the view's components.
-		 * 
-		 * @since 2018-12-27
-		 * @since v0.1.0
-		 */
-		private final void initComponents() {
-			final JPanel masterPanel = new JPanel();
-			this.frame.add(masterPanel);
-
-			masterPanel.setLayout(new BorderLayout());
-
-			{ // pane with all of the tabs
-				final JTabbedPane masterPane = new JTabbedPane();
-				masterPanel.add(masterPane, BorderLayout.CENTER);
-
-				{ // panel for unit conversion
-					final JPanel convertPanel = new JPanel();
-					masterPane.addTab("Convert Units", convertPanel);
-
-					convertPanel.setLayout(new GridLayout(5, 1));
-
-					{ // panel for units to convert from
-						final JPanel fromPanel = new JPanel();
-						convertPanel.add(fromPanel);
-
-						fromPanel.setBorder(BorderFactory.createTitledBorder("From"));
-						fromPanel.setLayout(new GridLayout(1, 1));
-
-						{ // entry for units
-							fromPanel.add(this.fromEntry);
-						}
-					}
-
-					{ // panel for units to convert to
-						final JPanel toPanel = new JPanel();
-						convertPanel.add(toPanel);
-
-						toPanel.setBorder(BorderFactory.createTitledBorder("To"));
-						toPanel.setLayout(new GridLayout(1, 1));
-
-						{ // entry for units
-							toPanel.add(this.toEntry);
-						}
-					}
-
-					{ // button to convert
-						final JButton convertButton = new JButton("Convert!");
-						convertPanel.add(convertButton);
-
-						convertButton.addActionListener(e -> this.presenter.convert());
-					}
-
-					{ // output of conversion
-						final JPanel outputPanel = new JPanel();
-						convertPanel.add(outputPanel);
-
-						outputPanel.setBorder(BorderFactory.createTitledBorder("Output"));
-						outputPanel.setLayout(new GridLayout(1, 1));
-
-						{ // output
-							outputPanel.add(this.output);
-							this.output.setEditable(false);
-						}
-					}
-
-					{ // panel for specifying precision
-						final JPanel sigDigPanel = new JPanel();
-						convertPanel.add(sigDigPanel);
-
-						sigDigPanel.setBorder(BorderFactory.createTitledBorder("Significant Digits"));
-
-						{ // slider
-							final JSlider sigDigSlider = new JSlider(0, 12);
-							sigDigPanel.add(sigDigSlider);
-
-							sigDigSlider.setMajorTickSpacing(4);
-							sigDigSlider.setMinorTickSpacing(1);
-							sigDigSlider.setSnapToTicks(true);
-							sigDigSlider.setPaintTicks(true);
-							sigDigSlider.setPaintLabels(true);
-
-							sigDigSlider.addChangeListener(
-									e -> this.presenter.setSignificantFigures(sigDigSlider.getValue()));
-						}
-					}
-				}
-
-				{ // panel to look up units
-					final JPanel unitLookupPanel = new JPanel();
-					masterPane.addTab("Unit Viewer", unitLookupPanel);
-
-					unitLookupPanel.setLayout(new GridLayout());
-
-					{ // panel for listing and searching
-						final JPanel listPanel = new JPanel();
-						unitLookupPanel.add(listPanel);
-
-						listPanel.setLayout(new BorderLayout());
-
-						{ // unit search box
-							listPanel.add(this.unitFilterEntry, BorderLayout.PAGE_START);
-							this.unitFilterEntry.addCaretListener(e -> this.presenter.unitFilterUpdated());
-						}
-
-						{ // a list of units
-							listPanel.add(new JScrollPane(this.unitNameList), BorderLayout.CENTER);
-							this.unitNameList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); // temp
-							this.unitNameList.addListSelectionListener(e -> {
-								this.presenter.unitNameSelected();
-							});
-						}
-					}
-
-					{ // the text box for unit's toString
-						unitLookupPanel.add(this.unitTextBox);
-						this.unitTextBox.setEditable(false);
-						this.unitTextBox.setLineWrap(true);
-					}
-				}
-
-				{ // panel to look up prefixes
-					final JPanel prefixLookupPanel = new JPanel();
-					masterPane.addTab("Prefix Viewer", prefixLookupPanel);
-
-					prefixLookupPanel.setLayout(new GridLayout(1, 2));
-
-					{ // panel for listing and seaching
-						final JPanel prefixListPanel = new JPanel();
-						prefixLookupPanel.add(prefixListPanel);
-
-						prefixListPanel.setLayout(new BorderLayout());
-
-						{ // prefix search box
-							prefixListPanel.add(this.prefixFilterEntry, BorderLayout.PAGE_START);
-							this.prefixFilterEntry.addCaretListener(e -> this.presenter.prefixFilterUpdated());
-						}
-
-						{ // a list of prefixes
-							prefixListPanel.add(new JScrollPane(this.prefixNameList), BorderLayout.CENTER);
-							this.prefixNameList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); // temp
-							this.prefixNameList.addListSelectionListener(e -> {
-								this.presenter.prefixSelected();
-							});
-						}
-					}
-
-					{ // the text box for prefix's toString
-						prefixLookupPanel.add(this.prefixTextBox);
-						this.unitTextBox.setEditable(false);
-					}
-				}
-			}
-		}
-
-		/**
-		 * Sets the text in the output of the conversion panel.
-		 * 
-		 * @param text
-		 *            text to set
-		 * @since 2019-01-15
-		 * @since v0.1.0
-		 */
-		public void setOutputText(final String text) {
-			this.output.setText(text);
-		}
-
-		/**
-		 * Sets the text of the prefix text box.
-		 * 
-		 * @param text
-		 *            text to set
-		 * @since 2019-01-15
-		 * @since v0.1.0
-		 */
-		public void setPrefixTextBoxText(final String text) {
-			this.prefixTextBox.setText(text);
-		}
-
-		/**
-		 * Sets the text of the unit text box.
-		 * 
-		 * @param t
-		 *            text to set
-		 * @see javax.swing.text.JTextComponent#setText(java.lang.String)
-		 */
-		public void setUnitTextBoxText(final String t) {
-			this.unitTextBox.setText(t);
-		}
-
-		/**
-		 * Shows an error dialog.
-		 * 
-		 * @param title
-		 *            title of dialog
-		 * @param message
-		 *            message in dialog
-		 * @since 2019-01-14
-		 * @since v0.1.0
-		 */
-		public void showErrorDialog(final String title, final String message) {
-			JOptionPane.showMessageDialog(this.frame, message, title, JOptionPane.ERROR_MESSAGE);
-		}
-	}
-
-	public static void main(final String[] args) {
-		new View().init();
-	}
-}
diff --git a/src/unitConverter/unit/BaseUnit.java b/src/unitConverter/unit/BaseUnit.java
deleted file mode 100755
index fe36c45..0000000
--- a/src/unitConverter/unit/BaseUnit.java
+++ /dev/null
@@ -1,180 +0,0 @@
-/**
- * Copyright (C) 2018 Adrien Hopkins
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package unitConverter.unit;
-
-import java.util.Objects;
-
-import unitConverter.dimension.UnitDimension;
-
-/**
- * A unit that is the base for its dimension. It does not have to be for a base dimension, so units like the Newton and
- * Joule are still base units.
- * 
- * @author Adrien Hopkins
- * @since 2018-12-23
- * @since v0.1.0
- */
-public final class BaseUnit extends AbstractUnit {
-	/**
-	 * Is this unit a full base (i.e. m, s, ... but not N, J, ...)
-	 * 
-	 * @since 2019-01-15
-	 * @since v0.1.0
-	 */
-	private final boolean isFullBase;
-
-	/**
-	 * Creates the {@code BaseUnit}.
-	 * 
-	 * @param dimension
-	 *            dimension measured by unit
-	 * @param system
-	 *            system that unit is a part of
-	 * @param name
-	 *            name of unit
-	 * @param symbol
-	 *            symbol of unit
-	 * @since 2018-12-23
-	 * @since v0.1.0
-	 */
-	BaseUnit(final UnitDimension dimension, final UnitSystem system) {
-		super(dimension, system);
-		this.isFullBase = dimension.isBase();
-	}
-
-	/**
-	 * @return this unit as a {@code LinearUnit}
-	 * @since 2019-01-25
-	 * @since v0.1.0
-	 */
-	public LinearUnit asLinearUnit() {
-		return this.times(1);
-	}
-
-	@Override
-	public double convertFromBase(final double value) {
-		return value;
-	}
-
-	@Override
-	public double convertToBase(final double value) {
-		return value;
-	}
-
-	/**
-	 * Divides this unit by another unit.
-	 * 
-	 * @param other
-	 *            unit to divide by
-	 * @return quotient of two units
-	 * @throws IllegalArgumentException
-	 *             if this unit's system is not other's system
-	 * @throws NullPointerException
-	 *             if other is null
-	 * @since 2018-12-22
-	 * @since v0.1.0
-	 */
-	public BaseUnit dividedBy(final BaseUnit other) {
-		Objects.requireNonNull(other, "other must not be null.");
-		if (!this.getSystem().equals(other.getSystem()))
-			throw new IllegalArgumentException("Incompatible base units for division.");
-		return new BaseUnit(this.getDimension().dividedBy(other.getDimension()), this.getSystem());
-	}
-
-	/**
-	 * Divides this unit by a divisor
-	 * 
-	 * @param divisor
-	 *            amount to divide by
-	 * @return quotient
-	 * @since 2018-12-23
-	 * @since v0.1.0
-	 */
-	public LinearUnit dividedBy(final double divisor) {
-		return new LinearUnit(this, 1 / divisor);
-	}
-
-	@Override
-	public boolean equals(final Object obj) {
-		if (!(obj instanceof BaseUnit))
-			return false;
-		final BaseUnit other = (BaseUnit) obj;
-		return Objects.equals(this.getSystem(), other.getSystem())
-				&& Objects.equals(this.getDimension(), other.getDimension());
-	}
-
-	@Override
-	public int hashCode() {
-		final int prime = 31;
-		int result = 1;
-		result = result * prime + this.getSystem().hashCode();
-		result = result * prime + this.getDimension().hashCode();
-		return result;
-	}
-
-	/**
-	 * Multiplies this unit by another unit.
-	 * 
-	 * @param other
-	 *            unit to multiply by
-	 * @return product of two units
-	 * @throws IllegalArgumentException
-	 *             if this unit's system is not other's system
-	 * @throws NullPointerException
-	 *             if other is null
-	 * @since 2018-12-22
-	 * @since v0.1.0
-	 */
-	public BaseUnit times(final BaseUnit other) {
-		Objects.requireNonNull(other, "other must not be null.");
-		if (!this.getSystem().equals(other.getSystem()))
-			throw new IllegalArgumentException("Incompatible base units for multiplication.");
-		return new BaseUnit(this.getDimension().times(other.getDimension()), this.getSystem());
-	}
-
-	/**
-	 * Multiplies this unit by a multiplier.
-	 * 
-	 * @param multiplier
-	 *            amount to multiply by
-	 * @return product
-	 * @since 2018-12-23
-	 * @since v0.1.0
-	 */
-	public LinearUnit times(final double multiplier) {
-		return new LinearUnit(this, multiplier);
-	}
-
-	/**
-	 * Returns this unit, but to an exponent.
-	 * 
-	 * @param exponent
-	 *            exponent
-	 * @return result of exponentiation
-	 * @since 2019-01-15
-	 * @since v0.1.0
-	 */
-	public BaseUnit toExponent(final int exponent) {
-		return this.getSystem().getBaseUnit(this.getDimension().toExponent(exponent));
-	}
-
-	@Override
-	public String toString() {
-		return String.format("%s base unit of%s dimension %s", this.getSystem(), this.isFullBase ? " base" : "",
-				this.getDimension());
-	}
-}
diff --git a/src/unitConverter/unit/LinearUnit.java b/src/unitConverter/unit/LinearUnit.java
deleted file mode 100644
index b786b3b..0000000
--- a/src/unitConverter/unit/LinearUnit.java
+++ /dev/null
@@ -1,184 +0,0 @@
-/**
- * Copyright (C) 2019 Adrien Hopkins
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package unitConverter.unit;
-
-import java.util.Objects;
-
-import unitConverter.dimension.UnitDimension;
-
-/**
- * A unit that is equal to a certain number multiplied by its base.
- * 
- * @author Adrien Hopkins
- * @since 2018-12-22
- * @since v0.1.0
- */
-public final class LinearUnit extends AbstractUnit {
-	/**
-	 * The value of one of this unit in this unit's base unit
-	 * 
-	 * @since 2018-12-22
-	 * @since v0.1.0
-	 */
-	private final double conversionFactor;
-
-	/**
-	 * 
-	 * Creates the {@code LinearUnit}.
-	 * 
-	 * @param base
-	 *            unit's base
-	 * @param conversionFactor
-	 *            value of one of this unit in its base
-	 * @since 2018-12-23
-	 * @since v0.1.0
-	 */
-	LinearUnit(final BaseUnit base, final double conversionFactor) {
-		super(base);
-		this.conversionFactor = conversionFactor;
-	}
-
-	/**
-	 * Creates the {@code LinearUnit} as a base unit.
-	 * 
-	 * @param dimension
-	 *            dimension measured by unit
-	 * @param system
-	 *            system unit is part of
-	 * @since 2019-01-25
-	 * @since v0.1.0
-	 */
-	LinearUnit(final UnitDimension dimension, final UnitSystem system, final double conversionFactor) {
-		super(dimension, system);
-		this.conversionFactor = conversionFactor;
-	}
-
-	@Override
-	public double convertFromBase(final double value) {
-		return value / this.getConversionFactor();
-	}
-
-	@Override
-	public double convertToBase(final double value) {
-		return value * this.getConversionFactor();
-	}
-
-	/**
-	 * Divides this unit by a scalar.
-	 * 
-	 * @param divisor
-	 *            scalar to divide by
-	 * @return quotient
-	 * @since 2018-12-23
-	 * @since v0.1.0
-	 */
-	public LinearUnit dividedBy(final double divisor) {
-		return new LinearUnit(this.getBase(), this.getConversionFactor() / divisor);
-	}
-
-	/**
-	 * Divides this unit by another unit.
-	 * 
-	 * @param other
-	 *            unit to divide by
-	 * @return quotient of two units
-	 * @throws NullPointerException
-	 *             if other is null
-	 * @since 2018-12-22
-	 * @since v0.1.0
-	 */
-	public LinearUnit dividedBy(final LinearUnit other) {
-		Objects.requireNonNull(other, "other must not be null");
-		final BaseUnit base = this.getBase().dividedBy(other.getBase());
-		return new LinearUnit(base, this.getConversionFactor() / other.getConversionFactor());
-	}
-
-	@Override
-	public boolean equals(final Object obj) {
-		if (!(obj instanceof LinearUnit))
-			return false;
-		final LinearUnit other = (LinearUnit) obj;
-		return Objects.equals(this.getBase(), other.getBase())
-				&& Objects.equals(this.getConversionFactor(), other.getConversionFactor());
-	}
-
-	/**
-	 * @return conversionFactor
-	 * @since 2018-12-22
-	 * @since v0.1.0
-	 */
-	public final double getConversionFactor() {
-		return this.conversionFactor;
-	}
-
-	@Override
-	public int hashCode() {
-		final int prime = 31;
-		int result = 1;
-		result = result * prime + this.getBase().hashCode();
-		result = result * prime + Double.hashCode(this.getConversionFactor());
-		return result;
-	}
-
-	/**
-	 * Multiplies this unit by a scalar.
-	 * 
-	 * @param multiplier
-	 *            scalar to multiply by
-	 * @return product
-	 * @since 2018-12-23
-	 * @since v0.1.0
-	 */
-	public LinearUnit times(final double multiplier) {
-		return new LinearUnit(this.getBase(), this.getConversionFactor() * multiplier);
-	}
-
-	/**
-	 * Multiplies this unit by another unit.
-	 * 
-	 * @param other
-	 *            unit to multiply by=
-	 * @return product of two units
-	 * @throws NullPointerException
-	 *             if other is null
-	 * @since 2018-12-22
-	 * @since v0.1.0
-	 */
-	public LinearUnit times(final LinearUnit other) {
-		Objects.requireNonNull(other, "other must not be null");
-		final BaseUnit base = this.getBase().times(other.getBase());
-		return new LinearUnit(base, this.getConversionFactor() * other.getConversionFactor());
-	}
-
-	/**
-	 * Returns this unit but to an exponent.
-	 * 
-	 * @param exponent
-	 *            exponent to exponientate unit to
-	 * @return exponientated unit
-	 * @since 2019-01-15
-	 * @since v0.1.0
-	 */
-	public LinearUnit toExponent(final int exponent) {
-		return new LinearUnit(this.getBase().toExponent(exponent), Math.pow(this.conversionFactor, exponent));
-	}
-
-	@Override
-	public String toString() {
-		return super.toString() + String.format(" (equal to %s * base)", this.getConversionFactor());
-	}
-}
diff --git a/src/unitConverter/unit/UnitTest.java b/src/unitConverter/unit/UnitTest.java
deleted file mode 100755
index c3237eb..0000000
--- a/src/unitConverter/unit/UnitTest.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/**
- * Copyright (C) 2018 Adrien Hopkins
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package unitConverter.unit;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import org.junit.jupiter.api.Test;
-
-import unitConverter.dimension.StandardDimensions;
-
-/**
- * Testing the various Unit classes
- * 
- * @author Adrien Hopkins
- * @since 2018-12-22
- */
-class UnitTest {
-	@Test
-	void testConversion() {
-		final BaseUnit metre = SI.METRE;
-		final Unit inch = metre.times(0.0254);
-
-		assertEquals(1.9, inch.convertToBase(75), 0.01);
-	}
-
-	@Test
-	void testEquals() {
-		final BaseUnit metre = SI.METRE;
-		final Unit meter = SI.SI.getBaseUnit(StandardDimensions.LENGTH);
-
-		assertEquals(metre, meter);
-	}
-}