diff --git a/build.gradle.kts b/build.gradle.kts
index 44e87fd..3f7d095 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -31,6 +31,7 @@ dependencies {
     testImplementation("org.assertj", "assertj-core", "3.22.0")
     testImplementation("org.junit.jupiter", "junit-jupiter-api", "5.8.2")
     testRuntimeOnly("org.junit.jupiter", "junit-jupiter-engine", "5.8.2")
+    implementation(kotlin("reflect"))
 }
 
 tasks {
@@ -94,13 +95,20 @@ tasks {
 // By default, build everything, put it somewhere convenient, and run the tests.
 defaultTasks = mutableListOf("build", "test")
 
+val compileArgs = listOf(
+    "-Xopt-in=kotlin.RequiresOptIn"
+)
+
 val compileKotlin: KotlinCompile by tasks
 compileKotlin.kotlinOptions {
     jvmTarget = "8"
+    freeCompilerArgs += compileArgs
 }
+
 val compileTestKotlin: KotlinCompile by tasks
 compileTestKotlin.kotlinOptions {
     jvmTarget = "8"
+    freeCompilerArgs += compileArgs
 }
 
 java {
diff --git a/src/main/kotlin/org/ageseries/libage/data/BiMap.kt b/src/main/kotlin/org/ageseries/libage/data/BiMap.kt
index 848be88..0272c79 100644
--- a/src/main/kotlin/org/ageseries/libage/data/BiMap.kt
+++ b/src/main/kotlin/org/ageseries/libage/data/BiMap.kt
@@ -57,7 +57,7 @@ interface MutableBiMap<F, B>: BiMap<F, B> {
      * the guarantees above.
      */
     /**
-     * Add a bijection from [f] to [b], returning true iff some bijection had to be replaced.
+     * Add a bijection from [f] to [b], returning true if some bijection had to be replaced.
      */
     fun addOrReplace(f: F, b: B): Boolean
 
@@ -65,8 +65,14 @@ interface MutableBiMap<F, B>: BiMap<F, B> {
      * Add a bijection from [f] to [b]. If this replaces some other bijection, raise an error.
      */
     fun add(f: F, b: B) {
-        if(forward[f] != null || backward[b] != null) error("would replace a bijection")
-        addOrReplace(f, b)  // assert not this
+        val existingF = forward[f]
+        val existingB = backward[b]
+
+        if(existingF != null || existingB != null) {
+            error("Associating $f and $b would replace $existingF $existingB")
+        }
+
+        addOrReplace(f, b)
     }
 
     /**
@@ -94,6 +100,20 @@ interface MutableBiMap<F, B>: BiMap<F, B> {
     }
 }
 
+/**
+ * Bijectively associates the keys with values selected using [valueSelector].
+ * Similar to Kotlin's [associateWith].
+ * */
+inline fun <K, V> Iterable<K>.associateWithBi(valueSelector: (K) -> V): BiMap<K, V> {
+    val result = mutableBiMapOf<K, V>()
+
+    this.forEach { k ->
+        result.add(k, valueSelector(k))
+    }
+
+    return result
+}
+
 /**
  * An implementation of [MutableBiMap] using a pair of Kotlin's standard maps.
  */
@@ -139,17 +159,24 @@ class MutableMapPairBiMap<F, B>(pairs: Iterator<Pair<F, B>>): MutableBiMap<F, B>
         forward.clear()
         backward.clear()
     }
+
+    override fun toString() = buildString {
+        forward.forEach { (f, b) ->
+            this.appendLine("$f <-> $b")
+        }
+    }
 }
 
 /**
  * An immutable view of a realized [MutableBiMap].
  */
 @JvmInline
-value class ImmutableBiMapView<F, B>(val inner: MutableBiMap<F, B>): BiMap<F, B> {
+value class ImmutableBiMapView<F, B>(private val inner: MutableBiMap<F, B>): BiMap<F, B> {
     override val forward: Map<F, B>
-        inline get() = inner.forward
+        get() = inner.forward
+
     override val backward: Map<B, F>
-        inline get() = inner.backward
+        get() = inner.backward
 }
 
 /**
diff --git a/src/main/kotlin/org/ageseries/libage/data/DisjointSet.kt b/src/main/kotlin/org/ageseries/libage/data/DisjointSet.kt
index f22f785..9673030 100644
--- a/src/main/kotlin/org/ageseries/libage/data/DisjointSet.kt
+++ b/src/main/kotlin/org/ageseries/libage/data/DisjointSet.kt
@@ -1,25 +1,19 @@
 package org.ageseries.libage.data
 
 /**
- * A class for using the Disjoint Sets "Union-Find" algorithm.
+ * Implementation of the Disjoint-Set data structure designed for use in conjunction with the Union-Find algorithm.
+ * It is intended to be extended by inheritors, where the term "Super" (akin to a **superclass**) clarifies its nature.
+ * To enhance usability, a *self-type parameter* ([Self]) has been integrated.
  *
- * There are two ways to use this:
+ * The [representative] can be retrieved as [Self], and the [union] operation readily accepts [Self].
+ * Essentially, inheritors can work with instances of their class without necessitating casting (unlike the old implementation).
  *
- * - Inherit from it, using the methods on the object itself;
- * - compose it into your class; or
- * - do both.
- *
- * Typical use case is as follows:
- *
- * 1. Choose your method above; for the former, the DisjointSet object is `this`; for the latter, substitute your field.
- * 2. Unify DisjointSets by calling [unite].
- * 3. Determine if two DisjointSets are in the same component by testing their [representative] for equality.
- * 4. Optionally, mutate the data on a DisjointSet subclass' representative, knowing that the mutations are visible from all DisjointSets with the same representative.
- *
- * Note that it is difficult to control which instance will ultimately *be* the representative; in the cases where it can't be avoided, [priority] can be used, but this is advisable only as a last resort (since it reduces the optimality of this algorithm).
+ * It's important to note that controlling which instance ultimately becomes the representative can be challenging.
+ * In cases where this is unavoidable, the [priority] parameter can be employed.
+ * However, it's advisable to use this option sparingly, as it compromises the optimality of the algorithm and should only be considered as a last resort.
 */
-open class DisjointSet {
-
+@Suppress("UNCHECKED_CAST") // Side effect of self parameter. Fine in our case.
+abstract class SuperDisjointSet<Self : SuperDisjointSet<Self>> {
     /**
      * The size of this tree; loosely, how many Sets have been merged, including transitively, with this one.
      *
@@ -32,7 +26,8 @@ open class DisjointSet {
      *
      * Following this recursively will lead to the [representative]. All representatives refer to themselves as their parent.
      */
-    var parent: DisjointSet = this
+    @Suppress("LeakingThis") // Fine in this case.
+    var parent: Self = this as Self
 
     /**
      * The priority of the merge. If set, this overrides the "merge by size" algorithm in [unite].
@@ -48,34 +43,65 @@ open class DisjointSet {
      *
      * This is implemented using the "Path splitting" algorithm.
      */
-    val representative: DisjointSet
+    val representative: Self
         get() {
-            var cur = this
-            while (cur.parent != cur) {
-                val next = cur.parent
-                cur.parent = next.parent
-                cur = next
+            var current = this
+
+            while (current.parent != current) {
+                val next = current.parent
+                current.parent = next.parent
+                current = next
             }
-            return cur
+
+            return current as Self
         }
 
     /**
-     * Unite this instance with another instance of DisjointSet.
+     * *Union operation*.
      *
      * After this is done, both this and [other] will have the same [representative] as each other (and as all other Sets with which they were previously united).
      *
      * This is implemented using the "by size" merge algorithm, adjusted for [priority].
      */
-    open fun unite(other: DisjointSet) {
-        val trep = representative
-        val orep = other.representative
-        if (trep == orep) return
-        val (bigger, smaller) = when {
-            trep.priority > orep.priority -> Pair(trep, orep)
-            orep.priority > trep.priority -> Pair(orep, trep)
-            else -> if (trep.size < orep.size) Pair(orep, trep) else Pair(trep, orep)
+    open fun unite(other: Self) {
+        val thisRep = representative
+        val otherRep = other.representative
+
+        if (thisRep == otherRep){
+            return
+        }
+
+        val bigger: Self
+        val smaller: Self
+
+        // Override with priority:
+        if(thisRep.priority > otherRep.priority) {
+            bigger = thisRep
+            smaller = otherRep
+        }
+        else if(otherRep.priority > thisRep.priority) {
+            bigger = otherRep
+            smaller = thisRep
+        }
+        else {
+            // By size:
+            if (thisRep.size < otherRep.size) {
+                bigger = otherRep
+                smaller = thisRep
+            } else {
+                bigger = thisRep
+                smaller = otherRep
+            }
         }
+
         smaller.parent = bigger.parent
         bigger.size += smaller.size
     }
 }
+
+/**
+ * Composable disjoint set, implemented as a [SuperDisjointSet].
+ * This implementation proves beneficial in specific algorithms where certain elements are partitioned using union-find.
+ * These elements might represent pure data or simply may not want or need to implement [SuperDisjointSet].
+ * */
+class DisjointSet(override var priority: Int = 0) : SuperDisjointSet<DisjointSet>() // *It also proves useful in unit tests.
\ No newline at end of file
diff --git a/src/main/kotlin/org/ageseries/libage/data/Events.kt b/src/main/kotlin/org/ageseries/libage/data/Events.kt
new file mode 100644
index 0000000..e2365e1
--- /dev/null
+++ b/src/main/kotlin/org/ageseries/libage/data/Events.kt
@@ -0,0 +1,118 @@
+package org.ageseries.libage.data
+
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.CopyOnWriteArrayList
+import kotlin.reflect.KClass
+
+/**
+ * Producer of events which are distributed to [EventHandler]s.
+ * */
+interface EventSource {
+    /**
+     * Adds a [handler] for the event [eventClass].
+     * */
+    fun registerHandler(eventClass: KClass<*>, handler: EventHandler<Event>)
+
+    /**
+     * Removes [handler] for the event [eventClass].
+     * */
+    fun unregisterHandler(eventClass: KClass<*>, handler: EventHandler<Event>)
+}
+
+/**
+ * Dispatcher for events of different types.
+ * */
+interface EventDispatcher {
+    /**
+     * Sends the [event] to all handlers capable of handling it.
+     * @return The number of handlers which received the event.
+     * */
+    fun send(event: Event): Int
+}
+
+/**
+ * The Event Bus oversees a collection of event handlers.
+ * When an event is dispatched, it is relayed to all handlers capable of managing that specific event type.
+ * Currently, event polymorphism is not implemented so a handler must be registered with the exact class of the event.
+ * The system is designed with thread safety in mind.
+ * @param allowList An optional whitelist of event classes. If a handler for an event which is not allowed is registered, an error is raised. Same goes for events that are sent.
+ * */
+class EventBus(private val allowList: Set<KClass<*>>? = null) : EventSource, EventDispatcher {
+    private val handlers = ConcurrentHashMap<KClass<*>, CopyOnWriteArrayList<EventHandler<Event>>>()
+
+    private fun validateEvent(eventClass: KClass<*>) {
+        if (allowList != null) {
+            check(allowList.contains(eventClass)) {
+                "The event manager prohibits $eventClass"
+            }
+        }
+
+    }
+
+    override fun registerHandler(eventClass: KClass<*>, handler: EventHandler<Event>) {
+        validateEvent(eventClass)
+
+        val handlers = handlers.computeIfAbsent(eventClass) {
+            CopyOnWriteArrayList()
+        }
+
+        handlers.add(handler)
+    }
+
+    override fun unregisterHandler(eventClass: KClass<*>, handler: EventHandler<Event>) {
+        validateEvent(eventClass)
+
+        val handlers = handlers[eventClass]
+            ?: error("Could not find handlers for $eventClass")
+
+        if (!handlers.remove(handler)) {
+            error("Could not remove handler $handler")
+        }
+    }
+
+    /**
+     * Sends an event to all subscribed listeners.
+     * */
+    override fun send(event: Event): Int {
+        validateEvent(event.javaClass.kotlin)
+
+        val listeners = this.handlers[event::class]
+            ?: return 0
+
+        var visited = 0
+        listeners.forEach {
+            it.handle(event)
+            ++visited
+        }
+
+        return visited
+    }
+}
+
+/**
+ * Registers an event handler for events of type [TEvent].
+ * */
+@Suppress("UNCHECKED_CAST")
+inline fun <reified TEvent : Event> EventSource.registerHandler(handler: EventHandler<TEvent>) {
+    registerHandler(TEvent::class, handler as EventHandler<Event>)
+}
+
+/**
+ * Removes an event handler for events of type [TEvent].
+ * */
+@Suppress("UNCHECKED_CAST")
+inline fun <reified TEvent : Event> EventSource.unregisterHandler(handler: EventHandler<TEvent>) {
+    unregisterHandler(TEvent::class, handler as EventHandler<Event>)
+}
+
+/**
+ * Marker interface implemented by all events.
+ * */
+interface Event
+
+/**
+ * A handler for events of the specified type.
+ * */
+fun interface EventHandler<T : Event> {
+    fun handle(event: T)
+}
\ No newline at end of file
diff --git a/src/main/kotlin/org/ageseries/libage/data/MultiMap.kt b/src/main/kotlin/org/ageseries/libage/data/MultiMap.kt
index db27643..ce2fe85 100644
--- a/src/main/kotlin/org/ageseries/libage/data/MultiMap.kt
+++ b/src/main/kotlin/org/ageseries/libage/data/MultiMap.kt
@@ -243,3 +243,23 @@ fun <K, V> Map<K, V>.toMultiMap(): MultiMap<K, V> = entries.map { it.toPair() }.
  * Creates a MutableMultiMap from a Map, with each key associated to a set of size at most one.
  */
 fun <K, V> Map<K, V>.toMutableMultiMap(): MutableMultiMap<K, V> = entries.map { it.toPair() }.toMutableMultiMap()
+
+/**
+ * Constructs a [MultiMap] keyed by [K] with [T] values.
+ * Similar to [associateBy]
+ * */
+inline fun <T, K> Iterable<T>.associateByMulti(keySelector: (T) -> K): MultiMap<K, T> {
+    val result = MutableSetMapMultiMap<K, T>()
+
+    this.forEach { value ->
+        result[keySelector(value)].add(value)
+    }
+
+    return result
+}
+
+inline fun <T, K> Array<T>.associateByMulti(keySelector: (T) -> K): MultiMap<K, T> {
+    val result = MutableSetMapMultiMap<K, T>()
+    this.forEach { value -> result[keySelector(value)].add(value) }
+    return result
+}
\ No newline at end of file
diff --git a/src/main/kotlin/org/ageseries/libage/data/Quantity.kt b/src/main/kotlin/org/ageseries/libage/data/Quantity.kt
index c2212e1..ecf14fe 100644
--- a/src/main/kotlin/org/ageseries/libage/data/Quantity.kt
+++ b/src/main/kotlin/org/ageseries/libage/data/Quantity.kt
@@ -1,9 +1,26 @@
+@file:Suppress("unused")
+@file:JvmName(JVM_NAME)
+
 package org.ageseries.libage.data
 
 import org.ageseries.libage.mathematics.rounded
+import org.ageseries.libage.utils.sourceName
 import kotlin.math.abs
 import kotlin.math.log
 import kotlin.math.pow
+import kotlin.reflect.KProperty
+import kotlin.reflect.jvm.kotlinProperty
+
+typealias ScaleRef<T> = KProperty<QuantityScale<T>>
+
+private const val JVM_NAME = "QuantityKt"
+private const val CLASS_NAME = "org.ageseries.libage.data.$JVM_NAME"
+
+private val SELF by lazy {
+    checkNotNull(Class.forName(CLASS_NAME)) {
+        "Failed to resolve Quantity class $CLASS_NAME"
+    }
+}
 
 /**
  * A linear scale.
@@ -27,56 +44,157 @@ data class Scale(val factor: Double, val base: Double) {
 }
 
 /**
- * [Scale] parameterized by [Unit], which corresponds to the physical property that the scale measures (e.g. distance, time, ...)
+ * [Scale], parameterized by [Unit], aligns with the physical attribute measured by the scale (such as distance, time, and so forth).
+ * Notably, [Unit] remains distinct from the [scale]; for instance, [Distance] can be measured in [METER]s, feet, dragon tails, american football fields, and other units.
+ * It is important to recognize that [Unit] functions merely as a compiler mechanism and holds no inherent functional significance.
+ * @param dimensionType The class of the *symbolic interface* [Unit]. This is the same for all auxiliary units.
  * */
-data class QuantityScale<Unit>(val scale: Scale) {
-    val base get() = scale.base
-
+open class QuantityScale<Unit>(val dimensionType: Class<*>, val scale: Scale) {
     val factor get() = scale.factor
 
     /**
      * Amplifies this scale [amplify] times.
+     * Example: *GRAMS * 1000* will result in *KILOGRAMS*.
      * */
-    operator fun times(amplify: Double) = QuantityScale<Unit>(Scale(scale.factor / amplify, scale.base))
+    operator fun times(amplify: Double) = QuantityScale<Unit>(dimensionType, Scale(scale.factor / amplify, scale.base))
 
     /**
      * Reduces this scale [reduce] times.
+     * Example: *KILOGRAMS / 1000* will result in *GRAMS*.
      * */
-    operator fun div(reduce: Double) = QuantityScale<Unit>(Scale(scale.factor * reduce, scale.base))
+    operator fun div(reduce: Double) = QuantityScale<Unit>(dimensionType, Scale(scale.factor * reduce, scale.base))
 
     /**
      * Amplifies this scale 1000 times.
+     * Example: *+GRAMS* will result in *KILOGRAMS*.
      * */
     operator fun unaryPlus() = this * 1000.0
 
     /**
      * Reduces this scale 1000 times.
+     * Example: *-KILOGRAMS* will result in *GRAMS*.
      * */
     operator fun unaryMinus() = this / 1000.0
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as QuantityScale<*>
+
+        return scale == other.scale
+    }
+
+    override fun hashCode(): Int {
+        return scale.hashCode()
+    }
+}
+
+/**
+ * Signifies a multiplication factor employed to adjust a [QuantityScale].
+ * Presently, its extension is not supported; to minimize runtime cost, a lookup table is precomputed.
+ * This design ensures the avoidance of additional allocations for new instances of [QuantityScale] (the composition cost boils down to accessing the precomputed instance).
+ * */
+class ScaleMultiplier internal constructor(val factor: Double, val index: Int) {
+    /**
+     * Composes the base [scale] with this multiplier, returning a scale which is equivalent to the result of *[scale] * [factor]*.
+     * */
+    operator fun<T> times(scale: SourceQuantityScale<T>) = scale.multiples[index]
 }
 
 /**
- * Represents a physical quantity, characterised by a [Unit] and a real number [value].
+ * Composes the base scale with this multiplier, returning another source scale.
+ * */
+internal infix fun<T> ScaleMultiplier.sourceCompose(scale: SourceQuantityScale<T>) = SourceQuantityScale<T>(scale.dimensionType, scale.multiples[index].scale)
+
+/** Transforms the units into **pico- (×10⁻¹²)** */
+val PICO = ScaleMultiplier(1e-12, 0)
+
+/** Transforms the units into **nano- (×10⁻⁹)** */
+val NANO = ScaleMultiplier(1e-9, 1)
+
+/** Transforms the units into **micro- (×10⁻⁶)** */
+val MICRO = ScaleMultiplier(1e-6, 2)
+
+/** Transforms the units into **milli- (×10⁻³)** */
+val MILLI = ScaleMultiplier(1e-3, 3)
+
+/** Transforms the units into **kilo- (×10³)** */
+val KILO = ScaleMultiplier(1e3, 4)
+
+/** Transforms the units into **nano- (×10⁶)** */
+val MEGA = ScaleMultiplier(1e6, 5)
+
+/** Transforms the units into **nano- (×10⁹)** */
+val GIGA = ScaleMultiplier(1e9, 6)
+
+/** Transforms the units into **nano- (×10¹²)** */
+val TERA = ScaleMultiplier(1e12, 7)
+
+private val MULTIPLIERS = listOf(PICO, NANO, MICRO, MILLI, KILO, MEGA, GIGA, TERA)
+
+/**
+ * [QuantityScale] that is composable with [ScaleMultiplier].
+ * "Source" means it is a fundamental multiple of the standard (base) scale; normal multiplication/division yields non-source [QuantityScale] instances.
+ * Yielding [SourceQuantityScale] would cause infinite recursive creation of child scales.
+ * */
+class SourceQuantityScale<Unit>(dimensionType: Class<*>, scale: Scale) : QuantityScale<Unit>(dimensionType, scale) {
+    /**
+     * Pre-computed lookup table for multiples of this scale.
+     * When we apply a [ScaleMultiplier], we just fetch the pre-computed scale.
+     * */
+    internal val multiples = Array(MULTIPLIERS.size) { index ->
+        val multiplier = MULTIPLIERS.first { it.index == index }
+        // This operation creates the base [QuantityScale] which doesn't just recursively keep creating other lookup tables.
+        this * multiplier.factor
+    }
+}
+
+/**
+ * Amplifies this scale and results in a new [SourceQuantityScale] (as opposed to [times] which results in [QuantityScale]).
+ * Separating from [this.times] is necessary to prevent the children scales creating children scales infinitely.
+ * */
+internal infix fun <U> SourceQuantityScale<U>.sourceAmplify(amplify: Double) = SourceQuantityScale<U>(dimensionType, Scale(scale.factor / amplify, scale.base))
+
+/**
+ * Reduces this scale and results in a new [SourceQuantityScale] (as opposed to [div] which results in [QuantityScale]).
+ * Separating from [this.div] is necessary to prevent the children scales creating children scales infinitely.
+ * */
+internal infix fun <U> SourceQuantityScale<U>.sourceReduce(reduce: Double) = SourceQuantityScale<U>(dimensionType, Scale(scale.factor * reduce, scale.base))
+
+internal fun <U> SourceQuantityScale<U>.sourceAmp() = this sourceAmplify 1000.0
+
+internal fun <U> SourceQuantityScale<U>.sourceSub() = this sourceReduce 1000.0
+
+/**
+ * Denotes a tangible quantity distinguished by a designated [Unit] and a numeric [value].
+ * The [value] is consistently expressed in fundamental units, such as Kelvin, Meter, Kilogram, and the like.
+ * This design is sufficiently straightforward to be instantiated as an inline value-class, thereby rendering the runtime overhead of carrying around [Quantity] virtually negligible.
+ * The [not] operator was chosen because it is the least "ugly" way to quickly fetch the [value] for subsequent operations with [Double].
+ * If you don't like it, Grissess, just access [value].
  * */
 @JvmInline
 value class Quantity<Unit>(val value: Double) : Comparable<Quantity<Unit>> {
-    constructor(quantity: Double, s: QuantityScale<Unit>) : this(s.scale.unmap(quantity))
+    /**
+     * Creates a [Quantity] where its [value] is established as the equivalent of [sourceValue] in the [standardScale].
+     * */
+    constructor(sourceValue: Double, scale: QuantityScale<Unit>) : this(scale.scale.unmap(sourceValue))
 
     val isZero get() = value == 0.0
 
     /**
-     * Gets the numerical value of this quantity.
+     * Gets the [value] quickly and nicely.
      * */
     operator fun not() = value
-
     operator fun unaryMinus() = Quantity<Unit>(-value)
     operator fun unaryPlus() = Quantity<Unit>(+value)
     operator fun plus(b: Quantity<Unit>) = Quantity<Unit>(this.value + b.value)
     operator fun minus(b: Quantity<Unit>) = Quantity<Unit>(this.value - b.value)
     operator fun times(scalar: Double) = Quantity<Unit>(this.value * scalar)
     operator fun div(scalar: Double) = Quantity<Unit>(this.value / scalar)
+
     /**
-     * Divides the quantity by another quantity of the same unit. This, in turn, cancels out the quantity, returning the resulting number.
+     * Divides the quantity by another quantity of the same unit. This, in turn, cancels out the [Unit], returning the resulting number.
      * */
     operator fun div(b: Quantity<Unit>) = this.value / b.value
 
@@ -90,15 +208,26 @@ value class Quantity<Unit>(val value: Double) : Comparable<Quantity<Unit>> {
     operator fun rangeTo(s: QuantityScale<Unit>) = s.scale.map(value)
 
     override fun toString() = value.toString()
-
-    fun <U2> reparam(factor: Double = 1.0) = Quantity<U2>(value * factor)
 }
 
-/** An iterator over a sequence of values of type `Quantity`. */
+@JvmName("quantityPlusDouble") operator fun <U> Quantity<U>.plus(b: Double) = Quantity<U>(this.value + b)
+@JvmName("quantityMinusDouble") operator fun <U> Quantity<U>.minus(b: Double) = Quantity<U>(this.value - b)
+@JvmName("doublePlusQuantity") operator fun <U> Double.plus(b: Quantity<U>) = Quantity<U>(this + b.value)
+@JvmName("doubleMinusQuantity") operator fun <U> Double.minus(b: Quantity<U>) = Quantity<U>(this - b.value)
+
+fun <U> min(a: Quantity<U>, b: Quantity<U>) = Quantity<U>(kotlin.math.min(!a, !b))
+fun <U> max(a: Quantity<U>, b: Quantity<U>) = Quantity<U>(kotlin.math.max(!a, !b))
+fun <U> abs(q: Quantity<U>) = Quantity<U>(abs(!q))
+
+/**
+ * An iterator over a sequence of values of type [Quantity].
+ * */
 abstract class QuantityIterator<Unit> : Iterator<Quantity<Unit>> {
     final override fun next() = nextQuantity()
 
-    /** Returns the next value in the sequence without boxing. */
+    /**
+     * Returns the next value in the sequence without boxing.
+     * */
     abstract fun nextQuantity() : Quantity<Unit>
 }
 
@@ -138,290 +267,533 @@ class QuantityArray<Unit>(val backing: DoubleArray) {
     }
 }
 
-fun <U> min(a: Quantity<U>, b: Quantity<U>) = Quantity<U>(kotlin.math.min(!a, !b))
-fun <U> max(a: Quantity<U>, b: Quantity<U>) = Quantity<U>(kotlin.math.max(!a, !b))
-fun <U> abs(q: Quantity<U>) = Quantity<U>(kotlin.math.abs(!q))
+/**
+ * Categorizes the given numerical value into a scale and represents it using a corresponding scale factor.
+ * A scale factor (such as "kilo," "mega," etc.) is selected from a predefined list based on the magnitude of the given value in the specified base.
+ * The chosen scale factor is inserted into the designated position marked by '#' within the unit string.
+ * If '#' does not exist, it will be implied that the multiple shall be inserted at the start of the string.
+ * [symbol] can also be left empty (you'll still get the number in formatted form and suffixed with the multiple).
+ * Examples:
+ * ```
+ * classifyIntoMultiple(
+ *      value = 1500.0,
+ *      base = 1000.0,
+ *      map = listOf(1.0 to "kilo"),
+ *      symbol = "meters"
+ * ) // 1.5 kilometers
+ *
+ * classifyIntoMultiple(
+ *       value = 10.0,
+ *       base = 1000.0,
+ *       map = listOf(1.0 to "kilo"),
+ *       symbol = "meters"
+ *  ) // 10.0 meters (because inferFist is true by default)
+ *
+ *  classifyIntoMultiple(
+ *       value = 10.0,
+ *       base = 1000.0,
+ *       map = listOf(1.0 to "kilo"),
+ *       symbol = "meters",
+ *       inferFist = false
+ *  ) // 0.01 kilometers (because inferFist is false)
+ *
+ * classifyIntoMultiple(
+ *      value = 10.0,
+ *      base = 1000.0,
+ *      map = listOf(1.0 to "kilo", 0.0 to "*"),
+ *      symbol = "meters",
+ *      inferFist = false
+ * ) // 10.0 *meters
+ *
+ * // Trying out non-integer magnitudes is left as an exercise to the reader.
+ * ```
+ * @param value The value to classify.
+ * @param base The base to use. Usually, this is 10 or 1000.
+ * @param map A map of magnitudes *to* multiplier. Not actually a [Map] because the algorithm scans the entire map to find the best multiplier (justified because we don't care)
+ * @param symbol The unit to place after the multiplier.
+ * @param decimals The number of decimals to round the final value to.
+ * @param inferFirst If true, no multiple will be prepended to the [symbol], if the value is around magnitude 0.
+ * */
+fun classifyIntoMultiple(value: Double, base: Double, map: List<Pair<Double, String>>, symbol: String, decimals: Int = 2, inferFirst: Boolean = true) : String {
+    if(value < 0.0) {
+        return "-${classifyIntoMultiple(-value, base, map, symbol)}"
+    }
+
+    val magnitude = log(value, base)
+
+    var (targetMagnitude, prefix) = map
+        .filter { it.first <= magnitude }
+        .maxByOrNull { it.first } ?:
+    map.minByOrNull { abs(it.first - magnitude) }!!
+
+    if(inferFirst) {
+        if(0.0 <= magnitude && abs(magnitude - targetMagnitude) > abs(magnitude)) {
+            prefix = ""
+            targetMagnitude = 0.0
+        }
+    }
+
+    val multiple = if(symbol.isNotEmpty()) {
+        if(symbol.contains("#")) {
+            symbol.replace("#", prefix)
+        }
+        else {
+            prefix + symbol
+        }
+    }
+    else {
+        prefix
+    }
+
+    return "${(value / base.pow(targetMagnitude)).rounded(decimals)} $multiple"
+}
+
+/**
+ * Describes the base of classification base and multiples.
+ * @param value The classification base.
+ * @param multiples Impromptu map of magnitudes to the desired multiple.
+ * */
+enum class ScaleMultiples(val value: Double, val multiples: List<Pair<Double, String>>) {
+    Base1000Standard(
+        1000.0,
+        listOf(
+            -1.0 to "m", -2.0 to "µ", -3.0 to "n", -4.0 to "p", -5.0 to "f", -6.0 to "a", -7.0 to "z", -8.0 to "y",
+            1.0 to "k", 2.0 to "M", 3.0 to "G", 4.0 to "T", 5.0 to "P", 6.0 to "E", 7.0 to "Z", 8.0 to "Y"
+        )
+    ),
+    Base1000Long(
+        1000.0,
+        listOf(
+            -1.0 to "milli",
+            -2.0 to "micro",
+            -3.0 to "nano",
+            -4.0 to "pico",
+            -5.0 to "femto",
+            -6.0 to "atto",
+            -7.0 to "zepto",
+            -8.0 to "yocto",
+            1.0 to "kilo",
+            2.0 to "mega",
+            3.0 to "giga",
+            4.0 to "tera",
+            5.0 to "peta",
+            6.0 to "exa",
+            7.0 to "zetta",
+            8.0 to "yotta"
+        )
+    ),
+    Base10Standard(
+        10.0,
+        listOf(
+            -1.0 to "d",
+            -2.0 to "c",
+            -3.0 to "m",
+            -6.0 to "µ",
+            -9.0 to "n",
+            -12.0 to "p",
+            -15.0 to "f",
+            -18.0 to "a",
+            -21.0 to "z",
+            -24.0 to "y",
+            1.0 to "da",
+            2.0 to "h",
+            3.0 to "k",
+            6.0 to "M",
+            9.0 to "G",
+            12.0 to "T",
+            15.0 to "P",
+            18.0 to "E",
+            21.0 to "Z",
+            24.0 to "Y"
+        )
+    ),
+    Base10Long(
+        10.0,
+        listOf(
+            -1.0 to "deci",
+            -2.0 to "centi",
+            -3.0 to "milli",
+            -6.0 to "micro",
+            -9.0 to "nano",
+            -12.0 to "pico",
+            -15.0 to "femto",
+            -18.0 to "atto",
+            -21.0 to "zepto",
+            -24.0 to "yocto",
+            1.0 to "deka",
+            2.0 to "hecto",
+            3.0 to "kilo",
+            6.0 to "mega",
+            9.0 to "giga",
+            12.0 to "tera",
+            15.0 to "peta",
+            18.0 to "exa",
+            21.0 to "zetta",
+            24.0 to "yotta"
+        )
+    )
+}
+
+/**
+ * Classifies this physical dimension with the [symbol] (e.g. *"#m"* for meters). The symbol *#* is where the multiple will be placed.
+ * @param factor An adjustment factor for special cases. E.G. for [KILOGRAM], this factor is set to *1000* and the symbol is "g".
+ * @param base The base to use. This specifies the prefixes (e.g. "kilo", "mega", ...) to place in front of the [symbol] when [classifyIntoMultiple]ing.
+ * */
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+annotation class DimensionClassifier(
+    val symbol: String,
+    val factor: Double = 1.0,
+    val base: ScaleMultiples = ScaleMultiples.Base1000Standard
+)
+
+/**
+ * Auxiliary classifier for scales. It is applied to [QuantityScale] fields.
+ * This is used to override the default classification (e.g. using a config option downstream).
+ * @param identifiers Override names for this auxiliary scale. These will be used as identifiers instead of [symbol]. Use this when the symbol cannot be typed (e.g. Å)
+ * */
+@Target(AnnotationTarget.PROPERTY)
+@Retention(AnnotationRetention.RUNTIME)
+annotation class ScaleClassifier(
+    val symbol: String,
+    vararg val identifiers: String,
+    val factor: Double = 1.0,
+    val base: ScaleMultiples = ScaleMultiples.Base1000Standard
+)
 
 /**
  * Defines the standard scale of the [Unit] (a scale with factor 1).
  * */
-fun <Unit> standardScale(factor: Double = 1.0) = QuantityScale<Unit>(Scale(factor, 0.0))
+inline fun <reified Unit> standardScale(factor: Double = 1.0) = SourceQuantityScale<Unit>(
+    Unit::class.java,
+    Scale(factor, 0.0)
+)
+
+@DimensionClassifier("g", factor = 1000.0) interface Mass
+val KILOGRAM = standardScale<Mass>()
+@ScaleClassifier("g") val GRAM = KILOGRAM.sourceSub()
+@ScaleClassifier("gr") val GRAIN = KILOGRAM sourceAmplify 6.479891e-5
+@ScaleClassifier("oz") val OUNCE = KILOGRAM sourceAmplify 0.0283495231
+@ScaleClassifier("st") val STONE = KILOGRAM sourceAmplify 6.35029318
+@ScaleClassifier("lb") val POUND = KILOGRAM sourceAmplify 0.45359237
+@ScaleClassifier("t") val TON = KILOGRAM sourceAmplify 907.18474
+
+@ScaleClassifier("firkin") val FIRKIN = KILOGRAM sourceAmplify 40.8233
 
+@DimensionClassifier("Da") interface AtomicMass
+val DALTON = standardScale<AtomicMass>()
 
-interface Mass
-val KILOGRAMS = standardScale<Mass>()
-val GRAMS = -KILOGRAMS
-val MILLIGRAMS = -GRAMS
-val kg by ::KILOGRAMS
-val g by ::GRAMS
-val mg by ::MILLIGRAMS
+/**
+ * Gets the atomic mass expressed in [KILOGRAM].
+ * The result may not be useful due to the limited precision we're working with.
+ * */
+fun Quantity<AtomicMass>.asStandardMass() = Quantity(!this * 1.66053906660e-27, KILOGRAM)
 
-interface Time
+@DimensionClassifier("s") interface Time
 val SECOND = standardScale<Time>()
-val MILLISECONDS = -SECOND
-val MICROSECONDS = -MILLISECONDS
-val NANOSECONDS = -MICROSECONDS
-val MINUTES = SECOND * 60.0
-val HOURS = MINUTES * 60.0
-val DAYS = HOURS * 24.0
-val s by ::SECOND
-val ms by ::MILLISECONDS
-
-@Classify("m")
-interface Distance
-val METER = standardScale<Distance>()
-val CENTIMETERS = METER / 100.0
-val MILLIMETERS = -METER
-val m by ::METER
-val cm by ::CENTIMETERS
-val mm by ::MILLIMETERS
+@ScaleClassifier("rel", "rels") val REL = SECOND sourceAmplify 1.2
+@ScaleClassifier("min") val MINUTE = SECOND sourceAmplify 60.0
+@ScaleClassifier("h") val HOUR = MINUTE sourceAmplify 60.0
+@ScaleClassifier("d") val DAY = HOUR sourceAmplify 24.0
+@ScaleClassifier("fortnight") val FORTNIGHT = SECOND sourceAmplify 1209600.0
 
-interface Energy
+@DimensionClassifier("Hz") interface Frequency
+val HERTZ = standardScale<Frequency>()
+
+@DimensionClassifier("m") interface Distance
+val METER = standardScale<Distance>()
+@ScaleClassifier("cm") val CENTIMETER = METER sourceReduce 100.0
+@ScaleClassifier("ft") val FOOT = METER sourceAmplify 0.3048
+@ScaleClassifier("in") val INCH = METER sourceAmplify 0.0254
+@ScaleClassifier("yd") val YARD = METER sourceAmplify 0.9144
+@ScaleClassifier("mi") val MILE = METER sourceAmplify 1609.344
+
+@ScaleClassifier("light-nanoseconds") val LIGHT_NANOSECONDS = CENTIMETER sourceAmplify 29.9792458
+@ScaleClassifier("attoparsec") val ATTO_PARSEC = CENTIMETER sourceAmplify 3.086
+@ScaleClassifier("metric foot") val METRIC_FOOT = (MILLI sourceCompose METER) sourceAmplify 300.0
+@ScaleClassifier("cubit") val CUBIT = CENTIMETER sourceAmplify  120.0
+@ScaleClassifier("furlong") val FURLONG = METER sourceAmplify 201.168
+@ScaleClassifier("football field") val AMERICAN_FOOTBALL_FIELD = METER sourceAmplify 91.44
+@ScaleClassifier("Å", "A") val ANGSTROM = METER sourceReduce 1e10
+
+@DimensionClassifier("K") interface Temperature
+val KELVIN = standardScale<Temperature>()
+@ScaleClassifier("°F", "F") val FAHRENHEIT = SourceQuantityScale<Temperature>(Temperature::class.java, Scale(9.0 / 5.0, -459.67))
+@ScaleClassifier("Rk") val RANKINE = KELVIN sourceAmplify 0.555556 // Not R (Roentgen)
+@ScaleClassifier("°C", "C") val CELSIUS = SourceQuantityScale<Temperature>(Temperature::class.java, Scale(1.0, -273.15))
+@ScaleClassifier("mG") val MILLIGRADE = SourceQuantityScale<Temperature>(Temperature::class.java, Scale(10.0, -2731.5))
+@ScaleClassifier("G") val GRADE = SourceQuantityScale<Temperature>(Temperature::class.java, Scale(0.01, -2.7315))
+@ScaleClassifier("|G|") val ABSOLUTE_GRADE = SourceQuantityScale<Temperature>(Temperature::class.java, Scale(0.01, 0.0))
+
+@DimensionClassifier("J") interface Energy
 val JOULE = standardScale<Energy>()
-val MILLIJOULE = -JOULE
-val MICROJOULE = -MILLIJOULE
-val NANOJOULE = -MICROJOULE
-val ERG = JOULE * 1e-7
-val KILOJOULES = +JOULE
-val MEGAJOULES = +KILOJOULES
-val GIGAJOULES = +MEGAJOULES
-val WATT_SECONDS = QuantityScale<Energy>(Scale(JOULE.factor, 0.0))
-val WATT_MINUTES = WATT_SECONDS * 60.0
-val WATT_HOURS = WATT_MINUTES * 60.0
-val KILOWATT_HOURS = WATT_HOURS * 1000.0
-val MEGAWATT_HOURS = KILOWATT_HOURS * 1000.0
-val J by ::JOULE
-val kJ by ::KILOJOULES
-val MJ by ::MEGAJOULES
-val GJ by ::GIGAJOULES
-val Ws by ::WATT_SECONDS
-val Wmin by ::WATT_MINUTES
-val Wh by ::WATT_HOURS
-val kWh by ::KILOWATT_HOURS
-val MWh by ::MEGAWATT_HOURS
-// Serious precision issues? Hope not! :Fish_Smug:
-val ELECTRON_VOLT = JOULE * 1.602176634e-19
-val KILO_ELECTRON_VOLT = JOULE * 1.602176634e-16
-val MEGA_ELECTRON_VOLT = JOULE * 1.602176634e-13
-val GIGA_ELECTRON_VOLT = JOULE * 1.602176634e-10
-val TERA_ELECTRON_VOLT = JOULE * 1.602176634e-7
-val eV by ::ELECTRON_VOLT
-val keV by ::KILO_ELECTRON_VOLT
-val MeV by ::MEGA_ELECTRON_VOLT
-val GeV by ::GIGA_ELECTRON_VOLT
-val TeV by ::TERA_ELECTRON_VOLT
-
-interface Power
+@ScaleClassifier("BTU") val BTU = JOULE sourceAmplify 1055.05585262
+@ScaleClassifier("cal") val CALORIE = JOULE sourceAmplify 4.18400
+@ScaleClassifier("kcal") val KILOCALORIE = CALORIE.sourceAmp()
+@ScaleClassifier("Ws") val WATT_SECOND = JOULE
+@ScaleClassifier("Wmin") val WATT_MINUTE = WATT_SECOND sourceAmplify  60.0
+@ScaleClassifier("Wh") val WATT_HOUR = WATT_MINUTE sourceAmplify 60.0
+
+@ScaleClassifier("erg") val ERG = JOULE sourceAmplify 1e-7
+@ScaleClassifier("eV") val ELECTRON_VOLT = JOULE sourceAmplify  1.602176634e-19 // Serious precision issues? Hope not! :Fish_Smug:
+
+@DimensionClassifier("W") interface Power
 val WATT = standardScale<Power>()
-val MILLIWATT = -WATT
-val KILOWATT = +WATT
-val MEGAWATT = +KILOWATT
-val GIGAWATT = +MEGAWATT
-val W by ::WATT
-val kW by ::KILOWATT
-val MW by ::MEGAWATT
-val GW by ::GIGAWATT
-
-interface Potential
-val VOLT = standardScale<Potential>()
-val KILOVOLT = +VOLT
-val MILLIVOLT = -VOLT
-val V by ::VOLT
-val KV by ::KILOVOLT
+@ScaleClassifier("BTU/s") val BTU_PER_SECOND = WATT sourceAmplify 1055.05585
+@ScaleClassifier("cal/s") val CALORIE_PER_SECOND = WATT sourceAmplify 4.18400
+@ScaleClassifier("kcal/s") val KILOCALORIE_PER_SECOND = WATT sourceAmplify 4184.0
+@ScaleClassifier("hp") val HORSEPOWER = WATT sourceAmplify 745.699872
 
-interface Current
-val AMPERE = standardScale<Current>()
-val MILLIAMPERE = -AMPERE
-val A by ::AMPERE
-val mA by ::MILLIAMPERE
+@DimensionClassifier("g/m³", factor = 1000.0) interface Density
+val KILOGRAM_PER_METER3 = standardScale<Density>()
+@ScaleClassifier("g/cm³") val G_PER_CM3 = KILOGRAM_PER_METER3 sourceAmplify 1000.0
+@ScaleClassifier("g/L") val G_PER_L = KILOGRAM_PER_METER3
 
-interface Resistance
-val OHM = standardScale<Resistance>()
-val KILOOHM = +OHM
-val MEGAOHM = +KILOOHM
-val GIGAOHM = +MEGAOHM
-val MILLIOHM = -OHM
+@DimensionClassifier("m²") interface Area
+val METER2 = standardScale<Area>()
+
+@DimensionClassifier("m³") interface Volume
+val METER3 = standardScale<Volume>()
+@ScaleClassifier("L") val LITER = METER3.sourceSub()
 
-interface Radioactivity
+@DimensionClassifier("Bq") interface Radioactivity
 val BECQUEREL = standardScale<Radioactivity>()
-val KILOBECQUERELS = BECQUEREL * 1e3
-val MEGABECQUERELS = BECQUEREL * 1e6
-val GIGABECQUERELS = BECQUEREL * 1e9
-val TERABECQUERELS = BECQUEREL * 1e12
-val CURIE = GIGABECQUERELS * 37.0
-val MILLICURIES = MEGABECQUERELS * 37.0
-val MICROCURIES = KILOBECQUERELS * 37.0
-val NANOCURIES = BECQUEREL * 37.0
-val KILOCURIES = +CURIE
-val MEGACURIES = +KILOCURIES
-val GIGACURIES = +MEGACURIES // Average conversation with Grissess (every disintegration is a cute dragon image)
-val Bq by ::BECQUEREL
-val kBq by ::KILOBECQUERELS
-val MBq by ::MEGABECQUERELS
-val GBq by ::GIGABECQUERELS
-val TBq by ::TERABECQUERELS
-val Ci by ::CURIE
-val kCi by ::KILOCURIES
-val mCi by ::MILLICURIES
-val uCi by ::MICROCURIES
-val nCi by ::NANOCURIES
-
-interface RadiationAbsorbedDose
+@ScaleClassifier("Ci") val CURIE = (GIGA sourceCompose BECQUEREL) sourceAmplify 37.0
+
+@DimensionClassifier("Gy") interface RadiationAbsorbedDose
 val GRAY = standardScale<RadiationAbsorbedDose>()
-val MILLIGRAY = -GRAY
-val RAD = GRAY / 100.0
-val Gy by ::GRAY
-val mGy by ::MILLIGRAY
+@ScaleClassifier("rad") val RAD = GRAY sourceReduce 100.0
 
-interface RadiationDoseEquivalent
+@DimensionClassifier("Sv") interface RadiationDoseEquivalent
 val SIEVERT = standardScale<RadiationDoseEquivalent>()
-val MILLISIEVERTS = -SIEVERT
-val MICROSIEVERTS = -MILLISIEVERTS
-val NANOSIEVERTS = -MICROSIEVERTS
-val REM = SIEVERT / 100.0
-val MILLIREM = -REM
-val MICROREM = -MILLIREM
-val Sv by ::SIEVERT
-val mSv by ::MILLISIEVERTS
-val uSv by ::MICROSIEVERTS
-val nSv by ::NANOSIEVERTS
-
-interface RadiationExposure
-val COULOMB_PER_KG = standardScale<RadiationExposure>()
-val ROENTGEN = COULOMB_PER_KG / 3875.96899225
-val MILLIROENTGEN = -ROENTGEN
-val MICROROENTGEN = -MILLIROENTGEN
-val NANOROENTGEN = -MICROROENTGEN
-val R by ::ROENTGEN
-val mR by ::MILLIROENTGEN
-val uR by ::MICROROENTGEN
-val nR by ::NANOROENTGEN
-
-interface ReciprocalDistance
+@ScaleClassifier("rem") val REM = SIEVERT sourceReduce 100.0
+
+@DimensionClassifier("C/kg") interface RadiationExposure
+val COULOMB_PER_KILOGRAM = standardScale<RadiationExposure>()
+@ScaleClassifier("R") val ROENTGEN = COULOMB_PER_KILOGRAM sourceReduce 3875.96899225
+
+@DimensionClassifier("1/m") interface ReciprocalDistance
 val RECIP_METER = standardScale<ReciprocalDistance>()
-val RECIP_CENTIMETERS = RECIP_METER * 100.0
+val RECIP_CENTIMETER = RECIP_METER sourceAmplify 100.0
 
 interface ArealDensity
-val KG_PER_M2 = standardScale<ArealDensity>()
-val G_PER_CM2 = KG_PER_M2 * 10.0
-
-interface Density
-val KG_PER_M3 = standardScale<Density>()
-val G_PER_CM3 = KG_PER_M3 * 1000.0
-val G_PER_L = KG_PER_M3
+val KILOGRAM_PER_METER2 = standardScale<ArealDensity>()
+val GRAM_PER_CENTIMETER2 = KILOGRAM_PER_METER2 sourceAmplify 10.0
 
 interface ReciprocalArealDensity
-val M2_PER_KG = standardScale<ReciprocalArealDensity>()
-val CM2_PER_G = M2_PER_KG / 10.0
+val METER2_PER_KILOGRAM = standardScale<ReciprocalArealDensity>()
+val CENTIMETER2_PER_GRAM = METER2_PER_KILOGRAM sourceReduce 10.0
 
-interface Velocity
-val M_PER_S = standardScale<Velocity>()
-val KM_PER_S = +M_PER_S
+@DimensionClassifier("m/s") interface Velocity
+val METER_PER_SECOND = standardScale<Velocity>()
 
-interface Substance
+@DimensionClassifier("mol") interface Substance
 val MOLE = standardScale<Substance>()
 
 interface MolarConcentration
-val MOLE_PER_M3 = standardScale<MolarConcentration>()
+val MOLE_PER_METER3 = standardScale<MolarConcentration>()
 
-interface Area
-val M2 = standardScale<Area>()
+@DimensionClassifier("J/kgK") interface SpecificHeatCapacity
+val JOULE_PER_KILOGRAM_KELVIN = standardScale<SpecificHeatCapacity>()
+@ScaleClassifier("J/gK") val JOULE_PER_GRAM_KELVIN = JOULE_PER_KILOGRAM_KELVIN.sourceAmp()
+@ScaleClassifier("kJ/kgK") val KILOJOULE_PER_KILOGRAM_KELVIN = JOULE_PER_KILOGRAM_KELVIN.sourceAmp()
 
-interface Volume
-val M3 = standardScale<Volume>()
-val LITERS = M3 / 1000.0
-val MILLILITERS = -LITERS
-val L by ::LITERS
-val mL by ::MILLILITERS
+@DimensionClassifier("J/K") interface HeatCapacity
+val JOULE_PER_KELVIN = standardScale<HeatCapacity>()
 
-interface Temperature
-val KELVIN = standardScale<Temperature>()
-val RANKINE = KELVIN * 0.555556
-val CELSIUS = QuantityScale<Temperature>(Scale(1.0, -273.15))
-val CENTIGRADE by ::CELSIUS
-val MILLIGRADE = QuantityScale<Temperature>(Scale(10.0, -2731.5))
-val GRADE = QuantityScale<Temperature>(Scale(0.01, -2.7315))
-val ABSOLUTE_GRADE = QuantityScale<Temperature>(Scale(0.01, 0.0))
-
-interface SpecificHeatCapacity
-val J_PER_KG_K = standardScale<SpecificHeatCapacity>()
-val J_PER_G_K = +J_PER_KG_K
-val KJ_PER_KG_K = +J_PER_KG_K
-
-interface HeatCapacity
-val J_PER_K = standardScale<HeatCapacity>()
-
-interface ThermalConductivity
-val W_PER_M_K = standardScale<ThermalConductivity>()
-val mW_PER_M_K = -W_PER_M_K
-
-interface MolecularWeight
-val KG_PER_MOLE = standardScale<MolecularWeight>()
-val G_PER_MOLE = -KG_PER_MOLE
-
-interface Pressure
+@DimensionClassifier("W/mK") interface ThermalConductivity
+val WATT_PER_METER_KELVIN = standardScale<ThermalConductivity>()
+
+@DimensionClassifier("W/K") interface ThermalConductance
+val WATT_PER_KELVIN = standardScale<ThermalConductance>()
+
+@DimensionClassifier("Ωm") interface ElectricalResistivity
+val OHM_METER = standardScale<ElectricalResistivity>()
+
+@DimensionClassifier("kg/mol") interface MolecularWeight
+val KILOGRAM_PER_MOLE = standardScale<MolecularWeight>()
+@ScaleClassifier("g/mol") val GRAM_PER_MOLE = KILOGRAM_PER_MOLE.sourceSub()
+
+@DimensionClassifier("Pa") interface Pressure
 val PASCAL = standardScale<Pressure>()
-val ATMOSPHERES = PASCAL * 9.86923e-6
-val Pa by ::PASCAL
-val Atm by ::ATMOSPHERES
+@ScaleClassifier("Atm") val ATMOSPHERE = PASCAL sourceAmplify 9.86923e-6
 
-interface Intensity
-val WATT_PER_M2 = standardScale<Intensity>()
-val KILOWATT_PER_M2 = +WATT_PER_M2
+@DimensionClassifier("W/m²") interface Intensity
+val WATT_PER_METER2 = standardScale<Intensity>()
 
-val BASE_1000_PREFIXES = listOf(
-    -1.0 to "m", -2.0 to "µ", -3.0 to "n", -4.0 to "p", -5.0 to "f", -6.0 to "a", -7.0 to "z", -8.0 to "y",
-    1.0 to "k", 2.0 to "M", 3.0 to "G", 4.0 to "T", 5.0 to "P", 6.0 to "E", 7.0 to "Z", 8.0 to "Y"
-)
+@DimensionClassifier("V") interface Potential
+val VOLT = standardScale<Potential>()
 
-val BASE_1000_PREFIXES_LONG = listOf(
-    -1.0 to "milli", -2.0 to "micro", -3.0 to "nano", -4.0 to "pico", -5.0 to "femto", -6.0 to "atto", -7.0 to "zepto", -8.0 to "yocto",
-    1.0 to "kilo", 2.0 to "mega", 3.0 to "giga", 4.0 to "tera", 5.0 to "peta", 6.0 to "exa", 7.0 to "zetta", 8.0 to "yotta"
-)
+@DimensionClassifier("A") interface Current
+val AMPERE = standardScale<Current>()
 
-val BASE_10_PREFIXES = listOf(
-    -1.0 to "d", -2.0 to "c", -3.0 to "m", -6.0 to "µ", -9.0 to "n", -12.0 to "p", -15.0 to "f", -18.0 to "a", -21.0 to "z", -24.0 to "y",
-    1.0 to "da", 2.0 to "h", 3.0 to "k", 6.0 to "M", 9.0 to "G", 12.0 to "T", 15.0 to "P", 18.0 to "E", 21.0 to "Z", 24.0 to "Y"
-)
+@DimensionClassifier("Ω") interface Resistance
+val OHM = standardScale<Resistance>()
 
-val BASE_10_PREFIXES_LONG = listOf(
-    -1.0 to "deci", -2.0 to "centi", -3.0 to "milli", -6.0 to "micro", -9.0 to "nano", -12.0 to "pico", -15.0 to "femto", -18.0 to "atto", -21.0 to "zepto", -24.0 to "yocto",
-    1.0 to "deka", 2.0 to "hecto", 3.0 to "kilo", 6.0 to "mega", 9.0 to "giga", 12.0 to "tera", 15.0 to "peta", 18.0 to "exa", 21.0 to "zetta", 24.0 to "yotta"
-)
+@DimensionClassifier("F") interface Capacitance
+val FARAD = standardScale<Capacitance>()
 
-fun classify(value: Double, base: Double, map: List<Pair<Double, String>>, unit: String, decimals: Int = 2, inferFirst: Boolean = true) : String {
-    if(value < 0.0) {
-        return "-${classify(-value, base, map, unit)}"
+@DimensionClassifier("S") interface ElectricalConductance
+val SIEMENS = standardScale<ElectricalConductance>()
+
+@DimensionClassifier("C") interface ElectricalCharge
+val COULOMB = standardScale<ElectricalCharge>()
+
+@DimensionClassifier("H") interface Inductance
+val HENRY = standardScale<Inductance>()
+
+@DimensionClassifier("J/kg") interface MassEnergyDensity
+val JOULE_PER_KILOGRAM = standardScale<MassEnergyDensity>()
+
+@DimensionClassifier("J/m³") interface VolumeEnergyDensity
+val JOULE_PER_METER3 = standardScale<VolumeEnergyDensity>()
+
+/**
+ * Gets a map of dimension type (dimension interface) to a multimap of scale reference (property holding the [QuantityScale]) and its declared [ScaleClassifier]ers.
+ * */
+val AUXILIARY_CLASSIFIERS: Map<Class<*>, MultiMap<ScaleRef<*>, String>> = run {
+    val map = LinkedHashMap<Class<*>, MutableSetMapMultiMap<ScaleRef<*>, String>>()
+
+    SELF.declaredFields.forEach { field ->
+        if((QuantityScale::class.java).isAssignableFrom(field.type)) {
+            val property = field.kotlinProperty
+                ?: return@forEach
+
+            val annotation = property.annotations.firstOrNull { it is ScaleClassifier }
+                ?: return@forEach
+
+            annotation as ScaleClassifier
+
+            val scale = checkNotNull(property.getter.call() as? QuantityScale<*>) {
+                "Failed to fetch $property"
+            }
+
+            val auxiliaries = map.getOrPut(scale.dimensionType) { MutableSetMapMultiMap() }
+
+            val identifiers = if(annotation.identifiers.isEmpty()) {
+                listOf(annotation.symbol).iterator()
+            }
+            else {
+                annotation.identifiers.iterator()
+            }
+
+            identifiers.forEach {
+                @Suppress("UNCHECKED_CAST")
+                auxiliaries[property as ScaleRef<*>].add(it)
+            }
+        }
     }
 
-    val magnitude = log(value, base)
+    map
+}
 
-    var (targetMagnitude, prefix) = map
-        .filter { it.first <= magnitude }
-        .maxByOrNull { it.first } ?:
-        map.minByOrNull { abs(it.first - magnitude) }!!
+/**
+ * Gets a map of dimension type classes (dimension interface).
+ * Useful as an ID for config values.
+ * Examples values:
+ * ```
+ * Temperature::class.java [the Class] <-> "Temperature" [the human-readable String]
+ * ```
+ * */
+val DIMENSION_TYPES = run {
+    val dimensionTypes = HashSet<Class<*>>()
 
-    if(inferFirst) {
-        if(0.0 <= magnitude && abs(magnitude - targetMagnitude) > abs(magnitude)) {
-            prefix = ""
-            targetMagnitude = 0.0
+    SELF.declaredFields.forEach { field ->
+        if((QuantityScale::class.java).isAssignableFrom(field.type)) {
+            val property = field.kotlinProperty
+                ?: return@forEach
+
+            val scale = checkNotNull(property.getter.call() as? QuantityScale<*>) {
+                "Failed to fetch $property"
+            }
+
+            dimensionTypes.add(scale.dimensionType)
         }
     }
 
-    return "${(value / base.pow(targetMagnitude)).rounded(decimals)} $prefix$unit"
+    dimensionTypes
+}.associateWithBi { it.sourceName() }
+
+/**
+ * Classifies the [value] as a quantity on the scale defined by [dimensionType] (class of the dimension interface).
+ * If the dimension interface has [DimensionClassifier], the options from the annotation will be used.
+ * Otherwise, [ScaleMultiples.Base1000Standard] will be used and no unit symbol will be added.
+ * Examples:
+ * ```
+ * classify(Temperature::class.java, !Quantity(0.0, CELSIUS)) // 273.15 K
+ * ```
+ * */
+fun classify(dimensionType: Class<*>, value: Double) : String {
+    val annotation = dimensionType.getDeclaredAnnotation(DimensionClassifier::class.java)
+
+    return if(annotation == null) {
+        classifyIntoMultiple(
+            value,
+            ScaleMultiples.Base1000Standard.value,
+            ScaleMultiples.Base1000Standard.multiples,
+            ""
+        )
+    }
+    else {
+        classifyIntoMultiple(
+            value * annotation.factor,
+            annotation.base.value,
+            annotation.base.multiples,
+            annotation.symbol
+        )
+    }
 }
 
-@Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-annotation class Classify(val symbol: String)
+/**
+ * Classifies this quantity into a *multiple* using the [classify], passing in [T] as dimension interface.
+ * Examples:
+ * ```
+ * val quantity = Quantity(10, KILO * METER)
+ * quantity.classify() // 10 km
+ * ```
+ * */
+inline fun<reified T> Quantity<T>.classify() = classify(T::class.java, !this)
 
-inline fun<reified T> Quantity<T>.classify() : String {
-    val annotation = T::class.java.getDeclaredAnnotation(Classify::class.java)
+/**
+ * Classifies the [value] as a quantity on the scale defined by [scaleRef] (a defined secondary scale).
+ * If the field has [ScaleClassifier], the options from the annotation will be used.
+ * Otherwise, as a fallback, the value will be classified using [classify] (classification based on the dimension interface).
+ * This normally shouldn't happen if I don't forget to add @Auxiliary to the scales.
+ *
+ * Examples:
+ * ```
+ * classifyAuxiliary(::FOOT, !Quantity(10.0, KILO * METER)) // show in feet
+ * classifyAuxiliary(::METER, !Quantity(10.0, KILO * METER)) // METER does not have @Auxiliary, so it will just show in.. meters (default scale)
+ * classifyAuxiliary(selectedScale, !Quantity(10.0, KILO * METER)) // selectedScale could something from AUXILIARY_CLASSIFIERS
+ * ```
+ * */
+fun classifyAuxiliary(scaleRef: ScaleRef<*>, value: Double) : String {
+    val annotation = scaleRef::annotations.get().firstOrNull { it is ScaleClassifier } as? ScaleClassifier
+    val quantityScale = scaleRef.call()
 
     return if(annotation == null) {
-        classify(!this, 1000.0, BASE_1000_PREFIXES, "")
+        // Fallback - classify in standard scale:
+        classify(quantityScale.dimensionType, value)
     }
     else {
-        classify(!this, 1000.0, BASE_1000_PREFIXES, annotation.symbol)
+        classifyIntoMultiple(
+            quantityScale.scale.map(value) * annotation.factor,
+            annotation.base.value,
+            annotation.base.multiples,
+            annotation.symbol
+        )
     }
-}
\ No newline at end of file
+}
+
+/**
+ * Classifies this quantity with the specified auxiliary unit.
+ * If the auxiliary does not exist, the base classification will be used.
+ * Examples:
+ * ```
+ * val quantity = Quantity(10.0, KILO * METER)
+ * quantity.classifyAuxiliary(::FEET) // show in feet
+ * quantity.classifyAuxiliary(::METER) // METER does not have @Auxiliary, so it will just show in.. meters (default scale)
+ * quantity.classifyAuxiliary(::KELVIN) // Compilation error (type-safe, based on the dimension interface)
+ * ```
+ * */
+inline fun<reified T> Quantity<T>.classifyAuxiliary(scale: ScaleRef<T>) = classifyAuxiliary(scale, !this)
\ No newline at end of file
diff --git a/src/main/kotlin/org/ageseries/libage/mathematics/Geometry.kt b/src/main/kotlin/org/ageseries/libage/mathematics/Geometry.kt
index c2d2f82..87075b3 100644
--- a/src/main/kotlin/org/ageseries/libage/mathematics/Geometry.kt
+++ b/src/main/kotlin/org/ageseries/libage/mathematics/Geometry.kt
@@ -5,7 +5,7 @@ package org.ageseries.libage.mathematics
 import java.util.ArrayList
 import kotlin.math.*
 
-private const val GEOMETRY_COMPARE_EPS = 1e-8
+private const val GEOMETRY_COMPARE_EPS = 1e-7
 private const val GEOMETRY_NORMALIZED_EPS = 1e-6
 
 data class Matrix3x3(val c0: Vector3d, val c1: Vector3d, val c2: Vector3d) {
@@ -63,7 +63,7 @@ data class Matrix3x3(val c0: Vector3d, val c1: Vector3d, val c2: Vector3d) {
         else -> error("Row $r out of bounds")
     }
 
-    operator fun get(c: Int, r: Int) = when (r) {
+    operator fun get(r: Int, c: Int) = when (r) {
         0 -> getColumn(c).x
         1 -> getColumn(c).y
         2 -> getColumn(c).z
@@ -90,12 +90,6 @@ data class Matrix3x3(val c0: Vector3d, val c1: Vector3d, val c2: Vector3d) {
     }
 
     companion object {
-        fun rows(r0: Vector3d, r1: Vector3d, r2: Vector3d) = Matrix3x3(
-            Vector3d(r0.x, r1.x, r2.x),
-            Vector3d(r0.y, r1.y, r2.y),
-            Vector3d(r0.z, r1.z, r2.z)
-        )
-
         val identity = Matrix3x3(Vector3d.unitX, Vector3d.unitY, Vector3d.unitZ)
 
         inline fun get(array: DoubleArray, c: Int, r: Int) = r * 3 + c
@@ -185,16 +179,13 @@ data class Matrix4x4(val c0: Vector4d, val c1: Vector4d, val c2: Vector4d, val c
     val normFrobeniusSqr get() = c0.normSqr + c1.normSqr + c2.normSqr + c3.normSqr
     val normFrobenius get() = sqrt(normFrobeniusSqr)
 
-    // Inlined for performance. We're already down a deep rabbit hole of performance issues
-    // because of our design (and ⅅ), so at least let me have this one.
-    val determinant
-        get() =
-            Matrix3x3(c1.y, c2.y, c3.y, c1.z, c2.z, c3.z, c1.w, c2.w, c3.w).determinant * c0.x -
-            Matrix3x3(c1.x, c2.x, c3.x, c1.z, c2.z, c3.z, c1.w, c2.w, c3.w).determinant * c0.y +
-            Matrix3x3(c1.x, c2.x, c3.x, c1.y, c2.y, c3.y, c1.w, c2.w, c3.w).determinant * c0.z -
-            Matrix3x3(c1.x, c2.x, c3.x, c1.y, c2.y, c3.y, c1.z, c2.z, c3.z).determinant * c0.w
-
-    fun eliminate(eliminateC: Int, eliminateR: Int): Matrix3x3 {
+    val determinant get() =
+        Matrix3x3(c1.y, c2.y, c3.y, c1.z, c2.z, c3.z, c1.w, c2.w, c3.w).determinant * c0.x -
+        Matrix3x3(c1.x, c2.x, c3.x, c1.z, c2.z, c3.z, c1.w, c2.w, c3.w).determinant * c0.y +
+        Matrix3x3(c1.x, c2.x, c3.x, c1.y, c2.y, c3.y, c1.w, c2.w, c3.w).determinant * c0.z -
+        Matrix3x3(c1.x, c2.x, c3.x, c1.y, c2.y, c3.y, c1.z, c2.z, c3.z).determinant * c0.w
+
+    fun eliminate(eliminateR: Int, eliminateC: Int): Matrix3x3 {
         val values = DoubleArray(3 * 3)
 
         var irActual = 0
@@ -218,6 +209,7 @@ data class Matrix4x4(val c0: Vector4d, val c1: Vector4d, val c2: Vector4d, val c
 
     fun minor(c: Int, r: Int) = eliminate(c, r).determinant
     fun cofactor(c: Int, r: Int) = minor(c, r) * (-1).pow(c + r)
+
     val cofactorMatrix get() =
         Matrix4x4(
             cofactor(0, 0), cofactor(1, 0), cofactor(2, 0), cofactor(3, 0),
@@ -225,6 +217,7 @@ data class Matrix4x4(val c0: Vector4d, val c1: Vector4d, val c2: Vector4d, val c
             cofactor(0, 2), cofactor(1, 2), cofactor(2, 2), cofactor(3, 2),
             cofactor(0, 3), cofactor(1, 3), cofactor(2, 3), cofactor(3, 3)
         )
+
     val adjugateMatrix get() = cofactorMatrix.transpose
 
     fun approxEq(other: Matrix4x4, eps: Double = GEOMETRY_COMPARE_EPS) =
@@ -260,7 +253,7 @@ data class Matrix4x4(val c0: Vector4d, val c1: Vector4d, val c2: Vector4d, val c
         else -> error("Row $r out of bounds")
     }
 
-    operator fun get(c: Int, r: Int) = when (r) {
+    operator fun get(r: Int, c: Int) = when (r) {
         0 -> getColumn(c).x
         1 -> getColumn(c).y
         2 -> getColumn(c).z
@@ -399,6 +392,31 @@ data class Matrix4x4Dual(val c0: Vector4dDual, val c1: Vector4dDual, val c2: Vec
     }
 }
 
+data class Vector2di(val x: Int, val y: Int) {
+    constructor(value: Int) : this(value, value)
+
+    operator fun unaryPlus() = this
+    operator fun unaryMinus() = Vector2di(-x, -y)
+    operator fun times(b: Int) = Vector2di(x * b, y * b)
+    operator fun div(b: Int) = Vector2di(x / b, y / b)
+    operator fun minus(b: Vector2di) = Vector2di(x - b.x, y - b.y)
+    operator fun plus(b: Vector2di) = Vector2di(x + b.x, y + b.y)
+
+    companion object {
+        val zero = Vector2di(0, 0)
+        val one = Vector2di(1, 1)
+        val unitX = Vector2di(1, 0)
+        val unitY = Vector2di(0, 1)
+
+        fun manhattan(a: Vector2di, b: Vector2di) : Int {
+            val dx = abs(a.x - b.x)
+            val dy = abs(a.y - b.y)
+
+            return dx + dy
+        }
+    }
+}
+
 data class Vector2d(val x: Double, val y: Double) {
     constructor(value: Double) : this(value, value)
 
@@ -1932,7 +1950,7 @@ fun bresenham(
     }
 }
 
-fun dda(ray: Ray3d, withSource: Boolean = true, user: (Int, Int, Int) -> Boolean) {
+inline fun dda(ray: Ray3d, withSource: Boolean = true, user: (Int, Int, Int) -> Boolean) {
     var x = floor(ray.origin.x).toInt()
     var y = floor(ray.origin.y).toInt()
     var z = floor(ray.origin.z).toInt()
diff --git a/src/main/kotlin/org/ageseries/libage/mathematics/Interpolation.kt b/src/main/kotlin/org/ageseries/libage/mathematics/Interpolation.kt
index b108552..21bb899 100644
--- a/src/main/kotlin/org/ageseries/libage/mathematics/Interpolation.kt
+++ b/src/main/kotlin/org/ageseries/libage/mathematics/Interpolation.kt
@@ -813,10 +813,8 @@ fun <T> T.adaptscan(t0: Double, t1: Double, tIncrMax: Double, iMax: Int = Int.MA
     return if (this.adaptscan(t0, t1, tIncrMax, iMax, condition) { results.add(it) }) results else null
 }
 
-fun Spline3d.intersectGrid3d(t0: Double, t1: Double, tIncrMax: Double, iMax: Int) : HashSet<Vector3di>? {
-    val results = HashSet<Vector3di>()
-
-    val flag = this.adaptscan(t0, t1, tIncrMax, iMax, { _, a, b ->
+fun Spline3d.intersectGrid3d(t0: Double, t1: Double, tIncrMax: Double, iMax: Int, consumer: (Double) -> Unit) =
+    this.adaptscan(t0, t1, tIncrMax, iMax, { _, a, b ->
         val pA = this.evaluate(a)
         val pB = this.evaluate(b)
 
@@ -826,13 +824,7 @@ fun Spline3d.intersectGrid3d(t0: Double, t1: Double, tIncrMax: Double, iMax: Int
         else {
             (pA distanceToSqr pB) > 0.5
         }
-    }) {
-        results.add(this.evaluate(it).floorInt())
-    }
-
-    return if(flag) results
-    else null
-}
+    }, consumer)
 
 /**
  * Uses a grid interpolator and maps values to grid indices using splines.
diff --git a/src/main/kotlin/org/ageseries/libage/mathematics/Math.kt b/src/main/kotlin/org/ageseries/libage/mathematics/Math.kt
index 2ace275..af5d742 100644
--- a/src/main/kotlin/org/ageseries/libage/mathematics/Math.kt
+++ b/src/main/kotlin/org/ageseries/libage/mathematics/Math.kt
@@ -1,5 +1,3 @@
-@file:Suppress("NOTHING_TO_INLINE")
-
 package org.ageseries.libage.mathematics
 
 import org.jetbrains.annotations.ApiStatus.Internal
@@ -244,11 +242,25 @@ fun coth(x: Double) = cosh(x) / sinh(x)
 fun sech(x: Double) = 1.0 / cosh(x)
 fun csch(x: Double) = 1.0 / sinh(x)
 
+@Target(AnnotationTarget.FUNCTION)
+@RequiresOptIn(level = RequiresOptIn.Level.ERROR)
+annotation class UnsafeDualAPI
+
 class Dual private constructor(private val values: DoubleArray) : AbstractList<Double>() {
+    /**
+     * Constructs a [Dual] from the single [value].
+     * */
+    constructor(value: Double) : this(DoubleArray(1).also {
+        it[0] = value
+    })
+
+    /**
+     * Constructs a [Dual] from the [values], by copying the [values] into a *new* [DoubleArray].
+     * */
     constructor(values: List<Double>) : this(values.toDoubleArray())
 
     /**
-     * Constructs a [Dual] from the value [head] and the [tail].
+     * Constructs a [Dual] from the value [head] and the [tail] by appending [tail] to [head].
      * */
     constructor(head: Double, tail: Dual) : this(
         DoubleArray(tail.values.size + 1).also {
@@ -265,7 +277,7 @@ class Dual private constructor(private val values: DoubleArray) : AbstractList<D
     )
 
     /**
-     * Constructs a [Dual] from the values [head] and the [tail].
+     * Constructs a [Dual] from the values [head] and the [tail] by appending [tail] to [head].
      * */
     constructor(head: Dual, tail: Double) : this(
         DoubleArray(head.values.size + 1).also {
@@ -282,7 +294,8 @@ class Dual private constructor(private val values: DoubleArray) : AbstractList<D
     )
 
     /**
-     * Constructs a [Dual] from the [head] and the [tail].
+     * Constructs a [Dual] from the [head] and the [tail] by appending [tail] to [head].
+     * The [head] and [tail] will not be mutated.
      * */
     constructor(head: DoubleArray, tail: DoubleArray) : this(
         DoubleArray(head.size + tail.size).also {
@@ -291,6 +304,9 @@ class Dual private constructor(private val values: DoubleArray) : AbstractList<D
         }
     )
 
+    /**
+     * Constructs a [Dual] from the [head] and the [tail] by appending [tail] to [head].
+     * */
     constructor(head: List<Double>, tail: List<Double>) : this(
         DoubleArray(head.size + tail.size).also {
             var sourceIndex = 0
@@ -308,10 +324,26 @@ class Dual private constructor(private val values: DoubleArray) : AbstractList<D
         }
     )
 
+    /**
+     * Constructs a [Dual] from the [head] and the [tail] by appending [tail] to [head].
+     * */
     constructor(head: Dual, tail: Dual) : this(head.values, tail.values)
+
+    /**
+     * Constructs a [Dual] from the [head] and the [tail] by appending [tail] to [head].
+     * The [head] will not be mutated.
+     * */
     constructor(head: DoubleArray, tail: Dual) : this(head, tail.values)
+
+    /**
+     * Constructs a [Dual] from the [head] and the [tail] by appending [tail] to [head].
+     * The [tail] will not be mutated.
+     * */
     constructor(head: Dual, tail: DoubleArray) : this(head.values, tail)
 
+    /**
+     * Gets a copy of the underlying array of [values].
+     * */
     fun bind() = values.clone()
 
     override operator fun get(index: Int) = values[index]
@@ -337,36 +369,32 @@ class Dual private constructor(private val values: DoubleArray) : AbstractList<D
      * */
     fun tail(n: Int = 1) = Dual(DoubleArray(size - n) { values[it + n] })
 
-    operator fun unaryPlus() = this
-
-    operator fun unaryMinus() = Dual(
-        DoubleArray(size).also {
-            for (i in it.indices) {
-                it[i] = -this[i]
-            }
-        }
-    )
-
-    operator fun plus(other: Dual): Dual =
-        if (this.isReal || other.isReal) const(this[0] + other[0])
-        else Dual(this.value + other.value, this.tail() + other.tail())
+    /**
+     * Applies the [operation] component-wise on the values in this dual and the other dual.
+     * The resulting dual respects the **truncation rule**.
+     * */
+    private inline fun componentWise(other: Dual, operation: (Double, Double) -> Double) : Dual {
+        val a = this.values
+        val b = other.values
 
-    operator fun minus(other: Dual): Dual =
-        if (this.isReal || other.isReal) const(this[0] - other[0])
-        else Dual(this.value - other.value, this.tail() - other.tail())
+        val size = min(a.size, b.size)
+        require(size >= 0)
 
-    operator fun times(other: Dual): Dual =
-        if (this.isReal || other.isReal) const(this[0] * other[0])
-        else Dual(this.value * other.value, this.tail() * other.head() + this.head() * other.tail())
+        val array = DoubleArray(size)
 
-    operator fun div(other: Dual): Dual =
-        if (this.isReal || other.isReal) const(this[0] / other[0])
-        else Dual(this.value / other.value, (this.tail() * other - this * other.tail()) / (other * other))
+        var i = 0
+        while(i < size) {
+            array[i] = operation(a[i], b[i])
+            i++
+        }
 
-    inline fun function(x: ((Double) -> Double), dx: ((Dual) -> Dual)): Dual =
-        if (this.isReal) const(x(this.value))
-        else Dual(x(this.value), dx(this.head()) * this.tail())
+        return Dual(array)
+    }
 
+    /**
+     * Maps the [value] using [transform] and leaves the rest of the dual untouched.
+     * */
+    @OptIn(UnsafeDualAPI::class)
     inline fun mapValue(transform: (Double) -> Double) : Dual {
         val values = bind()
 
@@ -374,43 +402,73 @@ class Dual private constructor(private val values: DoubleArray) : AbstractList<D
             values[0] = transform(values[0])
         }
 
-        return castFromArray(values)
+        return wrapUnsafe(values)
     }
 
+    /**
+     * Maps the [value] using [transformValue] and the rest of the dual using [transformTail].
+     * */
+    @OptIn(UnsafeDualAPI::class)
     inline fun mapValueAndTail(transformValue: (Double) -> Double, transformTail: (Double) -> Double) : Dual {
-        val values = bind()
-        val size = values.size
+        val source = unwrapUnsafe(this)
+        val size = source.size
+        val values = DoubleArray(size)
 
         if(size > 0) {
-            values[0] = transformValue(values[0])
+            values[0] = transformValue(source[0])
 
             var i = 1
             while (i < size) {
-                values[i] = transformTail(values[i])
+                values[i] = transformTail(source[i])
                 i++
             }
         }
 
-        return castFromArray(values)
+        return wrapUnsafe(values)
     }
 
+    /**
+     * Maps all the values using the [transform].
+     * */
+    @OptIn(UnsafeDualAPI::class)
     inline fun map(transform: (Double) -> Double) : Dual {
-        val values = bind()
-        val size = values.size
+        val source = unwrapUnsafe(this)
+        val size = source.size
+        val values = DoubleArray(size)
 
         var i = 0
         while(i < size) {
-            values[i] = transform(values[i])
+            values[i] = transform(source[i])
             i++
         }
 
-        return castFromArray(values)
+        return wrapUnsafe(values)
     }
 
+    operator fun unaryPlus(): Dual = this
+
+    operator fun unaryMinus(): Dual = map { -it }
+
+    operator fun plus(other: Dual): Dual = componentWise(other) { a, b -> a + b }
+
+    operator fun minus(other: Dual): Dual = componentWise(other) { a, b -> a - b }
+
+    operator fun times(other: Dual): Dual =
+        if (this.isReal || other.isReal) Dual(this.value * other.value)
+        else Dual(this.value * other.value, this.tail() * other.head() + this.head() * other.tail())
+
+    operator fun div(other: Dual): Dual =
+        if (this.isReal || other.isReal) Dual(this.value / other.value)
+        else Dual(this.value / other.value, (this.tail() * other - this * other.tail()) / (other * other))
+
+    inline fun function(x: (Double) -> Double, dx: (Dual) -> Dual): Dual =
+        if (this.isReal) Dual(x(this.value))
+        else Dual(x(this.value), dx(this.head()) * this.tail())
+
     operator fun plus(const: Double) = mapValue { it + const }
     operator fun minus(const: Double) = mapValue { it - const }
-    operator fun times(constant: Double) = map { v -> v * constant }
-    operator fun div(constant: Double) = map { v -> v / constant }
+    operator fun times(constant: Double) = if(constant == 1.0) this else map { it * constant }
+    operator fun div(constant: Double) = if(constant == 1.0) this else map { it / constant }
 
     override fun equals(other: Any?): Boolean {
         if (this === other) {
@@ -458,16 +516,43 @@ class Dual private constructor(private val values: DoubleArray) : AbstractList<D
     companion object {
         val empty = Dual(doubleArrayOf())
 
-        fun const(x: Double, n: Int = 1) = Dual(DoubleArray(n).also { it[0] = x })
+        /**
+         * Constructs a [Dual] referencing the [array] without a defensive copy.
+         * Only appropriate to use when [array] is guaranteed to not be mutated after the resulting [Dual] is in use.
+         * */
+        @UnsafeDualAPI
+        fun wrapUnsafe(array: DoubleArray): Dual = Dual(array)
+
+        /**
+         * Gets a reference to the underlying storage.
+         * Only appropriate to use when the resulting array will not be mutated.
+         * */
+        @UnsafeDualAPI
+        fun unwrapUnsafe(dual: Dual): DoubleArray = dual.values
 
-        fun variable(v: Double, n: Int = 1) = Dual(
-            DoubleArray(n).also {
-                it[0] = v
-                if (n > 1) {
-                    it[1] = 1.0
+        fun const(x: Double, n: Int = 1): Dual {
+            val array = DoubleArray(n)
+
+            if(n > 0) {
+                array[0] = x
+            }
+
+            return Dual(array)
+        }
+
+        fun variable(v: Double, n: Int = 1): Dual {
+            val array = DoubleArray(n)
+
+            if(n > 0) {
+                array[0] = v
+
+                if(n > 1) {
+                    array[1] = 1.0
                 }
             }
-        )
+
+            return Dual(array)
+        }
 
         /**
          * Creates a [Dual] from the provided [values].
@@ -477,13 +562,6 @@ class Dual private constructor(private val values: DoubleArray) : AbstractList<D
 
         fun of(vararg values: Double) = Dual(values.asList())
 
-        /**
-         * Constructs a [Dual] referencing the [array] without a defensive copy.
-         * Only appropriate to use when [array] is guaranteed to not be mutated after the resulting [Dual] is in use.
-         * */
-        @Internal
-        fun castFromArray(array: DoubleArray) = Dual(array)
-
         /**
          * Adjusts [a] and [b] using the [head] operator so that their [size] is equal to the smallest size between [a] and [b].
          * */
@@ -504,8 +582,8 @@ class Dual private constructor(private val values: DoubleArray) : AbstractList<D
 
 operator fun Double.plus(dual: Dual) = dual.mapValue { this + it }
 operator fun Double.minus(dual: Dual) = dual.mapValueAndTail({ this - it }, { -it })
-operator fun Double.times(dual: Dual) = dual.map { this * it }
-operator fun Double.div(dual: Dual) = this * (dual.pow(-1)) // Found that using the power then product is much quicker to compute! But it introduces some extra numerical error...
+operator fun Double.times(dual: Dual) = if(this == 1.0) dual else dual.map { this * it }
+operator fun Double.div(dual: Dual) = if(this == 1.0) dual.pow(-1) else this * (dual.pow(-1))
 
 fun sin(x: Dual): Dual = x.function({ sin(it) }) { cos(it) }
 fun cos(x: Dual): Dual = x.function({ cos(it) }) { -sin(it) }
@@ -532,8 +610,10 @@ fun ln(x: Dual): Dual = x.function({ ln(it) }) { 1.0 / it }
 fun ln1p(x: Dual): Dual = x.function({ ln1p(it) }) { 1.0 / (1.0 + it) }
 fun log2(x: Dual): Dual = x.function({ log2(it) }) { 1.0 / (it * LN_2)}
 fun log10(x: Dual): Dual = x.function({ log10(it) }) { 1.0 / (it * LN_10)}
+fun log(x: Dual, base: Double): Dual = x.function({ log(it, base) }) { 1.0 / (it * ln(base))}
 fun exp(x: Dual): Dual = x.function({ exp(it) }) { exp(it) }
 fun expm1(x: Dual): Dual = x.function({ expm1(it) }) { exp(it) }
+fun exp(x: Dual, base: Double): Dual = x.function({ base.pow(it) }) { exp(it, base) * ln(base) }
 
 /**
  * Dual version of [kotlin.math.atan2]
@@ -551,7 +631,7 @@ fun atan2(y: Dual, x: Dual) : Dual {
         Dual.const(atan2(y.value, x.value))
     }
     else if(size > 1) {
-        val tangent = (y / x)
+        val tangent = y / x
         val head = tangent.head()
         Dual(atan2(y.value, x.value), 1.0 / (head * head + 1.0) * tangent.tail())
     }
@@ -559,21 +639,3 @@ fun atan2(y: Dual, x: Dual) : Dual {
         Dual.empty
     }
 }
-
-// The argument is first and the base is second so that the methods are consistent with [kotlin.math].
-
-fun log(x: Dual, base: Double): Dual = if(x.isReal) {
-    Dual.of(log(x.value, base))
-}
-else {
-    val y = ln(base)
-    x.function({ log(it, base) }) { 1.0 / (it * y)}
-}
-
-fun exp(x: Dual, base: Double): Dual = if(x.isReal) {
-    Dual.of(base.pow(x.value))
-}
-else {
-    val y = ln(base)
-    x.function({ base.pow(it) }) { exp(it, base) * y }
-}
\ No newline at end of file
diff --git a/src/main/kotlin/org/ageseries/libage/parsers/falstad/Falstad.kt b/src/main/kotlin/org/ageseries/libage/parsers/falstad/Falstad.kt
index 88e9cd9..da0ecc9 100644
--- a/src/main/kotlin/org/ageseries/libage/parsers/falstad/Falstad.kt
+++ b/src/main/kotlin/org/ageseries/libage/parsers/falstad/Falstad.kt
@@ -20,8 +20,8 @@ import org.ageseries.libage.sim.electrical.mna.Node
 import org.ageseries.libage.sim.electrical.mna.component.Component
 import org.ageseries.libage.sim.electrical.mna.component.Resistor
 import org.ageseries.libage.sim.electrical.mna.component.VoltageSource
-import org.ageseries.libage.data.DisjointSet
-import org.ageseries.libage.space.Vec2i
+import org.ageseries.libage.data.SuperDisjointSet
+import org.ageseries.libage.mathematics.Vector2di
 
 /**
  * A splitting pattern for runs of one or more spaces (ASCII 32).
@@ -45,9 +45,9 @@ data class PinRef(val component: Component, val pinidx: Int) {
 }
 
 /**
- * A simple wrapper class for a position (as a [Vec2i]) referring to a position within the Falstad canvas.
+ * A simple wrapper class for a position (as a [Vector2di]) referring to a position within the Falstad canvas.
  */
-data class PinPos(val pos: Vec2i)
+data class PinPos(val pos: Vector2di)
 
 /**
  * Represents a line of text from a Falstad save.
@@ -120,7 +120,7 @@ data class CCData(val falstad: Falstad, val line: FalstadLine) {
      *
      * The exact elements consumed are indices 1 through 4 inclusive.
      */
-    val pinPositions get() = (0 until 2).map { i -> PinPos(Vec2i(line.getInt(1 + 2 * i), line.getInt(2 + 2 * i))) }
+    val pinPositions get() = (0 until 2).map { i -> PinPos(Vector2di(line.getInt(1 + 2 * i), line.getInt(2 + 2 * i))) }
 
     /**
      * Get the first point of the bounding box in pinPositions.
@@ -161,11 +161,11 @@ data class CCData(val falstad: Falstad, val line: FalstadLine) {
 }
 
 /**
- * A [DisjointSet] subclass which holds a [PinPos].
+ * A [SuperDisjointSet] subclass which holds a [PinPos].
  *
  * The Set class is used to implement the Disjoint Sets algorithm; the representative of the merged sets is used to determine which PinPos' are connected by wires, and thus merged into [Node]s as present in the [Circuit].
  */
-data class PosSet(val pos: PinPos) : DisjointSet()
+data class PosSet(val pos: PinPos) : SuperDisjointSet<PosSet>()
 
 /**
  * An interface for constructing [Component]s (usually)
@@ -238,7 +238,7 @@ abstract class PoleConstructor : IComponentConstructor {
         ccd.circuit.add(c)
         configure(ccd, c)
         ccd.pinPositions.withIndex().forEach { posidx ->
-            val pp = (ccd.falstad.getPin(posidx.value).representative as PosSet)
+            val pp = ccd.falstad.getPin(posidx.value).representative
             ccd.falstad.addPinRef(pp, PinRef(c, posidx.index))
         }
     }
@@ -255,7 +255,7 @@ abstract class PoleConstructor : IComponentConstructor {
  */
 class Falstad(val source: String) {
     /**
-     * "List of roots" (of the [Disjoint Set][DisjointSet] forest); a mapping from [PinPos] to [PosSet].
+     * "List of roots" (of the [Disjoint Set][SuperDisjointSet] forest); a mapping from [PinPos] to [PosSet].
      *
      * The values of this map are members of the forest (not necessarily "roots", but the root can easily be found as the representative).
      */
@@ -346,7 +346,7 @@ class Falstad(val source: String) {
             val repmap: MutableMultiMap<PosSet, PosSet> = mutableMultiMapOf()
             roots.values.forEach { set ->
                 dprintln("F.<init>: r $set => ${set.representative}")
-                repmap[set.representative as PosSet] = set
+                repmap[set.representative] = set
             }
 
             repmap.keyMapping.forEach { rep ->
@@ -359,7 +359,7 @@ class Falstad(val source: String) {
 
         val mergedRefs: MutableMultiMap<PosSet, PinRef> = mutableMultiMapOf()
         roots.values.forEach { posset ->
-            mergedRefs[posset.representative as PosSet].addAll(refs[posset])
+            mergedRefs[posset.representative].addAll(refs[posset])
         }
 
         if (DEBUG) mergedRefs.entries.forEach { pair ->
@@ -378,7 +378,7 @@ class Falstad(val source: String) {
         }
 
         grounds.forEach { posset ->
-            val pinset = refs[posset.representative as PosSet]
+            val pinset = refs[posset.representative]
             if (pinset.isNotEmpty()) {
                 // Only need to connect 1; the disjoint PosSets are merged right now
                 val pr = pinset.iterator().next()
diff --git a/src/main/kotlin/org/ageseries/libage/parsers/falstad/components/generic/OutputProbe.kt b/src/main/kotlin/org/ageseries/libage/parsers/falstad/components/generic/OutputProbe.kt
index a2180d9..07be338 100644
--- a/src/main/kotlin/org/ageseries/libage/parsers/falstad/components/generic/OutputProbe.kt
+++ b/src/main/kotlin/org/ageseries/libage/parsers/falstad/components/generic/OutputProbe.kt
@@ -3,7 +3,6 @@ package org.ageseries.libage.parsers.falstad.components.generic
 import org.ageseries.libage.parsers.falstad.CCData
 import org.ageseries.libage.parsers.falstad.IComponentConstructor
 import org.ageseries.libage.parsers.falstad.PinRef
-import org.ageseries.libage.parsers.falstad.PosSet
 import org.ageseries.libage.sim.electrical.mna.component.Resistor
 
 /**
@@ -22,7 +21,7 @@ class OutputProbe : IComponentConstructor {
         ccd.circuit.add(r)
         r.ground(1)
 
-        val pp = (ccd.falstad.getPin(ccd.pos).representative as PosSet)
+        val pp = ccd.falstad.getPin(ccd.pos).representative
         val pr = PinRef(r, 0)
         ccd.falstad.addPinRef(pp, pr)
         ccd.falstad.addOutput(pr)
diff --git a/src/main/kotlin/org/ageseries/libage/sim/Material.kt b/src/main/kotlin/org/ageseries/libage/sim/Material.kt
index 8fc59fa..99be113 100644
--- a/src/main/kotlin/org/ageseries/libage/sim/Material.kt
+++ b/src/main/kotlin/org/ageseries/libage/sim/Material.kt
@@ -1,36 +1,45 @@
 package org.ageseries.libage.sim
 
+import org.ageseries.libage.data.*
+
 /**
- * Material
- *
- * Contains data about materials that we need for various calculations such as electrical and thermal simulations
- */
-class Material(
-    /** Intrinsic linear electrical resistance, in Ohm/m. */
-    val electricalResistivity: Double,
-    /** Intrinsic linear thermal conductivity (on one axis), in W/mK. */
-    val thermalConductivity: Double,
-    /** Intrinsic specific heat capacity, in J/Kkg. */
-    val specificHeat: Double,
-    /** Density at STP, in g/cm^3 (or kd/dm^3). */
-    val density: Double,
+ * Represents a physical material with some useful properties.
+ * */
+data class Material(
+    val label: String,
+    val electricalResistivity: Quantity<ElectricalResistivity>,
+    val thermalConductivity: Quantity<ThermalConductivity>,
+    val specificHeat: Quantity<SpecificHeatCapacity>,
+    val density: Quantity<Density>,
 ) {
-    override fun toString() =
-        "<Mat ${electricalResistivity}Ohm/m ${thermalConductivity}W/mK ${specificHeat}J/Kkg ${density}g/cm^3>"
+    override fun toString() = "<$label ρ=${electricalResistivity.classify()} κ=${thermalConductivity.classify()} c=${specificHeat.classify()} ρ=${density.classify()}>"
 
     companion object {
-        // Good sources for this information:
-        // Electrical resistivity: https://en.wikipedia.org/wiki/Electrical_resistivity_and_conductivity
-        // Thermal conductivity: https://en.wikipedia.org/wiki/List_of_thermal_conductivities
-        // Specific heat: https://en.wikipedia.org/wiki/Table_of_specific_heat_capacities
-        // 		(use STANDARD_TEMPERATURE; note that the table has J/Kg, not J/Kkg!)
-        // 		alternatively: https://www.engineeringtoolbox.com/specific-heat-solids-d_154.html
-        //		(also uses kJ/Kkg = J/Kg!)
-        // Density: https://en.wikipedia.org/wiki/Density
-        val COPPER = Material(1.68e-8, 401.0, 385.0, 8.94)
-        val LATEX_RUBBER = Material(1e13, 0.134, 1130.0, 0.92)
-        val IRON = Material(9.7e-8, 83.5, 412.0, 7.87)
-        val GLASS = Material(1e13, 1.11, 840.0, 2.5)
-        val ALUMINUM = Material(2.65e-8, 100.0, 897.0, 2.7)
+        /**
+         * Constructs a material with **S.I.** properties.
+         * */
+        private fun def(label: String, electricalResistivity: Double, thermalConductivity: Double, specificHeat: Double, density: Double) = Material(
+            label,
+            Quantity(electricalResistivity, OHM_METER),
+            Quantity(thermalConductivity, WATT_PER_METER_KELVIN),
+            Quantity(specificHeat, JOULE_PER_KILOGRAM_KELVIN),
+            Quantity(density, KILOGRAM_PER_METER3)
+        )
+
+        val LATEX_RUBBER = def(
+            "Latex Rubber",
+            1e13,
+            0.134,
+            1130.0,
+            0.92
+        )
+
+        val GLASS = def(
+            "Glass",
+            1e13,
+            1.11,
+            840.0,
+            2.5
+        )
     }
 }
\ No newline at end of file
diff --git a/src/main/kotlin/org/ageseries/libage/sim/PeriodicTable.kt b/src/main/kotlin/org/ageseries/libage/sim/PeriodicTable.kt
new file mode 100644
index 0000000..04434d3
--- /dev/null
+++ b/src/main/kotlin/org/ageseries/libage/sim/PeriodicTable.kt
@@ -0,0 +1,3941 @@
+@file:Suppress("unused", "CanBeParameter", "LocalVariableName", "MemberVisibilityCanBePrivate")
+
+package org.ageseries.libage.sim
+
+import org.ageseries.libage.data.*
+import org.ageseries.libage.mathematics.rounded
+
+enum class ChemicalMetallicity(private val label: String) {
+    Metal("Metal"),
+    NonMetal("Non-Metal"),
+    Metalloid("Metalloid");
+
+    override fun toString() = label
+}
+
+enum class ChemicalPhase(private val label: String) {
+    Gas("Gas"),
+    Solid("Solid"),
+    Liquid("Liquid"),
+    Artificial("Artificial");
+
+    override fun toString() = label
+}
+
+enum class ChemicalElementType(private val label: String) {
+    Actinide("Actinide"),
+    AlkalineEarthMetal("Alkaline Earth Metal"),
+    Lanthanide("Lanthanide"),
+    Halogen("Halogen"),
+    NobleGas("Noble Gas"),
+    Metal("Metal"),
+    Metalloid("Metalloid"),
+    Transactinide("Transactinide"),
+    NonMetal("Non-Metal"),
+    AlkaliMetal("Alkali Metal"),
+    TransitionMetal("Transition Metal"),
+    Undefined("N/A");
+
+    override fun toString() = label
+}
+
+/**
+ * The Periodic Table of Elements.
+ * */
+@Suppress("PropertyName")
+enum class ChemicalElement(
+    /** **Atomic Number** of the element. */
+    val Z: Int,
+    /** Common (friendly) name of the element. */
+    val label: String,
+    /** **Atomic Symbol** of the element. */
+    val symbol: String,
+    /** Gets the **Atomic Mass** / **Mass Number** (in atomic units) of the element. */
+    val A: Quantity<AtomicMass>,
+    /** Gets the number of neutrons in the nucleus (in the reference isotope). */
+    val neutrons: Int,
+    /** Gets the number of protons in the nucleus (in the reference isotope). */
+    val protons: Int,
+    /** Gets the number of electrons in the electron shell (neutral state, obviously). */
+    val electrons: Int,
+    /** Gets the **period** where the element resides in the Periodic Table. */
+    val period: Int,
+    /** Gets the **group** where the element resides in the Periodic Table. */
+    val group: Int,
+    /** Gets the **phase** of the element in standard conditions. */
+    val phase: ChemicalPhase,
+    /** True, if the element is radioactive. Otherwise, false. */
+    val isRadioactive: Boolean,
+    /** True, if the element occurs in nature on Earth. Otherwise, false (it is man-made). */
+    val isNatural: Boolean,
+    /** Classification of the element based on it being a **Metal**, **Non-Metal** or **Metalloid**. */
+    val metallicProperty: ChemicalMetallicity,
+    /** Refined classification of the element. */
+    val type: ChemicalElementType,
+    /** **Atomic radius** is the mean or typical distance from the center of the nucleus to the outermost isolated electron. */
+    val atomicRadius: Quantity<Distance>,
+    /** **Electronegativity** of the element, on the Pauli scale. */
+    val electronegativity: Double,
+    /** **First ionization energy** of the element, the energy required to remove the outermost electron. */
+    val firstIonization: Double,
+    /** The **density** of the element at standard conditions. */
+    val density: Quantity<Density>,
+    /** The **melting point** of the element at standard conditions. */
+    val meltingPoint: Quantity<Temperature>,
+    /** The **boiling point** of the element at standard conditions. */
+    val boilingPoint: Quantity<Temperature>,
+    /** The number of major isotopes this element has. */
+    val isotopeCount: Int,
+    /** Person or institution that discovered this element. */
+    val discoverer: String,
+    /** The year the element was discovered in. */
+    val discoveryYear: Int,
+    /** The **specific heat** of the element at standard conditions. */
+    val specificHeat: Quantity<SpecificHeatCapacity>,
+    /** The number of electron shells of the element. */
+    val electronShells: Int,
+    /** **Valence** of the atom. */
+    val valence: Int,
+    /** **Excitation energy** of the atom, the minimum amount of energy required to promote a specific electron from its ground state to a higher energy level. */
+    val excitationEnergy: Quantity<Energy>,
+    /** **Thermal conductivity** of the element. If unknown, the value will be `0`. */
+    val thermalConductivity: Quantity<ThermalConductivity>,
+    /** **Electrical resistivity** (specific resistivity) of the element. If unknown or not conductive, the value will be [Double.POSITIVE_INFINITY].*/
+    val electricalResistivity: Quantity<ElectricalResistivity>,
+    /** The source of the main data. Changes must be specified in comments next to the value in question. */
+    val source: String
+) {
+    Hydrogen(
+        1,
+        "Hydrogen",
+        "H",
+        1.007,
+        0,
+        1,
+        1,
+        1,
+        1,
+        ChemicalPhase.Gas,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.NonMetal,
+        0.79,
+        2.2,
+        13.5984,
+        8.99E-5,
+        14.175,
+        20.28,
+        3,
+        "Cavendish",
+        1766,
+        14.304,
+        1,
+        1,
+        19.2,
+        0.1805,
+        Double.POSITIVE_INFINITY
+    ),
+    Helium(
+        2,
+        "Helium",
+        "He",
+        4.002,
+        2,
+        2,
+        2,
+        1,
+        18,
+        ChemicalPhase.Gas,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.NobleGas,
+        0.49,
+        0.0,
+        24.5874,
+        1.79E-4,
+        0.0,
+        4.22,
+        5,
+        "Janssen",
+        1868,
+        5.193,
+        1,
+        0,
+        41.8,
+        0.1513,
+        Double.POSITIVE_INFINITY
+    ),
+    Lithium(
+        3,
+        "Lithium",
+        "Li",
+        6.941,
+        4,
+        3,
+        3,
+        2,
+        1,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.AlkaliMetal,
+        2.1,
+        0.98,
+        5.3917,
+        0.534,
+        453.85,
+        1615.0,
+        5,
+        "Arfvedson",
+        1817,
+        3.582,
+        2,
+        1,
+        40.0,
+        85.0,
+        9.400000000002e-8
+    ),
+    Beryllium(
+        4,
+        "Beryllium",
+        "Be",
+        9.012,
+        5,
+        4,
+        4,
+        2,
+        2,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.AlkalineEarthMetal,
+        1.4,
+        1.57,
+        9.3227,
+        1.85,
+        1560.15,
+        2742.0,
+        6,
+        "Vaulquelin",
+        1798,
+        1.825,
+        2,
+        2,
+        63.7,
+        190.0,
+        3.999999999998e-8
+    ),
+    Boron(
+        5,
+        "Boron",
+        "B",
+        10.811,
+        6,
+        5,
+        5,
+        2,
+        13,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metalloid,
+        ChemicalElementType.Metalloid,
+        1.2,
+        2.04,
+        8.298,
+        2.34,
+        2573.15,
+        4200.0,
+        6,
+        "Gay-Lussac",
+        1808,
+        1.026,
+        2,
+        3,
+        76.0,
+        27.0,
+        10000.0
+    ),
+    Carbon(
+        6,
+        "Carbon",
+        "C",
+        12.011,
+        6,
+        6,
+        6,
+        2,
+        14,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.NonMetal,
+        0.91,
+        2.55,
+        11.2603,
+        2.27,
+        3948.15,
+        4300.0,
+        7,
+        "N/A",
+        0,
+        0.709,
+        2,
+        4,
+        78.0,
+        140.0,
+        0.00001
+    ),
+    Nitrogen(
+        7,
+        "Nitrogen",
+        "N",
+        14.007,
+        7,
+        7,
+        7,
+        2,
+        15,
+        ChemicalPhase.Gas,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.NonMetal,
+        0.75,
+        3.04,
+        14.5341,
+        0.00125,
+        63.29,
+        77.36,
+        8,
+        "Rutherford",
+        1772,
+        1.04,
+        2,
+        5,
+        82.0,
+        0.02583,
+        Double.POSITIVE_INFINITY
+    ),
+    Oxygen(
+        8,
+        "Oxygen",
+        "O",
+        15.999,
+        8,
+        8,
+        8,
+        2,
+        16,
+        ChemicalPhase.Gas,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.NonMetal,
+        0.65,
+        3.44,
+        13.6181,
+        0.00143,
+        50.5,
+        90.2,
+        8,
+        "Priestley/Scheele",
+        1774,
+        0.918,
+        2,
+        6,
+        95.0,
+        0.02658,
+        Double.POSITIVE_INFINITY
+    ),
+    Fluorine(
+        9,
+        "Fluorine",
+        "F",
+        18.998,
+        10,
+        9,
+        9,
+        2,
+        17,
+        ChemicalPhase.Gas,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.Halogen,
+        0.57,
+        3.98,
+        17.4228,
+        0.0017,
+        53.63,
+        85.03,
+        6,
+        "Moissan",
+        1886,
+        0.824,
+        2,
+        7,
+        115.0,
+        0.0277,
+        Double.POSITIVE_INFINITY
+    ),
+    Neon(
+        10,
+        "Neon",
+        "Ne",
+        20.18,
+        10,
+        10,
+        10,
+        2,
+        18,
+        ChemicalPhase.Gas,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.NobleGas,
+        0.51,
+        0.0,
+        21.5645,
+        9.0E-4,
+        24.703,
+        27.07,
+        8,
+        "Ramsay and Travers",
+        1898,
+        1.03,
+        2,
+        8,
+        137.0,
+        0.0491,
+        Double.POSITIVE_INFINITY
+    ),
+    Sodium(
+        11,
+        "Sodium",
+        "Na",
+        22.99,
+        12,
+        11,
+        11,
+        3,
+        1,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.AlkaliMetal,
+        2.2,
+        0.93,
+        5.1391,
+        0.971,
+        371.15,
+        1156.0,
+        7,
+        "Davy",
+        1807,
+        1.228,
+        3,
+        1,
+        149.0,
+        140.0,
+        4.699999999998e-8
+    ),
+    Magnesium(
+        12,
+        "Magnesium",
+        "Mg",
+        24.305,
+        12,
+        12,
+        12,
+        3,
+        2,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.AlkalineEarthMetal,
+        1.7,
+        1.31,
+        7.6462,
+        1.74,
+        923.15,
+        1363.0,
+        8,
+        "Black",
+        1755,
+        1.023,
+        3,
+        2,
+        156.0,
+        160.0,
+        4.399999999999e-8
+    ),
+    Aluminum(
+        13,
+        "Aluminum",
+        "Al",
+        26.982,
+        14,
+        13,
+        13,
+        3,
+        13,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Metal,
+        1.8,
+        1.61,
+        5.9858,
+        2.7,
+        933.4,
+        2792.0,
+        8,
+        "Wshler",
+        1827,
+        0.897,
+        3,
+        3,
+        166.0,
+        235.0,
+        2.6e-8
+    ),
+    Silicon(
+        14,
+        "Silicon",
+        "Si",
+        28.086,
+        14,
+        14,
+        14,
+        3,
+        14,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metalloid,
+        ChemicalElementType.Metalloid,
+        1.5,
+        1.9,
+        8.1517,
+        2.33,
+        1683.15,
+        3538.0,
+        8,
+        "Berzelius",
+        1824,
+        0.705,
+        3,
+        4,
+        173.0,
+        150.0,
+        0.001
+    ),
+    Phosphorus(
+        15,
+        "Phosphorus",
+        "P",
+        30.974,
+        16,
+        15,
+        15,
+        3,
+        15,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.NonMetal,
+        1.2,
+        2.19,
+        10.4867,
+        1.82,
+        317.25,
+        553.0,
+        7,
+        "BranBrand",
+        1669,
+        0.769,
+        3,
+        5,
+        173.0,
+        0.236,
+        1e-7
+    ),
+    Sulfur(
+        16,
+        "Sulfur",
+        "S",
+        32.065,
+        16,
+        16,
+        16,
+        3,
+        16,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.NonMetal,
+        1.1,
+        2.58,
+        10.36,
+        2.07,
+        388.51,
+        717.8,
+        10,
+        "N/A",
+        0,
+        0.71,
+        3,
+        6,
+        180.0,
+        0.205,
+        1e15
+    ),
+    Chlorine(
+        17,
+        "Chlorine",
+        "Cl",
+        35.453,
+        18,
+        17,
+        17,
+        3,
+        17,
+        ChemicalPhase.Gas,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.Halogen,
+        0.97,
+        3.16,
+        12.9676,
+        0.00321,
+        172.31,
+        239.11,
+        11,
+        "Scheele",
+        1774,
+        0.479,
+        3,
+        7,
+        174.0,
+        0.0089,
+        100.0
+    ),
+    Argon(
+        18,
+        "Argon",
+        "Ar",
+        39.948,
+        22,
+        18,
+        18,
+        3,
+        18,
+        ChemicalPhase.Gas,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.NobleGas,
+        0.88,
+        0.0,
+        15.7596,
+        0.00178,
+        83.96,
+        87.3,
+        8,
+        "Rayleigh and Ramsay",
+        1894,
+        0.52,
+        3,
+        8,
+        188.0,
+        0.01772,
+        Double.POSITIVE_INFINITY
+    ),
+    Potassium(
+        19,
+        "Potassium",
+        "K",
+        39.098,
+        20,
+        19,
+        19,
+        4,
+        1,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.AlkaliMetal,
+        2.8,
+        0.82,
+        4.3407,
+        0.862,
+        336.5,
+        1032.0,
+        10,
+        "Davy",
+        1807,
+        0.757,
+        4,
+        1,
+        190.0,
+        100.0,
+        7.000000000002e-8
+    ),
+    Calcium(
+        20,
+        "Calcium",
+        "Ca",
+        40.078,
+        20,
+        20,
+        20,
+        4,
+        2,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.AlkalineEarthMetal,
+        2.2,
+        1.0,
+        6.1132,
+        1.54,
+        1112.15,
+        1757.0,
+        14,
+        "Davy",
+        1808,
+        0.647,
+        4,
+        2,
+        191.0,
+        200.0,
+        3.399999999999e-8
+    ),
+    Scandium(
+        21,
+        "Scandium",
+        "Sc",
+        44.956,
+        24,
+        21,
+        21,
+        4,
+        3,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        2.1,
+        1.36,
+        6.5615,
+        2.99,
+        1812.15,
+        3109.0,
+        15,
+        "Nilson",
+        1878,
+        0.568,
+        4,
+        0,
+        216.0,
+        16.0,
+        5.5e-7
+    ),
+    Titanium(
+        22,
+        "Titanium",
+        "Ti",
+        47.867,
+        26,
+        22,
+        22,
+        4,
+        4,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        2.0,
+        1.54,
+        6.8281,
+        4.54,
+        1933.15,
+        3560.0,
+        9,
+        "Gregor",
+        1791,
+        0.523,
+        4,
+        0,
+        233.0,
+        22.0,
+        4e-7
+    ),
+    Vanadium(
+        23,
+        "Vanadium",
+        "V",
+        50.942,
+        28,
+        23,
+        23,
+        4,
+        5,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.9,
+        1.63,
+        6.7462,
+        6.11,
+        2175.15,
+        3680.0,
+        9,
+        "del Rio",
+        1801,
+        0.489,
+        4,
+        0,
+        245.0,
+        31.0,
+        2e-7
+    ),
+    Chromium(
+        24,
+        "Chromium",
+        "Cr",
+        51.996,
+        28,
+        24,
+        24,
+        4,
+        6,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.9,
+        1.66,
+        6.7665,
+        7.15,
+        2130.15,
+        2944.0,
+        9,
+        "Vauquelin",
+        1797,
+        0.449,
+        4,
+        0,
+        257.0,
+        94.0,
+        1.3e-7
+    ),
+    Manganese(
+        25,
+        "Manganese",
+        "Mn",
+        54.938,
+        30,
+        25,
+        25,
+        4,
+        7,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.8,
+        1.55,
+        7.434,
+        7.44,
+        1519.15,
+        2334.0,
+        11,
+        "Gahn, Scheele",
+        1774,
+        0.479,
+        4,
+        0,
+        272.0,
+        7.7,
+        1.6e-6
+    ),
+    Iron(
+        26,
+        "Iron",
+        "Fe",
+        55.845,
+        30,
+        26,
+        26,
+        4,
+        8,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.7,
+        1.83,
+        7.9024,
+        7.87,
+        1808.15,
+        3134.0,
+        10,
+        "N/A",
+        0,
+        0.449,
+        4,
+        0,
+        286.0,
+        79.0,
+        9.700000000001e-8
+    ),
+    Cobalt(
+        27,
+        "Cobalt",
+        "Co",
+        58.933,
+        32,
+        27,
+        27,
+        4,
+        9,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.7,
+        1.88,
+        7.881,
+        8.86,
+        1768.15,
+        3200.0,
+        14,
+        "Brandt",
+        1735,
+        0.421,
+        4,
+        0,
+        297.0,
+        100.0,
+        6.000000000002e-8
+    ),
+    Nickel(
+        28,
+        "Nickel",
+        "Ni",
+        58.693,
+        31,
+        28,
+        28,
+        4,
+        10,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.6,
+        1.91,
+        7.6398,
+        8.91,
+        1726.15,
+        3186.0,
+        11,
+        "Cronstedt",
+        1751,
+        0.444,
+        4,
+        0,
+        311.0,
+        91.0,
+        7.000000000002e-8
+    ),
+    Copper(
+        29,
+        "Copper",
+        "Cu",
+        63.546,
+        35,
+        29,
+        29,
+        4,
+        11,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.6,
+        1.9,
+        7.7264,
+        8.96,
+        1357.75,
+        2835.0,
+        11,
+        "N/A",
+        0,
+        0.385,
+        4,
+        0,
+        322.0,
+        400.0,
+        1.7e-8
+    ),
+    Zinc(
+        30,
+        "Zinc",
+        "Zn",
+        65.38,
+        35,
+        30,
+        30,
+        4,
+        12,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.5,
+        1.65,
+        9.3942,
+        7.13,
+        692.88,
+        1180.0,
+        15,
+        "N/A",
+        0,
+        0.388,
+        4,
+        0,
+        330.0,
+        120.0,
+        5.900000000001e-8
+    ),
+    Gallium(
+        31,
+        "Gallium",
+        "Ga",
+        69.723,
+        39,
+        31,
+        31,
+        4,
+        13,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Metal,
+        1.8,
+        1.81,
+        5.9993,
+        5.91,
+        302.91,
+        2477.0,
+        14,
+        "de Boisbaudran",
+        1875,
+        0.371,
+        4,
+        3,
+        334.0,
+        29.0,
+        1.4e-7
+    ),
+    Germanium(
+        32,
+        "Germanium",
+        "Ge",
+        72.64,
+        41,
+        32,
+        32,
+        4,
+        14,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metalloid,
+        ChemicalElementType.Metalloid,
+        1.5,
+        2.01,
+        7.8994,
+        5.32,
+        1211.45,
+        3106.0,
+        17,
+        "Winkler",
+        1886,
+        0.32,
+        4,
+        4,
+        350.0,
+        60.0,
+        0.0005
+    ),
+    Arsenic(
+        33,
+        "Arsenic",
+        "As",
+        74.922,
+        42,
+        33,
+        33,
+        4,
+        15,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metalloid,
+        ChemicalElementType.Metalloid,
+        1.3,
+        2.18,
+        9.7886,
+        5.78,
+        1090.15,
+        887.0,
+        14,
+        "Albertus Magnus",
+        1250,
+        0.329,
+        4,
+        5,
+        347.0,
+        50.0,
+        3e-7
+    ),
+    Selenium(
+        34,
+        "Selenium",
+        "Se",
+        78.96,
+        45,
+        34,
+        34,
+        4,
+        16,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.NonMetal,
+        1.2,
+        2.55,
+        9.7524,
+        4.81,
+        494.15,
+        958.0,
+        20,
+        "Berzelius",
+        1817,
+        0.321,
+        4,
+        6,
+        348.0,
+        0.52,
+        Double.POSITIVE_INFINITY
+    ),
+    Bromine(
+        35,
+        "Bromine",
+        "Br",
+        79.904,
+        45,
+        35,
+        35,
+        4,
+        17,
+        ChemicalPhase.Liquid,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.Halogen,
+        1.1,
+        2.96,
+        11.8138,
+        3.12,
+        266.05,
+        332.0,
+        19,
+        "Balard",
+        1826,
+        0.474,
+        4,
+        7,
+        343.0,
+        0.12,
+        1e10
+    ),
+    Krypton(
+        36,
+        "Krypton",
+        "Kr",
+        83.798,
+        48,
+        36,
+        36,
+        4,
+        18,
+        ChemicalPhase.Gas,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.NobleGas,
+        1.0,
+        0.0,
+        13.9996,
+        0.00373,
+        115.93,
+        119.93,
+        23,
+        "Ramsay and Travers",
+        1898,
+        0.248,
+        4,
+        8,
+        352.0,
+        0.00943,
+        Double.POSITIVE_INFINITY
+    ),
+    Rubidium(
+        37,
+        "Rubidium",
+        "Rb",
+        85.468,
+        48,
+        37,
+        37,
+        5,
+        1,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.AlkaliMetal,
+        3.0,
+        0.82,
+        4.1771,
+        1.53,
+        312.79,
+        961.0,
+        20,
+        "Bunsen and Kirchoff",
+        1861,
+        0.363,
+        5,
+        1,
+        363.0,
+        58.0,
+        1.2e-7
+    ),
+    Strontium(
+        38,
+        "Strontium",
+        "Sr",
+        87.62,
+        50,
+        38,
+        38,
+        5,
+        2,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.AlkalineEarthMetal,
+        2.5,
+        0.95,
+        5.6949,
+        2.64,
+        1042.15,
+        1655.0,
+        18,
+        "Davy",
+        1808,
+        0.301,
+        5,
+        2,
+        366.0,
+        35.0,
+        1.3e-7
+    ),
+    Yttrium(
+        39,
+        "Yttrium",
+        "Y",
+        88.906,
+        50,
+        39,
+        39,
+        5,
+        3,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        2.3,
+        1.22,
+        6.2173,
+        4.47,
+        1799.15,
+        3609.0,
+        21,
+        "Gadolin",
+        1794,
+        0.298,
+        5,
+        0,
+        379.0,
+        17.0,
+        5.7e-7
+    ),
+    Zirconium(
+        40,
+        "Zirconium",
+        "Zr",
+        91.224,
+        51,
+        40,
+        40,
+        5,
+        4,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        2.2,
+        1.33,
+        6.6339,
+        6.51,
+        2125.15,
+        4682.0,
+        20,
+        "Klaproth",
+        1789,
+        0.278,
+        5,
+        0,
+        393.0,
+        23.0,
+        4.2e-7
+    ),
+    Niobium(
+        41,
+        "Niobium",
+        "Nb",
+        92.906,
+        52,
+        41,
+        41,
+        5,
+        5,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        2.1,
+        1.6,
+        6.7589,
+        8.57,
+        2741.15,
+        5017.0,
+        24,
+        "Hatchett",
+        1801,
+        0.265,
+        5,
+        0,
+        417.0,
+        54.0,
+        1.5e-7
+    ),
+    Molybdenum(
+        42,
+        "Molybdenum",
+        "Mo",
+        95.96,
+        54,
+        42,
+        42,
+        5,
+        6,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        2.0,
+        2.16,
+        7.0924,
+        10.2,
+        2890.15,
+        4912.0,
+        20,
+        "Scheele",
+        1778,
+        0.251,
+        5,
+        0,
+        424.0,
+        139.0,
+        4.999999999997e-8
+    ),
+    Technetium(
+        43,
+        "Technetium",
+        "Tc",
+        98.0,
+        55,
+        43,
+        43,
+        5,
+        7,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        2.0,
+        1.9,
+        7.28,
+        11.5,
+        2473.15,
+        5150.0,
+        23,
+        "Perrier and Segrè",
+        1937,
+        0.0,
+        5,
+        0,
+        428.0,
+        51.0,
+        2e-7
+    ),
+    Ruthenium(
+        44,
+        "Ruthenium",
+        "Ru",
+        101.07,
+        57,
+        44,
+        44,
+        5,
+        8,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.9,
+        2.2,
+        7.3605,
+        12.4,
+        2523.15,
+        4423.0,
+        16,
+        "Klaus",
+        1844,
+        0.238,
+        5,
+        0,
+        441.0,
+        120.0,
+        7.000000000002e-8
+    ),
+    Rhodium(
+        45,
+        "Rhodium",
+        "Rh",
+        102.906,
+        58,
+        45,
+        45,
+        5,
+        9,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.8,
+        2.28,
+        7.4589,
+        12.4,
+        2239.15,
+        3968.0,
+        20,
+        "Wollaston",
+        1803,
+        0.243,
+        5,
+        0,
+        449.0,
+        150.0,
+        4.300000000003e-8
+    ),
+    Palladium(
+        46,
+        "Palladium",
+        "Pd",
+        106.42,
+        60,
+        46,
+        46,
+        5,
+        10,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.8,
+        2.2,
+        8.3369,
+        12.0,
+        1825.15,
+        3236.0,
+        21,
+        "Wollaston",
+        1803,
+        0.244,
+        5,
+        0,
+        470.0,
+        71.0,
+        1e-7
+    ),
+    Silver(
+        47,
+        "Silver",
+        "Ag",
+        107.868,
+        61,
+        47,
+        47,
+        5,
+        11,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.8,
+        1.93,
+        7.5762,
+        10.5,
+        1234.15,
+        2435.0,
+        27,
+        "N/A",
+        0,
+        0.235,
+        5,
+        0,
+        470.0,
+        430.0,
+        1.6e-8
+    ),
+    Cadmium(
+        48,
+        "Cadmium",
+        "Cd",
+        112.411,
+        64,
+        48,
+        48,
+        5,
+        12,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.7,
+        1.69,
+        8.9938,
+        8.69,
+        594.33,
+        1040.0,
+        22,
+        "Stromeyer",
+        1817,
+        0.232,
+        5,
+        0,
+        469.0,
+        96.0,
+        7.000000000002e-8
+    ),
+    Indium(
+        49,
+        "Indium",
+        "In",
+        114.818,
+        66,
+        49,
+        49,
+        5,
+        13,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Metal,
+        2.0,
+        1.78,
+        5.7864,
+        7.31,
+        429.91,
+        2345.0,
+        34,
+        "Reich and Richter",
+        1863,
+        0.233,
+        5,
+        3,
+        488.0,
+        82.0,
+        8.000000000001e-8
+    ),
+    Tin(
+        50,
+        "Tin",
+        "Sn",
+        118.71,
+        69,
+        50,
+        50,
+        5,
+        14,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Metal,
+        1.7,
+        1.96,
+        7.3439,
+        7.29,
+        505.21,
+        2875.0,
+        28,
+        "N/A",
+        0,
+        0.228,
+        5,
+        4,
+        488.0,
+        67.0,
+        1.1e-7
+    ),
+    Antimony(
+        51,
+        "Antimony",
+        "Sb",
+        121.76,
+        71,
+        51,
+        51,
+        5,
+        15,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metalloid,
+        ChemicalElementType.Metalloid,
+        1.5,
+        2.05,
+        8.6084,
+        6.69,
+        904.05,
+        1860.0,
+        29,
+        "N/A",
+        0,
+        0.207,
+        5,
+        5,
+        487.0,
+        24.0,
+        4e-7
+    ),
+    Tellurium(
+        52,
+        "Tellurium",
+        "Te",
+        127.6,
+        76,
+        52,
+        52,
+        5,
+        16,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metalloid,
+        ChemicalElementType.Metalloid,
+        1.4,
+        2.1,
+        9.0096,
+        6.23,
+        722.8,
+        1261.0,
+        29,
+        "von Reichenstein",
+        1782,
+        0.202,
+        5,
+        6,
+        485.0,
+        3.0,
+        0.0001
+    ),
+    Iodine(
+        53,
+        "Iodine",
+        "I",
+        126.904,
+        74,
+        53,
+        53,
+        5,
+        17,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.Halogen,
+        1.3,
+        2.66,
+        10.4513,
+        4.93,
+        386.65,
+        457.4,
+        24,
+        "Courtois",
+        1811,
+        0.214,
+        5,
+        7,
+        491.0,
+        0.449,
+        1e7
+    ),
+    Xenon(
+        54,
+        "Xenon",
+        "Xe",
+        131.293,
+        77,
+        54,
+        54,
+        5,
+        18,
+        ChemicalPhase.Gas,
+        false,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.NobleGas,
+        1.2,
+        0.0,
+        12.1298,
+        0.00589,
+        161.45,
+        165.03,
+        31,
+        "Ramsay and Travers",
+        1898,
+        0.158,
+        5,
+        8,
+        482.0,
+        0.00565,
+        Double.POSITIVE_INFINITY
+    ),
+    Cesium(
+        55,
+        "Cesium",
+        "Cs",
+        132.905,
+        78,
+        55,
+        55,
+        6,
+        1,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.AlkaliMetal,
+        3.3,
+        0.79,
+        3.8939,
+        1.87,
+        301.7,
+        944.0,
+        22,
+        "Bunsen and Kirchoff",
+        1860,
+        0.242,
+        6,
+        1,
+        488.0,
+        36.0,
+        2e-7
+    ),
+    Barium(
+        56,
+        "Barium",
+        "Ba",
+        137.327,
+        81,
+        56,
+        56,
+        6,
+        2,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.AlkalineEarthMetal,
+        2.8,
+        0.89,
+        5.2117,
+        3.59,
+        1002.15,
+        2170.0,
+        25,
+        "Davy",
+        1808,
+        0.204,
+        6,
+        2,
+        491.0,
+        18.0,
+        3.5e-7
+    ),
+    Lanthanum(
+        57,
+        "Lanthanum",
+        "La",
+        138.905,
+        82,
+        57,
+        57,
+        6,
+        3,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.7,
+        1.1,
+        5.5769,
+        6.15,
+        1193.15,
+        3737.0,
+        19,
+        "Mosander",
+        1839,
+        0.195,
+        6,
+        0,
+        501.0,
+        13.0,
+        6.1e-7
+    ),
+    Cerium(
+        58,
+        "Cerium",
+        "Ce",
+        140.116,
+        82,
+        58,
+        58,
+        6,
+        0,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.7,
+        1.12,
+        5.5387,
+        6.77,
+        1071.15,
+        3716.0,
+        19,
+        "Berzelius",
+        1803,
+        0.192,
+        6,
+        0,
+        523.0,
+        11.0,
+        7.5e-7
+    ),
+    Praseodymium(
+        59,
+        "Praseodymium",
+        "Pr",
+        140.908,
+        82,
+        59,
+        59,
+        6,
+        0,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.7,
+        1.13,
+        5.473,
+        6.77,
+        1204.15,
+        3793.0,
+        15,
+        "von Welsbach",
+        1885,
+        0.193,
+        6,
+        0,
+        535.0,
+        13.0,
+        7e-7
+    ),
+    Neodymium(
+        60,
+        "Neodymium",
+        "Nd",
+        144.242,
+        84,
+        60,
+        60,
+        6,
+        0,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.6,
+        1.14,
+        5.525,
+        7.01,
+        1289.15,
+        3347.0,
+        16,
+        "von Welsbach",
+        1885,
+        0.19,
+        6,
+        0,
+        546.0,
+        17.0,
+        6.4e-7
+    ),
+    Promethium(
+        61,
+        "Promethium",
+        "Pm",
+        145.0,
+        84,
+        61,
+        61,
+        6,
+        0,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.6,
+        1.13,
+        5.582,
+        7.26,
+        1204.15,
+        3273.0,
+        14,
+        "Marinsky et al.",
+        1945,
+        0.0,
+        6,
+        0,
+        560.0,
+        15.0,
+        7.5e-7
+    ),
+    Samarium(
+        62,
+        "Samarium",
+        "Sm",
+        150.36,
+        88,
+        62,
+        62,
+        6,
+        0,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.6,
+        1.17,
+        5.6437,
+        7.52,
+        1345.15,
+        2067.0,
+        17,
+        "Boisbaudran",
+        1879,
+        0.197,
+        6,
+        0,
+        574.0,
+        13.0,
+        9.4e-7
+    ),
+    Europium(
+        63,
+        "Europium",
+        "Eu",
+        151.964,
+        89,
+        63,
+        63,
+        6,
+        0,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.6,
+        1.2,
+        5.6704,
+        5.24,
+        1095.15,
+        1802.0,
+        21,
+        "Demarcay",
+        1901,
+        0.182,
+        6,
+        0,
+        580.0,
+        14.0,
+        9e-7
+    ),
+    Gadolinium(
+        64,
+        "Gadolinium",
+        "Gd",
+        157.25,
+        93,
+        64,
+        64,
+        6,
+        0,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.5,
+        1.2,
+        6.1501,
+        7.9,
+        1585.15,
+        3546.0,
+        17,
+        "de Marignac",
+        1880,
+        0.236,
+        6,
+        0,
+        591.0,
+        11.0,
+        1.3e-6
+    ),
+    Terbium(
+        65,
+        "Terbium",
+        "Tb",
+        158.925,
+        94,
+        65,
+        65,
+        6,
+        0,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.5,
+        1.2,
+        5.8638,
+        8.23,
+        1630.15,
+        3503.0,
+        24,
+        "Mosander",
+        1843,
+        0.182,
+        6,
+        0,
+        614.0,
+        11.0,
+        1.2e-6
+    ),
+    Dysprosium(
+        66,
+        "Dysprosium",
+        "Dy",
+        162.5,
+        97,
+        66,
+        66,
+        6,
+        0,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.5,
+        1.22,
+        5.9389,
+        8.55,
+        1680.15,
+        2840.0,
+        21,
+        "de Boisbaudran",
+        1886,
+        0.17,
+        6,
+        0,
+        628.0,
+        11.0,
+        9.1e-7
+    ),
+    Holmium(
+        67,
+        "Holmium",
+        "Ho",
+        164.93,
+        98,
+        67,
+        67,
+        6,
+        0,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.5,
+        1.23,
+        6.0215,
+        8.8,
+        1743.15,
+        2993.0,
+        29,
+        "Delafontaine and Soret",
+        1878,
+        0.165,
+        6,
+        0,
+        650.0,
+        16.0,
+        9.4e-7
+    ),
+    Erbium(
+        68,
+        "Erbium",
+        "Er",
+        167.259,
+        99,
+        68,
+        68,
+        6,
+        0,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.5,
+        1.24,
+        6.1077,
+        9.07,
+        1795.15,
+        3503.0,
+        16,
+        "Mosander",
+        1843,
+        0.168,
+        6,
+        0,
+        658.0,
+        15.0,
+        8.6e-7
+    ),
+    Thulium(
+        69,
+        "Thulium",
+        "Tm",
+        168.934,
+        100,
+        69,
+        69,
+        6,
+        0,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.4,
+        1.25,
+        6.1843,
+        9.32,
+        1818.15,
+        2223.0,
+        18,
+        "Cleve",
+        1879,
+        0.16,
+        6,
+        0,
+        674.0,
+        17.0,
+        7e-7
+    ),
+    Ytterbium(
+        70,
+        "Ytterbium",
+        "Yb",
+        173.054,
+        103,
+        70,
+        70,
+        6,
+        0,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.4,
+        1.1,
+        6.2542,
+        6.97,
+        1097.15,
+        1469.0,
+        16,
+        "Marignac",
+        1878,
+        0.155,
+        6,
+        0,
+        684.0,
+        39.0,
+        2.8e-7
+    ),
+    Lutetium(
+        71,
+        "Lutetium",
+        "Lu",
+        174.967,
+        104,
+        71,
+        71,
+        6,
+        0,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Lanthanide,
+        2.3,
+        1.27,
+        5.4259,
+        9.84,
+        1936.15,
+        3675.0,
+        22,
+        "Urbain / von Welsbach",
+        1907,
+        0.154,
+        6,
+        0,
+        694.0,
+        16.0,
+        5.7e-7
+    ),
+    Hafnium(
+        72,
+        "Hafnium",
+        "Hf",
+        178.49,
+        106,
+        72,
+        72,
+        6,
+        4,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        2.2,
+        1.3,
+        6.8251,
+        13.3,
+        2500.15,
+        4876.0,
+        17,
+        "Coster and von Hevesy",
+        1923,
+        0.144,
+        6,
+        0,
+        705.0,
+        23.0,
+        3e-7
+    ),
+    Tantalum(
+        73,
+        "Tantalum",
+        "Ta",
+        180.948,
+        108,
+        73,
+        73,
+        6,
+        5,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        2.1,
+        1.5,
+        7.5496,
+        16.7,
+        3269.15,
+        5731.0,
+        19,
+        "Ekeberg",
+        1801,
+        0.14,
+        6,
+        0,
+        718.0,
+        57.0,
+        1.3e-7
+    ),
+    Wolfram(
+        74,
+        "Wolfram",
+        "W",
+        183.84,
+        110,
+        74,
+        74,
+        6,
+        6,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        2.0,
+        2.36,
+        7.864,
+        19.3,
+        3680.15,
+        5828.0,
+        22,
+        "J. and F. d'Elhuyar",
+        1783,
+        0.132,
+        6,
+        0,
+        727.0,
+        170.0,
+        4.999999999997e-8
+    ),
+    Rhenium(
+        75,
+        "Rhenium",
+        "Re",
+        186.207,
+        111,
+        75,
+        75,
+        6,
+        7,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        2.0,
+        1.9,
+        7.8335,
+        21.0,
+        3453.15,
+        5869.0,
+        21,
+        "Noddack, Berg and Tacke",
+        1925,
+        0.137,
+        6,
+        0,
+        736.0,
+        48.0,
+        1.8e-7
+    ),
+    Osmium(
+        76,
+        "Osmium",
+        "Os",
+        190.23,
+        114,
+        76,
+        76,
+        6,
+        8,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.9,
+        2.2,
+        8.4382,
+        22.6,
+        3300.15,
+        5285.0,
+        19,
+        "Tennant",
+        1803,
+        0.13,
+        6,
+        0,
+        746.0,
+        87.0,
+        8.000000000001e-8
+    ),
+    Iridium(
+        77,
+        "Iridium",
+        "Ir",
+        192.217,
+        115,
+        77,
+        77,
+        6,
+        9,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.9,
+        2.2,
+        8.967,
+        22.6,
+        2716.15,
+        4701.0,
+        25,
+        "Tennant",
+        1804,
+        0.131,
+        6,
+        0,
+        757.0,
+        150.0,
+        4.699999999998e-8
+    ),
+    Platinum(
+        78,
+        "Platinum",
+        "Pt",
+        195.084,
+        117,
+        78,
+        78,
+        6,
+        10,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.8,
+        2.28,
+        8.9587,
+        21.5,
+        2045.15,
+        4098.0,
+        32,
+        "Ulloa/Wood",
+        1735,
+        0.133,
+        6,
+        0,
+        790.0,
+        71.0,
+        1.1e-7
+    ),
+    Gold(
+        79,
+        "Gold",
+        "Au",
+        196.967,
+        118,
+        79,
+        79,
+        6,
+        11,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.8,
+        2.54,
+        9.2255,
+        19.3,
+        1337.73,
+        3129.0,
+        21,
+        "N/A",
+        0,
+        0.129,
+        6,
+        0,
+        790.0,
+        320.0,
+        2.2e-8
+    ),
+    Mercury(
+        80,
+        "Mercury",
+        "Hg",
+        200.59,
+        121,
+        80,
+        80,
+        6,
+        12,
+        ChemicalPhase.Liquid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.TransitionMetal,
+        1.8,
+        2.0,
+        10.4375,
+        13.5,
+        234.43,
+        630.0,
+        26,
+        "N/A",
+        0,
+        0.14,
+        6,
+        0,
+        800.0,
+        8.3,
+        9.6e-7
+    ),
+    Thallium(
+        81,
+        "Thallium",
+        "Tl",
+        204.383,
+        123,
+        81,
+        81,
+        6,
+        13,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Metal,
+        2.1,
+        2.04,
+        6.1082,
+        11.9,
+        577.15,
+        1746.0,
+        28,
+        "Crookes",
+        1861,
+        0.129,
+        6,
+        3,
+        810.0,
+        46.0,
+        1.5e-7
+    ),
+    Lead(
+        82,
+        "Lead",
+        "Pb",
+        207.2,
+        125,
+        82,
+        82,
+        6,
+        14,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Metal,
+        1.8,
+        2.33,
+        7.4167,
+        11.3,
+        600.75,
+        2022.0,
+        29,
+        "N/A",
+        0,
+        0.129,
+        6,
+        4,
+        823.0,
+        35.0,
+        2.1e-7
+    ),
+    Bismuth(
+        83,
+        "Bismuth",
+        "Bi",
+        208.98,
+        126,
+        83,
+        83,
+        6,
+        15,
+        ChemicalPhase.Solid,
+        false,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Metal,
+        1.6,
+        2.02,
+        7.2856,
+        9.81,
+        544.67,
+        1837.0,
+        19,
+        "Geoffroy the Younger",
+        1753,
+        0.122,
+        6,
+        5,
+        823.0,
+        8.0,
+        1.3e-6
+    ),
+    Polonium(
+        84,
+        "Polonium",
+        "Po",
+        210.0,
+        126,
+        84,
+        84,
+        6,
+        16,
+        ChemicalPhase.Solid,
+        true,
+        true,
+        ChemicalMetallicity.Metalloid,
+        ChemicalElementType.Metalloid,
+        1.5,
+        2.0,
+        8.417,
+        9.32,
+        527.15,
+        1235.0,
+        34,
+        "Curie",
+        1898,
+        0.0,
+        6,
+        6,
+        830.0,
+        0.0,
+        4.3e-7
+    ),
+    Astatine(
+        85,
+        "Astatine",
+        "At",
+        210.0,
+        125,
+        85,
+        85,
+        6,
+        17,
+        ChemicalPhase.Solid,
+        true,
+        true,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.Halogen,
+        1.4,
+        2.2,
+        9.3,
+        7.0,
+        575.15,
+        610.0,
+        21,
+        "Corson et al.",
+        1940,
+        0.0,
+        6,
+        7,
+        825.0,
+        2.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Radon(
+        86,
+        "Radon",
+        "Rn",
+        222.0,
+        136,
+        86,
+        86,
+        6,
+        18,
+        ChemicalPhase.Gas,
+        true,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.NobleGas,
+        1.3,
+        0.0,
+        10.7485,
+        0.00973,
+        202.15,
+        211.3,
+        20,
+        "Dorn",
+        1900,
+        0.094,
+        6,
+        8,
+        794.0,
+        0.00361,
+        Double.POSITIVE_INFINITY
+    ),
+    Francium(
+        87,
+        "Francium",
+        "Fr",
+        223.0,
+        136,
+        87,
+        87,
+        7,
+        1,
+        ChemicalPhase.Solid,
+        true,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.AlkaliMetal,
+        0.0,
+        0.7,
+        4.0727,
+        1.87,
+        300.15,
+        950.0,
+        21,
+        "Perey",
+        1939,
+        0.0,
+        7,
+        1,
+        827.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Radium(
+        88,
+        "Radium",
+        "Ra",
+        226.0,
+        138,
+        88,
+        88,
+        7,
+        2,
+        ChemicalPhase.Solid,
+        true,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.AlkalineEarthMetal,
+        0.0,
+        0.9,
+        5.2784,
+        5.5,
+        973.15,
+        2010.0,
+        15,
+        "Pierre and Marie Curie",
+        1898,
+        0.0,
+        7,
+        2,
+        826.0,
+        19.0,
+        1e-6
+    ),
+    Actinium(
+        89,
+        "Actinium",
+        "Ac",
+        227.0,
+        138,
+        89,
+        89,
+        7,
+        3,
+        ChemicalPhase.Solid,
+        true,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        1.1,
+        5.17,
+        10.1,
+        1323.15,
+        3471.0,
+        11,
+        "Debierne/Giesel",
+        1899,
+        0.12,
+        7,
+        0,
+        841.0,
+        12.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Thorium(
+        90,
+        "Thorium",
+        "Th",
+        232.038,
+        142,
+        90,
+        90,
+        7,
+        0,
+        ChemicalPhase.Solid,
+        true,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        1.3,
+        6.3067,
+        11.7,
+        2028.15,
+        5061.0,
+        12,
+        "Berzelius",
+        1828,
+        0.113,
+        7,
+        0,
+        847.0,
+        54.0,
+        1.5e-7
+    ),
+    Protactinium(
+        91,
+        "Protactinium",
+        "Pa",
+        231.036,
+        140,
+        91,
+        91,
+        7,
+        0,
+        ChemicalPhase.Solid,
+        true,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        1.5,
+        5.89,
+        15.4,
+        1873.15,
+        4300.0,
+        14,
+        "Hahn and Meitner",
+        1917,
+        0.0,
+        7,
+        0,
+        878.0,
+        47.0,
+        1.8e-7
+    ),
+    Uranium(
+        92,
+        "Uranium",
+        "U",
+        238.029,
+        146,
+        92,
+        92,
+        7,
+        0,
+        ChemicalPhase.Solid,
+        true,
+        true,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        1.38,
+        6.1941,
+        19.0,
+        1405.15,
+        4404.0,
+        15,
+        "Peligot",
+        1841,
+        0.116,
+        7,
+        0,
+        890.0,
+        27.0,
+        2.8e-7
+    ),
+    Neptunium(
+        93,
+        "Neptunium",
+        "Np",
+        237.0,
+        144,
+        93,
+        93,
+        7,
+        0,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        1.36,
+        6.2657,
+        20.5,
+        913.15,
+        4273.0,
+        153,
+        "McMillan and Abelson",
+        1940,
+        0.0,
+        7,
+        0,
+        0.0,
+        6.0,
+        1.2e-6
+    ),
+    Plutonium(
+        94,
+        "Plutonium",
+        "Pu",
+        244.0,
+        150,
+        94,
+        94,
+        7,
+        0,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        1.28,
+        6.0262,
+        19.8,
+        913.15,
+        3501.0,
+        163,
+        "Seaborg et al.",
+        1940,
+        0.0,
+        7,
+        0,
+        0.0,
+        6.0,
+        1.5e-6
+    ),
+    Americium(
+        95,
+        "Americium",
+        "Am",
+        243.0,
+        148,
+        95,
+        95,
+        7,
+        0,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        1.3,
+        5.9738,
+        13.7,
+        1267.15,
+        2880.0,
+        133,
+        "Seaborg et al.",
+        1944,
+        0.0,
+        7,
+        0,
+        0.0,
+        10.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Curium(
+        96,
+        "Curium",
+        "Cm",
+        247.0,
+        151,
+        96,
+        96,
+        7,
+        0,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        1.3,
+        5.9915,
+        13.5,
+        1340.15,
+        3383.0,
+        133,
+        "Seaborg et al.",
+        1944,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Berkelium(
+        97,
+        "Berkelium",
+        "Bk",
+        247.0,
+        150,
+        97,
+        97,
+        7,
+        0,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        1.3,
+        6.1979,
+        14.8,
+        1259.15,
+        983.0,
+        83,
+        "Seaborg et al.",
+        1949,
+        0.0,
+        7,
+        0,
+        0.0,
+        10.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Californium(
+        98,
+        "Californium",
+        "Cf",
+        251.0,
+        153,
+        98,
+        98,
+        7,
+        0,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        1.3,
+        6.2817,
+        15.1,
+        1925.15,
+        1173.0,
+        123,
+        "Seaborg et al.",
+        1950,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Einsteinium(
+        99,
+        "Einsteinium",
+        "Es",
+        252.0,
+        153,
+        99,
+        99,
+        7,
+        0,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        1.3,
+        6.42,
+        13.5,
+        1133.15,
+        0.0,
+        123,
+        "Ghiorso et al.",
+        1952,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Fermium(
+        100,
+        "Fermium",
+        "Fm",
+        257.0,
+        157,
+        100,
+        100,
+        7,
+        0,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        1.3,
+        6.5,
+        0.0,
+        0.0,
+        0.0,
+        103,
+        "Ghiorso et al.",
+        1953,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Mendelevium(
+        101,
+        "Mendelevium",
+        "Md",
+        258.0,
+        157,
+        101,
+        101,
+        7,
+        0,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        1.3,
+        6.58,
+        0.0,
+        0.0,
+        0.0,
+        33,
+        "Ghiorso et al.",
+        1955,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Nobelium(
+        102,
+        "Nobelium",
+        "No",
+        259.0,
+        157,
+        102,
+        102,
+        7,
+        0,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        1.3,
+        6.65,
+        0.0,
+        0.0,
+        0.0,
+        73,
+        "Ghiorso et al.",
+        1958,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Lawrencium(
+        103,
+        "Lawrencium",
+        "Lr",
+        262.0,
+        159,
+        103,
+        103,
+        7,
+        0,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Actinide,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        203,
+        "Ghiorso et al.",
+        1961,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Rutherfordium(
+        104,
+        "Rutherfordium",
+        "Rf",
+        261.0,
+        157,
+        104,
+        104,
+        7,
+        4,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Transactinide,
+        0.0,
+        0.0,
+        0.0,
+        18.1,
+        0.0,
+        0.0,
+        0,
+        "Ghiorso et al.",
+        1969,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Dubnium(
+        105,
+        "Dubnium",
+        "Db",
+        262.0,
+        157,
+        105,
+        105,
+        7,
+        5,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Transactinide,
+        0.0,
+        0.0,
+        0.0,
+        39.0,
+        0.0,
+        0.0,
+        0,
+        "Ghiorso et al.",
+        1970,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Seaborgium(
+        106,
+        "Seaborgium",
+        "Sg",
+        266.0,
+        160,
+        106,
+        106,
+        7,
+        6,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Transactinide,
+        0.0,
+        0.0,
+        0.0,
+        35.0,
+        0.0,
+        0.0,
+        0,
+        "Ghiorso et al.",
+        1974,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Bohrium(
+        107,
+        "Bohrium",
+        "Bh",
+        264.0,
+        157,
+        107,
+        107,
+        7,
+        7,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Transactinide,
+        0.0,
+        0.0,
+        0.0,
+        37.0,
+        0.0,
+        0.0,
+        0,
+        "Armbruster and Münzenberg ",
+        1981,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Hassium(
+        108,
+        "Hassium",
+        "Hs",
+        267.0,
+        159,
+        108,
+        108,
+        7,
+        8,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Transactinide,
+        0.0,
+        0.0,
+        0.0,
+        41.0,
+        0.0,
+        0.0,
+        0,
+        "Armbruster and Münzenberg ",
+        1983,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Meitnerium(
+        109,
+        "Meitnerium",
+        "Mt",
+        268.0,
+        159,
+        109,
+        109,
+        7,
+        9,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Transactinide,
+        0.0,
+        0.0,
+        0.0,
+        35.0,
+        0.0,
+        0.0,
+        0,
+        "GSI, Darmstadt, West Germany",
+        1982,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Darmstadtium(
+        110,
+        "Darmstadtium ",
+        "Ds ",
+        271.0,
+        161,
+        110,
+        110,
+        7,
+        10,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Transactinide,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0,
+        "",
+        1994,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Roentgenium(
+        111,
+        "Roentgenium ",
+        "Rg ",
+        272.0,
+        161,
+        111,
+        111,
+        7,
+        11,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Transactinide,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0,
+        "",
+        1994,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Copernicium(
+        112,
+        "Copernicium ",
+        "Cn ",
+        285.0,
+        173,
+        112,
+        112,
+        7,
+        12,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Transactinide,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0,
+        "",
+        1996,
+        0.0,
+        7,
+        0,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Nihonium(
+        113,
+        "Nihonium",
+        "Nh",
+        284.0,
+        171,
+        113,
+        113,
+        7,
+        13,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Undefined,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0,
+        "",
+        2004,
+        0.0,
+        7,
+        3,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Flerovium(
+        114,
+        "Flerovium",
+        "Fl",
+        289.0,
+        175,
+        114,
+        114,
+        7,
+        14,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Transactinide,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0,
+        "",
+        1999,
+        0.0,
+        7,
+        4,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Moscovium(
+        115,
+        "Moscovium",
+        "Mc",
+        288.0,
+        173,
+        115,
+        115,
+        7,
+        15,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Undefined,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0,
+        "",
+        2010,
+        0.0,
+        7,
+        5,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Livermorium(
+        116,
+        "Livermorium",
+        "Lv",
+        292.0,
+        176,
+        116,
+        116,
+        7,
+        16,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.Metal,
+        ChemicalElementType.Transactinide,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0,
+        "",
+        2000,
+        0.0,
+        7,
+        6,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Tennessine(
+        117,
+        "Tennessine",
+        "Ts",
+        295.0,
+        178,
+        117,
+        117,
+        7,
+        17,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.Undefined,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0,
+        "",
+        2010,
+        0.0,
+        7,
+        7,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    ),
+    Oganesson(
+        118,
+        "Oganesson",
+        "Og",
+        294.0,
+        176,
+        118,
+        118,
+        7,
+        18,
+        ChemicalPhase.Artificial,
+        true,
+        false,
+        ChemicalMetallicity.NonMetal,
+        ChemicalElementType.NobleGas,
+        0.0,
+        0.0,
+        0.0,
+        7.2, // Wikipedia
+        0.0,
+        0.0,
+        0,
+        "Yuri Oganessian et. al.", // Me; also, there are a lot of missing entries, maybe fix
+        2006,
+        0.0,
+        7,
+        8,
+        0.0,
+        0.0,
+        Double.POSITIVE_INFINITY
+    );
+
+    /**
+     * Defines an element using carefully-chosen units.
+     * */
+    constructor(
+        Z: Int,
+        label: String,
+        symbol: String,
+        A: Double,
+        neutrons: Int,
+        protons: Int,
+        electrons: Int,
+        period: Int,
+        group: Int,
+        phase: ChemicalPhase,
+        isRadioactive: Boolean,
+        isNatural: Boolean,
+        metallicProperty: ChemicalMetallicity,
+        type: ChemicalElementType,
+        atomicRadius: Double,
+        electronegativity: Double,
+        firstIonization: Double,
+        density: Double,
+        meltingPoint: Double,
+        boilingPoint: Double,
+        isotopeCount: Int,
+        discoverer: String,
+        discoveryYear: Int,
+        specificHeat: Double,
+        electronShells: Int,
+        valence: Int,
+        excitationEnergy: Double,
+        thermalConductivity: Double,
+        electricalResistivity: Double,
+    ) : this(
+        Z,
+        label,
+        symbol,
+        Quantity(A, DALTON),
+        neutrons,
+        protons,
+        electrons,
+        period,
+        group,
+        phase,
+        isRadioactive,
+        isNatural,
+        metallicProperty,
+        type,
+        Quantity(atomicRadius, ANGSTROM),
+        electronegativity,
+        firstIonization,
+        Quantity(density, G_PER_CM3),
+        Quantity(meltingPoint, KELVIN),
+        Quantity(boilingPoint, KELVIN),
+        isotopeCount,
+        discoverer,
+        discoveryYear,
+        Quantity(specificHeat, JOULE_PER_GRAM_KELVIN),
+        electronShells,
+        valence,
+        Quantity(excitationEnergy, ELECTRON_VOLT),
+        Quantity(thermalConductivity, WATT_PER_METER_KELVIN),
+        Quantity(electricalResistivity, OHM_METER),
+        "https://gist.github.com/robertwb/22aa4dbfb6bcecd94f2176caa912b952 - bulk of the data, " +
+                "https://periodictable.com/Properties/A/Resistivity.an.log.html - electricalResistivity, " +
+                "https://periodictable.com/Properties/A/ThermalConductivity.an.html - thermalConductivity"
+    )
+
+    override fun toString() = symbol
+
+    /**
+     * Gets a [Material] with the properties of this element.
+     * **Some values may be invalid; for example, non-conductive elements will have infinite resistivity.**
+     * */
+    val asMaterial = Material(
+        label,
+        electricalResistivity,
+        thermalConductivity,
+        specificHeat,
+        density
+    )
+
+    /**
+     * Rich description of the element.
+     * */
+    val description = """
+        $symbol ($label):
+            Z: $Z, A: $A Da
+            Period $period Group $group
+            $neutrons n⁰ $protons p⁺ $electrons e⁻
+            $type
+            φ: $phase
+            M: $metallicProperty
+            R: ${(atomicRadius .. ANGSTROM).rounded(2)} Å
+            χ: $electronegativity
+            I1: $firstIonization
+            ρ: ${electricalResistivity.classify()} κ: ${thermalConductivity.classify()} c: ${specificHeat.classify()} ρ: ${density.classify()}
+            Melting: ${meltingPoint.classify()} Boiling: ${boilingPoint.classify()}
+            Valence: $valence Shells: $electronShells
+            Eₓ: ${(excitationEnergy .. ELECTRON_VOLT).rounded()} eV
+            Discovered by "${discoverer.ifBlank { "N/A" }}" in $discoveryYear
+    """.trimIndent()
+
+    companion object {
+        val sortedByZ = values().sortedBy { it.Z }
+        val sortedByDescendingZ = values().sortedByDescending { it.Z }
+        val sortedByA = values().sortedBy { it.A }
+        val sortedByDescendingA = values().sortedByDescending { it.A }
+        val sortedByNeutrons = values().sortedBy { it.neutrons }
+        val sortedByDescendingNeutrons = values().sortedByDescending { it.neutrons }
+        val sortedByProtons = values().sortedBy { it.protons }
+        val sortedByDescendingProtons = values().sortedByDescending { it.protons }
+        val sortedByElectrons = values().sortedBy { it.electrons }
+        val sortedByDescendingElectrons = values().sortedByDescending { it.electrons }
+        val sortedByAtomicRadius = values().sortedBy { it.atomicRadius }
+        val sortedByDescendingAtomicRadius = values().sortedByDescending { it.atomicRadius }
+        val sortedByElectronegativity = values().sortedBy { it.electronegativity }
+        val sortedByDescendingElectronegativity = values().sortedByDescending { it.electronegativity }
+        val sortedByFirstIonization = values().sortedBy { it.firstIonization }
+        val sortedByDescendingFirstIonization = values().sortedByDescending { it.firstIonization }
+        val sortedByDensity = values().sortedBy { !it.density }
+        val sortedByDescendingDensity = values().sortedByDescending { !it.density }
+        val sortedByMeltingPoint = values().sortedBy { !it.meltingPoint }
+        val sortedByDescendingMeltingPoint = values().sortedByDescending { !it.meltingPoint }
+        val sortedByBoilingPoint = values().sortedBy { !it.boilingPoint }
+        val sortedByDescendingBoilingPoint = values().sortedByDescending { !it.boilingPoint }
+        val sortedByIsotopeCount = values().sortedBy { it.isotopeCount }
+        val sortedByDescendingIsotopeCount = values().sortedByDescending { it.isotopeCount }
+        val sortedByDiscoveryYear = values().sortedBy { it.discoveryYear }
+        val sortedByDescendingDiscoveryYear = values().sortedByDescending { it.discoveryYear }
+        val sortedBySpecificHeat = values().sortedBy { !it.specificHeat }
+        val sortedByDescendingSpecificHeat = values().sortedByDescending { !it.specificHeat }
+        val sortedByElectronShells = values().sortedBy { it.electronShells }
+        val sortedByDescendingElectronShells = values().sortedByDescending { it.electronShells }
+        val sortedByExcitationEnergy = values().sortedBy { !it.excitationEnergy }
+        val sortedByDescendingExcitationEnergy = values().sortedByDescending { !it.excitationEnergy }
+        val sortedByThermalConductivity = values().sortedBy { !it.thermalConductivity }
+        val sortedByDescendingThermalConductivity = values().sortedByDescending { !it.thermalConductivity }
+        val sortedByElectricalResistivity = values().sortedBy { !it.electricalResistivity }
+        val sortedByDescendingElectricalResistivity = values().sortedByDescending { !it.electricalResistivity }
+
+        val byAtomicNumber = values().associateBy { it.Z }
+        val bySymbol = values().associateBy { it.symbol }
+        val bySymbol1 = values().filter { it.symbol.length == 1 }.associateBy { it.symbol }
+        val bySymbol2 = values().filter { it.symbol.length == 2 }.associateBy { it.symbol }
+        val byLabel = values().associateBy { it.label }
+        val byLabelLower = values().associateBy { it.label.lowercase() }
+        val byNeutronCount = values().associateByMulti { it.neutrons }
+        val byProtonCount = values().associateBy { it.protons }
+        val byElectronCount = values().associateBy { it.electrons }
+        val byPeriod = values().associateByMulti { it.period }
+        val byGroup = values().associateByMulti { it.group }
+        val byPhase = values().associateByMulti { it.phase }
+        val byIsRadioactive = values().associateByMulti { it.isRadioactive }
+        val byIsNatural = values().associateByMulti { it.isNatural }
+        val byMetallicProperty = values().associateByMulti { it.metallicProperty }
+        val byType = values().associateByMulti { it.type }
+        val byIsotopeCount = values().associateByMulti { it.isotopeCount }
+        val byElectronShells = values().associateByMulti { it.electronShells }
+        val byValence = values().associateByMulti { it.valence }
+        val byMaterial = values().associateByMulti { it.asMaterial }
+    }
+}
+
+/**
+ *  Gets the chemical element with the specified [symbol].
+ *  @return The chemical element with the [symbol], or `null` if it does no such element exists.
+ *  */
+fun getChemicalElementOrNull(symbol: String) = ChemicalElement.bySymbol[symbol]
+
+/**
+ *  Gets the chemical element with the specified [symbol] or throws [NoSuchElementException] if it does not exist.
+ *  @return The chemical element with the [symbol].
+ *  */
+fun getChemicalElement(symbol: String) = getChemicalElementOrNull(symbol) ?: throw NoSuchElementException("Element $symbol does not exist")
\ No newline at end of file
diff --git a/src/main/kotlin/org/ageseries/libage/sim/thermal/Thermal.kt b/src/main/kotlin/org/ageseries/libage/sim/Thermal.kt
similarity index 74%
rename from src/main/kotlin/org/ageseries/libage/sim/thermal/Thermal.kt
rename to src/main/kotlin/org/ageseries/libage/sim/Thermal.kt
index 54fcd22..966c095 100644
--- a/src/main/kotlin/org/ageseries/libage/sim/thermal/Thermal.kt
+++ b/src/main/kotlin/org/ageseries/libage/sim/Thermal.kt
@@ -1,14 +1,10 @@
 @file:Suppress("MemberVisibilityCanBePrivate")
 
-package org.ageseries.libage.sim.thermal
-
-import org.ageseries.libage.data.KELVIN
-import org.ageseries.libage.data.Quantity
-import org.ageseries.libage.data.Temperature
-import org.ageseries.libage.data.mutableMultiMapOf
-import org.ageseries.libage.sim.CIE
-import org.ageseries.libage.sim.Material
+package org.ageseries.libage.sim
+
+import org.ageseries.libage.data.*
 import java.util.*
+import java.util.function.Supplier
 import kotlin.math.PI
 import kotlin.math.pow
 import kotlin.math.sqrt
@@ -72,40 +68,59 @@ val Quantity<Temperature>.emissionColor: CIE.XYZ31 get() {
  */
 val STANDARD_TEMPERATURE = Quantity(273.15, KELVIN)
 
-class ThermalMass(
-    /** The material of this mass, used for its thermal properties. */
-    val material: Material,
-    /** Thermal energy, in J. Leave null to set [STANDARD_TEMPERATURE]. */
-    energy: Double? = null,
-    /** Mass, in kg. */
-    val mass: Double = 1.0,
-) {
-    var energy: Double = energy ?: (!STANDARD_TEMPERATURE * mass * material.specificHeat)
+/**
+ * Represents a *homogenous mass* of [material].
+ * @param material The material that best reflects the desired properties of this mass.
+ * @param energy The initial energy. Leave `null` to set it such that [temperature] is [STANDARD_TEMPERATURE].
+ * @param mass The mass of the body.
+ * */
+class ThermalMass(val material: Material, energy: Quantity<Energy>? = null, val mass: Quantity<Mass> = Quantity(1.0, KILOGRAM)) {
+    var energy: Quantity<Energy> = energy ?: Quantity(!STANDARD_TEMPERATURE * !mass * !material.specificHeat)
 
     /**
-     * Gets the temperature this mass would have if [energy] were set to [e].
+     * Gets the [Temperature] this mass would have if [ThermalMass.energy] were set to [energy].
+     *
+     * This does not mutate anything.
      * */
-    fun temperatureAt(e: Double) = Quantity(e / mass / material.specificHeat, KELVIN)
+    fun temperatureAt(energy: Quantity<Energy>) = Quantity(!energy / !mass / !material.specificHeat, KELVIN)
 
     /**
-     * Temperature of this mass, in K.
+     * The [Temperature] of this mass.
      *
      * Setting this changes the [energy].
      */
     var temperature: Quantity<Temperature>
         get() = temperatureAt(energy)
-        set(value) { energy = !value * mass * material.specificHeat }
+        set(value) { energy = Quantity(!value * !mass * !material.specificHeat, JOULE) }
+
+    override fun toString() = "<Thermal Mass $material m=${mass.classify()} E=${energy.classify()} T=${temperature.classify()}>"
+}
+
+/**
+ * Factory for [ThermalMass] instances. Includes all information necessary to create a new instance.
+ * */
+data class ThermalMassDefinition(val material: Material, val energy: Quantity<Energy>? = null, val mass: Quantity<Mass> = Quantity(1.0, KILOGRAM)) : Supplier<ThermalMass> {
+    /**
+     * Creates a new instance of [ThermalMass] with the properties specified in this definition.
+     * */
+    override fun get() = ThermalMass(material, energy, mass)
+
+    override fun toString() = "Def ${this()}"
 
-    override fun toString() = "<Thermal Mass $material ${mass}kg ${energy}J $temperature>"
+    /**
+     * Calls [get] to create a new instance of [ThermalMass].
+     * I quite like this; I don't particularly appreciate *`.get()`* semantics for a factory.
+     * */
+    operator fun invoke() = get()
 }
 
 data class ConnectionParameters(
-    /** Conductance of the contact point. There is almost always a little loss due to mechanical effects, unless the materials are welded. This is W/K, with no distance effect. */
-    val conductance: Double = 1.0,
-    /** How long the connection is between the two masses--which affects the transfer rate. Measured in m. */
-    val distance: Double = 1.0,
+    /** Conductance of the contact point with no distance effect. There is almost always a little loss due to mechanical effects, unless the materials are welded. */
+    val conductance: Quantity<ThermalConductance> = Quantity(1.0, WATT_PER_KELVIN),
+    /** How long the connection is between the two masses--which affects the transfer rate. */
+    val distance: Quantity<Distance> = Quantity(1.0, METER),
     /** The "scale" of power conducted along this connection. If constant density is assumed, such that mass and volume are related, this is linear in contact area, thus the name. */
-    val area: Double = 1.0,
+    val area: Double = 1.0, // Do we use SurfaceArea or nah?
     /** How far along the line segment from [MassConnection.a] to [MassConnection.b] the contact point is. Affects how much [MassConnection.a]'s conductance dominates over [MassConnection.b]'s. Keep this between 0.0 and 1.0 inclusive. Meaningless in [EnvironmentConnection]s. */
     val contactPoint: Double = 0.5,
     /**
@@ -133,7 +148,7 @@ interface Connection {
      * By convention, the returned energy transfers are in argument order; whereas the first is usually the
      * [ThermalMass], the second may or may not be relevant depending on whether there is a heat sink.
      */
-    fun transfer(dt: Double): Pair<Double, Double>
+    fun transfer(dt: Double): Pair<Quantity<Energy>, Quantity<Energy>>
 
     /**
      * [ThermalMass]es owned by this connection, so the [Simulator] can manage them.
@@ -158,25 +173,32 @@ class MassConnection(
      *
      * For this to be stable, [dt] must be held relatively small, since this is a linear approximation to an exponential curve--otherwise, overshoot may be observed.
      */
-    override fun transfer(dt: Double): Pair<Double, Double> {
+    override fun transfer(dt: Double): Pair<Quantity<Energy>, Quantity<Energy>> {
         // Kelvin
         val deltaT = !b.temperature - !a.temperature
         // W/K
-        val distCondA = a.material.thermalConductivity * params.contactPoint * params.distance
-        val distCondB = b.material.thermalConductivity * (1.0 - params.contactPoint) * params.distance
-        val overallCond = params.area * (distCondA * distCondB * params.conductance).pow(1.0 / 3.0)
+        val distCondA = !a.material.thermalConductivity * params.contactPoint * !params.distance
+        val distCondB = !b.material.thermalConductivity * (1.0 - params.contactPoint) * !params.distance
+        val overallCond = params.area * (distCondA * distCondB * !params.conductance).pow(1.0 / 3.0)
         // W
         val power = deltaT * overallCond
         // J
         val energy = power * dt
-        val critDamp = sqrt((a.mass + b.mass) / overallCond) * dt
+        val critDamp = sqrt((!a.mass + !b.mass) / overallCond) * dt
         val dTerm = prevFlux * critDamp * dt
         prevFlux = power
         var toA = energy - dTerm
         var toB = -energy + dTerm
-        if(toA > 0.0) { toA *= params.efficiency }
-        if(toB > 0.0) { toB *= params.efficiency }
-        return toA to toB
+
+        if(toA > 0.0) {
+            toA *= params.efficiency
+        }
+
+        if(toB > 0.0) {
+            toB *= params.efficiency
+        }
+
+        return Quantity(toA, JOULE) to Quantity(toB, JOULE)
     }
 
     override val masses: List<ThermalMass>
@@ -195,16 +217,16 @@ class EnvironmentConnection(
 
     override fun toString() = "<EnvConn $a $temperature $params>"
 
-    override fun transfer(dt: Double): Pair<Double, Double> {
+    override fun transfer(dt: Double): Pair<Quantity<Energy>, Quantity<Energy>> {
         // See above for comments explaining more of this
         val deltaT = !temperature - !a.temperature
-        val overallCond = sqrt(params.area * a.material.thermalConductivity * params.conductance)
+        val overallCond = sqrt(params.area * !a.material.thermalConductivity * !params.conductance)
         val power = deltaT * overallCond
-        val critDamp = sqrt(a.mass / overallCond) * dt
+        val critDamp = sqrt(!a.mass / overallCond) * dt
         var energy = (power - prevFlux * critDamp) * dt
         prevFlux = power
         if(energy > 0.0) { energy *= params.efficiency }
-        return energy to 0.0
+        return Quantity(energy, JOULE) to Quantity(0.0, JOULE)
     }
 
     override val masses: List<ThermalMass>
@@ -219,7 +241,7 @@ class Simulator {
     /**
      * Add a body to the simulation.
      *
-     * Without connection, this body will still conduct from/to the [environment].
+     * Without connection, this body will still conduct from/to the environment.
      */
     fun add(mass: ThermalMass) {
         masses.add(mass)
@@ -312,16 +334,16 @@ class Simulator {
             val masses = connection.masses
 
             masses.getOrNull(0)?.let { a ->
-                deltaE[a] = deltaE.getOrDefault(a, 0.0) + toA
+                deltaE[a] = deltaE.getOrDefault(a, 0.0) + !toA
             }
 
             masses.getOrNull(1)?.let { b ->
-                deltaE[b] = deltaE.getOrDefault(b, 0.0) + toB
+                deltaE[b] = deltaE.getOrDefault(b, 0.0) + !toB
             }
         }
 
         deltaE.entries.forEach { (mass, delta) ->
-            mass.energy += delta
+            mass.energy += Quantity(delta, JOULE)
         }
 
         deltaE.clear()
diff --git a/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/Circuit.kt b/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/Circuit.kt
index 23e0a9f..33ef4cf 100644
--- a/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/Circuit.kt
+++ b/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/Circuit.kt
@@ -409,8 +409,8 @@ class Circuit {
         val voltageSourceSet: MutableSet<VSource> = mutableSetOf()
 
         components.forEach {component ->
-            dprintln("component $component pinreps ${component.pins.map { it.representative as Pin }}")
-            pinSet.addAll(component.pins.map { it.representative as Pin })
+            dprintln("component $component pinreps ${component.pins.map { it.representative }}")
+            pinSet.addAll(component.pins.map { it.representative })
             voltageSourceSet.addAll(component.vsources)
         }
 
@@ -671,3 +671,5 @@ class Circuit {
         return sb.toString()
     }
 }
+
+const val LARGE_RESISTANCE = 1e9
\ No newline at end of file
diff --git a/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/CircuitBuilder.kt b/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/CircuitBuilder.kt
new file mode 100644
index 0000000..4c9a625
--- /dev/null
+++ b/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/CircuitBuilder.kt
@@ -0,0 +1,736 @@
+package org.ageseries.libage.sim.electrical.mna
+
+import org.ageseries.libage.data.SuperDisjointSet
+import org.ageseries.libage.data.MutableSetMapMultiMap
+import org.ageseries.libage.sim.electrical.mna.component.*
+import org.ageseries.libage.utils.addUnique
+import org.ageseries.libage.utils.putUnique
+import org.ageseries.libage.utils.removeElement
+
+/**
+ * Represents a virtual electrical component, where the term "virtual" denotes the possibility that it may or may not manifest as an actual [Component] incorporated into the circuit.
+ * */
+interface VirtualComponent : Term
+
+/**
+ * Represents a set of electrical components. The components are either real [Component]s or [VirtualComponent]s.
+ * */
+interface ElectricalComponentSet {
+    /**
+     * Adds the real component to the underlying circuit.
+     * @return True if the component was added. Otherwise, false (the component was already added).
+     * */
+    fun add(component: Component) : Boolean
+
+    /**
+     * Adds the virtual component to the underlying compiler.
+     * @return True if the component was added. Otherwise, false (the component was already added).
+     * */
+    fun add(component: VirtualComponent) : Boolean
+
+    /**
+     * Adds the [Term] ([Component] or [VirtualComponent]) to the underlying data structure.
+     * @return True if the term was added. Otherwise, false (the term was already added).
+     * */
+    fun add(component: Term) : Boolean
+}
+
+/**
+ * Represent a set of connections between [Component]s and other [Component]s, [VirtualComponent]s and other [VirtualComponent]s and [Component]s and [VirtualComponent]s.
+ * */
+interface ElectricalConnectivityMap {
+    /**
+     * Connects the *[aIdx]ᵗʰ* pin of virtual component [a] to the *[bIdx]ᵗʰ* pin of virtual component [b].
+     * This connection shall be denoted as *virtual-to-virtual* connection.
+     * */
+    fun connect(a: VirtualComponent, aIdx: Int, b: VirtualComponent, bIdx: Int)
+
+    /**
+     * Connects the *[aIdx]ᵗʰ* pin of real component [a] to the *[bIdx]ᵗʰ* pin of virtual component [b].
+     * This connection shall be denoted as *virtual-to-real* connection.
+     * */
+    fun connect(a: Component, aIdx: Int, b: VirtualComponent, bIdx: Int)
+
+    /**
+     * Connects the *[aIdx]ᵗʰ* pin of virtual component [a] to the *[bIdx]ᵗʰ* pin of real component [b].
+     * This connection is denoted as a *virtual-to-real* connection.
+     * */
+    fun connect(a: VirtualComponent, aIdx: Int, b: Component, bIdx: Int)
+
+    /**
+     * Connects the *[aIdx]ᵗʰ* pin of real component [a] to the *[bIdx]ᵗʰ* pin of real component [b].
+     * This connection isn't indicated differently in the documentation.
+     * The final outcome is the same as using **libage's** connection API, except that validation is performed (take notes, Grissess, don't just return if the component is not added, **throw an exception!**)
+     * */
+    fun connect(a: Component, aIdx: Int, b: Component, bIdx: Int)
+
+    /**
+     * Connects the *[aIdx]ᵗʰ* pin of underlying component of [a] to the *[bIdx]ᵗʰ* pin of underlying component of [b].
+     * This is equivalent to calling the other connection methods if the concrete types of [a] and [b] were known.
+     * */
+    fun connect(a: Term, aIdx: Int, b: Term, bIdx: Int)
+}
+
+/**
+ * Compiler that incorporates [VirtualResistor]s into [Circuit]s by collapsing sequences of [VirtualResistor]s into a single [Line] resistors and honoring connections.
+ * */
+class LineCompiler(private val circuitBuilder: CircuitBuilder) {
+    internal val lineGraphs = ArrayList<LineGraph>()
+
+    /**
+     * Electrical Pin implemented as a Disjoint-Set.
+     * To check whether a pin is connected to real [Component]s, we use the [hasRealsInternal] flag.
+     * If this flag is set, it's passed along to the representative during the union operation.
+     * This makes checking Condition I to identify breakpoints caused by real connections easy.
+     * Condition II can be checked using the [size] of the representative.
+     * */
+    internal class Pin : SuperDisjointSet<Pin>() {
+        internal var hasRealsInternal = false
+
+        /**
+         * Indicates veracity when considering whether this pin functions as a "break-point," signifying its shared status with real components (I) or its failure to precisely connect two components (II).
+         * We shall consider all virtual resistors that share this pin to be **outer**s.
+         * */
+        val isBreakPoint: Boolean get() {
+            val representative = representative
+
+            return representative.hasRealsInternal || representative.size != 2
+        }
+
+        /**
+         * Marks this set as being "connected" to a real component.
+         * */
+        fun markReal() {
+            representative.hasRealsInternal = true
+        }
+
+        /**
+         * Units this pin with the [other] pin and passes along [hasRealsInternal], if applicable.
+         * */
+        override fun unite(other: Pin) {
+            val hasReals = this.representative.hasRealsInternal || other.representative.hasRealsInternal
+
+            super.unite(other)
+
+            if(hasReals) {
+                markReal()
+            }
+        }
+    }
+
+    /**
+     * Set of all [VirtualResistor]s added so far. The value is a pair of pins, in the order positive-negative.
+     * */
+    internal val virtualResistors = HashMap<VirtualResistor, Pair<Pin, Pin>>()
+
+    /**
+     * [VirtualResistor]-[Component] connections by [VirtualResistor].
+     * */
+    private val virtualToRealConnections = MutableSetMapMultiMap<VirtualResistor, VirtualToRealInfo>()
+
+    /**
+     * [VirtualResistor]-[VirtualResistor] connections by [VirtualResistor].
+     * These connections are a reciprocal relationship; given two resistors, **R1** and **R2**,
+     * if [virtualToVirtualConnections]{**R1**} has a connection to **R2**, then [virtualToVirtualConnections]{**R2**} has a connection to **R1**.
+     * */
+    private val virtualToVirtualConnections = MutableSetMapMultiMap<VirtualResistor, VirtualToVirtualInfo>()
+
+    /**
+     * Adds the [resistor] if not already added.
+     * */
+    fun addResistor(resistor: VirtualResistor) : Boolean {
+        if(virtualResistors.containsKey(resistor)) {
+            return false
+        }
+
+        virtualResistors.putUnique(resistor, Pair(Pin(), Pin()))
+
+        return true
+    }
+
+    private fun validatePinIndex(pin: Int) {
+        require(pin == POSITIVE || pin == NEGATIVE) {
+            "Pin $pin is not valid for virtual resistors"
+        }
+    }
+
+    /**
+     * Connects the real [Component] [a] to the [VirtualComponent] [b]. [b]'s [bIdx]ᵗʰ [Pin] will be marked as real ([Pin.markReal]).
+     * This adds an edge to the [virtualToRealConnections] map.
+     * */
+    fun connect(a: Component, aIdx: Int, b: VirtualResistor, bIdx: Int) {
+        validatePinIndex(bIdx)
+
+        val (p, n) = checkNotNull(virtualResistors[b]) {
+            "$b is not added before calling connect"
+        }
+
+        virtualToRealConnections[b].add(VirtualToRealInfo(a, aIdx, bIdx))
+
+        if(bIdx == POSITIVE) {
+            p.markReal()
+        }
+        else {
+            n.markReal()
+        }
+    }
+
+    /**
+     * Connects the [VirtualComponent] [a] to the [VirtualComponent] [b].
+     * [a]'s [aIdx]ᵗʰ pin will be united ([Pin.unite]) with [b]'s [bIdx]ᵗʰ [Pin].
+     * This adds an edge to the [virtualToVirtualConnections] map.
+     * */
+    fun connect(a: VirtualResistor, aIdx: Int, b: VirtualResistor, bIdx: Int) {
+        validatePinIndex(aIdx)
+        validatePinIndex(bIdx)
+
+        val (aP, aN) = checkNotNull(virtualResistors[a]) { "$a is not added" }
+        val (bP, bN) = checkNotNull(virtualResistors[b]) { "$b is not added" }
+
+        virtualToVirtualConnections[a].add(VirtualToVirtualInfo(b, bIdx, aIdx))
+        virtualToVirtualConnections[b].add(VirtualToVirtualInfo(a, aIdx, bIdx))
+
+        if(aIdx == POSITIVE && bIdx == POSITIVE) {
+            aP.unite(bP)
+        }
+        else if(aIdx == POSITIVE && bIdx == NEGATIVE) {
+            aP.unite(bN)
+        }
+        else if(aIdx == NEGATIVE && bIdx == POSITIVE) {
+            aN.unite(bP)
+        }
+        else if(aIdx == NEGATIVE && bIdx == NEGATIVE) {
+            aN.unite(bN)
+        }
+        else {
+            // Shouldn't really happen since we [validatePinIndex]ed
+            error("Unexpected pins $aIdx $bIdx")
+        }
+    }
+
+    /**
+     * Gets the **anchor** in the line graph with [start] as one of the endpoints (outers).
+     * **An anchor** is a unique [VirtualResistor] connected to [start], that fits as the next [VirtualResistor] in [start]'s graph (either an inner or the other endpoint).
+     * The anchor is **unique**; there either is just one anchor, or no anchor at all (the graph is represented by the single resistor [start]).
+     * If [start] were to have two or more anchors, it would not fit as an endpoint.
+     *
+     * Algorithm description: The anchor is the [VirtualResistor] connected to one of [start]'s [Pin]s, a pin which is not a [Pin.isBreakPoint].
+     * */
+    private fun getAnchor(visited: HashSet<VirtualResistor>, start: VirtualResistor, pins: Pair<Pin, Pin>) : VirtualResistor? {
+        val pBreak = pins.first.isBreakPoint
+        val nBreak = pins.second.isBreakPoint
+
+        if(pBreak && nBreak) {
+            // We conclude that there are no candidates.
+            return null
+        }
+
+        // If both pins are valid, then [start] is playing hide and seek as a valid endpoint,
+        // and we've accidentally stumbled into the comedy section of the algorithm.
+        require(pBreak || nBreak) {
+            "Catastrophic blunder: both candidates are valid"
+        }
+
+        val connections = virtualToVirtualConnections[start]
+
+        val candidate = if(!pBreak) {
+            connections.firstOrNull { it.localPin == POSITIVE }?.remote
+        }
+        else {
+            connections.firstOrNull { it.localPin == NEGATIVE }?.remote
+        }
+
+        require(candidate != null) {
+            "Candidate expected"
+        }
+
+        require(!visited.contains(candidate)) {
+            "Candidate is already visited"
+        }
+
+        return candidate
+    }
+
+    /**
+     * Closes the line. The next resistor (could be inner or endpoint) is expected to be present in [queue].
+     *
+     * The algorithm employs a basic graph search. It terminates early under a specific condition:
+     * If a resistor from the [outers] set is encountered, it signifies the discovery of the other endpoint, concluding the search.
+     *
+     * Colloquially, this gets the portion of the graph between two break-point [Pin]s (as per my diagram, which you probably haven't seen).
+     * */
+    private fun closeLine(queue: ArrayDeque<VirtualResistor>, visited: HashSet<VirtualResistor>, outers: HashSet<VirtualResistor>, graph: LineGraph) {
+        while (queue.isNotEmpty()) {
+            val front = queue.removeFirst()
+
+            if(!visited.add(front)) {
+                continue
+            }
+
+            if(outers.remove(front)) {
+                graph.addOuter(front)
+                break
+            }
+
+            graph.addInner(front)
+
+            val lineConnections = virtualToVirtualConnections[front]
+
+            require(lineConnections.size == 2) {
+                "Invalid inner"
+            }
+
+            // Validation:
+
+            require(!virtualToRealConnections.contains(front))
+
+            lineConnections.forEach {
+                queue.add(it.remote)
+            }
+        }
+    }
+
+    /**
+     * Isolates all line graphs, adding them to [lineGraphs].
+     * @return The outer resistors that were found.
+     * */
+    internal fun isolateLineGraphs() : HashSet<VirtualResistor> {
+        val outers = HashSet<VirtualResistor>()
+
+        virtualResistors.forEach { (resistor, pins) ->
+            if(pins.first.isBreakPoint || pins.second.isBreakPoint) {
+                outers.add(resistor)
+            }
+        }
+
+        val visited = HashSet<VirtualResistor>()
+        val queue = ArrayDeque<VirtualResistor>()
+
+        while (outers.isNotEmpty()) {
+            val graph = LineGraph()
+
+            val start = outers.removeElement()
+            val pins = virtualResistors[start]!!
+
+            graph.addOuter(start)
+            visited.addUnique(start)
+
+            val candidate = getAnchor(visited, start, pins)
+
+            if(candidate != null) {
+                graph.anchor = candidate
+                queue.add(candidate)
+                closeLine(queue, visited, outers, graph)
+                queue.clear()
+            }
+
+            lineGraphs.add(graph)
+        }
+
+        return outers
+    }
+
+    /**
+     * Compiles all lines.
+     * - Line graphs are retrieved by [isolateLineGraphs]
+     * - Connections between endpoints are resolved as connections between the [Line]s that were generated
+     * - Connections between endpoints and real components are also resolved in the same manner
+     * */
+    fun compile() {
+        check(lineGraphs.isEmpty()) { "Invalid state" }
+
+        if(virtualResistors.isEmpty()) {
+            return
+        }
+
+        isolateLineGraphs()
+
+        /**
+         * Keys represent endpoint virtual resistors (denoted as K).
+         * The values consist of maps ("connectivityMap") corresponding to remote virtual resistors (all connected to K, referred to as R).
+         * Each map indicates the [Line] K is part of (for quick retrieval), and the specific pin of that [Line] where R is to connect with K.
+         * */
+        val connections = HashMap<VirtualResistor, HashMap<VirtualResistor, Pair<Line, Int>>>()
+
+        // An arbitrary pin number:
+        var pin = 0
+
+        lineGraphs.forEach { graph ->
+            val line = graph.line
+
+            circuitBuilder.add(line)
+
+            graph.forEachOrdered { resistor ->
+                val part = line.add(line.size);
+
+                resistor.setHandle(part)
+            }
+
+            if(graph.size == 1) {
+                // Single resistor. The virtual pins will be the same as the pins used by the real pins:
+                require(graph.outers.size == 1)
+                require(graph.inners.size == 0)
+
+                val outer = graph.outers.first()
+
+                virtualToRealConnections[outer].forEach { (remote, remoteIdx, localIdx) ->
+                    circuitBuilder.connect(line, localIdx, remote, remoteIdx)
+                }
+
+                val connectivityMap = HashMap<VirtualResistor, Pair<Line, Int>>(2)
+
+                // There may be some imaginary resistors connected - they just didn't fit the line graph invariant, so they are not included in this graph
+                virtualToVirtualConnections[outer].forEach { (remote, remoteIdx, localIdx) ->
+                    connectivityMap.putUnique(remote, Pair(line, localIdx))
+                }
+
+                connections.putUnique(outer, connectivityMap)
+            }
+            else {
+                // A line of resistors. We will assign the pins arbitrarily.
+
+                check(graph.outers.size == 2) { "Expected 2 outers " }
+
+                graph.outers.forEach { outer ->
+                    val connectivityMap = HashMap<VirtualResistor, Pair<Line, Int>>(2)
+
+                    val arbitraryPin = (pin++) % 2
+
+                    // This time, the outer resistor's real connections will all receive the same arbitrary pin of the Line.
+                    virtualToRealConnections[outer].forEach { (remote, remoteIdx, localIdx) ->
+                        circuitBuilder.connect(line, arbitraryPin, remote, remoteIdx)
+                    }
+
+                    // Other imaginary connections will use the arbitrary pin to connect to our Line:
+                    virtualToVirtualConnections[outer].forEach { (remote, remoteIdx, localIdx) ->
+                        connectivityMap.putUnique(remote, Pair(line, arbitraryPin))
+                    }
+
+                    connections.putUnique(outer, connectivityMap)
+                }
+            }
+        }
+
+        /**
+         * Resolve virtual connections, which will become real connections between Line components.
+         * These Line components are generated here; they stem from connected components of virtual resistors that require multiple real [Line] resistors for representation.
+         * There are some remaining line-to-line connections, originating from connections between elements within the same lines (inner to inner and inner to end point).
+         * We only need to address the subset of these connections occurring between the endpoints (outers) of different lines.
+         * */
+        lineGraphs.forEach { graph ->
+            graph.outers.forEach { outer ->
+                for (connection in virtualToVirtualConnections[outer]) {
+                    if(graph.contains(connection.remote)) {
+                        // Residual connection to a component in the graph
+                        // Those will not materialize into real connections.
+                        continue
+                    }
+
+                    // This will contain the pin of the remote line that we need to connect to.
+                    // *[connection.remote] is K
+                    val remoteEdgeMap = checkNotNull(connections[connection.remote]) {
+                        "Did not have remote edge map"
+                    }
+
+                    // *[outer] is R
+                    val (remoteLine, remotePin) = checkNotNull(remoteEdgeMap[outer]) {
+                        "Did not have remote virtual edge"
+                    }
+
+                    // This will contain the pin of our line that we need to connect with the remote line.
+                    // *[outer] is K
+                    val localEdgeMap = checkNotNull(connections[outer]) {
+                        "Did not have local edge map"
+                    }
+
+                    // *[connection.remote] is R
+                    val (localLine, localPin) = checkNotNull(localEdgeMap[connection.remote]) {
+                        "Did not have local imaginary edge"
+                    }
+
+                    check(graph.line == localLine) { "Line was not expected one " }
+                    check(localLine != remoteLine) { "Local line is remote line" }
+
+                    // Finally, this real connection will connect together the two Line components:
+                    circuitBuilder.connect(localLine, localPin, remoteLine, remotePin)
+                }
+            }
+        }
+    }
+
+    /**
+     * @param remote The other real [Component].
+     * @param remotePin The pin of [remote] where the connection will occur.
+     * @param localPin The pin of the virtual resistor to connect to [remote]'s [remotePin].
+     * */
+    internal data class VirtualToRealInfo(val remote: Component, val remotePin: Int, val localPin: Int)
+
+    /**
+     * @param remote The other virtual resistor.
+     * @param remotePin The pin of [remote] where the connection will occur.
+     * @param localPin The pin of the virtual resistor to connect to [remote]'s [remotePin].
+     * */
+    internal data class VirtualToVirtualInfo(val remote: VirtualResistor, val remotePin: Int, val localPin: Int)
+
+    /**
+     * Line-shaped graph of [VirtualResistor]s. It represents a portion of the circuit which matches the criteria described above.
+     * A line graph will transform into exactly one [Line] resistor.
+     * A line graph consists of:
+     * - One or two end points ([outers]): Virtual resistors that serve as the two ends of the actual [Line] resistor. They connect to other non-line components and may be the first or last resistors in a line (with 0 or 1 connections).
+     * - Zero or multiple inner parts ([inners]): Virtual resistors with two connections to other virtual resistors in their line graph. These do not transform into real [Line] resistors later on.
+     * The inner resistors represent the bulk the savings brought by this line. None of them will turn into [Resistor] components.
+     * */
+    internal class LineGraph {
+        val line = Line()
+
+        val size get() = inners.size + outers.size
+
+        /**
+         * Checks if this graph contains the [resistor].
+         * */
+        fun contains(resistor: VirtualResistor) = outers.contains(resistor) || inners.contains(resistor)
+
+        /**
+         * Iterates over the resistors in order:
+         *  1. First outer
+         *  2. Anchor and the rest of the inners
+         *  3. Second outer
+         * */
+        inline fun forEachOrdered(action: (VirtualResistor) -> Unit) {
+            if(outers.size == 1) {
+                // Single graph with one resistor
+                check(inners.isEmpty()) { "Outers size 1 had inners" }
+                check(anchor == null) { "Outers size 1 had anchor" }
+                action(outers.first())
+            }
+            else {
+                check(outers.size == 2) { "Outers size is ${outers.size}" }
+
+                val iterator = outers.iterator()
+
+                action(iterator.next())
+
+                if(inners.isNotEmpty()) {
+                    check(inners.first() == anchor) {
+                        "Expected first inner to be the anchor"
+                    }
+
+                    inners.forEach(action)
+                }
+
+                action(iterator.next())
+            }
+        }
+
+        // Linked hash set - order is preserved:
+
+        /**
+         * Gets all inner resistors in the cluster.
+         * */
+        val inners = LinkedHashSet<VirtualResistor>()
+
+        /**
+         * Gets all end point resistors in the graph.
+         * */
+        val outers = LinkedHashSet<VirtualResistor>()
+
+        /**
+         * Gets or sets the anchor - the resistor candidate that started the graph and is connected to the first outer.
+         * */
+        var anchor: VirtualResistor? = null
+
+        fun addInner(remote: VirtualResistor) = inners.addUnique(remote)
+
+        fun addOuter(remote: VirtualResistor) = outers.addUnique(remote)
+    }
+}
+
+/**
+ * [CircuitBuilder]:
+ * This is a wrapper around [Circuit], designed to streamline the process of incorporating [VirtualComponent]s and establishing connections through these virtual entities.
+ * The ultimate outcome is the creation and integration of tangible (real) [Component]s into the [Circuit].
+ *
+ *
+ * The number of generated [Component]s may be much smaller than the initial number of [VirtualComponent]s.
+ * Since cost grows exponentially with the number of [Component]s, this system is very precious for optimizing real-time simulations.
+ *
+ * Notably, both [ElectricalComponentSet] and [ElectricalConnectivityMap] are implemented. This [CircuitBuilder] is structured for use in multiple stages:
+ *  - Component Acquisition:
+ *      - During this phase, [Component]s and [VirtualComponent]s are added, typically by traversing game objects and passing them the builder as [ElectricalComponentSet].
+ *  - Connection Mapping:
+ *      - In this stage, connections between [Component]s, [VirtualComponent]s are established. This is also achieved by traversing game objects and passing the builder as [ElectricalConnectivityMap].
+ *  - Compilation:
+ *      - The final step involves calling [realizeVirtual], which generates [Component]s from the existing [VirtualComponent]s and establishes the necessary connections.
+ *      The builder cannot be used after this step; calling other methods in it is illegal and will result in an error.
+ * */
+class CircuitBuilder(val circuit: Circuit): ElectricalComponentSet, ElectricalConnectivityMap {
+    private val terms = HashSet<Term>()
+    private var realized = false
+
+    internal val lineCompiler = LineCompiler(this)
+
+    private fun checkUsage() {
+        check(!realized) {
+            "Tried to continue building after realized"
+        }
+    }
+
+    private fun requireIsAdded(component: Term) {
+        require(terms.contains(component)) {
+            "Tried to use component $component which was not added"
+        }
+    }
+
+    private fun validatePair(a: Term, b: Term) {
+        require(a !== b) { "Cannot connect $a to itself" }
+        requireIsAdded(a)
+        requireIsAdded(b)
+    }
+
+    override fun add(component: Component) : Boolean {
+        checkUsage()
+
+        if(!terms.add(component)) {
+            return false
+        }
+
+        circuit.add(component)
+
+        return true
+    }
+
+    override fun add(component: VirtualComponent) : Boolean {
+        checkUsage()
+
+        if(!terms.add(component)) {
+            return false
+        }
+
+        when (component) {
+            is VirtualResistor -> {
+                return lineCompiler.addResistor(component)
+            }
+
+            else -> {
+                error("Cannot add $component")
+            }
+        }
+    }
+
+    override fun add(component: Term) : Boolean {
+        checkUsage()
+
+        return when (component) {
+            is Component -> {
+                add(component)
+            }
+
+            is VirtualComponent -> {
+                add(component)
+            }
+
+            else -> {
+                error("Cannot add $component")
+            }
+        }
+    }
+
+    override fun connect(a: Component, aIdx: Int, b: Component, bIdx: Int) {
+        checkUsage()
+        validatePair(a, b)
+        a.connect(aIdx, b, bIdx)
+    }
+
+    override fun connect(a: Component, aIdx: Int, b: VirtualComponent, bIdx: Int) {
+        checkUsage()
+        validatePair(a, b)
+
+        if(b is VirtualResistor) {
+            lineCompiler.connect(a, aIdx, b, bIdx)
+        }
+        else {
+            error("Cannot connect $b")
+        }
+    }
+
+    override fun connect(a: VirtualComponent, aIdx: Int, b: Component, bIdx: Int) {
+        checkUsage()
+        connect(b, bIdx, a, aIdx)
+    }
+
+    override fun connect(a: VirtualComponent, aIdx: Int, b: VirtualComponent, bIdx: Int) {
+        checkUsage()
+        validatePair(a, b)
+
+        if(a is VirtualResistor && b is VirtualResistor) {
+            lineCompiler.connect(a, aIdx, b, bIdx)
+        }
+        else {
+            error("Invalid components $a $b")
+        }
+    }
+
+    override fun connect(a: Term, aIdx: Int, b: Term, bIdx: Int) {
+        checkUsage()
+
+        if(a is Component && b is Component) {
+            connect(a, aIdx, b, bIdx)
+        }
+        else if(a is Component && b is VirtualComponent) {
+            connect(a, aIdx, b, bIdx)
+        }
+        else if(a is VirtualComponent && b is Component) {
+            connect(a, aIdx, b, bIdx)
+        }
+        else if(a is VirtualComponent && b is VirtualComponent) {
+            connect(a, aIdx, b, bIdx)
+        }
+        else {
+            error("Cannot connect $a and $b")
+        }
+    }
+
+    /**
+     * Realizes all virtual components and connections, thereby finalizing [Circuit].
+     * */
+    fun build() {
+        checkUsage()
+        lineCompiler.compile()
+        realized = true
+    }
+}
+
+/**
+ * A [VirtualComponent] resembling a resistor (functionally equivalent, with one exception), which may or may not become an actual [Line] component.
+ * These are organized into line graphs, which become a single [Line] component, providing significant optimizations for circuits with extensive
+ * sections of virtual resistors in series, such as a straight wire or a power grid.
+ * **Polarity is not guaranteed to match that of a [Resistor]. Maybe sneak that in, Grissess?**
+ * */
+class VirtualResistor : IResistor, VirtualComponent {
+    var part: Line.Part? = null
+        private set
+
+    internal fun setHandle(handle: Line.Part) {
+        this.part = handle
+        handle.resistance = this.resistance
+    }
+
+    override val power: Double
+        get() = part?.power ?: 0.0
+
+    override val potential: Double
+        get() = part?.potential ?: 0.0
+
+    override val current: Double
+        get() = part?.current ?: 0.0
+
+    override var resistance: Double = 1.0
+        set(value) {
+            if(field != value) {
+                field = value
+                part?.resistance = value
+            }
+        }
+
+    override fun toString() = "Virtual[L=${part?.line?.hashCode()}, P=${part?.hashCode()}, R=$resistance]"
+}
\ No newline at end of file
diff --git a/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/Node.kt b/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/Node.kt
index c45da49..a573e9d 100644
--- a/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/Node.kt
+++ b/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/Node.kt
@@ -2,14 +2,14 @@ package org.ageseries.libage.sim.electrical.mna
 
 import org.ageseries.libage.debug.dprintln
 import org.ageseries.libage.sim.electrical.mna.component.Component
-import org.ageseries.libage.data.DisjointSet
+import org.ageseries.libage.data.SuperDisjointSet
 
 /**
  * A "node", in MNA; the non-resistive connections between [Component]s. All [Pin]s which are connected share a single instance of Node.
  *
  * Aside from identifying [Component]s' connections, the Nodes' potentials (relative to [Circuit.ground]) are computed as a result of the MNA algorithm.
  */
-open class Node(var circuit: Circuit) : IDetail, DisjointSet() {
+open class Node(var circuit: Circuit) : IDetail, SuperDisjointSet<Node>() {
     companion object {
         /**
          * Determine which of two (nullable) Nodes should subsume the other when the two are about to be merged.
diff --git a/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/component/Component.kt b/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/component/Component.kt
index a0cf31b..a1648e9 100644
--- a/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/component/Component.kt
+++ b/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/component/Component.kt
@@ -1,12 +1,8 @@
 package org.ageseries.libage.sim.electrical.mna.component
 
-import org.ageseries.libage.data.DisjointSet
+import org.ageseries.libage.data.SuperDisjointSet
 import org.ageseries.libage.debug.dprintln
-import org.ageseries.libage.sim.electrical.mna.Circuit
-import org.ageseries.libage.sim.electrical.mna.GroundNode
-import org.ageseries.libage.sim.electrical.mna.IDetail
-import org.ageseries.libage.sim.electrical.mna.Node
-import org.ageseries.libage.sim.electrical.mna.VSource
+import org.ageseries.libage.sim.electrical.mna.*
 import java.util.*
 import kotlin.collections.ArrayList
 
@@ -18,25 +14,24 @@ import kotlin.collections.ArrayList
 class ConnectionMutationException: Exception()
 
 /**
- * A connectable "point" on a component. The [representative] of this [DisjointSet] owns a [Node].
+ * A connectable "point" on a component. The [representative] of this [SuperDisjointSet] owns a [Node].
  */
-class Pin: DisjointSet() {
+class Pin: SuperDisjointSet<Pin>() {
     private var internalNode: Node? = null
+
     var node: Node?
-        get() = (representative as Pin).internalNode
+        get() = representative.internalNode
         set(value) {
-            dprintln("P.n.<set>: $this from=$node to=$value on=${representative as Pin}")
-            (representative as Pin).internalNode = value
+            dprintln("P.n.<set>: $this from=$node to=$value on=${representative}")
+            representative.internalNode = value
             dprintln("P.n.<set>: out $this node=$node")
         }
 
-    override fun unite(other: DisjointSet) {
-        val opin = other as? Pin
-        if(opin != null) {  // This should be the hot path
-            val node = Node.mergeData(internalNode, opin.internalNode)
-            internalNode = node
-            opin.internalNode = node
-        }
+    override fun unite(other: Pin) {
+        // This should be the hot path
+        val node = Node.mergeData(internalNode, other.internalNode)
+        internalNode = node
+        other.internalNode = node
         super.unite(other)
     }
 
@@ -51,20 +46,16 @@ class Pin: DisjointSet() {
  * As [Pin]s are created and destroyed anytime a [Component] is added or removed from a circuit, this class provides a stable abstraction for naming a [Pin] that can be safely sent wherever the [Component] is used.
  *
  * Because of the former, getters on this class should be treated as ephemeral, and *will* race with data modifications to the underlying [Circuit] without causing errors. If you have to cache these variables, keep their lifetimes short and bounded.
+ * @param component The [Component] whose pin is being described.
+ * @param pinIndex The index of the [Pin] on the [component].
  */
-class PinRef(
-    /** The [Component] whose pin is being described. */
-    val component: Component,
-    pinIndex: Int)
-{
+class PinRef(val component: Component, val pinIndex: Int) {
     init {
-       if(pinIndex < 0 || pinIndex >= component.pinCount)
-           error("Invalid pin index $pinIndex")
+        require(pinIndex >= 0 && pinIndex < component.pinCount) {
+            "Pin $pinIndex is out-of-bounds"
+        }
     }
 
-    /** The index of the [Pin] on the [component]. */
-    val pinIndex = pinIndex
-
     /** Whether the [component] is in a [Circuit]. */
     val isInCircuit get() = component.isInCircuit
 
@@ -128,6 +119,10 @@ class PinRef(
     }
 }
 
+/**
+ * Represents a common ancestor for [Component] and [VirtualComponent].
+ * Useful downstream, where we have methods and DTOs where we use [Term] instead of separate handling for [Component] and [VirtualComponent].
+ * */
 interface Term
 
 /**
diff --git a/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/component/Resistor.kt b/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/component/Resistor.kt
index f6a614c..0c4e530 100644
--- a/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/component/Resistor.kt
+++ b/src/main/kotlin/org/ageseries/libage/sim/electrical/mna/component/Resistor.kt
@@ -1,6 +1,7 @@
 package org.ageseries.libage.sim.electrical.mna.component
 
 import org.ageseries.libage.debug.dprintln
+import org.ageseries.libage.mathematics.approxEq
 import org.ageseries.libage.sim.electrical.mna.Circuit
 
 /**
@@ -285,4 +286,18 @@ open class Switch: Resistor() {
     fun toggle() {
         open = !open
     }
+}
+
+/**
+ * Updates the resistance if the deviation between the current resistance and [newValue] is larger than [eps].
+ * This should be used instead of setting [IResistor.resistance] whenever possible, because setting the resistance is expensive when [this] is [Resistor].
+ * @return True if the resistance was updated. Otherwise, false.
+ * */
+fun IResistor.updateResistance(newValue: Double, eps: Double = 1e-4): Boolean {
+    if(this.resistance.approxEq(newValue, eps)) {
+        return false
+    }
+
+    this.resistance = newValue
+    return true
 }
\ No newline at end of file
diff --git a/src/main/kotlin/org/ageseries/libage/space/Graph.kt b/src/main/kotlin/org/ageseries/libage/space/Graph.kt
deleted file mode 100644
index 23f7a8d..0000000
--- a/src/main/kotlin/org/ageseries/libage/space/Graph.kt
+++ /dev/null
@@ -1,254 +0,0 @@
-package org.ageseries.libage.space
-
-import java.util.ArrayList
-import java.util.WeakHashMap
-import org.ageseries.libage.data.MutableMultiMap
-import org.ageseries.libage.data.mutableMultiMapOf
-import org.ageseries.libage.debug.dprintln
-
-open class Object(val locator: Locator) {
-    var concom: ConnectedComponent? = null
-
-    // Only safe to use after this has been added to a space
-    val space: Space get() = concom!!.space
-
-    fun canConnectTo(other: Object, isA: Boolean): Boolean = true
-
-    // Only safe to call after this has been added to a space
-    fun connectTo(other: Object, isA: Boolean) {
-        if (isA) {
-            dprintln("O.cT: pre $concom onto ${other.concom}")
-            concom!!.merge(other.concom!!) // NB: Mutates either this.concom or other.concom
-            dprintln("O.cT: post $concom onto ${other.concom}")
-            // assert(concom == other.concom)
-        }
-    }
-}
-
-// TODO: Refactor this using the "Union-Find" Set--needs some care to keep track of the `objects` field, though.
-class ConnectedComponent(val space: Space) {
-    var objects: MutableSet<Object> = mutableSetOf()
-
-    fun add(obj: Object) {
-        obj.concom = this
-        objects.add(obj)
-    }
-
-    fun add(vararg obj: Object) {
-        obj.forEach { add(it) }
-    }
-
-    fun merge(other: ConnectedComponent) {
-        val (bigger, smaller) = if (objects.size < other.objects.size) Pair(other, this) else Pair(this, other)
-        smaller.objects.forEach { bigger.add(it) }
-        smaller.objects.clear()
-    }
-}
-
-open class Space {
-    val components: WeakHashMap<ConnectedComponent, Unit> = WeakHashMap()
-    val objectLocators: MutableMap<Locator, Object> = mutableMapOf()
-    val locatorVectors: MutableMultiMap<Vec3i, Locator> = mutableMultiMapOf()
-
-    fun add(obj: Object) {
-        dprintln("add: $obj at ${obj.locator}")
-        objectLocators[obj.locator] = obj
-        locatorVectors[obj.locator.vec3i] = obj.locator
-        val concom = ConnectedComponent(this)
-        concom.add(obj)
-        components[concom] = Unit
-        merge(obj)
-    }
-
-    fun add(vararg obj: Object) {
-        obj.forEach { add(it) }
-    }
-
-    fun remove(obj: Object) {
-        dprintln("remove: $obj at ${obj.locator}")
-        val objects = obj.concom!!.objects.toSet()
-        obj.concom!!.objects.clear() // This set is about to be emptied anyway, no need to hold these references
-
-        objects.forEach {
-            // Drop any previous cc references
-            it.concom = null
-            // Also remove from the locators so merge() doesn't observe a null concom
-            objectLocators.remove(it.locator)
-            locatorVectors.remove(it.locator.vec3i, it.locator)
-        }
-
-        // Rescan and merge new components
-        objects.forEach {
-            if (it != obj) add(it)
-        }
-    }
-
-    private fun canConnect(obj: Object, objb: Object, locator: Locator) =
-        obj.locator.canConnect(locator) && locator.canConnect(obj.locator) && obj.canConnectTo(
-            objb,
-            true
-        ) && objb.canConnectTo(obj, false)
-
-    protected fun merge(obj: Object) {
-        obj.locator.neighbors().forEach {
-            locatorVectors[it.vec3i].forEach { loc ->
-                val objb = objectLocators[loc]
-                dprintln("merge: consider loc $loc obj $objb")
-                if (objb != null && canConnect(obj, objb, loc)) {
-                    dprintln("merge: merging")
-                    obj.connectTo(objb, true)
-                    objb.connectTo(obj, false)
-                } else if (objb != null) {
-                    if (!obj.locator.canConnect(loc)) dprintln("merge: failed: this locator (${obj.locator}) can't connect to other locator ($loc)")
-                    if (!loc.canConnect(obj.locator)) dprintln("merge: failed: other locator ($loc) can't connect to this locator (${obj.locator})")
-                    if (!obj.canConnectTo(
-                            objb,
-                            true
-                        )
-                    ) dprintln("merge: failed: this object ($obj @ ${obj.locator}) can't connect to other object ($objb @ $loc)")
-                    if (!objb.canConnectTo(
-                            obj,
-                            false
-                        )
-                    ) dprintln("merge: failed: other object ($objb @ $loc) can't connect to this object ($obj @ ${obj.locator})")
-                }
-            }
-        }
-    }
-
-    companion object {
-        @JvmStatic
-        fun main(args: Array<String>) {
-            main_1()
-            println("===")
-            main_2()
-            println("===")
-            main_3()
-        }
-
-        private fun describe(space: Space) {
-            println("components:")
-            for ((loc, obj) in space.objectLocators) {
-                println("- $obj @ $loc ( = ${obj.locator}) in cc ${obj.concom}")
-            }
-            println("ccs:")
-            for ((cc, _) in space.components) {
-                println("- cc $cc:")
-                for (obj in cc.objects) {
-                    println("  - $obj @ ${obj.locator}")
-                }
-            }
-        }
-
-        fun main_1() {
-            println("main_1: Basic BlockPos Tests")
-
-            val space = Space()
-
-            println("--- addition ---")
-
-            val line = ArrayList<Object>()
-            for (i in 0 until 10) {
-                val o = Object(BlockPos(Vec3i(i, 0, 0)))
-                line.add(o)
-                space.add(o)
-            }
-
-            println("line:")
-            for (o in line) {
-                println("obj $o loc ${o.locator} cc ${o.concom}")
-            }
-
-            describe(space)
-
-            println()
-            println("--- removal ---")
-
-            space.remove(line[5])
-
-            println("line:")
-            for (o in line) {
-                println("obj $o loc ${o.locator} cc ${o.concom}")
-            }
-
-            describe(space)
-
-            println()
-            println("--- readdition ---")
-
-            space.add(line[5])
-
-            println("line:")
-            for (o in line) {
-                println("obj $o loc ${o.locator} cc ${o.concom}")
-            }
-
-            describe(space)
-        }
-
-        fun main_2() {
-            println("main_2: SurfacePos tests")
-
-            println("--- adding a line ---")
-
-            val space = Space()
-            val line = ArrayList<Object>()
-
-            for (i in 0 until 5) {
-                val o = Object(SurfacePos(Vec3i(i, 0, 0), PlanarFace.NegY))
-                line.add(o)
-                space.add(o)
-            }
-
-            describe(space)
-
-            println()
-            println("--- adding a side ---")
-
-            val side = Object(SurfacePos(Vec3i(4, 0, 0), PlanarFace.PosX))
-            space.add(side)
-
-            describe(space)
-
-            println()
-            println("--- adding wrapping sides ---")
-
-            val wrsidep = Object(SurfacePos(Vec3i(1, -1, 0), PlanarFace.PosX))
-            val wrsiden = Object(SurfacePos(Vec3i(-1, -1, 0), PlanarFace.NegX))
-            space.add(wrsidep, wrsidep)
-
-            describe(space)
-
-            println()
-            println("--- adding inverse face ---")
-
-            val inv = Object(SurfacePos(Vec3i(3, 0, 0), PlanarFace.PosY))
-            space.add(inv)
-
-            describe(space)
-        }
-
-        fun main_3() {
-            println("main_3: Interoperability tests")
-
-            val space = Space()
-            val so = Object(SurfacePos(Vec3i(5, 0, 0), PlanarFace.NegY))
-            space.add(so)
-
-            println("--- adding a blockpos on the adjacent plane ---")
-
-            val bpa = Object(BlockPos(Vec3i(5, 0, 1)))
-            space.add(bpa)
-
-            describe(space)
-
-            println()
-            println("--- adding a wrapped blockpos ---")
-
-            val bpw = Object(BlockPos(Vec3i(6, 1, 0)))
-            space.add(bpw)
-
-            describe(space)
-        }
-    }
-}
diff --git a/src/main/kotlin/org/ageseries/libage/space/Location.kt b/src/main/kotlin/org/ageseries/libage/space/Location.kt
deleted file mode 100644
index 3b9449f..0000000
--- a/src/main/kotlin/org/ageseries/libage/space/Location.kt
+++ /dev/null
@@ -1,527 +0,0 @@
-package org.ageseries.libage.space
-
-import kotlin.math.abs
-import kotlin.math.sign
-import kotlin.math.sqrt
-
-/**
- * A vector in a two-dimensional space of integers.
- */
-data class Vec2i(val x: Int, val y: Int) {
-    /**
-     * Gets the opposite vector.
-     */
-    operator fun unaryMinus() = Vec2i(-x, -y)
-
-    /**
-     * Gets the sum of this vector and another vector.
-     */
-    operator fun plus(other: Vec2i) = Vec2i(x + other.x, y + other.y)
-
-    /**
-     * Gets the sum of this vector and the opposite of another vector.
-     */
-    operator fun minus(other: Vec2i) = this + (-other)
-
-    /**
-     * Gets the scalar multiple of this vector.
-     */
-    operator fun times(scalar: Int) = Vec2i(x * scalar, y * scalar)
-
-    val isZero: Boolean get() = this == ZERO
-
-    companion object {
-        val ZERO = Vec2i(0, 0)
-        val XU = Vec2i(1, 0)
-        val YU = Vec2i(0, 1)
-    }
-}
-
-/**
- * A vector in a three-dimensional space of integers.
- */
-data class Vec3i(val x: Int, val y: Int, val z: Int) {
-    /**
-     * Gets the opposite vector.
-     */
-    operator fun unaryMinus() = Vec3i(-x, -y, -z)
-
-    /**
-     * Gets the sum of this vector and another vector.
-     */
-    operator fun plus(other: Vec3i) = Vec3i(x + other.x, y + other.y, z + other.z)
-
-    /**
-     * Gets the sum of this vector and the opposite of another vector.
-     */
-    operator fun minus(other: Vec3i) = this + (-other)
-
-    /**
-     * Gets the scalar multiple of this vector.
-     */
-    operator fun times(other: Int) = Vec3i(x * other, y * other, z * other)
-
-    val isZero: Boolean get() = (x == 0) && (y == 0) && (z == 0)
-
-    /**
-     * Calculates the L1 distance between two vectors.
-     * See https://en.wikipedia.org/wiki/Taxicab_geometry
-     */
-    fun l1norm(v: Vec3i): Int = abs(v.x - x) + abs(v.y - y) + abs(v.z - z)
-
-    val vec3f: Vec3f get() = Vec3f(x.toDouble(), y.toDouble(), z.toDouble())
-
-    companion object {
-        val ZERO = Vec3i(0, 0, 0)
-        val XU = Vec3i(1, 0, 0)
-        val YU = Vec3i(0, 1, 0)
-        val ZU = Vec3i(0, 0, 1)
-    }
-}
-
-/**
- * A vector in a three-dimensional real space.
- */
-data class Vec3f(val x: Double, val y: Double, val z: Double) {
-    operator fun unaryMinus() = Vec3f(-x, -y, -z)
-    operator fun plus(other: Vec3f) = Vec3f(x + other.x, y + other.y, z + other.z)
-    operator fun minus(other: Vec3f) = this + (-other)
-    fun recip() = Vec3f(1.0/x, 1.0/y, 1.0/z)
-    operator fun times(other: Vec3f) = Vec3f(x * other.x, y * other.y, z * other.z)
-    operator fun div(other: Vec3f) = this * other.recip()
-
-    operator fun plus(other: Double) = this + diag(other)
-    operator fun minus(other: Double) = this - diag(other)
-    operator fun times(other: Double) = this * diag(other)
-    operator fun div(other: Double) = this / diag(other)
-
-    val isZero: Boolean
-        get() = x == 0.0 && y == 0.0 && z == 0.0
-
-    fun dot(other: Vec3f) = x * other.x + y * other.y + z * other.z
-    val magSquared: Double get() = dot(this)
-    val mag: Double get() = sqrt(magSquared)
-
-    val normalized: Vec3f
-        get() = if(isZero) { ZERO } else { this / mag }
-
-    fun cross(other: Vec3f) = Vec3f(
-        y * other.z - z * other.y,
-        z * other.x - x * other.z,
-        x * other.y - y * other.x
-    )
-
-    // TODO: figure out this rounding mode and document it accordingly
-    // (Until then, don't rely on this!)
-    val vec3i: Vec3i get() = Vec3i(x.toInt(), y.toInt(), z.toInt())
-
-    companion object {
-        fun diag(v: Double) = Vec3f(v, v, v)
-
-        val ZERO = Vec3f(0.0, 0.0, 0.0)
-        val XU = Vec3f(1.0, 0.0, 0.0)
-        val YU = Vec3f(0.0, 1.0, 0.0)
-        val ZU = Vec3f(0.0, 0.0, 1.0)
-    }
-}
-
-/**
- * A direction oriented in two-dimensional space.
- */
-enum class PlanarDir(val int: Int) {
-    Up(0), Right(1), Down(2), Left(3);
-
-    companion object {
-        fun fromInt(i: Int) = when (i) {
-            0 -> Up
-            1 -> Right
-            2 -> Down
-            3 -> Left
-            else -> error("Not a PlanarDir: $i")
-        }
-    }
-
-    val rotated: PlanarDir get() = fromInt((int + 1) % 4)
-    val inverted: PlanarDir get() = fromInt((int + 2) % 4)
-    val rotated_left: PlanarDir get() = fromInt((int + 3) % 4)
-}
-
-/**
- * A set of unit vectors that represents each direction in three-dimensional space.
- */
-enum class Axis(val int: Int) {
-    X(0), Y(1), Z(2);
-
-    companion object {
-        fun fromInt(i: Int) = when (i) {
-            0 -> X
-            1 -> Y
-            2 -> Z
-            else -> null
-        }
-
-        /**
-         * Returns the axis in which a given vector is closest to. Perfect diagonals may return an axis that is nonsense.
-         */
-        fun fromVecMajor(v: Vec3i): Axis {
-            var (x, y, z) = v
-            x = abs(x); y = abs(y); z = abs(z)
-            val max = arrayOf(x, y, z).maxOrNull()
-            return when (max) {
-                x -> X
-                y -> Y
-                else -> Z
-            }
-        }
-
-        /* Microoptimization: avoid the overhead from constructing these repeatedly */
-        val X_VEC = Vec3i.XU
-        val Y_VEC = Vec3i.YU
-        val Z_VEC = Vec3i.ZU
-    }
-
-    val vec3i: Vec3i
-        get() = when (this) {
-            X -> X_VEC
-            Y -> Y_VEC
-            Z -> Z_VEC
-        }
-
-    /**
-     * Returns the cross product of this axis and another.
-     */
-    fun cross(other: Axis): Axis? = when (this) {
-        X -> when (other) {
-            X -> null
-            Y -> Z
-            Z -> Y
-        }
-        Y -> when (other) {
-            X -> Z
-            Y -> null
-            Z -> X
-        }
-        Z -> when (other) {
-            X -> Y
-            Y -> X
-            Z -> null
-        }
-    }
-}
-
-/**
- * The six orthogonal vectors corresponding to the faces of a cube as seen from the center.
- */
-enum class PlanarFace(val int: Int) {
-    PosX(0), PosY(1), PosZ(2), NegX(3), NegY(4), NegZ(5);
-
-    companion object {
-        /**
-         * Gets the face corresponding to a number.
-         */
-        fun fromInt(i: Int) = when (i) {
-            0 -> PosX
-            1 -> PosY
-            2 -> PosZ
-            3 -> NegX
-            4 -> NegY
-            5 -> NegZ
-            else -> error("Invalid PlanarFace: $i")
-        }
-
-        /**
-         * Gets the plane that the axis is pointing to from the center.
-         */
-        fun fromAxis(a: Axis, n: Boolean): PlanarFace = fromInt(a.int + if (n) 3 else 0)
-
-        /**
-         * Gets the plane that the vector is pointing to in respect to the center of the cube.
-         */
-        fun fromVec(v: Vec3i): PlanarFace {
-            val axis = Axis.fromVecMajor(v)
-            return fromAxis(
-                axis, when (axis) {
-                    Axis.X -> v.x < 0
-                    Axis.Y -> v.y < 0
-                    Axis.Z -> v.z < 0
-                }
-            )
-        }
-
-        /**
-         * Gets the plane that has the closest normal vector to the given vector.
-         */
-        fun fromNormal(v: Vec3i): PlanarFace = fromVec(v).inverse
-
-        /* See the microopt in Axis above */
-        val PosX_VEC = Axis.X_VEC
-        val PosY_VEC = Axis.Y_VEC
-        val PosZ_VEC = Axis.Z_VEC
-        val NegX_VEC = -PosX_VEC
-        val NegY_VEC = -PosY_VEC
-        val NegZ_VEC = -PosZ_VEC
-
-        val ADJACENCIES = arrayOf(
-            arrayOf(PosY, PosZ, NegY, NegZ),
-            arrayOf(PosX, PosZ, NegX, NegZ),
-            arrayOf(PosX, PosY, NegX, NegY)
-        )
-    }
-
-    val neg: Boolean get() = int > 2
-    val axis: Axis
-        get() = when (this) {
-            PosX, NegX -> Axis.X
-            PosY, NegY -> Axis.Y
-            PosZ, NegZ -> Axis.Z
-        }
-    val inverse: PlanarFace
-        get() = when (this) {
-            PosX -> NegX
-            NegX -> PosX
-            PosY -> NegY
-            NegY -> PosY
-            PosZ -> NegZ
-            NegZ -> PosZ
-        }
-
-    /**
-    "Vector": the vec that points out of the block center toward this face.
-     */
-    val vec3i: Vec3i
-        get() = if (neg) when (axis) {
-            Axis.X -> NegX_VEC
-            Axis.Y -> NegY_VEC
-            Axis.Z -> NegZ_VEC
-        } else axis.vec3i
-
-    /**
-     * "Normal": the vec that points, normal to this face, toward the block center.
-     */
-    val normal: Vec3i
-        get() = if (neg) axis.vec3i else when (axis) {
-            Axis.X -> NegX_VEC
-            Axis.Y -> NegY_VEC
-            Axis.Z -> NegZ_VEC
-        }
-
-    val adjacencies: Array<PlanarFace> get() = ADJACENCIES[int % 3]
-}
-
-/**
- * A generic location in a generic space. Also contains a method to check if something can connect with this and list
- * of locatable objects that can connect with this.
- */
-interface Locator {
-    val vec3i: Vec3i
-
-    /**
-     * A list of neighbors in which connections are possible with.
-     */
-    fun neighbors(): List<Locator>
-
-    /**
-     * Returns true if it is possible for this node and another node to connect.
-     * When overriding this, make sure a specific test is implemented for the specific
-     * locator that extended this interface. Ensure that the coverage of the test is
-     * proportional to the size of the implementation.
-     */
-    fun canConnect(other: Locator): Boolean = true
-}
-
-/**
- *  Locator support for "simple nodes" that take up an entire block in three-dimensional space.
- */
-open class BlockPos(override val vec3i: Vec3i) : Locator {
-    companion object {
-        val CONNECTIVITY_DELTAS = PlanarFace.values().map { it.vec3i }
-    }
-
-    override fun toString() = "BlockPos($vec3i)"
-
-    override fun neighbors(): List<Locator> = CONNECTIVITY_DELTAS.map { translated(it) }
-
-    /**
-     * Offsets a vector based on the position of this node.
-     */
-    fun translated(v: Vec3i) = BlockPos(vec3i + v)
-}
-
-/**
- *  Locator support for surface-mounted nodes the exist on a three-dimensional block. Up to six can exist per block,
- *  corresponding to each face.
- */
-open class SurfacePos(override val vec3i: Vec3i, val face: PlanarFace) : Locator {
-    companion object {
-        // On the same plane:
-        val PLANAR_DELTAS = arrayListOf(
-            Vec3i(1, 0, 0), Vec3i(-1, 0, 0), Vec3i(0, 0, 1), Vec3i(0, 0, -1)
-        )
-
-        // On adjacent planes:
-        val ADJACENT_DELTAS = arrayListOf(
-            // SurfacePos locators can connect to adjacent planes on the same block:
-            Vec3i(0, 0, 0),
-            // One unit down (anti-normal) in cardinal directions ("wrapping around")
-            Vec3i(1, -1, 0), Vec3i(-1, -1, 0), Vec3i(0, -1, 1), Vec3i(0, -1, -1)
-        )
-    }
-
-    override fun toString() = "SurfacePos($vec3i, $face)"
-
-    // Preserve chirality: invert _two_ components, or none.
-    // There's very little thought in the permutation otherwise, however; if those need to be changed, they can be.
-    /**
-     * Orients a vector based on which plane of a cube this node is on. This preserves chirality.
-     */
-    fun toGlobal(v: Vec3i): Vec3i = when (face) {
-        PlanarFace.NegX -> Vec3i(v.y, v.x, v.z)
-        PlanarFace.PosX -> Vec3i(-v.y, -v.x, v.z)
-        PlanarFace.PosY -> Vec3i(-v.x, -v.y, v.z)
-        PlanarFace.NegY -> v
-        PlanarFace.NegZ -> Vec3i(v.x, v.z, v.y)
-        PlanarFace.PosZ -> Vec3i(-v.x, v.z, -v.y)
-    }
-
-    /**
-     * Offsets a vector based on the position and orientation of this node.
-     */
-    fun translated(v: Vec3i) = SurfacePos(vec3i + toGlobal(v), face)
-
-    override fun neighbors(): List<Locator> = (PLANAR_DELTAS.map { translated(it) } + // Other adjacent blocks on the same plane
-        face.adjacencies.map { SurfacePos(vec3i, it) } + // Connections within the same block
-        face.adjacencies.map { SurfacePos(vec3i + face.vec3i + it.normal, it) } // "Wrapping" (L1=2) connections
-        )
-
-    override fun canConnect(other: Locator): Boolean = when (other) {
-        is SurfacePos -> when (other.vec3i.l1norm(vec3i)) {
-            0 -> other.face != face && other.face != face.inverse
-            1 -> face == other.face
-            2 -> {
-                val delta = other.vec3i - vec3i
-                val otherNorm = delta + face.normal
-                println(
-                    "SP.cC: L1=2: delta $delta other_norm $otherNorm face.normal ${face.normal} this.vec $vec3i other.vec ${other.vec3i} other.face ${other.face} PF.fN(on) ${
-                        PlanarFace.fromNormal(
-                            otherNorm
-                        )
-                    }"
-                )
-                other.face == PlanarFace.fromNormal(otherNorm)
-            }
-            else -> error("Illegal norm")
-        }
-        is BlockPos -> true
-        else -> true
-    }
-}
-
-object GPUtil {
-    fun gp(v: Vec3i): String = "${v.x},${v.z},${v.y}"
-    fun gp(v: Vec3f): String = "${v.x},${v.z},${v.y}"
-
-    data class FaceInfo(val offset: Vec3f, val ax1: Axis, val ax2: Axis)
-    fun faceInfo(face: PlanarFace): FaceInfo {
-        val axes = face.adjacencies.map { it.axis }
-        // Conjecture: there are two axes
-        val ax1 = axes[0]
-        val ax2 = axes[1]
-        var off = ax1.cross(ax2)!!.vec3i.vec3f
-        if(face.neg) off *= -1.0
-        return FaceInfo(off, ax1, ax2)
-    }
-
-    val signs = arrayOf(
-        Pair(-1.0, -1.0),
-        Pair(1.0, -1.0),
-        Pair(1.0, 1.0),
-        Pair(-1.0, 1.0),
-    )
-    fun plotFace(face: PlanarFace, origin: Vec3f = Vec3f.ZERO, style: String = "") {
-        val (off, ax1, ax2) = faceInfo(face)
-        val pts = mutableListOf<Vec3f>()
-        for ((sgn1, sgn2) in signs) {
-            val pt = origin + off + ax1.vec3i.vec3f * sgn1 + ax2.vec3i.vec3f * sgn2
-            pts.add(pt)
-        }
-        for ((idx, pt) in pts.withIndex()) {
-            val next = pts[(idx + 1) % pts.size]
-            println("set arrow from ${PlotSurfacePosRotations.gp(pt)} to ${PlotSurfacePosRotations.gp(next)} nohead $style")
-        }
-    }
-
-    fun plotCube(origin: Vec3f = Vec3f.ZERO, style: String = "") {
-        for(face in PlanarFace.values()) {
-            plotFace(face, origin, style)
-        }
-    }
-
-    val axisColors = arrayOf("#ff0000", "#00ff00", "#0000ff")
-    fun plotRose(origin: Vec3f = Vec3f.ZERO, scale: Double = 0.2, style: String = "") {
-        for(axis in Axis.values()) {
-            println("set arrow from ${gp(origin)} to ${gp(origin + axis.vec3i.vec3f * scale)} lc \"${axisColors[axis.int]}\" $style")
-        }
-    }
-
-    fun locatorSpace(pos: Vec3f) = pos * 2.0
-    fun locatorSpace(pos: Vec3i) = locatorSpace(pos.vec3f)
-
-    fun plotLocator(loc: Locator, style: String = "") {
-        when(loc) {
-            is BlockPos -> plotLocator(loc, style)
-            is SurfacePos -> plotLocator(loc, style)
-        }
-    }
-    fun plotLocator(loc: BlockPos, style: String = "") {
-        plotCube(locatorSpace(loc.vec3i), style)
-    }
-    fun plotLocator(loc: SurfacePos, style: String = "") {
-        plotFace(loc.face, locatorSpace(loc.vec3i), style)
-    }
-}
-
-class PlotSurfacePosRotations {
-    companion object {
-        val gp: (Vec3f) -> String = GPUtil::gp
-        val colors = GPUtil.axisColors
-
-        @JvmStatic
-        fun main(args: Array<String>) {
-            val units = with(Vec3i) { arrayOf(XU, YU, ZU) }
-            val faces = PlanarFace.values()
-            for(axis in arrayOf("x", "y", "z")) {
-                println("set ${axis}range [-1:1]")
-            }
-
-            for(face in faces) {
-                println("# Face: $face")
-                val off = GPUtil.faceInfo(face).offset
-                GPUtil.plotFace(face, style = "lc \"#007700\"")
-                println("set label \"$face\" at ${gp(off)} tc \"${colors[face.axis.int]}\"")
-
-                val sp = SurfacePos(Vec3i.ZERO, face)
-                for((idx, unit) in units.withIndex()) {
-                    val color = colors[idx]
-                    val mapped = sp.toGlobal(unit).vec3f / 5.0
-                    println("set arrow from ${gp(off)} to ${gp(off + mapped)} lc \"$color\"")
-                }
-                println("")
-            }
-        }
-    }
-}
-
-class PlotBlockPosNeighbors {
-    companion object {
-        @JvmStatic
-        fun main(args: Array<String>) {
-            val bp = BlockPos(Vec3i.ZERO)
-            for(neighbor in bp.neighbors()) {
-                GPUtil.plotLocator(neighbor, "lc \"#007700\"")
-                GPUtil.plotRose(GPUtil.locatorSpace(neighbor.vec3i))
-            }
-            GPUtil.plotLocator(bp, "lc \"#ff0000\"")
-            GPUtil.plotRose()
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/main/kotlin/org/ageseries/libage/utils/Extensions.kt b/src/main/kotlin/org/ageseries/libage/utils/Extensions.kt
new file mode 100644
index 0000000..4191c7d
--- /dev/null
+++ b/src/main/kotlin/org/ageseries/libage/utils/Extensions.kt
@@ -0,0 +1,47 @@
+package org.ageseries.libage.utils
+
+/**
+ * Adds the [value] to the map.
+ * Throws an error with the specified [message] if a value with [key] is already present.
+ * */
+inline fun<K, V> MutableMap<K, V>.putUnique(key: K, value: V, message: () -> String) {
+    require(this.put(key, value) == null, message)
+}
+
+/**
+ * Adds the [value] to the map.
+ * Throws an error if a value with [key] is already present.
+ * */
+fun<K, V> MutableMap<K, V>.putUnique(key: K, value: V) {
+    this.putUnique(key, value) {
+        "Mapping with $key $value was not unique"
+    }
+}
+
+/**
+ * Adds the [value] to the set.
+ * Throws an error with the specified [message] if [value] is already present.
+ * */
+inline fun<V> MutableSet<V>.addUnique(value: V, message: () -> String) {
+    require(this.add(value), message)
+}
+
+/**
+ * Adds the [value] to the set.
+ * Throws an error if [value] is already present.
+ * */
+fun<V> MutableSet<V>.addUnique(value: V) {
+    this.addUnique(value) {
+        "Element $value was not unique"
+    }
+}
+
+/**
+ * Removes an element from the set.
+ * If this set preserves order, then this operation will remove the first element in the set.
+ * */
+fun<T> MutableSet<T>.removeElement() : T {
+    val value = this.first()
+    this.remove(value)
+    return value
+}
\ No newline at end of file
diff --git a/src/main/kotlin/org/ageseries/libage/utils/Reflection.kt b/src/main/kotlin/org/ageseries/libage/utils/Reflection.kt
new file mode 100644
index 0000000..f934e40
--- /dev/null
+++ b/src/main/kotlin/org/ageseries/libage/utils/Reflection.kt
@@ -0,0 +1,15 @@
+package org.ageseries.libage.utils
+
+/**
+ * Gets the KClass#simpleName from the class of [T]. The result is the name as defined in the source code.
+ * */
+inline fun<reified T> sourceName() = checkNotNull(T::class.simpleName) {
+    "Failed to get name of ${T::class}"
+}
+
+/**
+ * Gets the Class#simpleName. The result is the name as defined in the source code.
+ * */
+fun Class<*>.sourceName() = checkNotNull(this.simpleName) {
+    "Failed to get name of $this"
+}
\ No newline at end of file
diff --git a/src/main/kotlin/org/ageseries/libage/utils/Watch.kt b/src/main/kotlin/org/ageseries/libage/utils/Watch.kt
new file mode 100644
index 0000000..680dfb7
--- /dev/null
+++ b/src/main/kotlin/org/ageseries/libage/utils/Watch.kt
@@ -0,0 +1,56 @@
+package org.ageseries.libage.utils
+
+import org.ageseries.libage.data.NANO
+import org.ageseries.libage.data.Quantity
+import org.ageseries.libage.data.SECOND
+import org.ageseries.libage.data.Time
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+import kotlin.system.measureNanoTime
+
+/**
+ * Simple stopwatch using [System.nanoTime]
+ * */
+class Stopwatch {
+    var initialTimeStamp = System.nanoTime()
+        private set
+
+    var lastSampleTimeStamp = initialTimeStamp
+        private set
+
+    /**
+     * Samples the elapsed time and resets the [lastSampleTimeStamp]. This does not affect [initialTimeStamp] and [total].
+     * @return The time elapsed since the last call to [sample].
+     * */
+    fun sample(): Quantity<Time> {
+        val current = System.nanoTime()
+        val elapsedNanoseconds = current - lastSampleTimeStamp
+        lastSampleTimeStamp = current
+
+        return Quantity(elapsedNanoseconds.toDouble(), NANO * SECOND)
+    }
+
+    fun resetTotal() {
+        initialTimeStamp = System.nanoTime()
+    }
+
+    /**
+     * Gets the time elapsed since the last call to [resetTotal].
+     * */
+    val total get() = Quantity((System.nanoTime() - initialTimeStamp).toDouble(), NANO * SECOND)
+}
+
+/**
+ * Measures the time spend executing [block] using [System.nanoTime].
+ * */
+@OptIn(ExperimentalContracts::class)
+inline fun measureDuration(block: () -> Unit) : Quantity<Time> {
+    contract {
+        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    }
+
+    val result = measureNanoTime(block)
+
+    return Quantity(result.toDouble(), NANO * SECOND)
+}
diff --git a/src/test/kotlin/org/eln2/libelectric/data/DisjointSetTest.kt b/src/test/kotlin/org/eln2/libelectric/data/DisjointSetTest.kt
new file mode 100644
index 0000000..832f4b8
--- /dev/null
+++ b/src/test/kotlin/org/eln2/libelectric/data/DisjointSetTest.kt
@@ -0,0 +1,62 @@
+package org.eln2.libelectric.data
+
+import org.ageseries.libage.data.DisjointSet
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNotEquals
+import org.junit.jupiter.api.Test
+
+internal class DisjointSetTest {
+    @Test
+    fun equalityAndInitialization() {
+        val a = DisjointSet()
+        val b = DisjointSet()
+
+        assertNotEquals(a, b)
+        assertNotEquals(a.representative, b.representative)
+        assertEquals(a.parent, a)
+        assertEquals(a.representative, a)
+        assertEquals(a, a)
+    }
+
+    @Test
+    fun unionBySize() {
+        val a = DisjointSet()
+        val b = DisjointSet()
+
+        a.unite(b)
+
+        assertEquals(a.representative, b.representative)
+        val rep1 = a.representative
+
+        assertEquals(rep1.size, 2)
+
+        val c = DisjointSet()
+        assertEquals(c.size, 1)
+        c.unite(a)
+
+        assertEquals(c.representative, rep1)
+        assertEquals(rep1.size, 3)
+
+        val d = DisjointSet()
+        d.unite(c)
+
+        listOf(a, b, c, d).forEach {
+            assertEquals(it.representative, rep1)
+        }
+    }
+
+    @Test
+    fun unionByPriority() {
+        val a = DisjointSet()
+        val b = DisjointSet()
+
+        a.unite(b)
+
+        val c = DisjointSet(1)
+        c.unite(a)
+
+        listOf(a, b, c).forEach {
+            assertEquals(it.representative, c)
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/test/kotlin/org/eln2/libelectric/data/EventTest.kt b/src/test/kotlin/org/eln2/libelectric/data/EventTest.kt
new file mode 100644
index 0000000..8d22adb
--- /dev/null
+++ b/src/test/kotlin/org/eln2/libelectric/data/EventTest.kt
@@ -0,0 +1,124 @@
+package org.eln2.libelectric.data
+
+import org.ageseries.libage.data.Event
+import org.ageseries.libage.data.EventBus
+import org.ageseries.libage.data.registerHandler
+import org.ageseries.libage.data.unregisterHandler
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.fail
+import java.util.concurrent.ConcurrentLinkedQueue
+import kotlin.random.Random
+
+class EventTest {
+    private class MyEvent1 : Event {
+        var received = false
+    }
+
+    private class MyEvent2 : Event {
+        var received = false
+    }
+
+    private class MyTestEventParallel(val x: Int): Event
+
+    @Test
+    fun testScalarDispatch(){
+        var eventsRegistered = true
+
+        var receiveCount1 = 0
+        var receiveCount2 = 0
+
+        fun handler1(event: MyEvent1){
+            if(!eventsRegistered){
+                fail("Received event after handler was removed")
+            }
+
+            receiveCount1++
+
+            event.received = true
+        }
+
+        fun handler2(event: MyEvent2){
+            if(!eventsRegistered){
+                fail("Received event after handler was removed")
+            }
+
+            receiveCount2++
+
+            event.received = true
+        }
+
+        val manager = EventBus()
+
+        manager.registerHandler(::handler1)
+        manager.registerHandler(::handler2)
+
+        repeat(100){
+            val event = MyEvent1()
+            manager.send(event)
+            assertTrue(event.received)
+        }
+
+        assertEquals(receiveCount1, 100)
+        assertEquals(receiveCount2, 0)
+
+        repeat(50){
+            val event = MyEvent2()
+            manager.send(event)
+            assertTrue(event.received)
+        }
+
+        assertEquals(receiveCount1, 100)
+        assertEquals(receiveCount2, 50)
+
+        manager.unregisterHandler(::handler1)
+        manager.unregisterHandler(::handler2)
+
+        eventsRegistered = false
+
+        repeat(50){
+            val a = MyEvent1()
+            val b = MyEvent2()
+
+            manager.send(a)
+            manager.send(b)
+
+            assertTrue(!a.received && !b.received)
+        }
+
+        assertEquals(receiveCount1, 100)
+        assertEquals(receiveCount2, 50)
+    }
+
+    @Test
+    fun testParallelDispatch(){
+        val manager = EventBus()
+
+        val toSend = (1..10000).map { MyTestEventParallel(it) }
+        val received = ConcurrentLinkedQueue<MyTestEventParallel>()
+
+        manager.registerHandler<MyTestEventParallel>{ received.add(it) }
+
+        val sendQueue = ConcurrentLinkedQueue(toSend)
+        val threads = (1..10).map{
+            return@map Thread {
+                while (true){
+                    val event = sendQueue.poll()
+                        ?: return@Thread
+
+                    manager.send(event)
+
+                    if(Random.nextInt(0, 10) == 5) {
+                        Thread.sleep(1)
+                    }
+                }
+            }
+        }
+
+        threads.forEach { it.start() }
+        threads.forEach { it.join() }
+
+        assertEquals(received.sortedBy { it.x }, toSend)
+    }
+}
\ No newline at end of file
diff --git a/src/test/kotlin/org/eln2/libelectric/data/QuantityTest.kt b/src/test/kotlin/org/eln2/libelectric/data/QuantityTest.kt
index 295d6d1..7a1532a 100644
--- a/src/test/kotlin/org/eln2/libelectric/data/QuantityTest.kt
+++ b/src/test/kotlin/org/eln2/libelectric/data/QuantityTest.kt
@@ -1,153 +1,13 @@
 package org.eln2.libelectric.data
 
 import org.ageseries.libage.data.*
-import org.ageseries.libage.sim.thermal.STANDARD_TEMPERATURE
+import org.ageseries.libage.sim.STANDARD_TEMPERATURE
 import org.eln2.libelectric.TestUtils.areEqual
 import org.eln2.libelectric.TestUtils.areEqualAstronomic
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 
 internal class QuantityTest {
-    private fun<U> test(a1: Double, s1: QuantityScale<U>, a2: Double, s2: QuantityScale<U>) {
-        areEqual(!Quantity(a1, s1), !Quantity(a2, s2))
-    }
-
-    private fun<U> testAstronomic(a1: Double, s1: QuantityScale<U>, a2: Double, s2: QuantityScale<U>) {
-        areEqualAstronomic(!Quantity(a1, s1), !Quantity(a2, s2))
-    }
-
-    private fun<U> test(a1: Double, s1: QuantityScale<U>, q1: Quantity<U>) {
-        areEqual(!Quantity(a1, s1), !q1)
-    }
-
-    @Test
-    fun mass() {
-        test(1.0, kg, 1000.0, g)
-        test(1.0, g, 1000.0, mg)
-    }
-
-    @Test
-    fun time() {
-        test(1.0, s, 1e3, ms)
-        test(1.0, s, 1e6, MICROSECONDS)
-        test(1.0, s, 1e9, NANOSECONDS)
-        test(1.0, MINUTES, 60.0, s)
-        test(1.0, HOURS, 3600.0, s)
-        test(1.0, DAYS, 24.0, HOURS)
-    }
-
-    @Test
-    fun distance() {
-        test(1.0, m, 100.0, cm)
-        test(1.0, m, 1000.0, mm)
-    }
-
-    @Test
-    fun energy() {
-        test(1.0, kJ, 1e3, J)
-        test(1.0, MJ, 1e6, J)
-        test(1.0, GJ, 1e9, J)
-        test(1.0, Ws, 1.0, J)
-        test(1.0, Wmin, 60.0, J)
-        test(1.0, Wh, 3.6e3, J)
-        test(1.0, kWh, 3.6e6, J)
-        test(1.0, MWh, 3.6e9, J)
-        test(1.0, J, 1e3, MILLIJOULE)
-        test(1.0, J, 1e6, MICROJOULE)
-        test(1.0, J, 1e9, NANOJOULE)
-        test(1.0, ERG, 100.0, NANOJOULE)
-    }
-
-    @Test
-    fun power() {
-        test(1.0, W, 1000.0, MILLIWATT)
-        test(1.0, kW, 1e3, W)
-        test(1.0, MW, 1e6, W)
-        test(1.0, GW, 1e9, W)
-    }
-
-    @Test
-    fun potential() {
-        test(1.0, KV, 1000.0, V)
-        test(1.0, V, 1000.0, MILLIVOLT)
-    }
-
-    @Test
-    fun current() {
-        test(1.0, A, 1000.0, mA)
-    }
-
-    @Test
-    fun resistance() {
-        test(1.0, KILOOHM, 1e3, OHM)
-        test(1.0, MEGAOHM, 1e6, OHM)
-        test(1.0, GIGAOHM, 1e9, OHM)
-        test(1.0, OHM, 1000.0, MILLIOHM)
-    }
-
-    @Test
-    fun electronVolt() {
-        test(1.0, J, 6.2415090744609997e18, eV)
-        test(1.0, J, 6.241509074461e15, keV)
-        test(1.0, J, 6.241509074461e12, MeV)
-        test(1.0, J, 6.2415090744609995e9, GeV)
-        test(1.0, J, 6241509.074461, TeV)
-    }
-
-    @Test
-    fun radioactivity() {
-        test(1.0, nCi, 37.0, Bq)
-        // Very large numerical errors occur at this scale.
-        // Maybe choose a multiple of Bq as a standard unit so that we mitigate these issues?
-        testAstronomic(1.0, kCi, 1e3, Ci)
-        testAstronomic(1.0, MEGACURIES, 1e6, Ci)
-        test(1.0, kBq, 1e3, Bq)
-        test(1.0, MBq, 1e6, Bq)
-        test(1.0, GBq, 1e9, Bq)
-        testAstronomic(1.0, Ci, 1e3, mCi)
-        testAstronomic(1.0, Ci, 1e6, uCi)
-        testAstronomic(1.0, Ci, 1e9, nCi)
-    }
-
-    @Test
-    fun radiationAbsorbedDose() {
-        test(1.0, Gy, 100.0, RAD)
-        test(1.0, Gy, 1000.0, mGy)
-    }
-
-    @Test
-    fun radiationDoseEquivalent() {
-        test(1.0, Sv, 1e3, mSv)
-        test(1.0, Sv, 1e6, uSv)
-        test(1.0, Sv, 1e9, nSv)
-        test(100.0, REM, 1.0, Sv)
-        test(1.0, REM, 1e3, MILLIREM)
-        test(1.0, REM, 1e6, MICROREM)
-    }
-
-    @Test
-    fun radiationExposure() {
-        test(1.0, R, 2.58e-4, COULOMB_PER_KG)
-        test(1.0, R, 1e3, mR)
-        test(1.0, R, 1e6, uR)
-        test(1.0, R, 1e9, nR)
-    }
-
-    @Test
-    fun temperature() {
-        val water_sp_bp = Quantity(1.0, GRADE)
-        test(0.0, CELSIUS, STANDARD_TEMPERATURE)
-        test(0.0, CENTIGRADE, STANDARD_TEMPERATURE)
-        test(0.0, GRADE, STANDARD_TEMPERATURE)
-        test(100.0, CELSIUS, water_sp_bp)
-        test(1000.0, MILLIGRADE, water_sp_bp)
-        test(3.7315, ABSOLUTE_GRADE, water_sp_bp)
-        test(2.7315, ABSOLUTE_GRADE, STANDARD_TEMPERATURE)
-        test(0.0, ABSOLUTE_GRADE, 0.0, KELVIN)
-        test(0.01, CENTIGRADE, 0.1, MILLIGRADE)
-        test(100.0, RANKINE, 55.5556, KELVIN)
-    }
-
     @Test
     fun quantityArrayTest() {
         val array = QuantityArray<Time>(doubleArrayOf(0.0, 1.0, 2.0))
diff --git a/src/test/kotlin/org/eln2/libelectric/mathematics/DualTest.kt b/src/test/kotlin/org/eln2/libelectric/mathematics/DualTest.kt
index 6c0e83a..e0c8bab 100644
--- a/src/test/kotlin/org/eln2/libelectric/mathematics/DualTest.kt
+++ b/src/test/kotlin/org/eln2/libelectric/mathematics/DualTest.kt
@@ -15,6 +15,7 @@ internal class DualTest {
 
     private fun rngNz() = random.nextDouble(0.5, 10.0) * snz(random.nextDouble(-1.0, 1.0))
 
+    @OptIn(UnsafeDualAPI::class)
     @Test
     fun constructors() {
         assertEquals(Dual(listOf(1.0, 2.0, 3.0)), Dual.of(1.0, 2.0, 3.0))
@@ -26,14 +27,73 @@ internal class DualTest {
         assertEquals(Dual.const(10.0, 1), Dual.of(10.0))
         assertEquals(Dual.const(10.0, 2), Dual.of(10.0, 0.0))
         assertEquals(Dual.const(10.0, 3), Dual.of(10.0, 0.0, 0.0))
-        assertEquals(Dual.castFromArray(doubleArrayOf(1.0, 2.0, 3.0)), Dual.of(1.0, 2.0, 3.0))
+        assertEquals(Dual.wrapUnsafe(doubleArrayOf(1.0, 2.0, 3.0)), Dual.of(1.0, 2.0, 3.0))
         assertEquals(Dual(Dual.of(1.0, 2.0), Dual.of(3.0, 4.0)), Dual.of(1.0, 2.0, 3.0, 4.0))
         assertEquals(Dual(Dual.empty, Dual.of(3.0, 4.0)), Dual.of(3.0, 4.0))
         assertEquals(Dual(Dual.of(1.0, 2.0), Dual.empty), Dual.of(1.0, 2.0))
         assertEquals(Dual(Dual.empty, Dual.empty), Dual.empty)
         assertEquals(Dual(listOf(1.0, 2.0), listOf(3.0, 4.0)), Dual.of(1.0, 2.0, 3.0, 4.0))
+        assertEquals(Dual.wrapUnsafe(doubleArrayOf(1.0, 2.0, 3.0)), Dual.of(1.0, 2.0, 3.0))
+        val a = doubleArrayOf(1.0, 2.0, 3.0)
+        assertTrue(Dual.unwrapUnsafe(Dual.wrapUnsafe(a)) === a)
     }
 
+    @Test
+    fun unary() {
+        range { _, xDual ->
+            areEqual(xDual, +xDual, (1.0) * xDual, xDual * (1.0), Dual.const(1.0, xDual.size) * xDual)
+            areEqual(-xDual, (-1.0) * xDual, xDual * (-1.0), Dual.const(-1.0, xDual.size) * xDual)
+        }
+    }
+
+    @Test
+    fun additionSubtraction() {
+        fun Dual.plusC(other: Dual): Dual =
+            if (this.isReal || other.isReal) Dual(this.value + other.value)
+            else Dual(this.value + other.value, this.tail() + other.tail())
+
+        fun Dual.minusC(other: Dual): Dual =
+            if (this.isReal || other.isReal) Dual(this.value - other.value)
+            else Dual(this.value - other.value, this.tail() - other.tail())
+
+        range(derivatives = 10, steps = 1000) { _, xDual ->
+            range(derivatives = 10, steps = 1000) { _, yDual ->
+                val sum = xDual + yDual
+                val sumC = xDual.plusC(yDual)
+                val diff = xDual - yDual
+                val diffC = xDual.minusC(yDual)
+
+                assertEquals(sum, sumC)
+                assertEquals(diff, diffC)
+            }
+        }
+    }
+
+    @Test
+    fun operatorTruncation() {
+        assertEquals((Dual.of(1.0, 2.0, 3.0) + Dual.of(4.0, 5.0, 6.0)).size, 3)
+        assertEquals((Dual.of(1.0, 2.0, 3.0) - Dual.of(4.0, 5.0, 6.0)).size, 3)
+        assertEquals((Dual.of(1.0, 2.0, 3.0) * Dual.of(4.0, 5.0, 6.0)).size, 3)
+        assertEquals((Dual.of(1.0, 2.0, 3.0) / Dual.of(4.0, 5.0, 6.0)).size, 3)
+        assertEquals((Dual.of(1.0, 2.0) + Dual.of(4.0, 5.0, 6.0)).size, 2)
+        assertEquals((Dual.of(1.0, 2.0) - Dual.of(4.0, 5.0, 6.0)).size, 2)
+        assertEquals((Dual.of(1.0, 2.0) * Dual.of(4.0, 5.0, 6.0)).size, 2)
+        assertEquals((Dual.of(1.0, 2.0) / Dual.of(4.0, 5.0, 6.0)).size, 2)
+        assertEquals((Dual.of(1.0, 2.0, 3.0) + Dual.of(4.0, 5.0)).size, 2)
+        assertEquals((Dual.of(1.0, 2.0, 3.0) - Dual.of(4.0, 5.0)).size, 2)
+        assertEquals((Dual.of(1.0, 2.0, 3.0) * Dual.of(4.0, 5.0)).size, 2)
+        assertEquals((Dual.of(1.0, 2.0, 3.0) / Dual.of(4.0, 5.0)).size, 2)
+        assertEquals((Dual.of(1.0) + Dual.of(4.0, 5.0, 6.0)).size, 1)
+        assertEquals((Dual.of(1.0) - Dual.of(4.0, 5.0, 6.0)).size, 1)
+        assertEquals((Dual.of(1.0) * Dual.of(4.0, 5.0, 6.0)).size, 1)
+        assertEquals((Dual.of(1.0) / Dual.of(4.0, 5.0, 6.0)).size, 1)
+        assertEquals((Dual.of(1.0, 2.0, 3.0) + Dual.of(4.0)).size, 1)
+        assertEquals((Dual.of(1.0, 2.0, 3.0) - Dual.of(4.0)).size, 1)
+        assertEquals((Dual.of(1.0, 2.0, 3.0) * Dual.of(4.0)).size, 1)
+        assertEquals((Dual.of(1.0, 2.0, 3.0) / Dual.of(4.0)).size, 1)
+    }
+
+    @OptIn(UnsafeDualAPI::class)
     @Test
     fun immutability() {
         let {
@@ -47,7 +107,7 @@ internal class DualTest {
 
         let {
             val array = doubleArrayOf(1.0, 2.0, 3.0)
-            val dual = Dual.castFromArray(array)
+            val dual = Dual.wrapUnsafe(array)
 
             assertTrue(dual.toList() == array.toList())
             array[0] = 10.0
@@ -83,6 +143,7 @@ internal class DualTest {
         }
     }
 
+    @OptIn(UnsafeDualAPI::class)
     @Test
     fun dequeOperations() {
         assertEquals(Dual.of(1.0, 2.0, 3.0).head(0), Dual.of(1.0, 2.0, 3.0))
@@ -93,7 +154,6 @@ internal class DualTest {
         assertEquals(Dual.of(1.0, 2.0, 3.0).tail(), Dual.of(2.0, 3.0))
         assertEquals(Dual.of(1.0, 2.0, 3.0).tail(1), Dual.of(2.0, 3.0))
         assertEquals(Dual.of(1.0, 2.0, 3.0).tail(2), Dual.of(3.0))
-        assertEquals(Dual.castFromArray(doubleArrayOf(1.0, 2.0, 3.0)), Dual.of(1.0, 2.0, 3.0))
     }
 
     @Test
diff --git a/src/test/kotlin/org/eln2/libelectric/mathematics/GeometryTest.kt b/src/test/kotlin/org/eln2/libelectric/mathematics/GeometryTest.kt
index 88acba2..e97f376 100644
--- a/src/test/kotlin/org/eln2/libelectric/mathematics/GeometryTest.kt
+++ b/src/test/kotlin/org/eln2/libelectric/mathematics/GeometryTest.kt
@@ -1,12 +1,14 @@
+@file:Suppress("LocalVariableName", "NonAsciiCharacters")
+
 package org.eln2.libelectric.mathematics
 
 import org.ageseries.libage.mathematics.*
 import org.eln2.libelectric.TestUtils.rangeScan
 import org.eln2.libelectric.TestUtils.rangeScanKd
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 import kotlin.math.PI
+import kotlin.math.pow
 import kotlin.math.sqrt
 
 internal class GeometryTest {
@@ -203,4 +205,318 @@ internal class GeometryTest {
             }
         }
     }
+
+    @Test
+    fun matrix3x3Multiplication() {
+        val A = Matrix3x3(
+            1.0, 2.0, 3.0,
+            4.0, 5.0, 6.0,
+            7.0, 8.0, 9.0
+        )
+
+        val B = Matrix3x3(
+            9.0, 8.0, 7.0,
+            6.0, 5.0, 4.0,
+            3.0, 2.0, 1.0
+        )
+
+        val AB = Matrix3x3(
+            30.0, 24.0, 18.0,
+            84.0, 69.0, 54.0,
+            138.0, 114.0, 90.0
+        )
+
+        assertEquals(A * B, AB)
+
+        val v = Vector3d(3.0, 1.0, 4.0)
+        val ABv = Vector3d(186.0, 537.0, 888.0)
+
+        assertEquals(AB * v, ABv)
+    }
+
+    @Test
+    fun matrix3x3RowsColumnsEntries() {
+        val A = Matrix3x3(
+            1.0, 2.0, 3.0,
+            4.0, 5.0, 6.0,
+            7.0, 8.0, 9.0
+        )
+
+        assertEquals(A.r0, Vector3d(1.0, 2.0, 3.0))
+        assertEquals(A.r1, Vector3d(4.0, 5.0, 6.0))
+        assertEquals(A.r2, Vector3d(7.0, 8.0, 9.0))
+
+        assertEquals(A.c0, Vector3d(1.0, 4.0, 7.0))
+        assertEquals(A.c1, Vector3d(2.0, 5.0, 8.0))
+        assertEquals(A.c2, Vector3d(3.0, 6.0, 9.0))
+
+        assertEquals(A.getRow(0), Vector3d(1.0, 2.0, 3.0))
+        assertEquals(A.getRow(1), Vector3d(4.0, 5.0, 6.0))
+        assertEquals(A.getRow(2), Vector3d(7.0, 8.0, 9.0))
+
+        assertEquals(A.getColumn(0), Vector3d(1.0, 4.0, 7.0))
+        assertEquals(A.getColumn(1), Vector3d(2.0, 5.0, 8.0))
+        assertEquals(A.getColumn(2), Vector3d(3.0, 6.0, 9.0))
+
+        assertEquals(A[0, 0], 1.0)
+        assertEquals(A[0, 1], 2.0)
+        assertEquals(A[0, 2], 3.0)
+        assertEquals(A[1, 0], 4.0)
+        assertEquals(A[1, 1], 5.0)
+        assertEquals(A[1, 2], 6.0)
+        assertEquals(A[2, 0], 7.0)
+        assertEquals(A[2, 1], 8.0)
+        assertEquals(A[2, 2], 9.0)
+    }
+
+    @Test
+    fun matrix3x3TraceFrobenius() {
+        val A = Matrix3x3(
+            1.0, 2.0, 3.0,
+            4.0, 5.0, 6.0,
+            7.0, 8.0, 9.0
+        )
+
+        assertEquals(A.trace, 1.0 + 5.0 + 9.0)
+        assertEquals(A.normFrobeniusSqr, 285.0)
+        assertEquals(A.normFrobenius, sqrt(285.0))
+    }
+
+    @Test
+    fun matrix3x3OrthogonalSpecialOrthogonal() {
+        val A = Matrix3x3(
+            1.0, 2.0, 3.0,
+            4.0, 5.0, 6.0,
+            7.0, 8.0, 9.0
+        )
+
+        assertFalse(A.isOrthogonal)
+        assertFalse(A.isSpecialOrthogonal)
+
+        assertTrue(Matrix3x3.identity.isOrthogonal && Matrix3x3.identity.isSpecialOrthogonal)
+        assertTrue(Rotation3d.exp(Vector3d.one.normalized() * 42.0)().let { it.isOrthogonal && it.isSpecialOrthogonal })
+    }
+
+    @Test
+    fun matrix3x3Transpose() {
+        val A = Matrix3x3(
+            1.0, 2.0, 3.0,
+            4.0, 5.0, 6.0,
+            7.0, 8.0, 9.0
+        )
+
+        val Aᵀ = Matrix3x3(
+            1.0, 4.0, 7.0,
+            2.0, 5.0, 8.0,
+            3.0, 6.0, 9.0
+        )
+
+        assertEquals(A.transpose, Aᵀ)
+    }
+
+    @Test
+    fun matrix3x3Determinant() {
+        val A = Matrix3x3(
+            1.0, 3.0, 1.0,
+            5.0, 2.0, 5.0,
+            1.0, 2.0, 4.0
+        )
+
+        assertEquals(A.determinant, -39.0)
+    }
+
+    @Test
+    fun matrix3x3Inverse() {
+        val A = Matrix3x3(
+            1.0, 3.0, 1.0,
+            5.0, 2.0, 5.0,
+            1.0, 2.0, 4.0
+        )
+
+        val expected = Matrix3x3(
+            0.05128205128205128, 0.2564102564102564, -0.3333333333333333,
+            0.38461538461538464, -0.07692307692307693, 0.0,
+            -0.20512820512820512, -0.02564102564102564, 0.3333333333333333
+        )
+
+        assertTrue((!A).approxEq(expected))
+    }
+
+    @Test
+    fun matrix4x4Multiplication() {
+        val A = Matrix4x4(
+            1.0, 2.0, 3.0, 4.0,
+            5.0, 6.0, 7.0, 8.0,
+            9.0, 10.0, 11.0, 12.0,
+            13.0, 14.0, 15.0, 16.0
+        )
+
+        val B = Matrix4x4(
+            16.0, 15.0, 14.0, 13.0,
+            12.0, 11.0, 10.0, 9.0,
+            8.0, 7.0, 6.0, 5.0,
+            4.0, 3.0, 2.0, 1.0
+        )
+
+        val AB = Matrix4x4(
+            80.0, 70.0, 60.0, 50.0,
+            240.0, 214.0, 188.0, 162.0,
+            400.0, 358.0, 316.0, 274.0,
+            560.0, 502.0, 444.0, 386.0
+        )
+
+        assertEquals(A * B, AB)
+
+        val v = Vector4d(3.0, 1.0, 4.0, 1.0)
+        val ABv = Vector4d(600.0, 1848.0, 3096.0, 4344.0)
+
+        assertEquals(AB * v, ABv)
+    }
+
+    @Test
+    fun matrix4x4RowsColumnsEntries() {
+        val A = Matrix4x4(
+            1.0, 2.0, 3.0, 4.0,
+            5.0, 6.0, 7.0, 8.0,
+            9.0, 10.0, 11.0, 12.0,
+            13.0, 14.0, 15.0, 16.0
+        )
+
+        assertEquals(A.r0, Vector4d(1.0, 2.0, 3.0, 4.0))
+        assertEquals(A.r1, Vector4d(5.0, 6.0, 7.0, 8.0))
+        assertEquals(A.r2, Vector4d(9.0, 10.0, 11.0, 12.0))
+        assertEquals(A.r3, Vector4d(13.0, 14.0, 15.0, 16.0))
+
+        assertEquals(A.c0, Vector4d(1.0, 5.0, 9.0, 13.0))
+        assertEquals(A.c1, Vector4d(2.0, 6.0, 10.0, 14.0))
+        assertEquals(A.c2, Vector4d(3.0, 7.0, 11.0, 15.0))
+        assertEquals(A.c3, Vector4d(4.0, 8.0, 12.0, 16.0))
+
+        assertEquals(A.getRow(0), Vector4d(1.0, 2.0, 3.0, 4.0))
+        assertEquals(A.getRow(1), Vector4d(5.0, 6.0, 7.0, 8.0))
+        assertEquals(A.getRow(2), Vector4d(9.0, 10.0, 11.0, 12.0))
+        assertEquals(A.getRow(3), Vector4d(13.0, 14.0, 15.0, 16.0))
+
+        assertEquals(A.getColumn(0), Vector4d(1.0, 5.0, 9.0, 13.0))
+        assertEquals(A.getColumn(1), Vector4d(2.0, 6.0, 10.0, 14.0))
+        assertEquals(A.getColumn(2), Vector4d(3.0, 7.0, 11.0, 15.0))
+        assertEquals(A.getColumn(3), Vector4d(4.0, 8.0, 12.0, 16.0))
+
+        assertEquals(A[0, 0], 1.0)
+        assertEquals(A[0, 1], 2.0)
+        assertEquals(A[0, 2], 3.0)
+        assertEquals(A[0, 3], 4.0)
+        assertEquals(A[1, 0], 5.0)
+        assertEquals(A[1, 1], 6.0)
+        assertEquals(A[1, 2], 7.0)
+        assertEquals(A[1, 3], 8.0)
+        assertEquals(A[2, 0], 9.0)
+        assertEquals(A[2, 1], 10.0)
+        assertEquals(A[2, 2], 11.0)
+        assertEquals(A[2, 3], 12.0)
+        assertEquals(A[3, 0], 13.0)
+        assertEquals(A[3, 1], 14.0)
+        assertEquals(A[3, 2], 15.0)
+        assertEquals(A[3, 3], 16.0)
+    }
+
+    @Test
+    fun matrix4x4TraceFrobenius() {
+        val A = Matrix4x4(
+            1.0, 2.0, 3.0, 4.0,
+            5.0, 6.0, 7.0, 8.0,
+            9.0, 10.0, 11.0, 12.0,
+            13.0, 14.0, 15.0, 16.0
+        )
+
+        assertEquals(A.trace, 1.0 + 6.0 + 11.0 + 16.0)
+        assertEquals(A.normFrobeniusSqr, (2.0 * sqrt(374.0)).pow(2))
+        assertEquals(A.normFrobenius, 2.0 * sqrt(374.0))
+    }
+
+    @Test
+    fun matrix4x4Transpose() {
+        val A = Matrix4x4(
+            1.0, 2.0, 3.0, 4.0,
+            5.0, 6.0, 7.0, 8.0,
+            9.0, 10.0, 11.0, 12.0,
+            13.0, 14.0, 15.0, 16.0
+        )
+
+        val Aᵀ = Matrix4x4(
+            1.0, 5.0, 9.0, 13.0,
+            2.0, 6.0, 10.0, 14.0,
+            3.0, 7.0, 11.0, 15.0,
+            4.0, 8.0, 12.0, 16.0
+        )
+
+        assertEquals(A.transpose, Aᵀ)
+    }
+
+    @Test
+    fun matrix4x4Determinant() {
+        val A = Matrix4x4(
+            3.0, 1.0, 4.0, 1.0,
+            2.0, 7.0, 1.0, 8.0,
+            1.0, 6.0, 1.0, 8.0,
+            1.0, 0.0, 1.0, 0.0
+        )
+
+        assertEquals(A.determinant, 10.0)
+    }
+
+    @Test
+    fun matrix4x4Inverse() {
+        val A = Matrix4x4(
+            3.0, 1.0, 4.0, 1.0,
+            2.0, 7.0, 1.0, 8.0,
+            1.0, 6.0, 1.0, 8.0,
+            1.0, 0.0, 1.0, 0.0
+        )
+
+        val expected = Matrix4x4(
+            -8.0, 2.0, -1.0, 31.0,
+            8.0, 8.0, -9.0, -31.0,
+            8.0, -2.0, 1.0, -21.0,
+            -6.0, -6.0, 8.0, 22.0
+        ) * (1.0 / 10.0)
+
+        assertTrue((!A).approxEq(expected))
+    }
+
+    @Test
+    fun ddaTest() {
+        // I calculated these intersections on paper by drawing
+        // Maybe find a trusted DDA implementation to also make a 3D test (can't really draw it very easily)
+
+        val start = Vector3d(2.5, 1.5, 0.0)
+        val end = Vector3d(5.5, 8.5, 0.0)
+        val ray = Ray3d.fromSourceAndDestination(start, end)
+
+        val results = mutableListOf<Vector2di>()
+
+        dda(ray, true) { x, y, z ->
+            assertEquals(z, 0)
+
+            if(x == 5 && y == 8) {
+                false
+            }
+            else {
+                results.add(Vector2di(x, y))
+                true
+            }
+        }
+
+        assertEquals(results[0], Vector2di(2, 1))
+        assertEquals(results[1], Vector2di(2, 2))
+        assertEquals(results[2], Vector2di(3, 2))
+        assertEquals(results[3], Vector2di(3, 3))
+        assertEquals(results[4], Vector2di(3, 4))
+        assertEquals(results[5], Vector2di(4, 4))
+        assertEquals(results[6], Vector2di(4, 5))
+        assertEquals(results[7], Vector2di(4, 6))
+        assertEquals(results[8], Vector2di(4, 7))
+        assertEquals(results[9], Vector2di(5, 7))
+        assertEquals(results.size, 10)
+    }
 }
\ No newline at end of file
diff --git a/src/test/kotlin/org/eln2/libelectric/sim/electrical/mna/CircuitBuilderTest.kt b/src/test/kotlin/org/eln2/libelectric/sim/electrical/mna/CircuitBuilderTest.kt
new file mode 100644
index 0000000..3e27c10
--- /dev/null
+++ b/src/test/kotlin/org/eln2/libelectric/sim/electrical/mna/CircuitBuilderTest.kt
@@ -0,0 +1,295 @@
+@file:Suppress("UNUSED_VARIABLE")
+
+package org.eln2.libelectric.sim.electrical.mna
+
+import org.ageseries.libage.mathematics.approxEq
+import org.ageseries.libage.sim.electrical.mna.*
+import org.ageseries.libage.sim.electrical.mna.component.Line
+import org.ageseries.libage.sim.electrical.mna.component.Resistor
+import org.ageseries.libage.sim.electrical.mna.component.Term
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import java.lang.IllegalArgumentException
+import java.lang.IllegalStateException
+
+internal class CircuitBuilderTest {
+    @Test
+    fun testRealUnion() {
+        val a = LineCompiler.Pin()
+
+        assertFalse(a.hasRealsInternal)
+
+        val b = LineCompiler.Pin()
+
+        a.unite(b)
+
+        assertFalse(a.hasRealsInternal)
+        assertFalse(b.hasRealsInternal)
+
+        val c = LineCompiler.Pin()
+        val d = LineCompiler.Pin()
+
+        d.markReal()
+        d.unite(c)
+
+        assertTrue(c.representative.hasRealsInternal)
+        assertTrue(d.representative.hasRealsInternal)
+
+        c.unite(a)
+
+        listOf(a, b, c, d).forEach {
+            assertTrue(it.representative.hasRealsInternal)
+            assertEquals(it.representative, a.representative)
+        }
+    }
+
+    @Test
+    fun testBreakPoint() {
+        let {
+            val a = LineCompiler.Pin()
+            assertTrue(a.isBreakPoint) // only 1
+
+            val b = LineCompiler.Pin()
+
+            a.unite(b)
+
+            assertFalse(a.isBreakPoint)
+            assertFalse(b.isBreakPoint)
+
+            b.markReal()
+
+            assertTrue(a.isBreakPoint && a.representative.hasRealsInternal)
+            assertTrue(b.isBreakPoint && b.representative.hasRealsInternal)
+
+            val c = LineCompiler.Pin()
+            c.unite(b)
+
+            assertTrue(c.isBreakPoint && c.representative.hasRealsInternal)
+        }
+
+        let {
+            val a = LineCompiler.Pin()
+            val b = LineCompiler.Pin()
+            a.unite(b)
+
+            assertFalse(a.isBreakPoint)
+            assertFalse(b.isBreakPoint)
+
+            val c = LineCompiler.Pin()
+            c.unite(a)
+
+            listOf(a, b, c).forEach {
+                assertTrue(it.isBreakPoint) // 3
+            }
+        }
+
+    }
+
+    private fun runTest(action: (CircuitBuilder) -> Unit) {
+        val circuit = Circuit()
+        val builder = CircuitBuilder(circuit)
+        action(builder)
+    }
+
+    @Test
+    fun validation() {
+        fun<T : Term> test(v1: T, v2: T) {
+            runTest {
+                assertThrows<IllegalArgumentException> { it.connect(v1, 0, v1, 0) }
+                assertThrows<IllegalArgumentException> { it.connect(v1, 0, v2, 0) }
+
+                assertTrue(it.add(v1))
+                assertFalse(it.add(v1))
+
+                assertThrows<IllegalArgumentException> { it.connect(v1, 0, v1, 0) }
+                assertThrows<IllegalArgumentException> { it.connect(v1, 0, v2, 0) }
+
+                assertTrue(it.add(v2))
+                assertFalse(it.add(v2))
+
+                assertThrows<IllegalArgumentException> { it.connect(v1, 0, v1, 0) }
+                assertDoesNotThrow { it.connect(v1, 0, v2, 0) }
+
+                it.build()
+
+                assertThrows<IllegalStateException> { it.build() }
+                assertThrows<IllegalStateException> { it.connect(v1, 1, v2, 1) }
+                assertThrows<IllegalStateException> { it.add(v1) }
+
+            }
+        }
+
+        test(VirtualResistor(), VirtualResistor())
+        test(Resistor(), Resistor())
+        test(VirtualResistor(), Resistor())
+        test(Resistor(), VirtualResistor())
+    }
+
+    @Test
+    fun simpleCases() {
+        runTest {
+            it.build()
+            assertTrue(it.lineCompiler.lineGraphs.isEmpty())
+            assertEquals(it.circuit.components.size, 0)
+        }
+
+        runTest {
+            val r = Resistor()
+            it.add(r)
+            it.build()
+            assertTrue(it.lineCompiler.lineGraphs.isEmpty())
+            assertEquals(it.circuit.components.size, 1)
+            assertEquals(it.circuit.components.first(), r)
+        }
+
+        runTest {
+            val v = VirtualResistor()
+            v.resistance = 3141.0
+
+            it.add(v)
+            it.build()
+
+            assertEquals(it.lineCompiler.lineGraphs.size, 1)
+            assertEquals(it.circuit.components.size, 1)
+
+            val graph = it.lineCompiler.lineGraphs.first()
+            assertTrue(graph.outers.contains(v) && graph.outers.size == 1)
+            assertTrue(graph.inners.isEmpty())
+            assertEquals(graph.anchor, null)
+
+            it.lineCompiler.virtualResistors.values.forEach { (p, n) ->
+                assertTrue(!p.representative.hasRealsInternal && !n.representative.hasRealsInternal)
+            }
+
+            val component = it.circuit.components.first() as Line
+
+            assertTrue(component.isInCircuit && component.resistance == 3141.0 && component.parts.contains(v.part!!))
+        }
+
+        runTest {
+            val v1 = VirtualResistor()
+            val v2 = VirtualResistor()
+            v1.resistance = 31.0
+            v2.resistance = 41.0
+
+            it.add(v1)
+            it.add(v2)
+            it.build()
+
+            assertEquals(it.lineCompiler.lineGraphs.size, 2)
+            assertEquals(it.circuit.components.size, 2)
+
+            assertTrue(it.circuit.components.any { c -> c is Line && c.resistance == 31.0})
+            assertTrue(it.circuit.components.any { c -> c is Line && c.resistance == 41.0})
+        }
+
+        runTest {
+            val v1 = VirtualResistor()
+            val v2 = VirtualResistor()
+            v1.resistance = 31.0
+            v2.resistance = 41.0
+
+            it.add(v1)
+            it.add(v2)
+            it.connect(v1, POSITIVE, v2, POSITIVE)
+            it.build()
+
+            assertEquals(it.lineCompiler.lineGraphs.size, 1)
+            assertEquals(it.circuit.components.size, 1)
+
+            val graph = it.lineCompiler.lineGraphs.first()
+            assertTrue(graph.outers.contains(v1) && graph.outers.contains(v2) && graph.outers.size == 2)
+            assertTrue(graph.inners.isEmpty())
+            assertEquals(graph.anchor, graph.outers.toList().last())
+
+            it.lineCompiler.virtualResistors.values.forEach { (p, n) ->
+                assertTrue(!p.representative.hasRealsInternal && !n.representative.hasRealsInternal)
+            }
+
+            val component = it.circuit.components.first() as Line
+            assertEquals(component.resistance, 31.0 + 41.0)
+        }
+
+        runTest {
+            val v1 = VirtualResistor()
+            val v2 = VirtualResistor()
+            val v3 = VirtualResistor()
+            v1.resistance = 31.0
+            v2.resistance = 41.0
+            v3.resistance = 59.0
+
+            it.add(v1)
+            it.add(v2)
+            it.add(v3)
+            it.connect(v1, POSITIVE, v2, POSITIVE)
+            it.connect(v2, NEGATIVE, v3, POSITIVE)
+            it.build()
+
+            assertEquals(it.lineCompiler.lineGraphs.size, 1)
+            assertEquals(it.circuit.components.size, 1)
+
+            val graph = it.lineCompiler.lineGraphs.first()
+            assertTrue(graph.outers.contains(v1) && graph.outers.contains(v3) && graph.outers.size == 2)
+            assertTrue(graph.inners.contains(v2) && graph.inners.size == 1)
+            assertEquals(graph.anchor, v2)
+
+            val component = it.circuit.components.first() as Line
+            assertEquals(component.resistance, 31.0 + 41.0 + 59.0)
+        }
+
+        runTest {
+            var last: VirtualResistor? = null
+
+            for (resistance in 1..50) {
+                val v = VirtualResistor()
+
+                it.add(v)
+
+                v.resistance = resistance.toDouble()
+
+                if(last != null) {
+                    it.connect(v, NEGATIVE, last, POSITIVE)
+                }
+
+                last = v
+            }
+
+            it.build()
+
+            assertTrue(it.lineCompiler.lineGraphs.size == 1)
+            assertTrue(it.circuit.components.size == 1)
+
+            val component = it.circuit.components.first() as Line
+            assertTrue(component.resistance approxEq (50 * (50 + 1) / 2).toDouble())
+        }
+
+        runTest {
+            val v1 = VirtualResistor()
+            val v2 = VirtualResistor()
+            val v3 = VirtualResistor()
+            val R = Resistor()
+            v1.resistance = 31.0
+            v2.resistance = 41.0
+            v3.resistance = 59.0
+
+            it.add(v1)
+            it.add(v2)
+            it.add(v3)
+            it.connect(v1, POSITIVE, v2, POSITIVE)
+            it.connect(v2, NEGATIVE, v3, POSITIVE)
+            it.add(R)
+            it.connect(v2, NEGATIVE, R, NEGATIVE)
+            it.build()
+
+            assertEquals(it.lineCompiler.lineGraphs.size, 2)
+            assertEquals(it.circuit.components.size, 3)
+
+            assertTrue(it.circuit.components.count { c -> c is Line } == 2)
+            assertTrue(it.circuit.components.count { c -> c is Resistor && c !is Line } == 1)
+
+            val (p, n) = it.lineCompiler.virtualResistors[v2]!!
+            assertTrue(n.representative.hasRealsInternal && n.isBreakPoint)
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/test/kotlin/org/eln2/libelectric/sim/thermal/ThermalTests.kt b/src/test/kotlin/org/eln2/libelectric/sim/thermal/ThermalTests.kt
index 44d0abf..63c2ce4 100644
--- a/src/test/kotlin/org/eln2/libelectric/sim/thermal/ThermalTests.kt
+++ b/src/test/kotlin/org/eln2/libelectric/sim/thermal/ThermalTests.kt
@@ -3,13 +3,14 @@ package org.eln2.libelectric.sim.thermal
 import org.ageseries.libage.data.KELVIN
 import org.ageseries.libage.data.Quantity
 import org.ageseries.libage.data.Temperature
-import org.ageseries.libage.sim.Material
-import org.ageseries.libage.sim.thermal.*
+import org.ageseries.libage.sim.*
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 import kotlin.math.abs
 
 internal class ThermalTests {
+    val IRON = ChemicalElement.Iron.asMaterial
+
     companion object {
         val A_BIT = Quantity(10.0, KELVIN)
     }
@@ -17,9 +18,9 @@ internal class ThermalTests {
     @Test
     fun consistent_data_model() {
         val sim = Simulator()
-        val a = ThermalMass(Material.IRON)
-        val b = ThermalMass(Material.IRON)
-        val c = ThermalMass(Material.IRON)
+        val a = ThermalMass(IRON)
+        val b = ThermalMass(IRON)
+        val c = ThermalMass(IRON)
         assert(a !in sim.masses)
         assert(b !in sim.masses)
         assert(c !in sim.masses)
@@ -54,8 +55,8 @@ internal class ThermalTests {
     @Test
     fun perfectly_isolated() {
         val sim = Simulator()
-        val a = ThermalMass(Material.IRON)
-        val b = ThermalMass(Material.IRON)
+        val a = ThermalMass(IRON)
+        val b = ThermalMass(IRON)
         a.temperature = STANDARD_TEMPERATURE
         b.temperature = STANDARD_TEMPERATURE + A_BIT
         listOf(a, b).forEach { sim.add(it) }
@@ -71,8 +72,8 @@ internal class ThermalTests {
     @Test
     fun second_law() {
         val sim = Simulator()  // Don't conduct from/to env
-        val a = ThermalMass(Material.IRON)
-        val b = ThermalMass(Material.IRON)
+        val a = ThermalMass(IRON)
+        val b = ThermalMass(IRON)
         val lesser = STANDARD_TEMPERATURE
         val greater = STANDARD_TEMPERATURE + A_BIT
         listOf(lesser to greater, greater to lesser).forEach { (a_temp, b_temp) ->
@@ -92,10 +93,10 @@ internal class ThermalTests {
         var lastIncrease: Quantity<Temperature>? = null
         for(it in 1..10) {
             val sim = Simulator()
-            val cen = ThermalMass(Material.IRON)
+            val cen = ThermalMass(IRON)
             cen.temperature = STANDARD_TEMPERATURE
             val others = (1..it).map {
-                ThermalMass(Material.IRON).also {
+                ThermalMass(IRON).also {
                     it.temperature = STANDARD_TEMPERATURE + A_BIT
                 }
             }
@@ -115,8 +116,8 @@ internal class ThermalTests {
     @Test
     fun environment() {
         val sim = Simulator()
-        val a = ThermalMass(Material.IRON)
-        val b = ThermalMass(Material.IRON)
+        val a = ThermalMass(IRON)
+        val b = ThermalMass(IRON)
         listOf(a, b).forEach {
             sim.add(it)
         }
@@ -134,8 +135,8 @@ internal class ThermalTests {
     @Test
     fun equilibrium() {
         val sim = Simulator()
-        val a = ThermalMass(Material.IRON)
-        val b = ThermalMass(Material.IRON)
+        val a = ThermalMass(IRON)
+        val b = ThermalMass(IRON)
         a.temperature = STANDARD_TEMPERATURE
         b.temperature = STANDARD_TEMPERATURE + A_BIT
         sim.connect(a, b)
@@ -155,16 +156,16 @@ internal class ThermalTests {
     @Test
     fun astronomical() {
         val sim = Simulator()
-        val a = ThermalMass(Material.IRON)
-        val b = ThermalMass(Material.IRON)
+        val a = ThermalMass(IRON)
+        val b = ThermalMass(IRON)
         a.temperature = STANDARD_TEMPERATURE * 1000.0
         b.temperature = Quantity(0.0, KELVIN)
         sim.connect(a, b)
-        for(step in 0 until 1000) {
+        for(step in 0 until 10000) {
             sim.step(1.0)
             assert(!a.temperature >= 0.0) { "negative energy: $a" }
             assert(!b.temperature >= 0.0) { "negative energy: $b" }
-            println("${!b.temperature - !a.temperature},${a.temperature},${b.temperature}")
+            //println("${!b.temperature - !a.temperature},${a.temperature},${b.temperature}")
             if(abs(!a.temperature - !b.temperature) < 1e-9) {
                 println("equalized at $step: $a = $b")
                 return
diff --git a/src/test/kotlin/org/eln2/libelectric/space/VecTests.kt b/src/test/kotlin/org/eln2/libelectric/space/VecTests.kt
deleted file mode 100644
index b2312e7..0000000
--- a/src/test/kotlin/org/eln2/libelectric/space/VecTests.kt
+++ /dev/null
@@ -1,36 +0,0 @@
-package org.eln2.libelectric.space
-
-import org.ageseries.libage.space.Vec2i
-import org.ageseries.libage.space.Vec3i
-import org.junit.jupiter.api.Assertions
-import org.junit.jupiter.api.Test
-
-internal class VecTests {
-    @Test
-    fun vec2iEqualsTest() {
-        val v1 = Vec2i(2, 2)
-        val v2 = Vec2i(2, 2)
-        Assertions.assertEquals(true, v1 == v2)
-        Assertions.assertEquals(false, v1 == Vec2i.ZERO)
-    }
-
-    @Test
-    fun vec2iZeroEqualsTest() {
-        val v1 = Vec2i(0, 0)
-        Assertions.assertEquals(true, Vec2i.ZERO == v1)
-    }
-
-    @Test
-    fun vec3iEqualsTest() {
-        val v1 = Vec3i(2, 2, 2)
-        val v2 = Vec3i(2, 2, 2)
-        Assertions.assertEquals(true, v1 == v2)
-        Assertions.assertEquals(false, v1 == Vec3i.ZERO)
-    }
-
-    @Test
-    fun vec3iZeroEqualsTest() {
-        val v1 = Vec3i(0, 0, 0)
-        Assertions.assertEquals(true, Vec3i.ZERO == v1)
-    }
-}